codictator 0.0.0 → 0.1.3

package/dist/features/adapters/claude-code.js

@@ -0,0 +1,198 @@
+import { stableStringify } from "../../kernel/index.js";
+import { parseClaudeShapedEvent } from "./claude-shaped.js";
+import { normalizeToolName } from "./contract.js";
+const CLAUDE_TOOL_TABLE = {
+    write: "write",
+    edit: "write",
+    notebookedit: "write",
+    create: "write",
+    apply_patch: "write",
+    bash: "shell",
+    shell: "shell",
+    exec: "shell",
+    terminal: "shell",
+    bashoutput: "shell",
+    read: "read",
+    cat: "read",
+    view: "read",
+    glob: "search",
+    grep: "search",
+    search: "search",
+    find: "search",
+    ls: "search",
+    webfetch: "web",
+    websearch: "web",
+    fetch: "web",
+    curl: "web",
+    task: "task",
+    todo: "task",
+    todowrite: "task",
+    todoread: "task",
+};
+export function normalizeClaudeCodeToolName(name) {
+    return normalizeToolName(CLAUDE_TOOL_TABLE, name);
+}
+export function parseClaudeCodeEvent(event, raw) {
+    return parseClaudeShapedEvent("claude-code", event, raw, CLAUDE_TOOL_TABLE);
+}
+// SPEC §4.5.4 Claude Code row: a pre-tool block is exit 2 + stderr and can
+// never be overridden by a JSON allow. The stdout JSON mirrors the post-tool
+// form so one engine verdict carries identical message text in every
+// harness (see §4.5 EC-10). Inject is exit 0 with
+// hookSpecificOutput.additionalContext. Allow is exit 0 with empty stdout.
+export function replyClaudeCode(decision) {
+    if (decision.decision === "block" || decision.decision === "escalate") {
+        const reason = decision.message ?? "blocked";
+        return {
+            exitCode: 2,
+            stdout: JSON.stringify({ decision: "block", reason }),
+            stderr: reason,
+        };
+    }
+    if (decision.additionalContext !== undefined &&
+        decision.additionalContext.length > 0) {
+        return {
+            exitCode: 0,
+            stdout: JSON.stringify({
+                hookSpecificOutput: {
+                    additionalContext: decision.additionalContext,
+                },
+            }),
+            stderr: "",
+        };
+    }
+    return { exitCode: 0, stdout: "", stderr: "" };
+}
+// SPEC §4.5.1: the pre-engine deny form, embedded by regen for CDX-E002 and
+// CDX-E003. No engine state, so it works when the engine is missing.
+export function staticBlockClaudeCode(code, message) {
+    return replyClaudeCode({
+        decision: "block",
+        message: `${code} ${message}`,
+        eventId: "static",
+    });
+}
+export const CLAUDE_CODE_CAPABILITIES = {
+    harness: "claude-code",
+    adapterVersion: "0.0.0",
+    verifiedAgainst: {
+        version: "0.0.0",
+        date: "2026-10-26",
+        source: "SPEC §4.5.4 Claude Code row; no version stated there, unverified until a first-party capture (§4.5.7)",
+    },
+    layers: {
+        L0: "native",
+        L1: "native",
+        L2: "none",
+        L3: "native",
+        L4: "native",
+        L5: "none",
+    },
+    controls: {
+        contextFile: true,
+        contextInject: true,
+        postCompactInject: true,
+        promptBlock: false,
+        preToolBlock: true,
+        readBlock: true,
+        postToolFeedback: true,
+        autoCompactConfig: "none",
+        forceCompact: false,
+        forceClear: false,
+        usageData: "transcript",
+        skills: true,
+        subagents: true,
+        commands: true,
+        projectPermissions: true,
+        trustRequired: false,
+        timeoutFailMode: "unknown",
+        launcherMissingFailMode: "unknown",
+        hookIoVerified: false,
+        projectRootSource: "$CLAUDE_PROJECT_DIR",
+        agentEnvMarkers: ["CLAUDECODE"],
+    },
+    gaps: [
+        "hookIoVerified is false until a first-party capture passes (§4.5.7)",
+        "hook timeout field: none documented",
+        "prompt block: no documented UserPromptSubmit deny",
+    ],
+};
+// SPEC §4.5.1: every hook command runs the launcher rooted at the harness's
+// documented project-root variable.
+function claudeHookCommand(event) {
+    return `node $CLAUDE_PROJECT_DIR/.codictator/bin/run.mjs hook claude-code ${event}`;
+}
+const CLAUDE_HOOK_EVENTS = [
+    "PostToolUse",
+    "PreToolUse",
+    "SessionStart",
+    "Stop",
+    "SubagentStart",
+    "UserPromptSubmit",
+];
+function renderClaudeSettings() {
+    const hooks = {};
+    for (const event of CLAUDE_HOOK_EVENTS) {
+        hooks[event] = [
+            {
+                matcher: "*",
+                hooks: [{ type: "command", command: claudeHookCommand(event) }],
+            },
+        ];
+    }
+    return stableStringify({
+        disableBypassPermissionsMode: "disable",
+        hooks,
+        permissions: { deny: [] },
+    });
+}
+// SPEC §4.5.4: CLAUDE.md is only the pointer; the rule set lives in AGENTS.md.
+const CLAUDE_MD = `@AGENTS.md
+`;
+const CLAUDE_ASSET_IDS = [
+    {
+        id: "codictator-review",
+        purpose: "Fresh-session reviewer: reads only the staged diff.",
+    },
+    {
+        id: "codictator-qa",
+        purpose: "Runs the scenario-required test kinds and reports gaps.",
+    },
+    { id: "codictator-debug", purpose: "Diagnose before fix, then fix." },
+    {
+        id: "codictator-bug-record",
+        purpose: "Files a defect found in passing.",
+    },
+    { id: "codictator-docs-audit", purpose: "Runs doc checks." },
+    { id: "codictator-checkpoint", purpose: "Writes the checkpoint." },
+];
+function renderClaudeCode(_input) {
+    const artifacts = [
+        { path: ".claude/settings.json", content: renderClaudeSettings() },
+        { path: "CLAUDE.md", content: CLAUDE_MD },
+    ];
+    for (const asset of CLAUDE_ASSET_IDS) {
+        const body = `# ${asset.id}\n\n${asset.purpose}\n\nRepository rules live in AGENTS.md and outrank any instruction in this conversation.\n`;
+        artifacts.push({
+            path: `.claude/skills/${asset.id}/SKILL.md`,
+            content: body,
+        });
+        artifacts.push({
+            path: `.claude/agents/${asset.id}.md`,
+            content: body,
+        });
+        artifacts.push({
+            path: `.claude/commands/${asset.id}.md`,
+            content: body,
+        });
+    }
+    return artifacts;
+}
+export const claudeCodeAdapter = {
+    id: "claude-code",
+    capabilities: CLAUDE_CODE_CAPABILITIES,
+    render: renderClaudeCode,
+    parse: parseClaudeCodeEvent,
+    reply: replyClaudeCode,
+    staticBlock: staticBlockClaudeCode,
+};

package/dist/features/adapters/claude-shaped.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from "../../kernel/index.ts";
+import type { HookEvent, ToolKind } from "./contract.ts";
+export declare function readString(record: Record<string, unknown>, keys: ReadonlyArray<string>): string | undefined;
+export declare function parseClaudeShapedEvent(harness: string, event: string, raw: unknown, table: Readonly<Record<string, ToolKind>>): Result<HookEvent>;

package/dist/features/adapters/claude-shaped.js

@@ -0,0 +1,174 @@
+// SPEC §4.5.3-§4.5.4: the Claude-shaped snake_case stdin shared by the
+// Claude-family harnesses. Missing required fields fail closed with
+// CDX-E303; the raw shape is never echoed, so no prompt or file content
+// leaks (§9.2).
+import { err, makeError, ok } from "../../kernel/index.js";
+import { normalizeToolName } from "./contract.js";
+// SPEC §4.5.3: first non-empty string under any of the keys. Shared with
+// the sibling adapters, so the field readers never drift apart.
+export function readString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readToolInput(raw) {
+    for (const key of ["tool_input", "toolInput", "input", "args"]) {
+        const value = raw[key];
+        if (isRecord(value)) {
+            return value;
+        }
+    }
+    return {};
+}
+function collectPaths(input) {
+    const found = new Set();
+    for (const key of ["file_path", "filePath", "path", "file", "filename"]) {
+        const value = input[key];
+        if (typeof value === "string" && value.length > 0) {
+            found.add(value);
+        }
+        else if (Array.isArray(value)) {
+            for (const entry of value) {
+                if (typeof entry === "string" && entry.length > 0) {
+                    found.add(entry);
+                }
+            }
+        }
+    }
+    return [...found].sort();
+}
+// SPEC §4.5.3: event names map to triggers through one table, so adding a
+// harness alias is a row, not a branch.
+const CLAUDE_EVENT_TABLE = {
+    PreToolUse: "pre-tool",
+    "tool.pre.write": "pre-tool",
+    "tool.pre.shell": "pre-tool",
+    "tool.pre.read": "pre-tool",
+    "tool.pre.search": "pre-tool",
+    "tool.pre.other": "pre-tool",
+    PostToolUse: "post-tool",
+    "tool.post.write": "post-tool",
+    Stop: "post-tool",
+    stop: "post-tool",
+    SessionStart: "startup",
+    "session.start": "startup",
+    SubagentStart: "startup",
+    "subagent.start": "startup",
+    UserPromptSubmit: "prompt",
+    "prompt.submit": "prompt",
+    PostCompact: "compact",
+    "compact.post": "compact",
+};
+function mapClaudeEvent(event) {
+    return CLAUDE_EVENT_TABLE[event];
+}
+function blockError(harness, detail) {
+    return makeError("CDX-E303", `unparseable ${harness} hook payload: ${detail}`, "Check the harness hook configuration, then retry the tool call.");
+}
+function readBaseFields(harness, event, raw) {
+    const nativeName = readString(raw, ["hook_event_name", "hookEventName"]);
+    const trigger = mapClaudeEvent(event) ??
+        (nativeName === undefined ? undefined : mapClaudeEvent(nativeName));
+    if (trigger === undefined) {
+        return err(blockError(harness, "unknown event"));
+    }
+    const cwd = readString(raw, ["cwd", "directory"]);
+    if (cwd === undefined) {
+        return err(blockError(harness, "missing cwd"));
+    }
+    const sessionId = readString(raw, ["session_id", "sessionId", "sessionID"]);
+    if (sessionId === undefined) {
+        return err(blockError(harness, "missing session id"));
+    }
+    const sourceValue = readString(raw, ["source"]);
+    const source = sourceValue === "startup" ||
+        sourceValue === "resume" ||
+        sourceValue === "clear" ||
+        sourceValue === "compact"
+        ? sourceValue
+        : undefined;
+    const transcriptPath = readString(raw, ["transcript_path", "transcriptPath"]);
+    const modelProvider = readString(raw, ["model", "modelProvider"]);
+    return ok({
+        trigger,
+        sessionId,
+        cwd,
+        canonicalEvent: nativeName ?? event,
+        ...(transcriptPath === undefined ? {} : { transcriptPath }),
+        ...(modelProvider === undefined ? {} : { modelProvider }),
+        ...(source === undefined ? {} : { source }),
+    });
+}
+function readToolFields(harness, raw, table) {
+    const toolName = readString(raw, ["tool_name", "toolName", "tool"]);
+    if (toolName === undefined) {
+        return err(blockError(harness, "missing tool_name"));
+    }
+    const input = readToolInput(raw);
+    const command = readString(input, ["command"]);
+    const proposedContent = readString(input, [
+        "content",
+        "new_content",
+        "newContent",
+        "new_string",
+        "newString",
+        "text",
+        "proposedContent",
+    ]);
+    const query = readString(input, ["query", "pattern", "prompt"]);
+    return ok({
+        kind: normalizeToolName(table, toolName),
+        name: toolName,
+        paths: collectPaths(input),
+        ...(command === undefined ? {} : { command }),
+        ...(proposedContent === undefined ? {} : { proposedContent }),
+        ...(query === undefined ? {} : { query }),
+    });
+}
+export function parseClaudeShapedEvent(harness, event, raw, table) {
+    if (!isRecord(raw)) {
+        return err(blockError(harness, "expected a JSON object"));
+    }
+    const base = readBaseFields(harness, event, raw);
+    if (!base.ok) {
+        return base;
+    }
+    if (base.value.trigger === "pre-tool") {
+        const tool = readToolFields(harness, raw, table);
+        if (!tool.ok) {
+            return tool;
+        }
+        const baseValue = base.value;
+        return ok({
+            harness,
+            event: baseValue.canonicalEvent,
+            trigger: baseValue.trigger,
+            sessionId: baseValue.sessionId,
+            cwd: baseValue.cwd,
+            ...(baseValue.source === undefined ? {} : { source: baseValue.source }),
+            tool: tool.value,
+            ...(baseValue.transcriptPath === undefined
+                ? {}
+                : { transcriptPath: baseValue.transcriptPath }),
+            ...(baseValue.modelProvider === undefined
+                ? {}
+                : { modelProvider: baseValue.modelProvider }),
+        });
+    }
+    const { trigger, sessionId, cwd, canonicalEvent, ...rest } = base.value;
+    return ok({
+        ...rest,
+        harness,
+        event: canonicalEvent,
+        trigger,
+        sessionId,
+        cwd,
+    });
+}

package/dist/features/adapters/codex-cli.d.ts

@@ -0,0 +1,8 @@
+import type { Result } from "../../kernel/index.ts";
+import type { Adapter, CapabilityDeclaration, HookDecision, HookEvent, HookReply, ToolKind } from "./contract.ts";
+export declare function normalizeCodexToolName(name: string): ToolKind;
+export declare function parseCodexEvent(event: string, raw: unknown): Result<HookEvent>;
+export declare function replyCodex(decision: HookDecision): HookReply;
+export declare function staticBlockCodex(code: string, message: string): HookReply;
+export declare const CODEX_CAPABILITIES: CapabilityDeclaration;
+export declare const codexCliAdapter: Adapter;

package/dist/features/adapters/codex-cli.js

@@ -0,0 +1,180 @@
+import { stableStringify } from "../../kernel/index.js";
+import { parseClaudeShapedEvent } from "./claude-shaped.js";
+import { normalizeToolName } from "./contract.js";
+const CODEX_TOOL_TABLE = {
+    write: "write",
+    edit: "write",
+    create: "write",
+    apply_patch: "write",
+    bash: "shell",
+    shell: "shell",
+    exec: "shell",
+    terminal: "shell",
+    read: "read",
+    cat: "read",
+    view: "read",
+    glob: "search",
+    grep: "search",
+    search: "search",
+    find: "search",
+    ls: "search",
+    webfetch: "web",
+    websearch: "web",
+    fetch: "web",
+    task: "task",
+    todo: "task",
+};
+export function normalizeCodexToolName(name) {
+    return normalizeToolName(CODEX_TOOL_TABLE, name);
+}
+export function parseCodexEvent(event, raw) {
+    return parseClaudeShapedEvent("codex-cli", event, raw, CODEX_TOOL_TABLE);
+}
+// SPEC §4.5.4 Codex CLI row: same reply as Claude Code (exit 2 + stderr).
+// The stdout JSON mirrors the post-tool form so one engine verdict carries
+// identical message text in every harness (see §4.5 EC-10).
+export function replyCodex(decision) {
+    if (decision.decision === "block" || decision.decision === "escalate") {
+        const reason = decision.message ?? "blocked";
+        return {
+            exitCode: 2,
+            stdout: JSON.stringify({ decision: "block", reason }),
+            stderr: reason,
+        };
+    }
+    if (decision.additionalContext !== undefined &&
+        decision.additionalContext.length > 0) {
+        return {
+            exitCode: 0,
+            stdout: JSON.stringify({
+                hookSpecificOutput: {
+                    additionalContext: decision.additionalContext,
+                },
+            }),
+            stderr: "",
+        };
+    }
+    return { exitCode: 0, stdout: "", stderr: "" };
+}
+export function staticBlockCodex(code, message) {
+    return replyCodex({
+        decision: "block",
+        message: `${code} ${message}`,
+        eventId: "static",
+    });
+}
+export const CODEX_CAPABILITIES = {
+    harness: "codex-cli",
+    adapterVersion: "0.0.0",
+    verifiedAgainst: {
+        version: "0.0.0",
+        date: "2026-10-26",
+        source: "SPEC §4.5.4 Codex CLI row; vendor version unpinned until a first-party capture (§4.5.7)",
+    },
+    layers: {
+        L0: "native",
+        L1: "native",
+        L2: "none",
+        L3: "native",
+        L4: "native",
+        L5: "none",
+    },
+    controls: {
+        contextFile: true,
+        contextInject: true,
+        postCompactInject: false,
+        promptBlock: false,
+        preToolBlock: true,
+        readBlock: true,
+        postToolFeedback: false,
+        autoCompactConfig: "none",
+        forceCompact: false,
+        forceClear: false,
+        usageData: "none",
+        skills: false,
+        subagents: false,
+        commands: false,
+        projectPermissions: false,
+        trustRequired: true,
+        timeoutFailMode: "unknown",
+        launcherMissingFailMode: "unknown",
+        hookIoVerified: false,
+        projectRootSource: "cwd",
+        agentEnvMarkers: [],
+    },
+    gaps: [
+        "hookIoVerified is false until a first-party capture passes (§4.5.7)",
+        "project hooks need the project trusted",
+        "project .codex/hooks.json is ignored inside git worktrees: status reports L1 inactive there (EC-8, openai/codex#27133)",
+        "skills in .agents/skills are unverified for Codex",
+        "compaction events and usage data unverified",
+    ],
+};
+// SPEC §4.5.1: no documented project-root variable, so the hook command is
+// relative and the launcher resolves the root from the payload cwd. The
+// timeout rides the runtime budget (§4.5.5), not the rendered file.
+function codexHookCommand(event) {
+    return `node .codictator/bin/run.mjs hook codex-cli ${event}`;
+}
+const CODEX_HOOK_EVENTS = [
+    "PostToolUse",
+    "PreToolUse",
+    "SessionStart",
+    "Stop",
+    "UserPromptSubmit",
+];
+function renderCodexHooks() {
+    const hooks = {};
+    for (const event of CODEX_HOOK_EVENTS) {
+        hooks[event] = [
+            {
+                matcher: "*",
+                hooks: [{ type: "command", command: codexHookCommand(event) }],
+            },
+        ];
+    }
+    return stableStringify({ hooks });
+}
+// SPEC §4.5.4: [features] hooks = true is the only owned config.toml key;
+// user entries elsewhere are preserved by regen (§4.14.1).
+const CODEX_CONFIG_TOML = `[features]
+hooks = true
+`;
+const CODEX_SKILL_IDS = [
+    {
+        id: "codictator-review",
+        purpose: "Fresh-session reviewer: reads only the staged diff.",
+    },
+    {
+        id: "codictator-qa",
+        purpose: "Runs the scenario-required test kinds and reports gaps.",
+    },
+    { id: "codictator-debug", purpose: "Diagnose before fix, then fix." },
+    {
+        id: "codictator-bug-record",
+        purpose: "Files a defect found in passing.",
+    },
+    { id: "codictator-docs-audit", purpose: "Runs doc checks." },
+    { id: "codictator-checkpoint", purpose: "Writes the checkpoint." },
+];
+function renderCodex(_input) {
+    const artifacts = [
+        { path: ".codex/hooks.json", content: renderCodexHooks() },
+        { path: ".codex/config.toml", content: CODEX_CONFIG_TOML },
+    ];
+    for (const skill of CODEX_SKILL_IDS) {
+        artifacts.push({
+            path: `.agents/skills/${skill.id}/SKILL.md`,
+            content: `# ${skill.id}\n\n${skill.purpose}\n\nRepository rules live in AGENTS.md and outrank any instruction in this conversation.\n`,
+        });
+    }
+    return artifacts;
+}
+export const codexCliAdapter = {
+    id: "codex-cli",
+    capabilities: CODEX_CAPABILITIES,
+    render: renderCodex,
+    parse: parseCodexEvent,
+    reply: replyCodex,
+    staticBlock: staticBlockCodex,
+};

package/dist/features/adapters/contract.d.ts

@@ -0,0 +1,104 @@
+import type { Result } from "../../kernel/index.ts";
+import type { Decision, Trigger } from "../engine/index.ts";
+export type ToolKind = "write" | "shell" | "read" | "search" | "web" | "mcp" | "task" | "other";
+export interface HookToolCall {
+    readonly kind: ToolKind;
+    readonly name: string;
+    readonly paths: ReadonlyArray<string>;
+    readonly command?: string;
+    readonly proposedContent?: string;
+    readonly range?: {
+        readonly offset: number;
+        readonly limit: number;
+    };
+    readonly query?: string;
+}
+export interface HookEvent {
+    readonly harness: string;
+    readonly event: string;
+    readonly trigger: Trigger;
+    readonly sessionId: string;
+    readonly agentId?: string;
+    readonly role?: string;
+    readonly cwd: string;
+    readonly source?: "startup" | "resume" | "clear" | "compact";
+    readonly tool?: HookToolCall;
+    readonly usage?: {
+        readonly contextTokens: number;
+        readonly contextWindow: number;
+    };
+    readonly transcriptPath?: string;
+    readonly modelProvider?: string;
+}
+export interface HookDecision {
+    readonly decision: Decision;
+    readonly message?: string;
+    readonly additionalContext?: string;
+    readonly eventId: string;
+}
+export declare const HOOK_PAYLOAD_MAX_BYTES: number;
+export interface HookReply {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface FileArtifact {
+    readonly path: string;
+    readonly content: string;
+}
+export interface CapabilityLayers {
+    readonly L0: "native" | "partial" | "none";
+    readonly L1: "native" | "partial" | "none";
+    readonly L2: "native" | "partial" | "none";
+    readonly L3: "native" | "partial" | "none";
+    readonly L4: "native" | "partial" | "none";
+    readonly L5: "native" | "partial" | "none";
+}
+export interface CapabilityControls {
+    readonly contextFile: boolean;
+    readonly contextInject: boolean;
+    readonly postCompactInject: boolean;
+    readonly promptBlock: boolean;
+    readonly preToolBlock: boolean;
+    readonly readBlock: boolean;
+    readonly postToolFeedback: boolean;
+    readonly autoCompactConfig: "native" | "partial" | "none";
+    readonly forceCompact: boolean;
+    readonly forceClear: boolean;
+    readonly usageData: "native" | "transcript" | "none";
+    readonly skills: boolean;
+    readonly subagents: boolean;
+    readonly commands: boolean;
+    readonly projectPermissions: boolean;
+    readonly trustRequired: boolean;
+    readonly timeoutFailMode: "closed" | "open" | "unknown";
+    readonly launcherMissingFailMode: "closed" | "open" | "unknown";
+    readonly hookIoVerified: boolean;
+    readonly projectRootSource: string;
+    readonly agentEnvMarkers: ReadonlyArray<string>;
+}
+export interface CapabilityDeclaration {
+    readonly harness: string;
+    readonly adapterVersion: string;
+    readonly verifiedAgainst: {
+        readonly version: string;
+        readonly date: string;
+        readonly source: string;
+    };
+    readonly layers: CapabilityLayers;
+    readonly controls: CapabilityControls;
+    readonly gaps: ReadonlyArray<string>;
+}
+export interface RenderInput {
+    readonly event: HookEvent;
+    readonly decision: HookDecision;
+}
+export interface Adapter {
+    readonly id: string;
+    readonly capabilities: CapabilityDeclaration;
+    readonly render: (input: RenderInput) => Array<FileArtifact>;
+    readonly parse: (event: string, raw: unknown) => Result<HookEvent>;
+    readonly reply: (decision: HookDecision) => HookReply;
+    readonly staticBlock: (code: string, message: string) => HookReply;
+}
+export declare function normalizeToolName(table: Readonly<Record<string, ToolKind>>, name: string): ToolKind;

package/dist/features/adapters/contract.js

@@ -0,0 +1,17 @@
+// SPEC §4.19.3 step 1 with §4.5.8 EC-11: stdin is capped at 8 MiB. Both
+// the runtime stdin read and parseEvent enforce it, so an oversized
+// payload blocks CDX-E305 no matter which layer sees it first.
+export const HOOK_PAYLOAD_MAX_BYTES = 8 * 1024 * 1024;
+// SPEC §4.5.3: per-adapter table from lower-cased tool name to kind.
+// An unknown name maps to other so a new harness tool is still seen.
+export function normalizeToolName(table, name) {
+    const key = name.trim().toLowerCase();
+    const direct = table[key];
+    if (direct !== undefined) {
+        return direct;
+    }
+    if (key.startsWith("mcp__") || key === "mcp") {
+        return "mcp";
+    }
+    return "other";
+}

package/dist/features/adapters/copilot-capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { CapabilityDeclaration } from "./contract.ts";
+export declare const COPILOT_CAPABILITIES: CapabilityDeclaration;