@smeltjs/core 0.2.0 → 0.4.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"kilocode.d.ts","sourceRoot":"","sources":["../../src/harness/kilocode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAyB,cAAc,EAAE,MAAM,cAAc,CAAC;AAwB1E,eAAO,MAAM,QAAQ,EAAE,cAYtB,CAAC","sourcesContent":["import type { HarnessInstallContext, HarnessProfile } from './profile.ts';\nimport { instructionSnippet } from './snippet.ts';\n\n/**\n * KiloCode — ADVISORY tier. Instructions only, and honest about it.\n *\n * No first-class hook API (Kilo-Org/kilocode#5827), so nothing here is enforced: what\n * ships is a rules file this harness owns whole — the shared snippet plus the two\n * manual enforcement legs the snippet has no room for. `remove` deletes it.\n */\nfunction kilocodeRulesSource(ctx: HarnessInstallContext): string {\n  return `${instructionSnippet(ctx.thresholdBytes, ctx.budgetBytes)}\n<!-- smelt:hooks v1 advisory notes -->\n\nKiloCode has no first-class hook API (Kilo-Org/kilocode#5827), so nothing above is\nenforced — it is advisory. Two manual legs make it harder to bypass:\n\n1. Permissions: in your KiloCode per-tool permission config, set raw-read/execute\n   tools to \"ask\" so oversized reads surface for review instead of passing silently.\n2. MCP: expose smelt through an MCP server and prefer its tools; a resident server\n   also keeps smelt's grammar cache warm across calls.\n`;\n}\n\nexport const kilocode: HarnessProfile = {\n  id: 'kilocode',\n  name: 'KiloCode',\n  tier: 'advisory',\n  detect: ['.kilocode'],\n  detectHome: ['.config/kilo'],\n  instructionFile: '.kilocode/rules/smelt.md',\n  instructions: kilocodeRulesSource,\n  caveats: [\n    'no first-class hooks (Kilo-Org/kilocode#5827): enforcement is permissions config + MCP, both manual',\n  ],\n  install: [],\n};\n"]}

package/dist/harness/kilocode.js

@@ -0,0 +1,35 @@
+import { instructionSnippet } from './snippet.js';
+/**
+ * KiloCode — ADVISORY tier. Instructions only, and honest about it.
+ *
+ * No first-class hook API (Kilo-Org/kilocode#5827), so nothing here is enforced: what
+ * ships is a rules file this harness owns whole — the shared snippet plus the two
+ * manual enforcement legs the snippet has no room for. `remove` deletes it.
+ */
+function kilocodeRulesSource(ctx) {
+    return `${instructionSnippet(ctx.thresholdBytes, ctx.budgetBytes)}
+<!-- smelt:hooks v1 advisory notes -->
+
+KiloCode has no first-class hook API (Kilo-Org/kilocode#5827), so nothing above is
+enforced — it is advisory. Two manual legs make it harder to bypass:
+
+1. Permissions: in your KiloCode per-tool permission config, set raw-read/execute
+   tools to "ask" so oversized reads surface for review instead of passing silently.
+2. MCP: expose smelt through an MCP server and prefer its tools; a resident server
+   also keeps smelt's grammar cache warm across calls.
+`;
+}
+export const kilocode = {
+    id: 'kilocode',
+    name: 'KiloCode',
+    tier: 'advisory',
+    detect: ['.kilocode'],
+    detectHome: ['.config/kilo'],
+    instructionFile: '.kilocode/rules/smelt.md',
+    instructions: kilocodeRulesSource,
+    caveats: [
+        'no first-class hooks (Kilo-Org/kilocode#5827): enforcement is permissions config + MCP, both manual',
+    ],
+    install: [],
+};
+//# sourceMappingURL=kilocode.js.map

package/dist/harness/kilocode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kilocode.js","sourceRoot":"","sources":["../../src/harness/kilocode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD;;;;;;GAMG;AACH,SAAS,mBAAmB,CAAC,GAA0B;IACrD,OAAO,GAAG,kBAAkB,CAAC,GAAG,CAAC,cAAc,EAAE,GAAG,CAAC,WAAW,CAAC;;;;;;;;;;CAUlE,CAAC;AACF,CAAC;AAED,MAAM,CAAC,MAAM,QAAQ,GAAmB;IACtC,EAAE,EAAE,UAAU;IACd,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,CAAC,WAAW,CAAC;IACrB,UAAU,EAAE,CAAC,cAAc,CAAC;IAC5B,eAAe,EAAE,0BAA0B;IAC3C,YAAY,EAAE,mBAAmB;IACjC,OAAO,EAAE;QACP,qGAAqG;KACtG;IACD,OAAO,EAAE,EAAE;CACZ,CAAC","sourcesContent":["import type { HarnessInstallContext, HarnessProfile } from './profile.ts';\nimport { instructionSnippet } from './snippet.ts';\n\n/**\n * KiloCode — ADVISORY tier. Instructions only, and honest about it.\n *\n * No first-class hook API (Kilo-Org/kilocode#5827), so nothing here is enforced: what\n * ships is a rules file this harness owns whole — the shared snippet plus the two\n * manual enforcement legs the snippet has no room for. `remove` deletes it.\n */\nfunction kilocodeRulesSource(ctx: HarnessInstallContext): string {\n  return `${instructionSnippet(ctx.thresholdBytes, ctx.budgetBytes)}\n<!-- smelt:hooks v1 advisory notes -->\n\nKiloCode has no first-class hook API (Kilo-Org/kilocode#5827), so nothing above is\nenforced — it is advisory. Two manual legs make it harder to bypass:\n\n1. Permissions: in your KiloCode per-tool permission config, set raw-read/execute\n   tools to \"ask\" so oversized reads surface for review instead of passing silently.\n2. MCP: expose smelt through an MCP server and prefer its tools; a resident server\n   also keeps smelt's grammar cache warm across calls.\n`;\n}\n\nexport const kilocode: HarnessProfile = {\n  id: 'kilocode',\n  name: 'KiloCode',\n  tier: 'advisory',\n  detect: ['.kilocode'],\n  detectHome: ['.config/kilo'],\n  instructionFile: '.kilocode/rules/smelt.md',\n  instructions: kilocodeRulesSource,\n  caveats: [\n    'no first-class hooks (Kilo-Org/kilocode#5827): enforcement is permissions config + MCP, both manual',\n  ],\n  install: [],\n};\n"]}

package/dist/harness/opencode.d.ts

@@ -0,0 +1,3 @@
+import type { HarnessProfile } from './profile.ts';
+export declare const opencode: HarnessProfile;
+//# sourceMappingURL=opencode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"opencode.d.ts","sourceRoot":"","sources":["../../src/harness/opencode.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAyB,cAAc,EAAE,MAAM,cAAc,CAAC;AA6E1E,eAAO,MAAM,QAAQ,EAAE,cAmBtB,CAAC","sourcesContent":["import {\n  DENIED_WITHOUT_REASON,\n  REWRITE_ANNOUNCEMENT_JOIN,\n  REWRITE_ANNOUNCEMENT_OPENING,\n} from '../hooks/shim.ts';\n\nimport { guardCoreScriptPath, portablePath } from './paths.ts';\nimport type { HarnessInstallContext, HarnessProfile } from './profile.ts';\n\n/**\n * opencode — EXPERIMENTAL tier. Install and removal, end to end.\n *\n * The one harness with no shim script: its hook API is a JavaScript plugin, not a\n * stdin schema, so what the installer writes *is* the adapter. The plugin imports the\n * built guard core directly (the same module every shim calls) and maps\n * `tool.execute.before` onto it, so all policy still lives in exactly one place.\n *\n * Its two announcements — the rewrite sentence and the reasonless deny — are spliced\n * in from `hooks/shim.ts`'s constants rather than hand-typed into the template, where\n * nothing could see them drift from what the shims print.\n */\nfunction opencodePluginSource(ctx: HarnessInstallContext): string {\n  const guardCore = portablePath(ctx.cwd, guardCoreScriptPath());\n  return `// smelt:hooks v1 — opencode plugin shim. EXPERIMENTAL tier: mapped from the\n// capability matrix (docs/research/2026-09-02-harness-capability-matrix.md, opencode\n// row; https://opencode.ai/docs/plugins/). This template's deny/pass/window paths\n// were exercised directly against the built guard core (verified\n// 2026-09-02), but a live opencode session has not been smoke-tested — that needs\n// provider credentials. Caveat carried from the matrix: MCP tools can bypass plugin\n// hooks (sst/opencode#2319) — this guard sees built-in tools only.\n//\n// Thin adapter: maps tool.execute.before onto the smelt guard core (zero\n// dependencies), which owns every decision. Deny mode throws (opencode surfaces the\n// reason to the model); rewrite mode substitutes the faithful replacement command —\n// announced on stderr, because the plugin API has no reason channel on a rewrite\n// and a substitution must never be silent. Both announcements below are spliced in\n// from the shims' own constants, so this copy cannot drift from theirs.\nimport { pathToFileURL } from 'node:url';\n\nconst GUARD_CORE = ${JSON.stringify(guardCore)};\nconst core = await import(pathToFileURL(GUARD_CORE).href);\n\nexport const SmeltGuard = async () => ({\n  'tool.execute.before': async (input, output) => {\n    const tool = input?.tool;\n    const args = output?.args ?? {};\n    let request;\n    if (tool === 'read' && typeof args.filePath === 'string') {\n      request = {\n        tool: 'Read',\n        input: {\n          path: args.filePath,\n          offsetLimited: args.offset !== undefined || args.limit !== undefined,\n        },\n      };\n    } else if (tool === 'bash' && typeof args.command === 'string') {\n      request = { tool: 'Bash', input: { command: args.command } };\n    } else {\n      return;\n    }\n    const warn = (text) => process.stderr.write(text + '\\\\n');\n    const settings = core.readGuardSettings(process.cwd(), warn);\n    const decision = core.decide(request, settings, process.cwd());\n    if (decision.action !== 'deny') return;\n    if (\n      settings.enforcement === 'rewrite' &&\n      request.tool === 'Bash' &&\n      decision.suggestion !== undefined\n    ) {\n      warn(\n        ${JSON.stringify(REWRITE_ANNOUNCEMENT_OPENING)} +\n          decision.suggestion +\n          ${JSON.stringify(REWRITE_ANNOUNCEMENT_JOIN)} +\n          (decision.reason ?? ''),\n      );\n      output.args.command = decision.suggestion;\n      return;\n    }\n    throw new Error(decision.reason ?? ${JSON.stringify(DENIED_WITHOUT_REASON)});\n  },\n});\n`;\n}\n\nexport const opencode: HarnessProfile = {\n  id: 'opencode',\n  name: 'opencode',\n  tier: 'experimental',\n  detect: ['.opencode', 'opencode.json'],\n  detectHome: ['.config/opencode'],\n  instructionFile: 'AGENTS.md',\n  instructions: 'snippet',\n  caveats: [\n    'MCP tools can bypass opencode plugin hooks (sst/opencode#2319) — the guard sees built-in tools only',\n  ],\n  install: [\n    {\n      kind: 'own-file',\n      file: '.opencode/plugin/smelt-guard.js',\n      content: opencodePluginSource,\n      guardOnly: true,\n    },\n  ],\n};\n"]}

package/dist/harness/opencode.js

@@ -0,0 +1,97 @@
+import { DENIED_WITHOUT_REASON, REWRITE_ANNOUNCEMENT_JOIN, REWRITE_ANNOUNCEMENT_OPENING, } from '../hooks/shim.js';
+import { guardCoreScriptPath, portablePath } from './paths.js';
+/**
+ * opencode — EXPERIMENTAL tier. Install and removal, end to end.
+ *
+ * The one harness with no shim script: its hook API is a JavaScript plugin, not a
+ * stdin schema, so what the installer writes *is* the adapter. The plugin imports the
+ * built guard core directly (the same module every shim calls) and maps
+ * `tool.execute.before` onto it, so all policy still lives in exactly one place.
+ *
+ * Its two announcements — the rewrite sentence and the reasonless deny — are spliced
+ * in from `hooks/shim.ts`'s constants rather than hand-typed into the template, where
+ * nothing could see them drift from what the shims print.
+ */
+function opencodePluginSource(ctx) {
+    const guardCore = portablePath(ctx.cwd, guardCoreScriptPath());
+    return `// smelt:hooks v1 — opencode plugin shim. EXPERIMENTAL tier: mapped from the
+// capability matrix (docs/research/2026-09-02-harness-capability-matrix.md, opencode
+// row; https://opencode.ai/docs/plugins/). This template's deny/pass/window paths
+// were exercised directly against the built guard core (verified
+// 2026-09-02), but a live opencode session has not been smoke-tested — that needs
+// provider credentials. Caveat carried from the matrix: MCP tools can bypass plugin
+// hooks (sst/opencode#2319) — this guard sees built-in tools only.
+//
+// Thin adapter: maps tool.execute.before onto the smelt guard core (zero
+// dependencies), which owns every decision. Deny mode throws (opencode surfaces the
+// reason to the model); rewrite mode substitutes the faithful replacement command —
+// announced on stderr, because the plugin API has no reason channel on a rewrite
+// and a substitution must never be silent. Both announcements below are spliced in
+// from the shims' own constants, so this copy cannot drift from theirs.
+import { pathToFileURL } from 'node:url';
+
+const GUARD_CORE = ${JSON.stringify(guardCore)};
+const core = await import(pathToFileURL(GUARD_CORE).href);
+
+export const SmeltGuard = async () => ({
+  'tool.execute.before': async (input, output) => {
+    const tool = input?.tool;
+    const args = output?.args ?? {};
+    let request;
+    if (tool === 'read' && typeof args.filePath === 'string') {
+      request = {
+        tool: 'Read',
+        input: {
+          path: args.filePath,
+          offsetLimited: args.offset !== undefined || args.limit !== undefined,
+        },
+      };
+    } else if (tool === 'bash' && typeof args.command === 'string') {
+      request = { tool: 'Bash', input: { command: args.command } };
+    } else {
+      return;
+    }
+    const warn = (text) => process.stderr.write(text + '\\n');
+    const settings = core.readGuardSettings(process.cwd(), warn);
+    const decision = core.decide(request, settings, process.cwd());
+    if (decision.action !== 'deny') return;
+    if (
+      settings.enforcement === 'rewrite' &&
+      request.tool === 'Bash' &&
+      decision.suggestion !== undefined
+    ) {
+      warn(
+        ${JSON.stringify(REWRITE_ANNOUNCEMENT_OPENING)} +
+          decision.suggestion +
+          ${JSON.stringify(REWRITE_ANNOUNCEMENT_JOIN)} +
+          (decision.reason ?? ''),
+      );
+      output.args.command = decision.suggestion;
+      return;
+    }
+    throw new Error(decision.reason ?? ${JSON.stringify(DENIED_WITHOUT_REASON)});
+  },
+});
+`;
+}
+export const opencode = {
+    id: 'opencode',
+    name: 'opencode',
+    tier: 'experimental',
+    detect: ['.opencode', 'opencode.json'],
+    detectHome: ['.config/opencode'],
+    instructionFile: 'AGENTS.md',
+    instructions: 'snippet',
+    caveats: [
+        'MCP tools can bypass opencode plugin hooks (sst/opencode#2319) — the guard sees built-in tools only',
+    ],
+    install: [
+        {
+            kind: 'own-file',
+            file: '.opencode/plugin/smelt-guard.js',
+            content: opencodePluginSource,
+            guardOnly: true,
+        },
+    ],
+};
+//# sourceMappingURL=opencode.js.map

package/dist/harness/opencode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode.js","sourceRoot":"","sources":["../../src/harness/opencode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,4BAA4B,GAC7B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/D;;;;;;;;;;;GAWG;AACH,SAAS,oBAAoB,CAAC,GAA0B;IACtD,MAAM,SAAS,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,mBAAmB,EAAE,CAAC,CAAC;IAC/D,OAAO;;;;;;;;;;;;;;;;qBAgBY,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+BpC,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC;;YAE1C,IAAI,CAAC,SAAS,CAAC,yBAAyB,CAAC;;;;;;yCAMZ,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAAC;;;CAG7E,CAAC;AACF,CAAC;AAED,MAAM,CAAC,MAAM,QAAQ,GAAmB;IACtC,EAAE,EAAE,UAAU;IACd,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,cAAc;IACpB,MAAM,EAAE,CAAC,WAAW,EAAE,eAAe,CAAC;IACtC,UAAU,EAAE,CAAC,kBAAkB,CAAC;IAChC,eAAe,EAAE,WAAW;IAC5B,YAAY,EAAE,SAAS;IACvB,OAAO,EAAE;QACP,qGAAqG;KACtG;IACD,OAAO,EAAE;QACP;YACE,IAAI,EAAE,UAAU;YAChB,IAAI,EAAE,iCAAiC;YACvC,OAAO,EAAE,oBAAoB;YAC7B,SAAS,EAAE,IAAI;SAChB;KACF;CACF,CAAC","sourcesContent":["import {\n  DENIED_WITHOUT_REASON,\n  REWRITE_ANNOUNCEMENT_JOIN,\n  REWRITE_ANNOUNCEMENT_OPENING,\n} from '../hooks/shim.ts';\n\nimport { guardCoreScriptPath, portablePath } from './paths.ts';\nimport type { HarnessInstallContext, HarnessProfile } from './profile.ts';\n\n/**\n * opencode — EXPERIMENTAL tier. Install and removal, end to end.\n *\n * The one harness with no shim script: its hook API is a JavaScript plugin, not a\n * stdin schema, so what the installer writes *is* the adapter. The plugin imports the\n * built guard core directly (the same module every shim calls) and maps\n * `tool.execute.before` onto it, so all policy still lives in exactly one place.\n *\n * Its two announcements — the rewrite sentence and the reasonless deny — are spliced\n * in from `hooks/shim.ts`'s constants rather than hand-typed into the template, where\n * nothing could see them drift from what the shims print.\n */\nfunction opencodePluginSource(ctx: HarnessInstallContext): string {\n  const guardCore = portablePath(ctx.cwd, guardCoreScriptPath());\n  return `// smelt:hooks v1 — opencode plugin shim. EXPERIMENTAL tier: mapped from the\n// capability matrix (docs/research/2026-09-02-harness-capability-matrix.md, opencode\n// row; https://opencode.ai/docs/plugins/). This template's deny/pass/window paths\n// were exercised directly against the built guard core (verified\n// 2026-09-02), but a live opencode session has not been smoke-tested — that needs\n// provider credentials. Caveat carried from the matrix: MCP tools can bypass plugin\n// hooks (sst/opencode#2319) — this guard sees built-in tools only.\n//\n// Thin adapter: maps tool.execute.before onto the smelt guard core (zero\n// dependencies), which owns every decision. Deny mode throws (opencode surfaces the\n// reason to the model); rewrite mode substitutes the faithful replacement command —\n// announced on stderr, because the plugin API has no reason channel on a rewrite\n// and a substitution must never be silent. Both announcements below are spliced in\n// from the shims' own constants, so this copy cannot drift from theirs.\nimport { pathToFileURL } from 'node:url';\n\nconst GUARD_CORE = ${JSON.stringify(guardCore)};\nconst core = await import(pathToFileURL(GUARD_CORE).href);\n\nexport const SmeltGuard = async () => ({\n  'tool.execute.before': async (input, output) => {\n    const tool = input?.tool;\n    const args = output?.args ?? {};\n    let request;\n    if (tool === 'read' && typeof args.filePath === 'string') {\n      request = {\n        tool: 'Read',\n        input: {\n          path: args.filePath,\n          offsetLimited: args.offset !== undefined || args.limit !== undefined,\n        },\n      };\n    } else if (tool === 'bash' && typeof args.command === 'string') {\n      request = { tool: 'Bash', input: { command: args.command } };\n    } else {\n      return;\n    }\n    const warn = (text) => process.stderr.write(text + '\\\\n');\n    const settings = core.readGuardSettings(process.cwd(), warn);\n    const decision = core.decide(request, settings, process.cwd());\n    if (decision.action !== 'deny') return;\n    if (\n      settings.enforcement === 'rewrite' &&\n      request.tool === 'Bash' &&\n      decision.suggestion !== undefined\n    ) {\n      warn(\n        ${JSON.stringify(REWRITE_ANNOUNCEMENT_OPENING)} +\n          decision.suggestion +\n          ${JSON.stringify(REWRITE_ANNOUNCEMENT_JOIN)} +\n          (decision.reason ?? ''),\n      );\n      output.args.command = decision.suggestion;\n      return;\n    }\n    throw new Error(decision.reason ?? ${JSON.stringify(DENIED_WITHOUT_REASON)});\n  },\n});\n`;\n}\n\nexport const opencode: HarnessProfile = {\n  id: 'opencode',\n  name: 'opencode',\n  tier: 'experimental',\n  detect: ['.opencode', 'opencode.json'],\n  detectHome: ['.config/opencode'],\n  instructionFile: 'AGENTS.md',\n  instructions: 'snippet',\n  caveats: [\n    'MCP tools can bypass opencode plugin hooks (sst/opencode#2319) — the guard sees built-in tools only',\n  ],\n  install: [\n    {\n      kind: 'own-file',\n      file: '.opencode/plugin/smelt-guard.js',\n      content: opencodePluginSource,\n      guardOnly: true,\n    },\n  ],\n};\n"]}

package/dist/harness/paths.d.ts

@@ -0,0 +1,17 @@
+import type { ShimmedHarnessProfile } from './profile.ts';
+/**
+ * The shim script a harness's hook command runs. Takes a profile rather than an id,
+ * because only a profile that carries a hook schema (or a hand-written adapter) has a
+ * shim script on disk: a path for a harness that ships none would name a file the
+ * build never produced.
+ */
+export declare function shimScriptPath(profile: ShimmedHarnessProfile): string;
+/** The guard core as a module: what the opencode plugin imports at hook time. */
+export declare function guardCoreScriptPath(): string;
+/** The `smelt` binary — quoted into the stats and map hook commands. */
+export declare function smeltBinPath(): string;
+/** Inside the project, a project-relative path travels with the repo; outside, absolute. */
+export declare function portablePath(cwd: string, absolute: string): string;
+/** `node "<script>"` — how every harness config invokes something of smelt's. */
+export declare function nodeCommand(cwd: string, script: string, args?: string): string;
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/harness/paths.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAoB1D;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAErE;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED,wEAAwE;AACxE,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,4FAA4F;AAC5F,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGlE;AAED,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,MAAM,CAE1E","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/paths.js

@@ -0,0 +1,45 @@
+import { dirname, isAbsolute, join, relative, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Where the scripts a harness config points at actually live, and how a profile names
+ * one. Path facts only — nothing here reads or writes a file.
+ */
+/**
+ * The `dist` directory of this installed package — where the shipped guard core and
+ * shim scripts live. Computed from this module's own location, which is
+ * `<pkg>/dist/harness/` in every real run (the CLI executes from `dist`); under the
+ * test runner it is `<pkg>/src/harness/`, and the substitution still points at `dist`,
+ * which is where the scripts will exist once built — the paths are written into config
+ * files for *node* to execute, never imported.
+ */
+function packageDistDir() {
+    const here = dirname(fileURLToPath(import.meta.url)); // <pkg>/(dist|src)/harness
+    return join(dirname(dirname(here)), 'dist');
+}
+/**
+ * The shim script a harness's hook command runs. Takes a profile rather than an id,
+ * because only a profile that carries a hook schema (or a hand-written adapter) has a
+ * shim script on disk: a path for a harness that ships none would name a file the
+ * build never produced.
+ */
+export function shimScriptPath(profile) {
+    return join(packageDistDir(), 'hooks', 'shims', `${profile.id}.js`);
+}
+/** The guard core as a module: what the opencode plugin imports at hook time. */
+export function guardCoreScriptPath() {
+    return join(packageDistDir(), 'hooks', 'guard-core.js');
+}
+/** The `smelt` binary — quoted into the stats and map hook commands. */
+export function smeltBinPath() {
+    return join(packageDistDir(), 'cli', 'bin.js');
+}
+/** Inside the project, a project-relative path travels with the repo; outside, absolute. */
+export function portablePath(cwd, absolute) {
+    const rel = relative(cwd, absolute);
+    return rel.startsWith('..') || isAbsolute(rel) ? absolute : rel.split(sep).join('/');
+}
+/** `node "<script>"` — how every harness config invokes something of smelt's. */
+export function nodeCommand(cwd, script, args = '') {
+    return `node "${portablePath(cwd, script)}"${args === '' ? '' : ` ${args}`}`;
+}
+//# sourceMappingURL=paths.js.map

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,209 @@
+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;
+    /**
+     * The name a *list* of harnesses uses, where the maker's own spelling carries a
+     * category suffix a list does not need — "Codex CLI" is "Codex" in a tier clause,
+     * "Hermes Agent" is "Hermes". Optional, and defaulted by {@link harnessLabel} to
+     * {@link name}: only a harness whose prose name differs from its full name carries
+     * one, and it carries it here rather than in each of the four places a tier list is
+     * rendered. "Claude Code" has no suffix to drop, and so has none.
+     */
+    readonly shortName?: 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>;
+/**
+ * The tiers, in the order every rendered tier list walks them — most claimed first.
+ * {@link TIER_HONESTY}'s key order *is* that order, so a tier cannot exist without a
+ * line saying what it means, and the order lives once.
+ */
+export declare const HARNESS_TIERS: readonly HarnessTier[];
+/**
+ * How a list of harnesses spells this one: {@link HarnessProfile.shortName} where the
+ * maker's own name carries a suffix a list does not need, else {@link
+ * HarnessProfile.name}. The help's tier clause, the wizard's sentences and the site's
+ * tier table all render through this, so they cannot spell a harness three ways.
+ */
+export declare function harnessLabel(profile: HarnessProfile): 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;
+    /** Opt-in `smelt agents lint` at session start — shares SessionStart with the map. */
+    readonly lintOnStart: 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` and `smelt agents lint` 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  /**\n   * The name a *list* of harnesses uses, where the maker's own spelling carries a\n   * category suffix a list does not need — \"Codex CLI\" is \"Codex\" in a tier clause,\n   * \"Hermes Agent\" is \"Hermes\". Optional, and defaulted by {@link harnessLabel} to\n   * {@link name}: only a harness whose prose name differs from its full name carries\n   * one, and it carries it here rather than in each of the four places a tier list is\n   * rendered. \"Claude Code\" has no suffix to drop, and so has none.\n   */\n  readonly shortName?: 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 * The tiers, in the order every rendered tier list walks them — most claimed first.\n * {@link TIER_HONESTY}'s key order *is* that order, so a tier cannot exist without a\n * line saying what it means, and the order lives once.\n */\nexport const HARNESS_TIERS: readonly HarnessTier[] = Object.keys(TIER_HONESTY) as HarnessTier[];\n\n/**\n * How a list of harnesses spells this one: {@link HarnessProfile.shortName} where the\n * maker's own name carries a suffix a list does not need, else {@link\n * HarnessProfile.name}. The help's tier clause, the wizard's sentences and the site's\n * tier table all render through this, so they cannot spell a harness three ways.\n */\nexport function harnessLabel(profile: HarnessProfile): string {\n  return profile.shortName ?? profile.name;\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  /** Opt-in `smelt agents lint` at session start — shares SessionStart with the map. */\n  readonly lintOnStart: 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` and `smelt agents lint` on\n   * 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,41 @@
+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',
+};
+/**
+ * The tiers, in the order every rendered tier list walks them — most claimed first.
+ * {@link TIER_HONESTY}'s key order *is* that order, so a tier cannot exist without a
+ * line saying what it means, and the order lives once.
+ */
+export const HARNESS_TIERS = Object.keys(TIER_HONESTY);
+/**
+ * How a list of harnesses spells this one: {@link HarnessProfile.shortName} where the
+ * maker's own name carries a suffix a list does not need, else {@link
+ * HarnessProfile.name}. The help's tier clause, the wizard's sentences and the site's
+ * tier table all render through this, so they cannot spell a harness three ways.
+ */
+export function harnessLabel(profile) {
+    return profile.shortName ?? profile.name;
+}
+/** 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;AAyGlD,yEAAyE;AACzE,MAAM,CAAC,MAAM,YAAY,GAAgC;IACvD,QAAQ,EAAE,6DAA6D;IACvE,YAAY,EACV,mGAAmG;IACrG,QAAQ,EAAE,+DAA+D;CAC1E,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAA2B,MAAM,CAAC,IAAI,CAAC,YAAY,CAAkB,CAAC;AAEhG;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,OAAuB;IAClD,OAAO,OAAO,CAAC,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;AAC3C,CAAC;AAiGD,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  /**\n   * The name a *list* of harnesses uses, where the maker's own spelling carries a\n   * category suffix a list does not need — \"Codex CLI\" is \"Codex\" in a tier clause,\n   * \"Hermes Agent\" is \"Hermes\". Optional, and defaulted by {@link harnessLabel} to\n   * {@link name}: only a harness whose prose name differs from its full name carries\n   * one, and it carries it here rather than in each of the four places a tier list is\n   * rendered. \"Claude Code\" has no suffix to drop, and so has none.\n   */\n  readonly shortName?: 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 * The tiers, in the order every rendered tier list walks them — most claimed first.\n * {@link TIER_HONESTY}'s key order *is* that order, so a tier cannot exist without a\n * line saying what it means, and the order lives once.\n */\nexport const HARNESS_TIERS: readonly HarnessTier[] = Object.keys(TIER_HONESTY) as HarnessTier[];\n\n/**\n * How a list of harnesses spells this one: {@link HarnessProfile.shortName} where the\n * maker's own name carries a suffix a list does not need, else {@link\n * HarnessProfile.name}. The help's tier clause, the wizard's sentences and the site's\n * tier table all render through this, so they cannot spell a harness three ways.\n */\nexport function harnessLabel(profile: HarnessProfile): string {\n  return profile.shortName ?? profile.name;\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  /** Opt-in `smelt agents lint` at session start — shares SessionStart with the map. */\n  readonly lintOnStart: 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` and `smelt agents lint` on\n   * 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"]}