harnery 0.30.0 → 0.31.1

package/dist/core/hooks/adapter/detect.d.ts

@@ -0,0 +1,9 @@
+import type { Adapter } from "../events/schema.js";
+/**
+ * Resolve the adapter firing the hook. The dispatcher binary is always
+ * invoked with `--adapter <name>` per the wiring in each adapter's settings
+ * file (Phase 1). Returns null when the flag is missing; caller falls
+ * through to the env-based fallback or skips emission.
+ */
+export declare function detectAdapter(argv: readonly string[]): Adapter | null;
+//# sourceMappingURL=detect.d.ts.map

package/dist/core/hooks/{harness → adapter}/detect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/harness/detect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,GAAG,IAAI,CAWrE"}
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/adapter/detect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,GAAG,IAAI,CAWrE"}

package/dist/core/hooks/{harness → adapter}/detect.js

@@ -1,26 +1,26 @@
 import { coordEnv } from "../../../lib/env.js";
 /**
- * Resolve the harness firing the hook. The dispatcher binary is always
- * invoked with `--harness <name>` per the wiring in each harness's settings
+ * Resolve the adapter firing the hook. The dispatcher binary is always
+ * invoked with `--adapter <name>` per the wiring in each adapter's settings
  * file (Phase 1). Returns null when the flag is missing; caller falls
  * through to the env-based fallback or skips emission.
  */
-export function detectHarness(argv) {
+export function detectAdapter(argv) {
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
-        if (a === "--harness") {
+        if (a === "--adapter") {
             return validate(argv[i + 1]);
         }
-        if (a.startsWith("--harness=")) {
-            return validate(a.slice("--harness=".length));
+        if (a.startsWith("--adapter=")) {
+            return validate(a.slice("--adapter=".length));
         }
     }
-    return validate(coordEnv("AGENT_COORD_HARNESS"));
+    return validate(coordEnv("AGENT_COORD_ADAPTER"));
 }
 function validate(v) {
     if (v === "claude-code" || v === "cursor" || v === "codex")
         return v;
-    // Legacy: some harnesses use `claude_code` (underscore). Map
+    // Legacy: some adapters use `claude_code` (underscore). Map
     // it through so the env-based fallback works for callers that haven't
     // updated yet.
     if (v === "claude_code")

package/dist/core/hooks/{harness → adapter}/events.d.ts

@@ -1,43 +1,44 @@
 /**
- * Canonical hook-wiring spec per harness: which settings file to write, which
- * event key maps to which `agent-hook <subcommand>`, and how each harness encodes
+ * Canonical hook-wiring spec per adapter: which settings file to write, which
+ * event key maps to which `agent-hook <subcommand>`, and how each adapter encodes
  * a command hook. Single source of truth for `harn init` (and any future docs /
  * installers) so the wired set can't drift from what agent-hook actually handles.
  *
  * The event lists + entry shapes mirror exactly what a fully-wired project uses
- * for each harness (Claude Code `.claude/settings.json`, Cursor `.cursor/hooks.json`,
+ * for each adapter (Claude Code `.claude/settings.json`, Cursor `.cursor/hooks.json`,
  * Codex `.codex/hooks.json`).
  */
-export type HarnessId = "claude-code" | "cursor" | "codex";
+export type { Adapter as AdapterId } from "../events/schema.js";
+import type { Adapter as AdapterId } from "../events/schema.js";
 export interface HookEvent {
-    /** Key under the harness settings file's `hooks` map (e.g. `SessionStart`, `preToolUse`). */
+    /** Key under the adapter settings file's `hooks` map (e.g. `SessionStart`, `preToolUse`). */
     settingsKey: string;
     /** agent-hook subcommand to invoke for this event. */
     subcommand: string;
 }
 /**
- * How a harness encodes a single command hook under `hooks.<settingsKey>`:
+ * How a adapter encodes a single command hook under `hooks.<settingsKey>`:
  * - `claude`: `[{ hooks: [{ type: "command", command }] }]` (Claude Code + Codex)
  * - `cursor`: `[{ command }]` (Cursor: flat entry, no inner `hooks` array)
  */
 export type HookEntryShape = "claude" | "cursor";
-export interface HarnessSpec {
+export interface AdapterSpec {
     /** Settings file to wire, relative to the project root. */
     settingsFile: string;
-    /** Events this harness fires, mapped to agent-hook subcommands. */
+    /** Events this adapter fires, mapped to agent-hook subcommands. */
     events: HookEvent[];
     /** Per-entry encoding under the root `hooks` object. */
     entryShape: HookEntryShape;
     /** When set, ensure this top-level `version` key in the file (Cursor requires `1`). */
     rootVersion?: number;
-    /** Harness-owned entries from older specs that `init` should remove during migration. */
+    /** Adapter-owned entries from older specs that `init` should remove during migration. */
     legacyEvents?: HookEvent[];
-    /** Strict top-level settings keys accepted by this harness, when its parser is closed. */
+    /** Strict top-level settings keys accepted by this adapter, when its parser is closed. */
     allowedTopLevelKeys?: string[];
-    /** Strict hook event keys accepted by this harness, including events harnery does not wire. */
+    /** Strict hook event keys accepted by this adapter, including events harnery does not wire. */
     allowedEventKeys?: string[];
     /**
-     * Env var the harness exports to hook processes carrying the project root
+     * Env var the adapter exports to hook processes carrying the project root
      * (e.g. Claude Code's CLAUDE_PROJECT_DIR). When set, `init` anchors the
      * agent-hook path on it so the hook still spawns when the process cwd has
      * wandered (the session shell `cd`ing into a subdirectory or off-repo).
@@ -57,6 +58,6 @@ export declare const CODEX_EVENTS: HookEvent[];
 export declare const LEGACY_CODEX_EVENTS: HookEvent[];
 /** Every hook key accepted by Codex 0.144, including events harnery does not consume. */
 export declare const CODEX_ALLOWED_EVENT_KEYS: string[];
-/** Every supported harness, fully wireable by `harn init`. */
-export declare const HARNESS_SPECS: Record<HarnessId, HarnessSpec>;
+/** Every supported adapter, fully wireable by `harn init`. */
+export declare const ADAPTER_SPECS: Record<AdapterId, AdapterSpec>;
 //# sourceMappingURL=events.d.ts.map

package/dist/core/hooks/adapter/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/adapter/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,YAAY,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhE,OAAO,KAAK,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhE,MAAM,WAAW,SAAS;IACxB,6FAA6F;IAC7F,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEjD,MAAM,WAAW,WAAW;IAC1B,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,wDAAwD;IACxD,UAAU,EAAE,cAAc,CAAC;IAC3B,uFAAuF;IACvF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yFAAyF;IACzF,YAAY,CAAC,EAAE,SAAS,EAAE,CAAC;IAC3B,0FAA0F;IAC1F,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,+FAA+F;IAC/F,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,4CAA4C;AAC5C,eAAO,MAAM,kBAAkB,EAAE,SAAS,EAYzC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,EAWpC,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,YAAY,EAAE,SAAS,EAUnC,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,mBAAmB,EAAE,SAAS,EAI1C,CAAC;AAEF,yFAAyF;AACzF,eAAO,MAAM,wBAAwB,UAWpC,CAAC;AAEF,8DAA8D;AAC9D,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,SAAS,EAAE,WAAW,CAqBxD,CAAC"}

package/dist/core/hooks/{harness → adapter}/events.js

@@ -1,11 +1,11 @@
 /**
- * Canonical hook-wiring spec per harness: which settings file to write, which
- * event key maps to which `agent-hook <subcommand>`, and how each harness encodes
+ * Canonical hook-wiring spec per adapter: which settings file to write, which
+ * event key maps to which `agent-hook <subcommand>`, and how each adapter encodes
  * a command hook. Single source of truth for `harn init` (and any future docs /
  * installers) so the wired set can't drift from what agent-hook actually handles.
  *
  * The event lists + entry shapes mirror exactly what a fully-wired project uses
- * for each harness (Claude Code `.claude/settings.json`, Cursor `.cursor/hooks.json`,
+ * for each adapter (Claude Code `.claude/settings.json`, Cursor `.cursor/hooks.json`,
  * Codex `.codex/hooks.json`).
  */
 /** Claude Code: `.claude/settings.json`. */
@@ -69,8 +69,8 @@ export const CODEX_ALLOWED_EVENT_KEYS = [
     "SubagentStop",
     "Stop",
 ];
-/** Every supported harness, fully wireable by `harn init`. */
-export const HARNESS_SPECS = {
+/** Every supported adapter, fully wireable by `harn init`. */
+export const ADAPTER_SPECS = {
     "claude-code": {
         settingsFile: ".claude/settings.json",
         events: CLAUDE_CODE_EVENTS,

package/dist/core/hooks/{harness → adapter}/output.d.ts

@@ -1,37 +1,43 @@
 /**
- * Harness-aware hook output JSON. Each adapter target has its own protocol
+ * Adapter-aware hook output JSON. Each adapter target has its own protocol
  * shape, so encode it once here so post-emit handlers don't have to branch on
- * `harness` everywhere.
+ * `adapter` everywhere.
  *
- * Shapes (verified against live dispatchers + each harness's upstream hooks docs):
+ * Shapes (verified against live dispatchers + each adapter's upstream hooks docs):
  *
  * - **Claude Code**: `{hookSpecificOutput: {hookEventName, additionalContext}}`
  *   for SessionStart / UserPromptSubmit / SubagentStart; deny uses
  *   `{hookSpecificOutput: {hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason}}`.
  * - **Cursor**: `{additional_context, env?}` flat for sessionStart /
  *   beforeSubmitPrompt; deny uses `{permission: "deny", agent_message, user_message}`.
- * - **Codex**: structurally identical to Claude Code (confirmed by Phase 0
- *   probe + the matching shape in the Codex harness adapter).
+ * - **Codex**: structurally identical to Claude Code for context and tool
+ *   denials. Stop blocks are deliberately suppressed because their automatic
+ *   continuation can replace a completed user-facing answer.
  *
  * Every helper writes to process.stdout + newline-terminates so callers can
  * fire-and-forget. Empty text → no-op (no JSON written).
  */
-import type { Harness } from "../events/schema.js";
+import type { Adapter } from "../events/schema.js";
 export type SystemEvent = "SessionStart" | "UserPromptSubmit" | "SubagentStart";
 /** Emit a context-injection (peer table, wiring check, council pending, …). */
-export declare function emitContext(harness: Harness, event: SystemEvent, text: string): void;
+export declare function emitContext(adapter: Adapter, event: SystemEvent, text: string): void;
 /** Emit a PreToolUse deny: blocks the tool call with `reason` shown to the model. */
-export declare function emitDeny(harness: Harness, reason: string): void;
+export declare function emitDeny(adapter: Adapter, reason: string): void;
 /**
- * Emit a Stop-hook block in the firing harness's enforcement channel and return
+ * Emit a Stop-hook block in the firing adapter's enforcement channel and return
  * the process exit code the caller should use.
  *
- * The verdict (allow/block + reason) is computed harness-agnostically in
+ * The verdict (allow/block + reason) is computed adapter-agnostically in
  * agents/rules/stop-hook.ts; this function only shapes *how the block is
- * communicated back*, because each harness has a different mechanism:
+ * communicated back*, because each adapter has a different mechanism:
  *
- * - **Claude Code / Codex** honor `exit 2` + a stderr reason as a turn block,
- *   and the harness re-prompts the model with the stderr text.
+ * - **Claude Code** honors `exit 2` + a stderr reason as a turn block, and the
+ *   adapter re-prompts the model with the stderr text.
+ * - **Codex** also supports that channel, but Harnery must not use it for
+ *   coordination reminders. A Stop continuation can replace the completed
+ *   answer in clients that retain only the final continuation response. Return
+ *   success without output as a defense in depth behind the observe-only
+ *   verdict in `agents/rules/stop-hook.ts`.
  * - **Cursor** ignores stop-hook exit codes (non-zero = fail-open, the turn
  *   proceeds) and re-prompts ONLY via a `followup_message` field in stdout
  *   JSON, which it auto-submits as the next user message: the sanctioned
@@ -39,7 +45,7 @@ export declare function emitDeny(harness: Harness, reason: string): void;
  *   We exit 0 so Cursor treats the run as a success and honors the output.
  *   (Confirmed against cursor.com/docs/agent/hooks.)
  */
-export declare function emitStopBlock(harness: Harness, verdict: {
+export declare function emitStopBlock(adapter: Adapter, verdict: {
     reason?: string;
     rule: string;
 }): 0 | 2;

package/dist/core/hooks/adapter/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/adapter/output.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,kBAAkB,GAAG,eAAe,CAAC;AAEhF,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAIpF;AAED,qFAAqF;AACrF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAI/D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,CAAC,GAAG,CAAC,CAYjG"}

package/dist/core/hooks/{harness → adapter}/output.js

@@ -1,45 +1,51 @@
 /**
- * Harness-aware hook output JSON. Each adapter target has its own protocol
+ * Adapter-aware hook output JSON. Each adapter target has its own protocol
  * shape, so encode it once here so post-emit handlers don't have to branch on
- * `harness` everywhere.
+ * `adapter` everywhere.
  *
- * Shapes (verified against live dispatchers + each harness's upstream hooks docs):
+ * Shapes (verified against live dispatchers + each adapter's upstream hooks docs):
  *
  * - **Claude Code**: `{hookSpecificOutput: {hookEventName, additionalContext}}`
  *   for SessionStart / UserPromptSubmit / SubagentStart; deny uses
  *   `{hookSpecificOutput: {hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason}}`.
  * - **Cursor**: `{additional_context, env?}` flat for sessionStart /
  *   beforeSubmitPrompt; deny uses `{permission: "deny", agent_message, user_message}`.
- * - **Codex**: structurally identical to Claude Code (confirmed by Phase 0
- *   probe + the matching shape in the Codex harness adapter).
+ * - **Codex**: structurally identical to Claude Code for context and tool
+ *   denials. Stop blocks are deliberately suppressed because their automatic
+ *   continuation can replace a completed user-facing answer.
  *
  * Every helper writes to process.stdout + newline-terminates so callers can
  * fire-and-forget. Empty text → no-op (no JSON written).
  */
 /** Emit a context-injection (peer table, wiring check, council pending, …). */
-export function emitContext(harness, event, text) {
+export function emitContext(adapter, event, text) {
     if (!text || text.length === 0)
         return;
-    const json = buildContextJson(harness, event, text);
+    const json = buildContextJson(adapter, event, text);
     process.stdout.write(`${JSON.stringify(json)}\n`);
 }
 /** Emit a PreToolUse deny: blocks the tool call with `reason` shown to the model. */
-export function emitDeny(harness, reason) {
+export function emitDeny(adapter, reason) {
     if (!reason)
         return;
-    const json = buildDenyJson(harness, reason);
+    const json = buildDenyJson(adapter, reason);
     process.stdout.write(`${JSON.stringify(json)}\n`);
 }
 /**
- * Emit a Stop-hook block in the firing harness's enforcement channel and return
+ * Emit a Stop-hook block in the firing adapter's enforcement channel and return
  * the process exit code the caller should use.
  *
- * The verdict (allow/block + reason) is computed harness-agnostically in
+ * The verdict (allow/block + reason) is computed adapter-agnostically in
  * agents/rules/stop-hook.ts; this function only shapes *how the block is
- * communicated back*, because each harness has a different mechanism:
+ * communicated back*, because each adapter has a different mechanism:
  *
- * - **Claude Code / Codex** honor `exit 2` + a stderr reason as a turn block,
- *   and the harness re-prompts the model with the stderr text.
+ * - **Claude Code** honors `exit 2` + a stderr reason as a turn block, and the
+ *   adapter re-prompts the model with the stderr text.
+ * - **Codex** also supports that channel, but Harnery must not use it for
+ *   coordination reminders. A Stop continuation can replace the completed
+ *   answer in clients that retain only the final continuation response. Return
+ *   success without output as a defense in depth behind the observe-only
+ *   verdict in `agents/rules/stop-hook.ts`.
  * - **Cursor** ignores stop-hook exit codes (non-zero = fail-open, the turn
  *   proceeds) and re-prompts ONLY via a `followup_message` field in stdout
  *   JSON, which it auto-submits as the next user message: the sanctioned
@@ -47,22 +53,24 @@ export function emitDeny(harness, reason) {
  *   We exit 0 so Cursor treats the run as a success and honors the output.
  *   (Confirmed against cursor.com/docs/agent/hooks.)
  */
-export function emitStopBlock(harness, verdict) {
+export function emitStopBlock(adapter, verdict) {
+    if (adapter === "codex")
+        return 0;
     const message = `${verdict.reason ?? "End-of-turn coordination ritual incomplete."}\n[agent-hook stop]: rule=${verdict.rule}`;
-    if (harness === "cursor") {
+    if (adapter === "cursor") {
         process.stdout.write(`${JSON.stringify({ followup_message: message })}\n`);
         return 0;
     }
     process.stderr.write(`${message}\n`);
     return 2;
 }
-function buildContextJson(harness, event, text) {
-    if (harness === "cursor") {
+function buildContextJson(adapter, event, text) {
+    if (adapter === "cursor") {
         // Cursor uses a flat top-level key + an env block that survives across the
         // session. The dispatcher historically also wrote
-        // `env: {HARNERY_AGENT_COORD_HARNESS, HARNERY_AGENT_COORD_PLATFORM}`. These are
+        // `env: {HARNERY_AGENT_COORD_ADAPTER, HARNERY_AGENT_COORD_PLATFORM}`. These are
         // observer hints, not load-bearing; agent-hook + agent-coord recover the
-        // harness from event metadata. Drop them.
+        // adapter from event metadata. Drop them.
         return { additional_context: text };
     }
     // Claude Code + Codex share the `hookSpecificOutput` envelope.
@@ -73,8 +81,8 @@ function buildContextJson(harness, event, text) {
         },
     };
 }
-function buildDenyJson(harness, reason) {
-    if (harness === "cursor") {
+function buildDenyJson(adapter, reason) {
+    if (adapter === "cursor") {
         return { permission: "deny", agent_message: reason, user_message: reason };
     }
     return {

package/dist/core/hooks/{harness → adapter}/parse.d.ts

@@ -1,5 +1,5 @@
 /**
- * Harness payload parser. One file because all three harnesses (CC, Cursor,
+ * Adapter payload parser. One file because all three adapters (CC, Cursor,
  * Codex) share most of their PreToolUse / PostToolUse field names (Codex's
  * field names match CC's directly) and Cursor's deltas are small enough to
  * branch inline.
@@ -9,7 +9,7 @@
  * Phase 2 ship criterion is "parser correctness across thousands of real
  * events without affecting behavior": fail-soft beats fail-hard.
  */
-import type { Harness } from "../events/schema.js";
+import type { Adapter } from "../events/schema.js";
 export interface ParsedPayload {
     hook_event_name?: string;
     session_id?: string;
@@ -37,10 +37,10 @@ export interface ParsedPayload {
     raw: Record<string, unknown>;
 }
 /**
- * Parse the raw stdin payload string for any harness. Returns null when JSON
+ * Parse the raw stdin payload string for any adapter. Returns null when JSON
  * parse fails (Cursor occasionally fires hooks with no payload).
  */
-export declare function parsePayload(raw: string, _harness: Harness): ParsedPayload | null;
+export declare function parsePayload(raw: string, _adapter: Adapter): ParsedPayload | null;
 /**
  * Pull the bash command string out of a Bash/Shell tool_input. Returns
  * undefined for non-shell tools.
@@ -52,7 +52,7 @@ export declare function extractBashCommand(toolName: string | undefined, toolInp
  */
 export declare function extractToolDescription(toolInput: unknown): string | undefined;
 /**
- * Each harness uses a slightly different name for the "same" lifecycle event.
+ * Each adapter uses a slightly different name for the "same" lifecycle event.
  * Map the CLI-arg event-name (kebab-case, set by us in the wiring) to one of
  * the canonical event_types. Phase 2's CLI passes the kebab event
  * name; this returns the canonical event_type or null when the event has no

package/dist/core/hooks/{harness → adapter}/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/harness/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,MAAM,WAAW,aAAa;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uFAAuF;IACvF,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,aAAa,GAAG,IAAI,CAkCjF;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,SAAS,EAAE,OAAO,GACjB,MAAM,GAAG,SAAS,CASpB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAO7E;AAmBD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,GAChB;IAAE,UAAU,EAAE,mBAAmB,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAiCjE;AAED,MAAM,MAAM,mBAAmB,GAC3B,eAAe,GACf,aAAa,GACb,oBAAoB,GACpB,WAAW,GACX,gBAAgB,GAChB,eAAe,GACf,cAAc,GACd,eAAe,GACf,uBAAuB,GACvB,4BAA4B,GAC5B,8BAA8B,CAAC"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/adapter/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,MAAM,WAAW,aAAa;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uFAAuF;IACvF,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,aAAa,GAAG,IAAI,CAkCjF;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,SAAS,EAAE,OAAO,GACjB,MAAM,GAAG,SAAS,CASpB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAO7E;AAmBD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,GAChB;IAAE,UAAU,EAAE,mBAAmB,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAiCjE;AAED,MAAM,MAAM,mBAAmB,GAC3B,eAAe,GACf,aAAa,GACb,oBAAoB,GACpB,WAAW,GACX,gBAAgB,GAChB,eAAe,GACf,cAAc,GACd,eAAe,GACf,uBAAuB,GACvB,4BAA4B,GAC5B,8BAA8B,CAAC"}

package/dist/core/hooks/{harness → adapter}/parse.js

@@ -1,5 +1,5 @@
 /**
- * Harness payload parser. One file because all three harnesses (CC, Cursor,
+ * Adapter payload parser. One file because all three adapters (CC, Cursor,
  * Codex) share most of their PreToolUse / PostToolUse field names (Codex's
  * field names match CC's directly) and Cursor's deltas are small enough to
  * branch inline.
@@ -10,10 +10,10 @@
  * events without affecting behavior": fail-soft beats fail-hard.
  */
 /**
- * Parse the raw stdin payload string for any harness. Returns null when JSON
+ * Parse the raw stdin payload string for any adapter. Returns null when JSON
  * parse fails (Cursor occasionally fires hooks with no payload).
  */
-export function parsePayload(raw, _harness) {
+export function parsePayload(raw, _adapter) {
     if (!raw || raw.trim().length === 0)
         return null;
     let json;
@@ -93,7 +93,7 @@ function pickBool(o, k) {
 }
 // ── Event-name normalization ────────────────────────────────────────────────
 /**
- * Each harness uses a slightly different name for the "same" lifecycle event.
+ * Each adapter uses a slightly different name for the "same" lifecycle event.
  * Map the CLI-arg event-name (kebab-case, set by us in the wiring) to one of
  * the canonical event_types. Phase 2's CLI passes the kebab event
  * name; this returns the canonical event_type or null when the event has no

package/dist/core/hooks/{harness → adapter}/wiring.d.ts

@@ -1,7 +1,7 @@
 /**
- * Read-only harness-hook wiring inspection — the inverse of `harn init`'s
+ * Read-only adapter-hook wiring inspection — the inverse of `harn init`'s
  * writer (commands/init.ts `wireHooks`). Compares what `init` would wire
- * (HARNESS_SPECS) against what's actually present in a project's harness
+ * (ADAPTER_SPECS) against what's actually present in a project's adapter
  * settings file, so `harn doctor` and the SessionStart nudge can tell an agent
  * when a harnery upgrade changed the hook set but the project hasn't been
  * re-wired yet.
@@ -10,7 +10,7 @@
  * doctor check, and the session-start renderer all agree on what "wired" means
  * — there's exactly one definition of the `agent-hook <subcommand>` match.
  */
-import { type HarnessId, type HarnessSpec, type HookEntryShape, type HookEvent } from "./events.js";
+import { type AdapterId, type AdapterSpec, type HookEntryShape, type HookEvent } from "./events.js";
 /** Claude Code + Codex entry: `{ hooks: [{ type, command }] }`. */
 export interface ClaudeHookGroup {
     matcher?: string;
@@ -32,7 +32,7 @@ export interface SettingsFile {
     hooks?: Record<string, HookGroup[]>;
     [k: string]: unknown;
 }
-/** Build a hook entry in the harness's shape. */
+/** Build a hook entry in the adapter's shape. */
 export declare function makeEntry(shape: HookEntryShape, command: string): HookGroup;
 /** Pull every command string out of a hook entry, regardless of shape. */
 export declare function groupCommands(group: HookGroup): string[];
@@ -52,18 +52,18 @@ export interface WiringDiff {
      * these — they need explicit removal — so they're surfaced separately.
      */
     orphans: string[];
-    /** Settings fields rejected by a harness with a strict top-level schema. */
+    /** Settings fields rejected by a adapter with a strict top-level schema. */
     invalidTopLevelKeys: string[];
-    /** Hook event names rejected by a harness with a strict event schema. */
+    /** Hook event names rejected by a adapter with a strict event schema. */
     invalidEventKeys: string[];
 }
 /**
- * Pure diff of one settings object against one harness spec. Read-only inverse
+ * Pure diff of one settings object against one adapter spec. Read-only inverse
  * of `wireHooks`; no fs, so it's unit-testable.
  */
-export declare function diffWiring(settings: SettingsFile, spec: HarnessSpec): WiringDiff;
-export interface HarnessWiringStatus {
-    harness: HarnessId;
+export declare function diffWiring(settings: SettingsFile, spec: AdapterSpec): WiringDiff;
+export interface AdapterWiringStatus {
+    adapter: AdapterId;
     /** Settings file path, relative to the project root. */
     settingsFile: string;
     missing: HookEvent[];
@@ -73,17 +73,17 @@ export interface HarnessWiringStatus {
     parseError?: string;
 }
 /**
- * Inspect every harness whose settings file exists under `projectRoot` and
+ * Inspect every adapter whose settings file exists under `projectRoot` and
  * return only those with *drift*. Read-only; never writes.
  *
- * Drift is reported only for a harness the project has **already opted into** —
+ * Drift is reported only for a adapter the project has **already opted into** —
  * i.e. at least one harnery hook is already wired. A settings file with zero
- * harnery hooks just means this harness isn't harnery-wired here (a bare
+ * harnery hooks just means this adapter isn't harnery-wired here (a bare
  * `.claude/settings.json` is a generic Claude Code file); that's `harn init`'s
- * job to surface on first run, not drift to nag about every session. A harness
+ * job to surface on first run, not drift to nag about every session. A adapter
  * with no settings file at all, or an unparseable one, is skipped.
  */
-export declare function loadHarnessWiring(projectRoot: string): HarnessWiringStatus[];
+export declare function loadAdapterWiring(projectRoot: string): AdapterWiringStatus[];
 /**
  * Resolve the harnery package version for context in nudges/checks. Walks up
  * from this module to the package root (works under Bun from `src/` and Node

package/dist/core/hooks/{harness → adapter}/wiring.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wiring.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/harness/wiring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,SAAS,EACf,MAAM,aAAa,CAAC;AAErB,mEAAmE;AACnE,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC5C;AACD,0CAA0C;AAC1C,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AACD,MAAM,MAAM,SAAS,GAAG,eAAe,GAAG,eAAe,CAAC;AAE1D,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IACpC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB;AAED,iDAAiD;AACjD,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAE3E;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,EAAE,CAMxD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAEnF;AAQD,MAAM,WAAW,UAAU;IACzB,kDAAkD;IAClD,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,iCAAiC;IACjC,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB;;;;OAIG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,4EAA4E;IAC5E,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,GAAG,UAAU,CA2ChF;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,SAAS,CAAC;IACnB,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,mBAAmB,EAAE,CAwC5E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAkBvC"}
+{"version":3,"file":"wiring.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/adapter/wiring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,SAAS,EACf,MAAM,aAAa,CAAC;AAErB,mEAAmE;AACnE,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC5C;AACD,0CAA0C;AAC1C,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AACD,MAAM,MAAM,SAAS,GAAG,eAAe,GAAG,eAAe,CAAC;AAE1D,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IACpC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB;AAED,iDAAiD;AACjD,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAE3E;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,EAAE,CAMxD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAEnF;AAQD,MAAM,WAAW,UAAU;IACzB,kDAAkD;IAClD,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,iCAAiC;IACjC,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB;;;;OAIG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,4EAA4E;IAC5E,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,GAAG,UAAU,CA2ChF;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,SAAS,CAAC;IACnB,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,mBAAmB,EAAE,CAwC5E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAkBvC"}

package/dist/core/hooks/{harness → adapter}/wiring.js

@@ -1,7 +1,7 @@
 /**
- * Read-only harness-hook wiring inspection — the inverse of `harn init`'s
+ * Read-only adapter-hook wiring inspection — the inverse of `harn init`'s
  * writer (commands/init.ts `wireHooks`). Compares what `init` would wire
- * (HARNESS_SPECS) against what's actually present in a project's harness
+ * (ADAPTER_SPECS) against what's actually present in a project's adapter
  * settings file, so `harn doctor` and the SessionStart nudge can tell an agent
  * when a harnery upgrade changed the hook set but the project hasn't been
  * re-wired yet.
@@ -13,8 +13,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { HARNESS_SPECS, } from "./events.js";
-/** Build a hook entry in the harness's shape. */
+import { ADAPTER_SPECS, } from "./events.js";
+/** Build a hook entry in the adapter's shape. */
 export function makeEntry(shape, command) {
     return shape === "cursor" ? { command } : { hooks: [{ type: "command", command }] };
 }
@@ -40,7 +40,7 @@ function commandSubcommand(command) {
     return m ? m[1] : null;
 }
 /**
- * Pure diff of one settings object against one harness spec. Read-only inverse
+ * Pure diff of one settings object against one adapter spec. Read-only inverse
  * of `wireHooks`; no fs, so it's unit-testable.
  */
 export function diffWiring(settings, spec) {
@@ -84,19 +84,19 @@ export function diffWiring(settings, spec) {
     };
 }
 /**
- * Inspect every harness whose settings file exists under `projectRoot` and
+ * Inspect every adapter whose settings file exists under `projectRoot` and
  * return only those with *drift*. Read-only; never writes.
  *
- * Drift is reported only for a harness the project has **already opted into** —
+ * Drift is reported only for a adapter the project has **already opted into** —
  * i.e. at least one harnery hook is already wired. A settings file with zero
- * harnery hooks just means this harness isn't harnery-wired here (a bare
+ * harnery hooks just means this adapter isn't harnery-wired here (a bare
  * `.claude/settings.json` is a generic Claude Code file); that's `harn init`'s
- * job to surface on first run, not drift to nag about every session. A harness
+ * job to surface on first run, not drift to nag about every session. A adapter
  * with no settings file at all, or an unparseable one, is skipped.
  */
-export function loadHarnessWiring(projectRoot) {
+export function loadAdapterWiring(projectRoot) {
     const out = [];
-    for (const [id, spec] of Object.entries(HARNESS_SPECS)) {
+    for (const [id, spec] of Object.entries(ADAPTER_SPECS)) {
         const settingsPath = resolve(projectRoot, spec.settingsFile);
         if (!existsSync(settingsPath))
             continue;
@@ -106,7 +106,7 @@ export function loadHarnessWiring(projectRoot) {
         }
         catch (error) {
             out.push({
-                harness: id,
+                adapter: id,
                 settingsFile: spec.settingsFile,
                 missing: [],
                 orphans: [],
@@ -126,7 +126,7 @@ export function loadHarnessWiring(projectRoot) {
             continue; // current
         }
         out.push({
-            harness: id,
+            adapter: id,
             settingsFile: spec.settingsFile,
             missing: diff.missing,
             orphans: diff.orphans,

package/dist/core/hooks/cli.d.ts

@@ -3,8 +3,8 @@
  * alongside the legacy stream.
  *
  * Flow:
- *   1. Parse argv → event-name + harness.
- *   2. Read stdin → harness payload (JSON or empty).
+ *   1. Parse argv → event-name + adapter.
+ *   2. Read stdin → adapter payload (JSON or empty).
  *   3. Find coord root (walk up for .harnery/).
  *   4. Resolve instance_id (env → payload → pid-map walk).
  *   5. Map event-name → canonical event_type.
@@ -15,7 +15,7 @@
  * Phase 2 ship criterion: confirms parser correctness across thousands of
  * real events without affecting behavior. Always exits 0. Failures land in
  * `.harnery/debug/agent-hook.errors.ndjson` for audit but never break the
- * harness flow.
+ * adapter flow.
  */
 export {};
 //# sourceMappingURL=cli.d.ts.map