@smeltjs/core 0.2.0 → 0.3.0

package/dist/harness/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../src/harness/paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAIzC;;;GAGG;AAEH;;;;;;;GAOG;AACH,SAAS,cAAc;IACrB,MAAM,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,2BAA2B;IACjF,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,OAA8B;IAC3D,OAAO,IAAI,CAAC,cAAc,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;AACtE,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,mBAAmB;IACjC,OAAO,IAAI,CAAC,cAAc,EAAE,EAAE,OAAO,EAAE,eAAe,CAAC,CAAC;AAC1D,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,YAAY;IAC1B,OAAO,IAAI,CAAC,cAAc,EAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;AACjD,CAAC;AAED,4FAA4F;AAC5F,MAAM,UAAU,YAAY,CAAC,GAAW,EAAE,QAAgB;IACxD,MAAM,GAAG,GAAG,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IACpC,OAAO,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACvF,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,WAAW,CAAC,GAAW,EAAE,MAAc,EAAE,IAAI,GAAG,EAAE;IAChE,OAAO,SAAS,YAAY,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC;AAC/E,CAAC","sourcesContent":["import { dirname, isAbsolute, join, relative, sep } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nimport type { ShimmedHarnessProfile } from './profile.ts';\n\n/**\n * Where the scripts a harness config points at actually live, and how a profile names\n * one. Path facts only — nothing here reads or writes a file.\n */\n\n/**\n * The `dist` directory of this installed package — where the shipped guard core and\n * shim scripts live. Computed from this module's own location, which is\n * `<pkg>/dist/harness/` in every real run (the CLI executes from `dist`); under the\n * test runner it is `<pkg>/src/harness/`, and the substitution still points at `dist`,\n * which is where the scripts will exist once built — the paths are written into config\n * files for *node* to execute, never imported.\n */\nfunction packageDistDir(): string {\n  const here = dirname(fileURLToPath(import.meta.url)); // <pkg>/(dist|src)/harness\n  return join(dirname(dirname(here)), 'dist');\n}\n\n/**\n * The shim script a harness's hook command runs. Takes a profile rather than an id,\n * because only a profile that carries a hook schema (or a hand-written adapter) has a\n * shim script on disk: a path for a harness that ships none would name a file the\n * build never produced.\n */\nexport function shimScriptPath(profile: ShimmedHarnessProfile): string {\n  return join(packageDistDir(), 'hooks', 'shims', `${profile.id}.js`);\n}\n\n/** The guard core as a module: what the opencode plugin imports at hook time. */\nexport function guardCoreScriptPath(): string {\n  return join(packageDistDir(), 'hooks', 'guard-core.js');\n}\n\n/** The `smelt` binary — quoted into the stats and map hook commands. */\nexport function smeltBinPath(): string {\n  return join(packageDistDir(), 'cli', 'bin.js');\n}\n\n/** Inside the project, a project-relative path travels with the repo; outside, absolute. */\nexport function portablePath(cwd: string, absolute: string): string {\n  const rel = relative(cwd, absolute);\n  return rel.startsWith('..') || isAbsolute(rel) ? absolute : rel.split(sep).join('/');\n}\n\n/** `node \"<script>\"` — how every harness config invokes something of smelt's. */\nexport function nodeCommand(cwd: string, script: string, args = ''): string {\n  return `node \"${portablePath(cwd, script)}\"${args === '' ? '' : ` ${args}`}`;\n}\n"]}

package/dist/harness/profile.d.ts

@@ -0,0 +1,184 @@
+import type { HarnessHookSchema, ShimAdapter } from '../hooks/shim.ts';
+/**
+ * Everything smelt knows about one agent harness, in one place.
+ *
+ * Before this module existed, a harness's facts lived at seven edit sites: the
+ * `HarnessId` union, the `HARNESSES` array, a shim file, a case in `planInstall`, a
+ * case in `planRemove`, `MANAGED_EVENTS`, a test fixture — plus a hand-typed id list
+ * in the `--harness` help text, which could not be derived because the registry lived
+ * in `cli/hooks.ts` and `cli/hooks.ts` imports `CLI_NAME` from `cli/args.ts`. The
+ * registry was in the wrong module, and the cycle was the proof.
+ *
+ * A `HarnessProfile` is the single adapter carrying every per-harness fact, and the
+ * registry (`registry.ts`) is `Record<HarnessId, HarnessProfile>` so totality stays a
+ * compile error: a new `HarnessId` without a profile does not build. It imports
+ * nothing from `cli/`, so `cli/args.ts` derives the `--harness` list and every other
+ * rendered view is derived too — the managed event names, the files a re-run reads its
+ * toggles back from, the id list in an error message.
+ *
+ * Installing and removing are **data**, not switch statements: `install` is the list
+ * of artefacts `smelt hooks install` writes for this harness, and each artefact's kind
+ * is also how `smelt hooks remove` takes it back out — a JSON hook file is merged and
+ * strip-merged, a marker block is upserted and stripped, a file that is entirely ours
+ * is written and deleted. `planInstall`/`planRemove` fold over the list.
+ *
+ * The optional sections state capability, never invent it: a harness ships a shim
+ * exactly when it carries a {@link hooks} schema (or, for a harness a table cannot
+ * express, a hand-written {@link shim}), and only such a profile has a shim script
+ * path. What a profile does not claim, the installer does not write.
+ */
+export interface HarnessProfile {
+    readonly id: HarnessId;
+    /** The harness's own name, as its makers spell it. Shown wherever a tier is. */
+    readonly name: string;
+    readonly tier: HarnessTier;
+    /** Paths (relative to the project) whose existence means "this harness is in use here". */
+    readonly detect: readonly string[];
+    /** Paths relative to the user's home directory — "installed on this machine". */
+    readonly detectHome: readonly string[];
+    /** The standing-instructions file this harness reads (capability matrix column d). */
+    readonly instructionFile: string;
+    /**
+     * The standing-instructions layer — belt and braces under every shim, and the *only*
+     * layer an advisory harness has:
+     *
+     *  - `'snippet'`: upsert the shared marker-bracketed block into
+     *    {@link instructionFile} (a file several harnesses read, like `AGENTS.md`, is
+     *    planned once); `remove` strips the block and leaves every other byte.
+     *  - a renderer: a whole file this harness owns, snippet included — KiloCode's rules
+     *    file carries two manual enforcement legs the shared snippet has no room for;
+     *    `remove` deletes it.
+     */
+    readonly instructions: 'snippet' | HarnessFileContent;
+    /** Caveats carried from the capability matrix, shown at install time. */
+    readonly caveats: readonly string[];
+    /**
+     * Everything else `hooks install` writes for this harness, in the order it is
+     * written and listed. Empty means instructions only: the advisory tier, where
+     * nothing enforces anything and the output says so.
+     */
+    readonly install: readonly HarnessInstallStep[];
+    /**
+     * This harness's native pre-tool hook schema, as data. Present exactly when the
+     * harness ships a shim script (`dist/hooks/shims/<id>.js`) — absent for the advisory
+     * tier, and for opencode, whose hook API is a JavaScript plugin rather than a stdin
+     * schema.
+     */
+    readonly hooks?: HarnessHookSchema;
+    /**
+     * The escape hatch: a hand-written adapter, for a harness whose schema a table
+     * cannot express. Wins over {@link hooks} when both are present.
+     */
+    readonly shim?: ShimAdapter;
+}
+/** How much smelt is willing to claim about a harness. */
+export type HarnessTier = 'verified' | 'experimental' | 'advisory';
+/**
+ * Every harness the preset knows. The registry is keyed by this union, so adding an id
+ * without writing its profile is a compile error — and the `--harness` help list, the
+ * wizard's table and every error message read the registry, never a second list.
+ */
+export type HarnessId = 'claude-code' | 'codex' | 'gemini' | 'grok' | 'hermes' | 'cursor' | 'opencode' | 'cline' | 'kilocode' | 'aider';
+/** One line of honesty per tier, shown wherever a tier label appears. */
+export declare const TIER_HONESTY: Record<HarnessTier, string>;
+/**
+ * What the wizard settled on, as the installer's renderers see it: the toggles, the
+ * guard's settings, and the project directory every path is relative to. A renderer
+ * takes this and returns bytes; nothing writes.
+ */
+export interface HarnessInstallContext {
+    /** Project directory: every path a renderer emits is portable relative to it. */
+    readonly cwd: string;
+    readonly guard: boolean;
+    readonly statsOnStop: boolean;
+    readonly mapOnStart: boolean;
+    readonly thresholdBytes: number;
+    /** The `--budget` every suggested command and the snippet quote. */
+    readonly budgetBytes: number;
+}
+/** A file's bytes, rendered from the wizard's choices. */
+export type HarnessFileContent = (ctx: HarnessInstallContext) => string;
+/**
+ * One artefact `hooks install` writes. The kind is also the un-write: `json-hooks` is
+ * merged in and strip-merged out, `marker-block` is upserted and stripped,
+ * `own-file` is written and deleted.
+ */
+export type HarnessInstallStep = HarnessJsonHooks | HarnessMarkerBlock | HarnessOwnFile;
+/**
+ * A JSON settings/hooks file the harness reads. Our entries are merged in
+ * byte-faithfully and, on `remove`, stripped back out with everything foreign left
+ * exactly as it was.
+ */
+export interface HarnessJsonHooks {
+    readonly kind: 'json-hooks';
+    /** Project-relative path of the file. */
+    readonly file: string;
+    /** The pre-tool event, in this harness's spelling (`PreToolUse`, `BeforeTool`, …). */
+    readonly event: string;
+    /**
+     * One hook entry per matcher — the tool names the guard wants to see. `undefined`
+     * is a matcher-less entry, for a harness whose hook fires on every tool.
+     */
+    readonly matchers: readonly (string | undefined)[];
+    /**
+     * The entry shape: `'command-list'` is Claude Code's `{matcher, hooks:[{type,
+     * command}]}`, which Codex, Gemini and Grok mirror; `'bare-command'` is Cursor's
+     * `{command}`.
+     */
+    readonly entry: 'command-list' | 'bare-command';
+    /**
+     * True for a harness whose schema also carries the session-lifecycle events this
+     * preset offers — `smelt stats` on Stop, `smelt map` on SessionStart. The other
+     * harnesses wire the guard only, and the wizard's toggles say so.
+     */
+    readonly lifecycle: boolean;
+    /** Top-level keys a *fresh* file must carry (Cursor's `version: 1`). */
+    readonly shape?: {
+        readonly version: number;
+    };
+}
+/** A marker-bracketed block inside a file smelt shares with its owner. */
+export interface HarnessMarkerBlock {
+    readonly kind: 'marker-block';
+    readonly file: string;
+    readonly block: HarnessFileContent;
+    /** The marker line opening the block — also how `remove` finds it. */
+    readonly start: string;
+    readonly end: string;
+    /**
+     * Refuse the file instead of editing it when it already carries `contains` and none
+     * of ours: Codex's `config.toml` may have a hand-written `[features]` table, and an
+     * installer that merged into it would be editing what it was never asked to.
+     */
+    readonly skipWhen?: {
+        readonly contains: string;
+        readonly why: string;
+    };
+}
+/** A file that is entirely smelt's: written whole, deleted whole. */
+export interface HarnessOwnFile {
+    readonly kind: 'own-file';
+    readonly file: string;
+    readonly content: HarnessFileContent;
+    /** chmod after writing (Cline's hook must be executable). */
+    readonly mode?: number;
+    /** True when the file exists only to wire the guard — the guard toggle gates it. */
+    readonly guardOnly: boolean;
+}
+/**
+ * A profile that ships a shim script. Only these have a shim path: `shimScriptPath`
+ * takes one, so a harness with no shim cannot name a script that was never built.
+ */
+export type ShimmedHarnessProfile = HarnessProfile & ({
+    readonly hooks: HarnessHookSchema;
+} | {
+    readonly shim: ShimAdapter;
+});
+/** True for a profile that ships a shim script — the narrowing `shimScriptPath` needs. */
+export declare function hasShim(profile: HarnessProfile): profile is ShimmedHarnessProfile;
+/**
+ * The adapter this profile's shim script runs: the one its {@link HarnessProfile.hooks}
+ * schema describes, or the hand-written escape hatch where it carries one.
+ */
+export declare function shimAdapterOf(profile: ShimmedHarnessProfile): ShimAdapter;
+//# sourceMappingURL=profile.d.ts.map

package/dist/harness/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/harness/profile.ts"],"names":[],"mappings":"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","sourcesContent":["import { shimFromSchema } from '../hooks/shim.ts';\nimport type { HarnessHookSchema, ShimAdapter } from '../hooks/shim.ts';\n\n/**\n * Everything smelt knows about one agent harness, in one place.\n *\n * Before this module existed, a harness's facts lived at seven edit sites: the\n * `HarnessId` union, the `HARNESSES` array, a shim file, a case in `planInstall`, a\n * case in `planRemove`, `MANAGED_EVENTS`, a test fixture — plus a hand-typed id list\n * in the `--harness` help text, which could not be derived because the registry lived\n * in `cli/hooks.ts` and `cli/hooks.ts` imports `CLI_NAME` from `cli/args.ts`. The\n * registry was in the wrong module, and the cycle was the proof.\n *\n * A `HarnessProfile` is the single adapter carrying every per-harness fact, and the\n * registry (`registry.ts`) is `Record<HarnessId, HarnessProfile>` so totality stays a\n * compile error: a new `HarnessId` without a profile does not build. It imports\n * nothing from `cli/`, so `cli/args.ts` derives the `--harness` list and every other\n * rendered view is derived too — the managed event names, the files a re-run reads its\n * toggles back from, the id list in an error message.\n *\n * Installing and removing are **data**, not switch statements: `install` is the list\n * of artefacts `smelt hooks install` writes for this harness, and each artefact's kind\n * is also how `smelt hooks remove` takes it back out — a JSON hook file is merged and\n * strip-merged, a marker block is upserted and stripped, a file that is entirely ours\n * is written and deleted. `planInstall`/`planRemove` fold over the list.\n *\n * The optional sections state capability, never invent it: a harness ships a shim\n * exactly when it carries a {@link hooks} schema (or, for a harness a table cannot\n * express, a hand-written {@link shim}), and only such a profile has a shim script\n * path. What a profile does not claim, the installer does not write.\n */\nexport interface HarnessProfile {\n  readonly id: HarnessId;\n  /** The harness's own name, as its makers spell it. Shown wherever a tier is. */\n  readonly name: string;\n  readonly tier: HarnessTier;\n  /** Paths (relative to the project) whose existence means \"this harness is in use here\". */\n  readonly detect: readonly string[];\n  /** Paths relative to the user's home directory — \"installed on this machine\". */\n  readonly detectHome: readonly string[];\n  /** The standing-instructions file this harness reads (capability matrix column d). */\n  readonly instructionFile: string;\n  /**\n   * The standing-instructions layer — belt and braces under every shim, and the *only*\n   * layer an advisory harness has:\n   *\n   *  - `'snippet'`: upsert the shared marker-bracketed block into\n   *    {@link instructionFile} (a file several harnesses read, like `AGENTS.md`, is\n   *    planned once); `remove` strips the block and leaves every other byte.\n   *  - a renderer: a whole file this harness owns, snippet included — KiloCode's rules\n   *    file carries two manual enforcement legs the shared snippet has no room for;\n   *    `remove` deletes it.\n   */\n  readonly instructions: 'snippet' | HarnessFileContent;\n  /** Caveats carried from the capability matrix, shown at install time. */\n  readonly caveats: readonly string[];\n  /**\n   * Everything else `hooks install` writes for this harness, in the order it is\n   * written and listed. Empty means instructions only: the advisory tier, where\n   * nothing enforces anything and the output says so.\n   */\n  readonly install: readonly HarnessInstallStep[];\n  /**\n   * This harness's native pre-tool hook schema, as data. Present exactly when the\n   * harness ships a shim script (`dist/hooks/shims/<id>.js`) — absent for the advisory\n   * tier, and for opencode, whose hook API is a JavaScript plugin rather than a stdin\n   * schema.\n   */\n  readonly hooks?: HarnessHookSchema;\n  /**\n   * The escape hatch: a hand-written adapter, for a harness whose schema a table\n   * cannot express. Wins over {@link hooks} when both are present.\n   */\n  readonly shim?: ShimAdapter;\n}\n\n/** How much smelt is willing to claim about a harness. */\nexport type HarnessTier = 'verified' | 'experimental' | 'advisory';\n\n/**\n * Every harness the preset knows. The registry is keyed by this union, so adding an id\n * without writing its profile is a compile error — and the `--harness` help list, the\n * wizard's table and every error message read the registry, never a second list.\n */\nexport type HarnessId =\n  | 'claude-code'\n  | 'codex'\n  | 'gemini'\n  | 'grok'\n  | 'hermes'\n  | 'cursor'\n  | 'opencode'\n  | 'cline'\n  | 'kilocode'\n  | 'aider';\n\n/** One line of honesty per tier, shown wherever a tier label appears. */\nexport const TIER_HONESTY: Record<HarnessTier, string> = {\n  verified: 'schema verified against primary docs and pinned by fixtures',\n  experimental:\n    'schema mapped from the 2026-09-02 capability matrix, not yet smoke-tested against the real binary',\n  advisory: 'no usable hook API — instructions only, nothing enforces them',\n};\n\n/**\n * What the wizard settled on, as the installer's renderers see it: the toggles, the\n * guard's settings, and the project directory every path is relative to. A renderer\n * takes this and returns bytes; nothing writes.\n */\nexport interface HarnessInstallContext {\n  /** Project directory: every path a renderer emits is portable relative to it. */\n  readonly cwd: string;\n  readonly guard: boolean;\n  readonly statsOnStop: boolean;\n  readonly mapOnStart: boolean;\n  readonly thresholdBytes: number;\n  /** The `--budget` every suggested command and the snippet quote. */\n  readonly budgetBytes: number;\n}\n\n/** A file's bytes, rendered from the wizard's choices. */\nexport type HarnessFileContent = (ctx: HarnessInstallContext) => string;\n\n/**\n * One artefact `hooks install` writes. The kind is also the un-write: `json-hooks` is\n * merged in and strip-merged out, `marker-block` is upserted and stripped,\n * `own-file` is written and deleted.\n */\nexport type HarnessInstallStep = HarnessJsonHooks | HarnessMarkerBlock | HarnessOwnFile;\n\n/**\n * A JSON settings/hooks file the harness reads. Our entries are merged in\n * byte-faithfully and, on `remove`, stripped back out with everything foreign left\n * exactly as it was.\n */\nexport interface HarnessJsonHooks {\n  readonly kind: 'json-hooks';\n  /** Project-relative path of the file. */\n  readonly file: string;\n  /** The pre-tool event, in this harness's spelling (`PreToolUse`, `BeforeTool`, …). */\n  readonly event: string;\n  /**\n   * One hook entry per matcher — the tool names the guard wants to see. `undefined`\n   * is a matcher-less entry, for a harness whose hook fires on every tool.\n   */\n  readonly matchers: readonly (string | undefined)[];\n  /**\n   * The entry shape: `'command-list'` is Claude Code's `{matcher, hooks:[{type,\n   * command}]}`, which Codex, Gemini and Grok mirror; `'bare-command'` is Cursor's\n   * `{command}`.\n   */\n  readonly entry: 'command-list' | 'bare-command';\n  /**\n   * True for a harness whose schema also carries the session-lifecycle events this\n   * preset offers — `smelt stats` on Stop, `smelt map` on SessionStart. The other\n   * harnesses wire the guard only, and the wizard's toggles say so.\n   */\n  readonly lifecycle: boolean;\n  /** Top-level keys a *fresh* file must carry (Cursor's `version: 1`). */\n  readonly shape?: { readonly version: number };\n}\n\n/** A marker-bracketed block inside a file smelt shares with its owner. */\nexport interface HarnessMarkerBlock {\n  readonly kind: 'marker-block';\n  readonly file: string;\n  readonly block: HarnessFileContent;\n  /** The marker line opening the block — also how `remove` finds it. */\n  readonly start: string;\n  readonly end: string;\n  /**\n   * Refuse the file instead of editing it when it already carries `contains` and none\n   * of ours: Codex's `config.toml` may have a hand-written `[features]` table, and an\n   * installer that merged into it would be editing what it was never asked to.\n   */\n  readonly skipWhen?: { readonly contains: string; readonly why: string };\n}\n\n/** A file that is entirely smelt's: written whole, deleted whole. */\nexport interface HarnessOwnFile {\n  readonly kind: 'own-file';\n  readonly file: string;\n  readonly content: HarnessFileContent;\n  /** chmod after writing (Cline's hook must be executable). */\n  readonly mode?: number;\n  /** True when the file exists only to wire the guard — the guard toggle gates it. */\n  readonly guardOnly: boolean;\n}\n\n/**\n * A profile that ships a shim script. Only these have a shim path: `shimScriptPath`\n * takes one, so a harness with no shim cannot name a script that was never built.\n */\nexport type ShimmedHarnessProfile = HarnessProfile &\n  ({ readonly hooks: HarnessHookSchema } | { readonly shim: ShimAdapter });\n\n/** True for a profile that ships a shim script — the narrowing `shimScriptPath` needs. */\nexport function hasShim(profile: HarnessProfile): profile is ShimmedHarnessProfile {\n  return profile.hooks !== undefined || profile.shim !== undefined;\n}\n\n/**\n * The adapter this profile's shim script runs: the one its {@link HarnessProfile.hooks}\n * schema describes, or the hand-written escape hatch where it carries one.\n */\nexport function shimAdapterOf(profile: ShimmedHarnessProfile): ShimAdapter {\n  const { hooks, shim } = profile;\n  if (shim !== undefined) return shim;\n  /* v8 ignore next 5 -- unreachable: a ShimmedHarnessProfile carries one or the other */\n  if (hooks === undefined) {\n    throw new Error(\n      `smelt: harness \"${profile.id}\" claims a shim but carries neither a hook schema nor an adapter.`,\n    );\n  }\n  return shimFromSchema(hooks);\n}\n"]}

package/dist/harness/profile.js

@@ -0,0 +1,26 @@
+import { shimFromSchema } from '../hooks/shim.js';
+/** One line of honesty per tier, shown wherever a tier label appears. */
+export const TIER_HONESTY = {
+    verified: 'schema verified against primary docs and pinned by fixtures',
+    experimental: 'schema mapped from the 2026-09-02 capability matrix, not yet smoke-tested against the real binary',
+    advisory: 'no usable hook API — instructions only, nothing enforces them',
+};
+/** True for a profile that ships a shim script — the narrowing `shimScriptPath` needs. */
+export function hasShim(profile) {
+    return profile.hooks !== undefined || profile.shim !== undefined;
+}
+/**
+ * The adapter this profile's shim script runs: the one its {@link HarnessProfile.hooks}
+ * schema describes, or the hand-written escape hatch where it carries one.
+ */
+export function shimAdapterOf(profile) {
+    const { hooks, shim } = profile;
+    if (shim !== undefined)
+        return shim;
+    /* v8 ignore next 5 -- unreachable: a ShimmedHarnessProfile carries one or the other */
+    if (hooks === undefined) {
+        throw new Error(`smelt: harness "${profile.id}" claims a shim but carries neither a hook schema nor an adapter.`);
+    }
+    return shimFromSchema(hooks);
+}
+//# sourceMappingURL=profile.js.map

package/dist/harness/profile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.js","sourceRoot":"","sources":["../../src/harness/profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAgGlD,yEAAyE;AACzE,MAAM,CAAC,MAAM,YAAY,GAAgC;IACvD,QAAQ,EAAE,6DAA6D;IACvE,YAAY,EACV,mGAAmG;IACrG,QAAQ,EAAE,+DAA+D;CAC1E,CAAC;AA8FF,0FAA0F;AAC1F,MAAM,UAAU,OAAO,CAAC,OAAuB;IAC7C,OAAO,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,CAAC;AACnE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,OAA8B;IAC1D,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC;IAChC,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACpC,uFAAuF;IACvF,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CACb,mBAAmB,OAAO,CAAC,EAAE,mEAAmE,CACjG,CAAC;IACJ,CAAC;IACD,OAAO,cAAc,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC","sourcesContent":["import { shimFromSchema } from '../hooks/shim.ts';\nimport type { HarnessHookSchema, ShimAdapter } from '../hooks/shim.ts';\n\n/**\n * Everything smelt knows about one agent harness, in one place.\n *\n * Before this module existed, a harness's facts lived at seven edit sites: the\n * `HarnessId` union, the `HARNESSES` array, a shim file, a case in `planInstall`, a\n * case in `planRemove`, `MANAGED_EVENTS`, a test fixture — plus a hand-typed id list\n * in the `--harness` help text, which could not be derived because the registry lived\n * in `cli/hooks.ts` and `cli/hooks.ts` imports `CLI_NAME` from `cli/args.ts`. The\n * registry was in the wrong module, and the cycle was the proof.\n *\n * A `HarnessProfile` is the single adapter carrying every per-harness fact, and the\n * registry (`registry.ts`) is `Record<HarnessId, HarnessProfile>` so totality stays a\n * compile error: a new `HarnessId` without a profile does not build. It imports\n * nothing from `cli/`, so `cli/args.ts` derives the `--harness` list and every other\n * rendered view is derived too — the managed event names, the files a re-run reads its\n * toggles back from, the id list in an error message.\n *\n * Installing and removing are **data**, not switch statements: `install` is the list\n * of artefacts `smelt hooks install` writes for this harness, and each artefact's kind\n * is also how `smelt hooks remove` takes it back out — a JSON hook file is merged and\n * strip-merged, a marker block is upserted and stripped, a file that is entirely ours\n * is written and deleted. `planInstall`/`planRemove` fold over the list.\n *\n * The optional sections state capability, never invent it: a harness ships a shim\n * exactly when it carries a {@link hooks} schema (or, for a harness a table cannot\n * express, a hand-written {@link shim}), and only such a profile has a shim script\n * path. What a profile does not claim, the installer does not write.\n */\nexport interface HarnessProfile {\n  readonly id: HarnessId;\n  /** The harness's own name, as its makers spell it. Shown wherever a tier is. */\n  readonly name: string;\n  readonly tier: HarnessTier;\n  /** Paths (relative to the project) whose existence means \"this harness is in use here\". */\n  readonly detect: readonly string[];\n  /** Paths relative to the user's home directory — \"installed on this machine\". */\n  readonly detectHome: readonly string[];\n  /** The standing-instructions file this harness reads (capability matrix column d). */\n  readonly instructionFile: string;\n  /**\n   * The standing-instructions layer — belt and braces under every shim, and the *only*\n   * layer an advisory harness has:\n   *\n   *  - `'snippet'`: upsert the shared marker-bracketed block into\n   *    {@link instructionFile} (a file several harnesses read, like `AGENTS.md`, is\n   *    planned once); `remove` strips the block and leaves every other byte.\n   *  - a renderer: a whole file this harness owns, snippet included — KiloCode's rules\n   *    file carries two manual enforcement legs the shared snippet has no room for;\n   *    `remove` deletes it.\n   */\n  readonly instructions: 'snippet' | HarnessFileContent;\n  /** Caveats carried from the capability matrix, shown at install time. */\n  readonly caveats: readonly string[];\n  /**\n   * Everything else `hooks install` writes for this harness, in the order it is\n   * written and listed. Empty means instructions only: the advisory tier, where\n   * nothing enforces anything and the output says so.\n   */\n  readonly install: readonly HarnessInstallStep[];\n  /**\n   * This harness's native pre-tool hook schema, as data. Present exactly when the\n   * harness ships a shim script (`dist/hooks/shims/<id>.js`) — absent for the advisory\n   * tier, and for opencode, whose hook API is a JavaScript plugin rather than a stdin\n   * schema.\n   */\n  readonly hooks?: HarnessHookSchema;\n  /**\n   * The escape hatch: a hand-written adapter, for a harness whose schema a table\n   * cannot express. Wins over {@link hooks} when both are present.\n   */\n  readonly shim?: ShimAdapter;\n}\n\n/** How much smelt is willing to claim about a harness. */\nexport type HarnessTier = 'verified' | 'experimental' | 'advisory';\n\n/**\n * Every harness the preset knows. The registry is keyed by this union, so adding an id\n * without writing its profile is a compile error — and the `--harness` help list, the\n * wizard's table and every error message read the registry, never a second list.\n */\nexport type HarnessId =\n  | 'claude-code'\n  | 'codex'\n  | 'gemini'\n  | 'grok'\n  | 'hermes'\n  | 'cursor'\n  | 'opencode'\n  | 'cline'\n  | 'kilocode'\n  | 'aider';\n\n/** One line of honesty per tier, shown wherever a tier label appears. */\nexport const TIER_HONESTY: Record<HarnessTier, string> = {\n  verified: 'schema verified against primary docs and pinned by fixtures',\n  experimental:\n    'schema mapped from the 2026-09-02 capability matrix, not yet smoke-tested against the real binary',\n  advisory: 'no usable hook API — instructions only, nothing enforces them',\n};\n\n/**\n * What the wizard settled on, as the installer's renderers see it: the toggles, the\n * guard's settings, and the project directory every path is relative to. A renderer\n * takes this and returns bytes; nothing writes.\n */\nexport interface HarnessInstallContext {\n  /** Project directory: every path a renderer emits is portable relative to it. */\n  readonly cwd: string;\n  readonly guard: boolean;\n  readonly statsOnStop: boolean;\n  readonly mapOnStart: boolean;\n  readonly thresholdBytes: number;\n  /** The `--budget` every suggested command and the snippet quote. */\n  readonly budgetBytes: number;\n}\n\n/** A file's bytes, rendered from the wizard's choices. */\nexport type HarnessFileContent = (ctx: HarnessInstallContext) => string;\n\n/**\n * One artefact `hooks install` writes. The kind is also the un-write: `json-hooks` is\n * merged in and strip-merged out, `marker-block` is upserted and stripped,\n * `own-file` is written and deleted.\n */\nexport type HarnessInstallStep = HarnessJsonHooks | HarnessMarkerBlock | HarnessOwnFile;\n\n/**\n * A JSON settings/hooks file the harness reads. Our entries are merged in\n * byte-faithfully and, on `remove`, stripped back out with everything foreign left\n * exactly as it was.\n */\nexport interface HarnessJsonHooks {\n  readonly kind: 'json-hooks';\n  /** Project-relative path of the file. */\n  readonly file: string;\n  /** The pre-tool event, in this harness's spelling (`PreToolUse`, `BeforeTool`, …). */\n  readonly event: string;\n  /**\n   * One hook entry per matcher — the tool names the guard wants to see. `undefined`\n   * is a matcher-less entry, for a harness whose hook fires on every tool.\n   */\n  readonly matchers: readonly (string | undefined)[];\n  /**\n   * The entry shape: `'command-list'` is Claude Code's `{matcher, hooks:[{type,\n   * command}]}`, which Codex, Gemini and Grok mirror; `'bare-command'` is Cursor's\n   * `{command}`.\n   */\n  readonly entry: 'command-list' | 'bare-command';\n  /**\n   * True for a harness whose schema also carries the session-lifecycle events this\n   * preset offers — `smelt stats` on Stop, `smelt map` on SessionStart. The other\n   * harnesses wire the guard only, and the wizard's toggles say so.\n   */\n  readonly lifecycle: boolean;\n  /** Top-level keys a *fresh* file must carry (Cursor's `version: 1`). */\n  readonly shape?: { readonly version: number };\n}\n\n/** A marker-bracketed block inside a file smelt shares with its owner. */\nexport interface HarnessMarkerBlock {\n  readonly kind: 'marker-block';\n  readonly file: string;\n  readonly block: HarnessFileContent;\n  /** The marker line opening the block — also how `remove` finds it. */\n  readonly start: string;\n  readonly end: string;\n  /**\n   * Refuse the file instead of editing it when it already carries `contains` and none\n   * of ours: Codex's `config.toml` may have a hand-written `[features]` table, and an\n   * installer that merged into it would be editing what it was never asked to.\n   */\n  readonly skipWhen?: { readonly contains: string; readonly why: string };\n}\n\n/** A file that is entirely smelt's: written whole, deleted whole. */\nexport interface HarnessOwnFile {\n  readonly kind: 'own-file';\n  readonly file: string;\n  readonly content: HarnessFileContent;\n  /** chmod after writing (Cline's hook must be executable). */\n  readonly mode?: number;\n  /** True when the file exists only to wire the guard — the guard toggle gates it. */\n  readonly guardOnly: boolean;\n}\n\n/**\n * A profile that ships a shim script. Only these have a shim path: `shimScriptPath`\n * takes one, so a harness with no shim cannot name a script that was never built.\n */\nexport type ShimmedHarnessProfile = HarnessProfile &\n  ({ readonly hooks: HarnessHookSchema } | { readonly shim: ShimAdapter });\n\n/** True for a profile that ships a shim script — the narrowing `shimScriptPath` needs. */\nexport function hasShim(profile: HarnessProfile): profile is ShimmedHarnessProfile {\n  return profile.hooks !== undefined || profile.shim !== undefined;\n}\n\n/**\n * The adapter this profile's shim script runs: the one its {@link HarnessProfile.hooks}\n * schema describes, or the hand-written escape hatch where it carries one.\n */\nexport function shimAdapterOf(profile: ShimmedHarnessProfile): ShimAdapter {\n  const { hooks, shim } = profile;\n  if (shim !== undefined) return shim;\n  /* v8 ignore next 5 -- unreachable: a ShimmedHarnessProfile carries one or the other */\n  if (hooks === undefined) {\n    throw new Error(\n      `smelt: harness \"${profile.id}\" claims a shim but carries neither a hook schema nor an adapter.`,\n    );\n  }\n  return shimFromSchema(hooks);\n}\n"]}

package/dist/harness/registry.d.ts

@@ -0,0 +1,51 @@
+import type { HarnessId, HarnessProfile } from './profile.ts';
+/**
+ * The registry — every harness smelt knows, one {@link HarnessProfile} each.
+ *
+ * `Record<HarnessId, HarnessProfile>` on purpose: adding a `HarnessId` in `profile.ts`
+ * without writing its profile is a compile error, so the id list and the facts cannot
+ * drift. Every derived view — the `--harness` help list, the wizard's table, the
+ * managed event names, the files a re-run reads its toggles back from — is computed
+ * from this object, never written twice.
+ *
+ * This module imports **nothing from `cli/`**. That is the point: the registry used to
+ * live in `cli/hooks.ts`, which imports `CLI_NAME` from `cli/args.ts`, so `args.ts`
+ * could not import it back and the `--harness` help list was hand-typed five lines
+ * below two lists that were correctly derived.
+ *
+ * Key order is meaningful: it is the order every rendered harness list uses (the help
+ * text, the wizard's table, the "Known: …" of an unknown-harness error), so keep it
+ * stable and append new harnesses at the end.
+ */
+export declare const HARNESS_PROFILES: Readonly<Record<HarnessId, HarnessProfile>>;
+/** Every profile, in registry order. The list every rendered table walks. */
+export declare const HARNESSES: readonly HarnessProfile[];
+/** Every harness id, in registry order — the `--harness` help list, derived. */
+export declare const HARNESS_IDS: readonly HarnessId[];
+/** The profile for a harness id, or `undefined` for a string the user made up. */
+export declare function harnessById(id: string): HarnessProfile | undefined;
+/**
+ * The two session-lifecycle hooks this preset offers, named in each harness's schema:
+ * `smelt stats` when a turn ends, an opening `smelt map` when a session starts. Only
+ * the harnesses whose schema carries these events wire them (`step.lifecycle`), and
+ * `cli/hooks.ts` writes the entries under these exact keys — one spelling, so the
+ * managed-event list below cannot fall behind what the installer writes.
+ */
+export declare const LIFECYCLE_EVENTS: {
+    readonly stats: 'Stop';
+    readonly map: 'SessionStart';
+};
+/**
+ * The events this installer manages, across every harness's spelling of them —
+ * foreign entries under them are always preserved, and events nobody claims are never
+ * touched. Derived, so a harness that spells its pre-tool event a new way is managed
+ * by existing.
+ */
+export declare const MANAGED_EVENTS: readonly string[];
+/** The managed events that wire the PreToolUse guard, across harness spellings. */
+export declare const GUARD_EVENTS: readonly string[];
+/** The JSON hook files a re-run reads installed toggles back from, per harness. */
+export declare const JSON_HOOK_FILES: readonly string[];
+/** Guard-only files whose presence means the guard toggle was installed. */
+export declare const GUARD_ONLY_FILES: readonly string[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/harness/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/harness/registry.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,SAAS,EAAoB,cAAc,EAAE,MAAM,cAAc,CAAC;AAEhF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,cAAc,CAAC,CAWxE,CAAC;AAEF,6EAA6E;AAC7E,eAAO,MAAM,SAAS,EAAE,SAAS,cAAc,EAAoC,CAAC;AAEpF,gFAAgF;AAChF,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAA2C,CAAC;AAExF,kFAAkF;AAClF,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAElE;AASD;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;aAAK,KAAK,EAAE,MAAM;aAAE,GAAG,EAAE,cAAc;CAAW,CAAC;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,MAAM,EAO3C,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAEzC,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAE5C,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAQ7C,CAAC","sourcesContent":["import { aider } from './aider.ts';\nimport { claudeCode } from './claude-code.ts';\nimport { cline } from './cline.ts';\nimport { codex } from './codex.ts';\nimport { cursor } from './cursor.ts';\nimport { gemini } from './gemini.ts';\nimport { grok } from './grok.ts';\nimport { hermes } from './hermes.ts';\nimport { kilocode } from './kilocode.ts';\nimport { opencode } from './opencode.ts';\nimport type { HarnessId, HarnessJsonHooks, HarnessProfile } from './profile.ts';\n\n/**\n * The registry — every harness smelt knows, one {@link HarnessProfile} each.\n *\n * `Record<HarnessId, HarnessProfile>` on purpose: adding a `HarnessId` in `profile.ts`\n * without writing its profile is a compile error, so the id list and the facts cannot\n * drift. Every derived view — the `--harness` help list, the wizard's table, the\n * managed event names, the files a re-run reads its toggles back from — is computed\n * from this object, never written twice.\n *\n * This module imports **nothing from `cli/`**. That is the point: the registry used to\n * live in `cli/hooks.ts`, which imports `CLI_NAME` from `cli/args.ts`, so `args.ts`\n * could not import it back and the `--harness` help list was hand-typed five lines\n * below two lists that were correctly derived.\n *\n * Key order is meaningful: it is the order every rendered harness list uses (the help\n * text, the wizard's table, the \"Known: …\" of an unknown-harness error), so keep it\n * stable and append new harnesses at the end.\n */\nexport const HARNESS_PROFILES: Readonly<Record<HarnessId, HarnessProfile>> = {\n  'claude-code': claudeCode,\n  codex,\n  gemini,\n  grok,\n  hermes,\n  cursor,\n  opencode,\n  cline,\n  kilocode,\n  aider,\n};\n\n/** Every profile, in registry order. The list every rendered table walks. */\nexport const HARNESSES: readonly HarnessProfile[] = Object.values(HARNESS_PROFILES);\n\n/** Every harness id, in registry order — the `--harness` help list, derived. */\nexport const HARNESS_IDS: readonly HarnessId[] = HARNESSES.map((profile) => profile.id);\n\n/** The profile for a harness id, or `undefined` for a string the user made up. */\nexport function harnessById(id: string): HarnessProfile | undefined {\n  return HARNESSES.find((profile) => profile.id === id);\n}\n\n/** Every JSON hook step any profile declares, in registry order. */\nfunction jsonHookSteps(): readonly HarnessJsonHooks[] {\n  return HARNESSES.flatMap((profile) =>\n    profile.install.filter((step): step is HarnessJsonHooks => step.kind === 'json-hooks'),\n  );\n}\n\n/**\n * The two session-lifecycle hooks this preset offers, named in each harness's schema:\n * `smelt stats` when a turn ends, an opening `smelt map` when a session starts. Only\n * the harnesses whose schema carries these events wire them (`step.lifecycle`), and\n * `cli/hooks.ts` writes the entries under these exact keys — one spelling, so the\n * managed-event list below cannot fall behind what the installer writes.\n */\nexport const LIFECYCLE_EVENTS = { stats: 'Stop', map: 'SessionStart' } as const;\n\n/**\n * The events this installer manages, across every harness's spelling of them —\n * foreign entries under them are always preserved, and events nobody claims are never\n * touched. Derived, so a harness that spells its pre-tool event a new way is managed\n * by existing.\n */\nexport const MANAGED_EVENTS: readonly string[] = [\n  ...new Set(\n    jsonHookSteps().flatMap((step) => [\n      step.event,\n      ...(step.lifecycle ? Object.values(LIFECYCLE_EVENTS) : []),\n    ]),\n  ),\n];\n\n/** The managed events that wire the PreToolUse guard, across harness spellings. */\nexport const GUARD_EVENTS: readonly string[] = [\n  ...new Set(jsonHookSteps().map((step) => step.event)),\n];\n\n/** The JSON hook files a re-run reads installed toggles back from, per harness. */\nexport const JSON_HOOK_FILES: readonly string[] = [\n  ...new Set(jsonHookSteps().map((step) => step.file)),\n];\n\n/** Guard-only files whose presence means the guard toggle was installed. */\nexport const GUARD_ONLY_FILES: readonly string[] = [\n  ...new Set(\n    HARNESSES.flatMap((profile) =>\n      profile.install\n        .filter((step) => step.kind === 'own-file' && step.guardOnly)\n        .map((step) => step.file),\n    ),\n  ),\n];\n"]}

package/dist/harness/registry.js

@@ -0,0 +1,87 @@
+import { aider } from './aider.js';
+import { claudeCode } from './claude-code.js';
+import { cline } from './cline.js';
+import { codex } from './codex.js';
+import { cursor } from './cursor.js';
+import { gemini } from './gemini.js';
+import { grok } from './grok.js';
+import { hermes } from './hermes.js';
+import { kilocode } from './kilocode.js';
+import { opencode } from './opencode.js';
+/**
+ * The registry — every harness smelt knows, one {@link HarnessProfile} each.
+ *
+ * `Record<HarnessId, HarnessProfile>` on purpose: adding a `HarnessId` in `profile.ts`
+ * without writing its profile is a compile error, so the id list and the facts cannot
+ * drift. Every derived view — the `--harness` help list, the wizard's table, the
+ * managed event names, the files a re-run reads its toggles back from — is computed
+ * from this object, never written twice.
+ *
+ * This module imports **nothing from `cli/`**. That is the point: the registry used to
+ * live in `cli/hooks.ts`, which imports `CLI_NAME` from `cli/args.ts`, so `args.ts`
+ * could not import it back and the `--harness` help list was hand-typed five lines
+ * below two lists that were correctly derived.
+ *
+ * Key order is meaningful: it is the order every rendered harness list uses (the help
+ * text, the wizard's table, the "Known: …" of an unknown-harness error), so keep it
+ * stable and append new harnesses at the end.
+ */
+export const HARNESS_PROFILES = {
+    'claude-code': claudeCode,
+    codex,
+    gemini,
+    grok,
+    hermes,
+    cursor,
+    opencode,
+    cline,
+    kilocode,
+    aider,
+};
+/** Every profile, in registry order. The list every rendered table walks. */
+export const HARNESSES = Object.values(HARNESS_PROFILES);
+/** Every harness id, in registry order — the `--harness` help list, derived. */
+export const HARNESS_IDS = HARNESSES.map((profile) => profile.id);
+/** The profile for a harness id, or `undefined` for a string the user made up. */
+export function harnessById(id) {
+    return HARNESSES.find((profile) => profile.id === id);
+}
+/** Every JSON hook step any profile declares, in registry order. */
+function jsonHookSteps() {
+    return HARNESSES.flatMap((profile) => profile.install.filter((step) => step.kind === 'json-hooks'));
+}
+/**
+ * The two session-lifecycle hooks this preset offers, named in each harness's schema:
+ * `smelt stats` when a turn ends, an opening `smelt map` when a session starts. Only
+ * the harnesses whose schema carries these events wire them (`step.lifecycle`), and
+ * `cli/hooks.ts` writes the entries under these exact keys — one spelling, so the
+ * managed-event list below cannot fall behind what the installer writes.
+ */
+export const LIFECYCLE_EVENTS = { stats: 'Stop', map: 'SessionStart' };
+/**
+ * The events this installer manages, across every harness's spelling of them —
+ * foreign entries under them are always preserved, and events nobody claims are never
+ * touched. Derived, so a harness that spells its pre-tool event a new way is managed
+ * by existing.
+ */
+export const MANAGED_EVENTS = [
+    ...new Set(jsonHookSteps().flatMap((step) => [
+        step.event,
+        ...(step.lifecycle ? Object.values(LIFECYCLE_EVENTS) : []),
+    ])),
+];
+/** The managed events that wire the PreToolUse guard, across harness spellings. */
+export const GUARD_EVENTS = [
+    ...new Set(jsonHookSteps().map((step) => step.event)),
+];
+/** The JSON hook files a re-run reads installed toggles back from, per harness. */
+export const JSON_HOOK_FILES = [
+    ...new Set(jsonHookSteps().map((step) => step.file)),
+];
+/** Guard-only files whose presence means the guard toggle was installed. */
+export const GUARD_ONLY_FILES = [
+    ...new Set(HARNESSES.flatMap((profile) => profile.install
+        .filter((step) => step.kind === 'own-file' && step.guardOnly)
+        .map((step) => step.file))),
+];
+//# sourceMappingURL=registry.js.map

package/dist/harness/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/harness/registry.ts"],"names":[],"mappings":"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","sourcesContent":["import { aider } from './aider.ts';\nimport { claudeCode } from './claude-code.ts';\nimport { cline } from './cline.ts';\nimport { codex } from './codex.ts';\nimport { cursor } from './cursor.ts';\nimport { gemini } from './gemini.ts';\nimport { grok } from './grok.ts';\nimport { hermes } from './hermes.ts';\nimport { kilocode } from './kilocode.ts';\nimport { opencode } from './opencode.ts';\nimport type { HarnessId, HarnessJsonHooks, HarnessProfile } from './profile.ts';\n\n/**\n * The registry — every harness smelt knows, one {@link HarnessProfile} each.\n *\n * `Record<HarnessId, HarnessProfile>` on purpose: adding a `HarnessId` in `profile.ts`\n * without writing its profile is a compile error, so the id list and the facts cannot\n * drift. Every derived view — the `--harness` help list, the wizard's table, the\n * managed event names, the files a re-run reads its toggles back from — is computed\n * from this object, never written twice.\n *\n * This module imports **nothing from `cli/`**. That is the point: the registry used to\n * live in `cli/hooks.ts`, which imports `CLI_NAME` from `cli/args.ts`, so `args.ts`\n * could not import it back and the `--harness` help list was hand-typed five lines\n * below two lists that were correctly derived.\n *\n * Key order is meaningful: it is the order every rendered harness list uses (the help\n * text, the wizard's table, the \"Known: …\" of an unknown-harness error), so keep it\n * stable and append new harnesses at the end.\n */\nexport const HARNESS_PROFILES: Readonly<Record<HarnessId, HarnessProfile>> = {\n  'claude-code': claudeCode,\n  codex,\n  gemini,\n  grok,\n  hermes,\n  cursor,\n  opencode,\n  cline,\n  kilocode,\n  aider,\n};\n\n/** Every profile, in registry order. The list every rendered table walks. */\nexport const HARNESSES: readonly HarnessProfile[] = Object.values(HARNESS_PROFILES);\n\n/** Every harness id, in registry order — the `--harness` help list, derived. */\nexport const HARNESS_IDS: readonly HarnessId[] = HARNESSES.map((profile) => profile.id);\n\n/** The profile for a harness id, or `undefined` for a string the user made up. */\nexport function harnessById(id: string): HarnessProfile | undefined {\n  return HARNESSES.find((profile) => profile.id === id);\n}\n\n/** Every JSON hook step any profile declares, in registry order. */\nfunction jsonHookSteps(): readonly HarnessJsonHooks[] {\n  return HARNESSES.flatMap((profile) =>\n    profile.install.filter((step): step is HarnessJsonHooks => step.kind === 'json-hooks'),\n  );\n}\n\n/**\n * The two session-lifecycle hooks this preset offers, named in each harness's schema:\n * `smelt stats` when a turn ends, an opening `smelt map` when a session starts. Only\n * the harnesses whose schema carries these events wire them (`step.lifecycle`), and\n * `cli/hooks.ts` writes the entries under these exact keys — one spelling, so the\n * managed-event list below cannot fall behind what the installer writes.\n */\nexport const LIFECYCLE_EVENTS = { stats: 'Stop', map: 'SessionStart' } as const;\n\n/**\n * The events this installer manages, across every harness's spelling of them —\n * foreign entries under them are always preserved, and events nobody claims are never\n * touched. Derived, so a harness that spells its pre-tool event a new way is managed\n * by existing.\n */\nexport const MANAGED_EVENTS: readonly string[] = [\n  ...new Set(\n    jsonHookSteps().flatMap((step) => [\n      step.event,\n      ...(step.lifecycle ? Object.values(LIFECYCLE_EVENTS) : []),\n    ]),\n  ),\n];\n\n/** The managed events that wire the PreToolUse guard, across harness spellings. */\nexport const GUARD_EVENTS: readonly string[] = [\n  ...new Set(jsonHookSteps().map((step) => step.event)),\n];\n\n/** The JSON hook files a re-run reads installed toggles back from, per harness. */\nexport const JSON_HOOK_FILES: readonly string[] = [\n  ...new Set(jsonHookSteps().map((step) => step.file)),\n];\n\n/** Guard-only files whose presence means the guard toggle was installed. */\nexport const GUARD_ONLY_FILES: readonly string[] = [\n  ...new Set(\n    HARNESSES.flatMap((profile) =>\n      profile.install\n        .filter((step) => step.kind === 'own-file' && step.guardOnly)\n        .map((step) => step.file),\n    ),\n  ),\n];\n"]}

package/dist/harness/snippet.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The text every harness shares: the marker lines that bracket a block this installer
+ * owns inside somebody else's file, the token that identifies a hook entry as ours,
+ * and the instruction snippet itself.
+ */
+/** Marker lines bracketing every block this installer owns inside a shared file. */
+export declare const SNIPPET_START_MD = "<!-- smelt:hooks v1 start -->";
+export declare const SNIPPET_END_MD = "<!-- smelt:hooks v1 end -->";
+export declare const SNIPPET_START_HASH = "# smelt:hooks v1 start";
+export declare const SNIPPET_END_HASH = "# smelt:hooks v1 end";
+/** Substring that identifies a file (or JSON hook entry) as written by this installer. */
+export declare const OURS_TOKEN = "smelt:hooks";
+/**
+ * The instruction snippet — belt and braces under every shim, and the *only* layer
+ * for advisory harnesses. It teaches the three commands, and in particular what to do
+ * after a guard deny: run the named replacement, then `smelt retrieve` per marker.
+ */
+export declare function instructionSnippet(thresholdBytes: number, budgetBytes: number): string;
+//# sourceMappingURL=snippet.d.ts.map

package/dist/harness/snippet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snippet.d.ts","sourceRoot":"","sources":["../../src/harness/snippet.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,oFAAoF;AACpF,eAAO,MAAM,gBAAgB,kCAAkC,CAAC;AAChE,eAAO,MAAM,cAAc,gCAAgC,CAAC;AAC5D,eAAO,MAAM,kBAAkB,2BAA2B,CAAC;AAC3D,eAAO,MAAM,gBAAgB,yBAAyB,CAAC;AAEvD,0FAA0F;AAC1F,eAAO,MAAM,UAAU,gBAAgB,CAAC;AAExC;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAsBtF","sourcesContent":["/**\n * The text every harness shares: the marker lines that bracket a block this installer\n * owns inside somebody else's file, the token that identifies a hook entry as ours,\n * and the instruction snippet itself.\n */\n\n/** Marker lines bracketing every block this installer owns inside a shared file. */\nexport const SNIPPET_START_MD = '<!-- smelt:hooks v1 start -->';\nexport const SNIPPET_END_MD = '<!-- smelt:hooks v1 end -->';\nexport const SNIPPET_START_HASH = '# smelt:hooks v1 start';\nexport const SNIPPET_END_HASH = '# smelt:hooks v1 end';\n\n/** Substring that identifies a file (or JSON hook entry) as written by this installer. */\nexport const OURS_TOKEN = 'smelt:hooks';\n\n/**\n * The instruction snippet — belt and braces under every shim, and the *only* layer\n * for advisory harnesses. It teaches the three commands, and in particular what to do\n * after a guard deny: run the named replacement, then `smelt retrieve` per marker.\n */\nexport function instructionSnippet(thresholdBytes: number, budgetBytes: number): string {\n  return `${SNIPPET_START_MD}\n\n## smelt — context discipline\n\nThis project uses [smelt](https://github.com/smeltjs/smelt) to keep large tool output\nout of the context window, reversibly.\n\n- Do not read files over ${String(thresholdBytes)} bytes raw. Run\n  \\`smelt <file> --budget ${String(budgetBytes)} --focus <what you are looking for>\\`\n  instead (repeat \\`--focus\\` per term). Focused regions survive verbatim; everything\n  else collapses into a one-line marker stating what was removed.\n- Every marker ends in \\`retrieve(\"hash\")\\`. \\`smelt retrieve <hash>\\` prints the\n  exact original bytes back. Retrieve what you actually need — retrievals are counted,\n  and \\`smelt stats\\` reports the honest expansion rate.\n- For orientation, \\`smelt map . --budget ${String(budgetBytes)}\\` prints a ranked\n  symbol map of the repository.\n- If a smelt guard hook denies a raw read, run the exact replacement command named in\n  the denial, then \\`smelt retrieve\\` any marker you need expanded.\n\n${SNIPPET_END_MD}\n`;\n}\n"]}

package/dist/harness/snippet.js

@@ -0,0 +1,41 @@
+/**
+ * The text every harness shares: the marker lines that bracket a block this installer
+ * owns inside somebody else's file, the token that identifies a hook entry as ours,
+ * and the instruction snippet itself.
+ */
+/** Marker lines bracketing every block this installer owns inside a shared file. */
+export const SNIPPET_START_MD = '<!-- smelt:hooks v1 start -->';
+export const SNIPPET_END_MD = '<!-- smelt:hooks v1 end -->';
+export const SNIPPET_START_HASH = '# smelt:hooks v1 start';
+export const SNIPPET_END_HASH = '# smelt:hooks v1 end';
+/** Substring that identifies a file (or JSON hook entry) as written by this installer. */
+export const OURS_TOKEN = 'smelt:hooks';
+/**
+ * The instruction snippet — belt and braces under every shim, and the *only* layer
+ * for advisory harnesses. It teaches the three commands, and in particular what to do
+ * after a guard deny: run the named replacement, then `smelt retrieve` per marker.
+ */
+export function instructionSnippet(thresholdBytes, budgetBytes) {
+    return `${SNIPPET_START_MD}
+
+## smelt — context discipline
+
+This project uses [smelt](https://github.com/smeltjs/smelt) to keep large tool output
+out of the context window, reversibly.
+
+- Do not read files over ${String(thresholdBytes)} bytes raw. Run
+  \`smelt <file> --budget ${String(budgetBytes)} --focus <what you are looking for>\`
+  instead (repeat \`--focus\` per term). Focused regions survive verbatim; everything
+  else collapses into a one-line marker stating what was removed.
+- Every marker ends in \`retrieve("hash")\`. \`smelt retrieve <hash>\` prints the
+  exact original bytes back. Retrieve what you actually need — retrievals are counted,
+  and \`smelt stats\` reports the honest expansion rate.
+- For orientation, \`smelt map . --budget ${String(budgetBytes)}\` prints a ranked
+  symbol map of the repository.
+- If a smelt guard hook denies a raw read, run the exact replacement command named in
+  the denial, then \`smelt retrieve\` any marker you need expanded.
+
+${SNIPPET_END_MD}
+`;
+}
+//# sourceMappingURL=snippet.js.map

package/dist/harness/snippet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snippet.js","sourceRoot":"","sources":["../../src/harness/snippet.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,oFAAoF;AACpF,MAAM,CAAC,MAAM,gBAAgB,GAAG,+BAA+B,CAAC;AAChE,MAAM,CAAC,MAAM,cAAc,GAAG,6BAA6B,CAAC;AAC5D,MAAM,CAAC,MAAM,kBAAkB,GAAG,wBAAwB,CAAC;AAC3D,MAAM,CAAC,MAAM,gBAAgB,GAAG,sBAAsB,CAAC;AAEvD,0FAA0F;AAC1F,MAAM,CAAC,MAAM,UAAU,GAAG,aAAa,CAAC;AAExC;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,cAAsB,EAAE,WAAmB;IAC5E,OAAO,GAAG,gBAAgB;;;;;;;2BAOD,MAAM,CAAC,cAAc,CAAC;4BACrB,MAAM,CAAC,WAAW,CAAC;;;;;;4CAMH,MAAM,CAAC,WAAW,CAAC;;;;;EAK7D,cAAc;CACf,CAAC;AACF,CAAC","sourcesContent":["/**\n * The text every harness shares: the marker lines that bracket a block this installer\n * owns inside somebody else's file, the token that identifies a hook entry as ours,\n * and the instruction snippet itself.\n */\n\n/** Marker lines bracketing every block this installer owns inside a shared file. */\nexport const SNIPPET_START_MD = '<!-- smelt:hooks v1 start -->';\nexport const SNIPPET_END_MD = '<!-- smelt:hooks v1 end -->';\nexport const SNIPPET_START_HASH = '# smelt:hooks v1 start';\nexport const SNIPPET_END_HASH = '# smelt:hooks v1 end';\n\n/** Substring that identifies a file (or JSON hook entry) as written by this installer. */\nexport const OURS_TOKEN = 'smelt:hooks';\n\n/**\n * The instruction snippet — belt and braces under every shim, and the *only* layer\n * for advisory harnesses. It teaches the three commands, and in particular what to do\n * after a guard deny: run the named replacement, then `smelt retrieve` per marker.\n */\nexport function instructionSnippet(thresholdBytes: number, budgetBytes: number): string {\n  return `${SNIPPET_START_MD}\n\n## smelt — context discipline\n\nThis project uses [smelt](https://github.com/smeltjs/smelt) to keep large tool output\nout of the context window, reversibly.\n\n- Do not read files over ${String(thresholdBytes)} bytes raw. Run\n  \\`smelt <file> --budget ${String(budgetBytes)} --focus <what you are looking for>\\`\n  instead (repeat \\`--focus\\` per term). Focused regions survive verbatim; everything\n  else collapses into a one-line marker stating what was removed.\n- Every marker ends in \\`retrieve(\"hash\")\\`. \\`smelt retrieve <hash>\\` prints the\n  exact original bytes back. Retrieve what you actually need — retrievals are counted,\n  and \\`smelt stats\\` reports the honest expansion rate.\n- For orientation, \\`smelt map . --budget ${String(budgetBytes)}\\` prints a ranked\n  symbol map of the repository.\n- If a smelt guard hook denies a raw read, run the exact replacement command named in\n  the denial, then \\`smelt retrieve\\` any marker you need expanded.\n\n${SNIPPET_END_MD}\n`;\n}\n"]}

package/dist/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,KAAK,CAAC;AAE9B,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,KAAK,CAAC;AAE9B,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD","sourcesContent":["import { createHash } from 'node:crypto';\n\n/**\n * Length of the hex digest smelt uses as a retrieval key.\n *\n * The hash goes into every marker, so the model pays for it in tokens on every\n * elision. 16 hex characters is 64 bits — plenty for the number of elisions one\n * session produces, and cheap enough to inline. The store still verifies content on\n * collision rather than trusting the digest, so shortening it is a token decision,\n * not a correctness one.\n */\nexport const HASH_LENGTH = 16;\n\n/** Content hash of a string, over its UTF-8 bytes. Stable across runs and platforms. */\nexport function contentHash(content: string): string {\n  return createHash('sha256').update(content, 'utf8').digest('hex').slice(0, HASH_LENGTH);\n}\n"]}

package/dist/hash.js.map

@@ -1 +1 @@
-{"version":3,"file":"hash.js","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,EAAE,CAAC;AAE9B,wFAAwF;AACxF,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;AAC1F,CAAC"}
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,EAAE,CAAC;AAE9B,wFAAwF;AACxF,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;AAC1F,CAAC","sourcesContent":["import { createHash } from 'node:crypto';\n\n/**\n * Length of the hex digest smelt uses as a retrieval key.\n *\n * The hash goes into every marker, so the model pays for it in tokens on every\n * elision. 16 hex characters is 64 bits — plenty for the number of elisions one\n * session produces, and cheap enough to inline. The store still verifies content on\n * collision rather than trusting the digest, so shortening it is a token decision,\n * not a correctness one.\n */\nexport const HASH_LENGTH = 16;\n\n/** Content hash of a string, over its UTF-8 bytes. Stable across runs and platforms. */\nexport function contentHash(content: string): string {\n  return createHash('sha256').update(content, 'utf8').digest('hex').slice(0, HASH_LENGTH);\n}\n"]}

package/dist/hooks/guard-core.d.ts

@@ -1,11 +1,13 @@
 /**
- * The guard core — one zero-dependency node script, shared by every harness shim.
+ * The guard core — one zero-dependency node module, shared by every harness shim.
  *
- * Contract (KOT-212): stdin carries one JSON request
- * `{ tool, input: { path?, command?, offsetLimited? } }`, stdout answers with one
- * JSON decision `{ action: "allow" | "deny", reason?, suggestion? }`, and the exit
- * code is always 0 — the decision lives in the JSON, and each shim translates it
- * into its harness's own schema (exit 2, `permissionDecision`, `cancel:true`, …).
+ * Contract: a caller hands `decide` a {@link GuardRequest}
+ * (`{ tool, input: { path?, command?, offsetLimited? } }`) with the settings
+ * {@link readGuardSettings} read, and gets one {@link GuardDecision} back —
+ * `{ action: "allow" | "deny", reason?, suggestion? }`. Each shim translates that into
+ * its harness's own schema (exit 2, `permissionDecision`, `cancel:true`, …), and the
+ * opencode plugin — the one harness whose hook API is JavaScript — imports this module
+ * at hook time and calls the same two functions.
  *
  * Two properties are load-bearing and guarded:
  *
@@ -112,7 +114,12 @@ export declare const DEFAULT_GUARD_SETTINGS: GuardSettings;
 export declare function readGuardSettings(cwd: string, warn: (text: string) => void): GuardSettings;
 /** The same upward walk `cli/config.ts` does, re-implemented to keep this module tiny. */
 export declare function findGuardConfigFile(cwd: string): string | undefined;
-/** Parse one stdin request. `undefined` means malformed — the caller allows and warns. */
+/**
+ * Parse one {@link GuardRequest} *document* — the request shape as JSON, for an
+ * adapter that receives it over a pipe rather than building it in-process.
+ * `undefined` means malformed, and a caller that gets it allows and warns: the same
+ * fail-open rule the rest of this module lives under.
+ */
 export declare function parseGuardRequest(text: string): GuardRequest | undefined;
 /**
  * The decision, pure given a stat function — so tests exercise every branch without
@@ -154,11 +161,4 @@ export declare function shellQuote(value: string): string;
 export declare function isMainModule(moduleUrl: string): boolean;
 /** Every byte of fd 0 to EOF, retrying EAGAIN — the same shape `cli/bin.ts` uses. */
 export declare function readAllOfStdin(): string;
-/**
- * Run the guard over stdin and print the decision. Exit code 0 in every case —
- * including every failure, which becomes an allow with a stderr warning. A guard
- * subprocess that exits non-zero on its own bug would look like a policy decision
- * to some harnesses, and "my hook crashed" must never read as "denied".
- */
-export declare function runGuardMain(): void;
 //# sourceMappingURL=guard-core.d.ts.map