export type HarnessName = 'claude-code' | 'nexus-cortex' | 'grok-build' | 'gemini-cli' | 'browser-cortex';
export declare const HARNESSES: HarnessName[];
/**
 * Canonical concept → per-harness tool names. Seeded from the observed
 * FIVE-harness corpus plus each CLI's documented surface; extend as the
 * §27n roster lands. A name may map to several concepts' worth of behavior —
 * rung 1 keeps it 1:1 on the dominant sense.
 *
 * browser-cortex is the in-browser Nexus Terminal CORTEX agent (distinct from
 * the nexus-cortex CLI harness). Its tool surface is the `cortex_*` VFS family
 * (toolSeedData.ts, verified 2026-08-05); it omits concepts with no clean
 * dedicated equivalent (list_dir, todo, plan_mode) rather than inventing names.
 */
export declare const TOOL_CONCEPTS: Record<string, Partial<Record<HarnessName, string[]>>>;
/**
 * Rung 2 — arg-schema morphisms. Canonical field dialect = claude-code's
 * (canon IS the Anthropic wire shape; cortex is field-identical, verified).
 * Seeded EMPIRICALLY from the observed local four-harness corpus (2026-08-03
 * scan: claude-code 34 tools/6.4k calls; cortex 12; grok-build 4; gemini 11).
 * evidence grades: 'observed' = field names seen in real calls;
 * 'spec' = read from the harness's published tool schema, not yet observed;
 * 'unverified' = name-mapped at rung 1 but arg shape unconfirmed either way.
 */
export interface ArgMorph {
    /** Target tool name this morphism renders into. */
    tool: string;
    /** canonical field → target field (identity fields omitted). */
    rename?: Record<string, string>;
    /** Canonical fields with no target equivalent — reported, never silently lost. */
    drop?: string[];
    /** Target-required fields canon can't supply — value is a note/default hint. */
    require?: Record<string, string>;
    evidence: 'observed' | 'spec' | 'unverified';
}
export declare const ARG_MORPHISMS: Record<string, {
    canonical: string[];
    byHarness: Partial<Record<HarnessName, ArgMorph>>;
}>;
export interface MorphResult {
    status: 'ok' | 'partial' | 'unverified' | 'unmapped';
    concept?: string;
    targetTool?: string;
    input?: Record<string, unknown>;
    /** Canonical fields that had no target equivalent (with their values' presence). */
    dropped: string[];
    notes: string[];
}
/**
 * Re-express one tool call in a target harness's arg dialect.
 * Never silent (D8): drops and unverified grades are surfaced in the result.
 */
export declare function morphToolCall(call: {
    name: string;
    input: Record<string, unknown>;
}, source: HarnessName, target: HarnessName): MorphResult;
export interface ToolInventory {
    [harness: string]: Record<string, number>;
}
/** Scan the canonical line for observed tool_use names per harness. */
export declare function deriveToolInventory(store: string): Promise<ToolInventory>;
export interface ToolCompatReport {
    target: HarnessName;
    referenced: string[];
    mapped: {
        name: string;
        concept: string;
        targetNames: string[];
        argEvidence?: ArgMorph['evidence'];
        argDrops?: string[];
    }[];
    native: string[];
    mcp: string[];
    unmapped: string[];
}
/** Classify one session's tool references against a target harness. */
export declare function toolCompatibility(referenced: string[], target: HarnessName): ToolCompatReport;
/** Extract the tool_use names referenced in one canonical session file. */
export declare function sessionToolNames(file: string): Promise<string[]>;
export interface ToolCallSamples {
    [name: string]: {
        count: number;
        samples: string[];
    };
}
/**
 * Rung 4 evidence: per-tool call counts + up to `cap` sample inputs from one
 * canonical session file — the "original intent" the receiving model needs to
 * re-express an unmapped call in its local vocabulary.
 */
export declare function sessionToolCalls(file: string, cap?: number): Promise<ToolCallSamples>;
/**
 * Rung 4 — render the pull capsule: the compatibility report plus, for every
 * unmapped tool, its original calls so the receiving model can re-express the
 * INTENT against its own local tool menu (§27c: the model menu-follows with
 * judgment; no model-side translation layer). The capsule is generated content
 * and is untrusted input to the receiver (§27b doctrine).
 */
export declare function renderCapsule(r: ToolCompatReport, samples: ToolCallSamples, meta: {
    uuid: string;
    harness: string;
}): string;
/** Render the compatibility report for terminal output. */
export declare function renderCompat(r: ToolCompatReport): string;
//# sourceMappingURL=canonTools.d.ts.map