harnery 0.40.0 → 0.42.0

package/dist/commands/init.js

@@ -7,9 +7,13 @@
  *      null and every hook no-ops forever.
  *   2. Register the agent-hook entries in the adapter settings file.
  *
- * Wires whichever adapter `--adapter` names (Claude Code `.claude/settings.json`,
- * Cursor `.cursor/hooks.json`, or Codex `.codex/hooks.json`): the per-adapter
- * file path, event list, and hook-entry shape all come from ADAPTER_SPECS.
+ * Wires every adapter in the resolved set (Claude Code `.claude/settings.json`,
+ * Cursor `.cursor/hooks.json`, Codex `.codex/hooks.json`, or the OpenCode plugin
+ * directory `.opencode/plugins/harnery/`): the per-adapter file path, event list,
+ * and hook-entry shape all come from ADAPTER_SPECS. `--adapter` is repeatable (or
+ * comma-separated, or `all`); with no flag, init wires every adapter whose CLI is
+ * installed on this machine, plus any adapter the project already has wired, else
+ * claude-code.
  *
  * `harn init` does both, non-destructively: it merges hook entries into an
  * existing settings file (preserving any other hooks) and skips entries that are
@@ -20,19 +24,132 @@ import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { DEFAULT_BIN_NAME, pinnedBinName, stripJsonComments } from "../core/config.js";
+import { codexWindowsBridgeConfig, DEFAULT_BIN_NAME, pinnedBinName, stripJsonComments, } from "../core/config.js";
 import { canonicalJsonV3 } from "../core/events/v3/canonical.js";
 import { ADAPTER_CAPABILITY_PROFILES_V3 } from "../core/events/v3/capabilities.js";
 import { EVENT_V3_SCHEMA_DIGEST } from "../core/events/v3/generated.js";
 import { initializeEventLedgerV3, readEventV3ControlState, sha256V3, } from "../core/events/v3/index.js";
 import { ADAPTER_SPECS } from "../core/hooks/adapter/events.js";
-import { agentHookPathForProject, commandWiresSubcommand, diffWiring, groupCommands, hookCommand, isAgentHookCommand, makeEntry, } from "../core/hooks/adapter/wiring.js";
+import { checkOpenCodePlugin, installOpenCodePlugin, } from "../core/hooks/adapter/opencode-plugin.js";
+import { agentHookPathForProject, applyCursorStopLoopLimit, CURSOR_STOP_FOLLOWUP_LOOP_LIMIT, commandWiresSubcommand, diffWiring, expectedCommandWindows, groupCommands, hookCommand, hookTimeoutFor, isAgentHookCommand, makeEntry, orderHandlerKeys, summarizeAdapterWiring, } from "../core/hooks/adapter/wiring.js";
+import { detectInstalledAdapters } from "../core/workflow/adapters.js";
 import { applyIndexerExclusions } from "../lib/indexer-exclusions.js";
 import { applyInstructions, checkInstructions, } from "../lib/instructions/apply.js";
 import { applyGitHooks, checkGitHooks } from "../lib/instructions/git-hooks.js";
 import { HostAddendumError } from "../lib/instructions/host-addendum.js";
 // This file is src/commands/init.ts → harnery package root is two levels up.
 const HARNERY_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const ADAPTER_IDS = Object.keys(ADAPTER_SPECS);
+/** Parse explicit `--adapter` values; `all` expands and order is preserved, deduplicated. */
+function parseAdapterIds(requested) {
+    const adapters = [];
+    for (const raw of requested) {
+        const ids = raw === "all" ? ADAPTER_IDS : [raw];
+        for (const id of ids) {
+            if (!(id in ADAPTER_SPECS)) {
+                return {
+                    adapters: [],
+                    error: `Unknown adapter '${raw}'. Expected: ${ADAPTER_IDS.join(" | ")} | all.`,
+                };
+            }
+            if (!adapters.includes(id))
+                adapters.push(id);
+        }
+    }
+    return { adapters };
+}
+/**
+ * Which adapters `init` should wire. An explicit `--adapter` wins. Without one:
+ * every adapter whose CLI is installed on this machine, plus every adapter the
+ * project already has wired (committed wiring stays current on a box whose CLI is
+ * absent, e.g. CI). A machine with neither falls back to the historical
+ * claude-code default. `installed` is injectable so tests never key on the host's
+ * toolchain.
+ */
+export function resolveInitAdapters(projectRoot, requested, installed) {
+    if (requested.length > 0)
+        return parseAdapterIds(requested);
+    const detected = installed ?? detectInstalledAdapters();
+    const wired = summarizeAdapterWiring(projectRoot).wired;
+    const adapters = ADAPTER_IDS.filter((id) => detected.includes(id) || wired.includes(id));
+    return { adapters: adapters.length > 0 ? adapters : ["claude-code"] };
+}
+/** Drift check for one adapter's runtime wiring (settings hooks or the OpenCode plugin). */
+function checkAdapterHooks(projectRoot, adapter, bin) {
+    const spec = ADAPTER_SPECS[adapter];
+    const agentHook = agentHookPathForProject(projectRoot, HARNERY_ROOT);
+    if (spec.installMode === "opencode-plugin") {
+        // No hooks map to diff: the plugin directory is the wiring.
+        const plugin = checkOpenCodePlugin(projectRoot, { binName: bin, agentHook });
+        if (plugin.status === "missing") {
+            return {
+                drift: true,
+                error: false,
+                issues: [`${spec.settingsFile}: missing (re-run \`init --adapter opencode\`)`],
+            };
+        }
+        if (plugin.status === "foreign")
+            return { drift: false, error: true, issues: plugin.issues };
+        if (plugin.status === "stale")
+            return { drift: true, error: false, issues: plugin.issues };
+        return { drift: false, error: false, issues: [] };
+    }
+    const settingsPath = resolve(projectRoot, spec.settingsFile);
+    if (!existsSync(settingsPath)) {
+        return { drift: true, error: false, issues: [`${spec.settingsFile}: missing (re-run init)`] };
+    }
+    const issues = [];
+    let drift = false;
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+        const hookDiff = diffWiring(settings, spec, {
+            agentHookPath: agentHook,
+            adapter,
+            windowsBridgeEntryPoint: codexWindowsBridgeConfig(projectRoot).entryPoint,
+        });
+        drift =
+            hookDiff.missing.length > 0 ||
+                hookDiff.stale.length > 0 ||
+                hookDiff.duplicates.length > 0 ||
+                hookDiff.misplaced.length > 0 ||
+                hookDiff.orphans.length > 0 ||
+                hookDiff.invalidTopLevelKeys.length > 0 ||
+                hookDiff.invalidEventKeys.length > 0;
+        if (hookDiff.missing.length > 0) {
+            issues.push(`${spec.settingsFile}: missing hooks (${hookDiff.missing.map((e) => e.settingsKey).join(", ")})`);
+        }
+        if (hookDiff.stale.length > 0) {
+            issues.push(`${spec.settingsFile}: stale hook commands (${hookDiff.stale.map((e) => e.settingsKey).join(", ")})`);
+        }
+        if (hookDiff.duplicates.length > 0) {
+            issues.push(`${spec.settingsFile}: duplicate hooks (${hookDiff.duplicates.map((e) => e.settingsKey).join(", ")})`);
+        }
+        if (hookDiff.misplaced.length > 0) {
+            issues.push(`${spec.settingsFile}: hooks under the wrong event (${hookDiff.misplaced.map((e) => e.subcommand).join(", ")})`);
+        }
+        if (hookDiff.orphans.length > 0) {
+            issues.push(`${spec.settingsFile}: obsolete hooks (${hookDiff.orphans.join(", ")})`);
+        }
+        if (hookDiff.invalidTopLevelKeys.length > 0) {
+            issues.push(`${spec.settingsFile}: invalid fields (${hookDiff.invalidTopLevelKeys.join(", ")})`);
+        }
+        if (hookDiff.invalidEventKeys.length > 0) {
+            issues.push(`${spec.settingsFile}: unsupported events (${hookDiff.invalidEventKeys.join(", ")})`);
+        }
+    }
+    catch (error) {
+        return {
+            drift: false,
+            error: true,
+            issues: [`${spec.settingsFile}: invalid JSON (${error.message})`],
+        };
+    }
+    return { drift, error: false, issues };
+}
+/** Preserve first-seen order while dropping repeats (one pass per adapter repeats lines). */
+function dedupe(values) {
+    return [...new Set(values)];
+}
 export function registerInitCommand(program, emit, binName) {
     program
         .command("init")
@@ -40,19 +157,16 @@ export function registerInitCommand(program, emit, binName) {
         "hooks, and inject the agent-facing instructions block + skills " +
         "(idempotent; safe to re-run). Use --dry-run to preview, --check to " +
         "report drift without writing (exit 0 fresh / 2 drift / 1 error).")
-        .option("--adapter <id>", "claude-code | cursor | codex", "claude-code")
+        .option("--adapter <id>", "claude-code | cursor | codex | opencode | all; repeatable or comma-separated. " +
+        "Default: every adapter installed on this machine plus every adapter already wired, else claude-code", (value, previous) => previous.concat(value
+        .split(",")
+        .map((id) => id.trim())
+        .filter(Boolean)), [])
         .option("--dry-run", "Show what would change without writing")
         .option("--check", "Report managed-surface drift without writing; exit 0/2/1")
         .option("--instructions-only", "Refresh only AGENTS.md regions and Harnery-owned skills; leave runtime wiring untouched")
         .option("--project-root <path>", "Project root (default: git toplevel, else cwd)")
         .action((opts) => {
-        const adapter = opts.adapter;
-        const spec = ADAPTER_SPECS[adapter];
-        if (!spec) {
-            emit.text(`Unknown adapter '${opts.adapter}'. Expected: claude-code | cursor | codex.`);
-            emit.setExitCode(1);
-            return;
-        }
         const projectRoot = resolve(opts.projectRoot ?? gitTopLevel() ?? process.cwd());
         // A binName already pinned in this project's config.jsonc beats the
         // invoking CLI's name: the pin is a committed, deliberate declaration;
@@ -66,6 +180,15 @@ export function registerInitCommand(program, emit, binName) {
         // before every coord-root, config, ledger, adapter-settings, and Git-hook
         // operation so its no-runtime-writes contract is structural.
         if (opts.instructionsOnly === true) {
+            // Narrow by design: host sync tooling depends on one deterministic
+            // guidance layout, so this mode stays single-adapter and never detects.
+            const parsed = parseAdapterIds(opts.adapter);
+            if (parsed.error) {
+                emit.text(parsed.error);
+                emit.setExitCode(1);
+                return;
+            }
+            const adapter = parsed.adapters[0] ?? "claude-code";
             if (opts.check === true) {
                 const { status, issues } = checkInstructions(projectRoot, { binName: bin, adapter });
                 const head = status === "fresh"
@@ -95,55 +218,31 @@ export function registerInitCommand(program, emit, binName) {
             emit.text(renderInstructionsOnly(projectRoot, bin, dryRun, applied.actions, applied.warnings));
             return;
         }
+        const resolved = resolveInitAdapters(projectRoot, opts.adapter);
+        if (resolved.error) {
+            emit.text(resolved.error);
+            emit.setExitCode(1);
+            return;
+        }
+        const adapters = resolved.adapters;
         // ── --check: read-only drift report on every init-managed surface ─────
         if (opts.check === true) {
-            const { status, issues } = checkInstructions(projectRoot, { binName: bin, adapter });
+            const issues = [];
+            let instructionStatus = "fresh";
             let hookCheckError = false;
             let hookDrift = false;
-            const settingsPath = resolve(projectRoot, spec.settingsFile);
-            const agentHook = agentHookPathForProject(projectRoot, HARNERY_ROOT);
-            if (!existsSync(settingsPath)) {
-                hookDrift = true;
-                issues.push(`${spec.settingsFile}: missing (re-run init)`);
-            }
-            else {
-                try {
-                    const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
-                    const hookDiff = diffWiring(settings, spec, { agentHookPath: agentHook, adapter });
-                    hookDrift =
-                        hookDiff.missing.length > 0 ||
-                            hookDiff.stale.length > 0 ||
-                            hookDiff.duplicates.length > 0 ||
-                            hookDiff.misplaced.length > 0 ||
-                            hookDiff.orphans.length > 0 ||
-                            hookDiff.invalidTopLevelKeys.length > 0 ||
-                            hookDiff.invalidEventKeys.length > 0;
-                    if (hookDiff.missing.length > 0) {
-                        issues.push(`${spec.settingsFile}: missing hooks (${hookDiff.missing.map((e) => e.settingsKey).join(", ")})`);
-                    }
-                    if (hookDiff.stale.length > 0) {
-                        issues.push(`${spec.settingsFile}: stale hook commands (${hookDiff.stale.map((e) => e.settingsKey).join(", ")})`);
-                    }
-                    if (hookDiff.duplicates.length > 0) {
-                        issues.push(`${spec.settingsFile}: duplicate hooks (${hookDiff.duplicates.map((e) => e.settingsKey).join(", ")})`);
-                    }
-                    if (hookDiff.misplaced.length > 0) {
-                        issues.push(`${spec.settingsFile}: hooks under the wrong event (${hookDiff.misplaced.map((e) => e.subcommand).join(", ")})`);
-                    }
-                    if (hookDiff.orphans.length > 0) {
-                        issues.push(`${spec.settingsFile}: obsolete hooks (${hookDiff.orphans.join(", ")})`);
-                    }
-                    if (hookDiff.invalidTopLevelKeys.length > 0) {
-                        issues.push(`${spec.settingsFile}: invalid fields (${hookDiff.invalidTopLevelKeys.join(", ")})`);
-                    }
-                    if (hookDiff.invalidEventKeys.length > 0) {
-                        issues.push(`${spec.settingsFile}: unsupported events (${hookDiff.invalidEventKeys.join(", ")})`);
-                    }
-                }
-                catch (error) {
-                    hookCheckError = true;
-                    issues.push(`${spec.settingsFile}: invalid JSON (${error.message})`);
+            for (const adapter of adapters) {
+                const instructions = checkInstructions(projectRoot, { binName: bin, adapter });
+                if (instructions.status === "error")
+                    instructionStatus = "error";
+                else if (instructions.status === "drift" && instructionStatus !== "error") {
+                    instructionStatus = "drift";
                 }
+                issues.push(...instructions.issues);
+                const hooks = checkAdapterHooks(projectRoot, adapter, bin);
+                hookCheckError = hookCheckError || hooks.error;
+                hookDrift = hookDrift || hooks.drift;
+                issues.push(...hooks.issues);
             }
             const gitHooks = checkGitHooks(projectRoot);
             if (gitHooks.status !== "fresh")
@@ -155,20 +254,25 @@ export function registerInitCommand(program, emit, binName) {
             if (ledgerRuntimeIssues.length > 0) {
                 issues.push(`event ledger V3 is runtime-stale (${ledgerRuntimeIssues.join(", ")})`);
             }
-            const merged = status === "error" || hookCheckError
+            const merged = instructionStatus === "error" || hookCheckError
                 ? "error"
                 : hookDrift ||
+                    instructionStatus === "drift" ||
                     gitHooks.status !== "fresh" ||
                     ledger.state !== "active" ||
                     ledgerRuntimeIssues.length > 0
                     ? "drift"
-                    : status;
+                    : "fresh";
             const head = merged === "fresh"
                 ? "harn init --check: hooks + instructions + skills + event ledger V3 are current"
                 : merged === "drift"
                     ? "harn init --check: drift found (re-run `init` to refresh)"
                     : "harn init --check: error";
-            const lines = issues.length ? `\n${issues.map((i) => `  ✗ ${i}`).join("\n")}` : "";
+            const lines = issues.length
+                ? `\n${dedupe(issues)
+                    .map((i) => `  ✗ ${i}`)
+                    .join("\n")}`
+                : "";
             emit.text(`${head}${lines}`);
             emit.setExitCode(merged === "fresh" ? 0 : merged === "drift" ? 2 : 1);
             return;
@@ -247,63 +351,91 @@ export function registerInitCommand(program, emit, binName) {
                     : "· event ledger V3 already active");
         }
         // ── 2. adapter hooks ───────────────────────────────────────────────────
-        const settingsPath = resolve(projectRoot, spec.settingsFile);
-        const agentHook = agentHookPathForProject(projectRoot, HARNERY_ROOT);
-        let settings;
-        if (existsSync(settingsPath)) {
+        for (const adapter of adapters) {
+            const spec = ADAPTER_SPECS[adapter];
+            const settingsPath = resolve(projectRoot, spec.settingsFile);
+            const agentHook = agentHookPathForProject(projectRoot, HARNERY_ROOT);
+            if (spec.installMode === "opencode-plugin") {
+                // OpenCode has no hooks map. Install the plugin directory instead; the
+                // instructions + skills step below still runs (AGENTS.md and
+                // .agents/skills are read natively, so no shim or mirror is needed).
+                const plugin = installOpenCodePlugin(projectRoot, { binName: bin, agentHook, dryRun });
+                if (plugin.error) {
+                    emit.text(plugin.error);
+                    emit.setExitCode(1);
+                    return;
+                }
+                actions.push(...plugin.actions);
+            }
+            else {
+                let settings;
+                if (existsSync(settingsPath)) {
+                    try {
+                        settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+                    }
+                    catch (err) {
+                        emit.text(`✗ ${rel(projectRoot, settingsPath)} exists but isn't valid JSON; refusing to ` +
+                            `overwrite. Fix it and re-run.\n  (${err.message})`);
+                        emit.setExitCode(1);
+                        return;
+                    }
+                }
+                else {
+                    settings = {};
+                }
+                const bridge = codexWindowsBridgeConfig(projectRoot);
+                if (bridge.error && spec.windowsBridgeHooks) {
+                    actions.push(`⚠ ${bridge.error}; writing ${adapter} hooks without commandWindows`);
+                }
+                const { wired, already, removed, upgraded } = wireHooks(settings, spec, agentHook, adapter, { windowsBridgeEntryPoint: bridge.entryPoint });
+                if (wired === 0 && removed === 0 && upgraded === 0) {
+                    actions.push(`· all ${spec.events.length} ${adapter} hooks already wired in ${rel(projectRoot, settingsPath)}`);
+                }
+                else if (dryRun) {
+                    actions.push(`+ would wire ${wired} hook(s), upgrade ${upgraded} stale command(s), and remove ` +
+                        `${removed} obsolete/duplicate command(s) in ${rel(projectRoot, settingsPath)} (${already} already present)`);
+                }
+                else {
+                    mkdirSync(dirname(settingsPath), { recursive: true });
+                    writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+                    actions.push(`+ wired ${wired} hook(s), upgraded ${upgraded} stale command(s), and removed ` +
+                        `${removed} obsolete/duplicate command(s) in ${rel(projectRoot, settingsPath)} (${already} already present)`);
+                }
+                const authorizationReview = codexHookReviewAction(adapter);
+                if (authorizationReview)
+                    actions.push(authorizationReview);
+            }
+        }
+        // ── 3. agent-facing instructions block + skills ────────────────────────
+        // Idempotent per adapter: the AGENTS.md block is adapter-independent, the
+        // harn-* skills land in each adapter's directory, and the CLAUDE.md shim and
+        // Cursor rule exist only for their own adapter. A misconfigured host addendum
+        // aborts here rather than half-writing: the apply step validates the
+        // configured source before it touches a file, so a bad path leaves the repo
+        // exactly as it found it.
+        const warnings = [];
+        for (const adapter of adapters) {
+            let applied;
             try {
-                settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+                applied = applyInstructions(projectRoot, { binName: bin, adapter, dryRun });
             }
             catch (err) {
-                emit.text(`✗ ${rel(projectRoot, settingsPath)} exists but isn't valid JSON; refusing to ` +
-                    `overwrite. Fix it and re-run.\n  (${err.message})`);
+                if (!(err instanceof HostAddendumError))
+                    throw err;
+                emit.text(`${bin} init: ${err.message}`);
                 emit.setExitCode(1);
                 return;
             }
+            actions.push(...applied.actions);
+            warnings.push(...applied.warnings);
         }
-        else {
-            settings = {};
-        }
-        const { wired, already, removed, upgraded } = wireHooks(settings, spec, agentHook, adapter);
-        if (wired === 0 && removed === 0 && upgraded === 0) {
-            actions.push(`· all ${spec.events.length} ${adapter} hooks already wired in ${rel(projectRoot, settingsPath)}`);
-        }
-        else if (dryRun) {
-            actions.push(`+ would wire ${wired} hook(s), upgrade ${upgraded} stale command(s), and remove ` +
-                `${removed} obsolete/duplicate command(s) in ${rel(projectRoot, settingsPath)} (${already} already present)`);
-        }
-        else {
-            mkdirSync(dirname(settingsPath), { recursive: true });
-            writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
-            actions.push(`+ wired ${wired} hook(s), upgraded ${upgraded} stale command(s), and removed ` +
-                `${removed} obsolete/duplicate command(s) in ${rel(projectRoot, settingsPath)} (${already} already present)`);
-        }
-        const authorizationReview = codexHookReviewAction(adapter);
-        if (authorizationReview)
-            actions.push(authorizationReview);
-        // ── 3. agent-facing instructions block + skills ────────────────────────
-        // A misconfigured host addendum aborts here rather than half-writing: the
-        // apply step validates the configured source before it touches a file, so
-        // a bad path leaves the repo exactly as it found it.
-        let applied;
-        try {
-            applied = applyInstructions(projectRoot, { binName: bin, adapter, dryRun });
-        }
-        catch (err) {
-            if (!(err instanceof HostAddendumError))
-                throw err;
-            emit.text(`${bin} init: ${err.message}`);
-            emit.setExitCode(1);
-            return;
-        }
-        actions.push(...applied.actions);
         // ── 4. git-hook managed regions ────────────────────────────────────────
         // Same lifecycle contract as the instructions block: the coordination
         // content of the consumer's git hooks is machine-owned and versioned;
         // everything else in those files belongs to the host.
         const gitHooks = applyGitHooks(projectRoot, { dryRun });
         actions.push(...gitHooks.actions);
-        emit.text(render(projectRoot, dryRun, actions, [...applied.warnings, ...gitHooks.warnings]));
+        emit.text(render(projectRoot, dryRun, dedupe(actions), dedupe([...warnings, ...gitHooks.warnings])));
     });
 }
 function gitBuild(root) {
@@ -357,7 +489,7 @@ export function codexHookReviewAction(adapter) {
  *
  * Token-aware matching keeps `stop` from matching `stop-failure`.
  */
-export function wireHooks(settings, spec, agentHookPath, adapter) {
+export function wireHooks(settings, spec, agentHookPath, adapter, options) {
     if (spec.rootVersion !== undefined && settings.version === undefined) {
         settings.version = spec.rootVersion;
     }
@@ -374,6 +506,13 @@ export function wireHooks(settings, spec, agentHookPath, adapter) {
     }
     for (const { settingsKey, subcommand } of spec.events) {
         const command = hookCommand(spec, agentHookPath, subcommand, adapter);
+        const timeout = hookTimeoutFor(spec, subcommand);
+        const commandWindows = expectedCommandWindows(spec, agentHookPath, subcommand, adapter, options);
+        const handlerFields = {
+            timeout,
+            commandWindows,
+            windowsBridge: spec.windowsBridgeHooks === true,
+        };
         let present = false;
         for (const key of Object.keys(settings.hooks)) {
             if (key === settingsKey)
@@ -383,7 +522,7 @@ export function wireHooks(settings, spec, agentHookPath, adapter) {
         const groups = settings.hooks[settingsKey] ?? [];
         const nextGroups = [];
         for (const group of groups) {
-            const normalized = normalizeEventGroup(group, subcommand, command, present);
+            const normalized = normalizeEventGroup(group, subcommand, command, handlerFields, present);
             if (normalized.found && !present)
                 present = true;
             upgraded += normalized.upgraded;
@@ -400,7 +539,9 @@ export function wireHooks(settings, spec, agentHookPath, adapter) {
             continue;
         }
         const current = settings.hooks[settingsKey] ?? [];
-        current.push(makeEntry(spec.entryShape, command));
+        current.push(makeEntry(spec.entryShape, command, spec.entryShape === "cursor" && subcommand === "stop"
+            ? { loop_limit: CURSOR_STOP_FOLLOWUP_LOOP_LIMIT }
+            : { timeout, commandWindows }));
         settings.hooks[settingsKey] = current;
         wired++;
     }
@@ -416,7 +557,7 @@ export function wireHooks(settings, spec, agentHookPath, adapter) {
  * that don't set the var. Only the env expansion is quoted so the
  * `agent-hook <subcommand> ` wiring match stays byte-identical.
  */
-function normalizeEventGroup(group, subcommand, canonical, alreadyFound) {
+function normalizeEventGroup(group, subcommand, canonical, fields, alreadyFound) {
     let found = false;
     let upgraded = 0;
     let removed = 0;
@@ -429,11 +570,14 @@ function normalizeEventGroup(group, subcommand, canonical, alreadyFound) {
                 group.command = canonical;
                 upgraded++;
             }
+            if (applyCursorStopLoopLimit(group, subcommand))
+                upgraded++;
         }
     }
     if ("hooks" in group && Array.isArray(group.hooks)) {
         const kept = [];
-        for (const hook of group.hooks) {
+        for (const original of group.hooks) {
+            let hook = original;
             if (typeof hook.command !== "string" || !commandWiresSubcommand(hook.command, subcommand)) {
                 kept.push(hook);
                 continue;
@@ -443,8 +587,26 @@ function normalizeEventGroup(group, subcommand, canonical, alreadyFound) {
                 continue;
             }
             found = true;
+            let changed = false;
             if (hook.command !== canonical) {
                 hook.command = canonical;
+                changed = true;
+            }
+            if (fields.timeout !== undefined && hook.timeout !== fields.timeout) {
+                hook.timeout = fields.timeout;
+                changed = true;
+            }
+            // Harnery owns commandWindows on its own handlers for adapters that run
+            // it: write the opted-in command, or remove one a project opted out of.
+            if (fields.windowsBridge && hook.commandWindows !== fields.commandWindows) {
+                if (fields.commandWindows === undefined)
+                    delete hook.commandWindows;
+                else
+                    hook.commandWindows = fields.commandWindows;
+                changed = true;
+            }
+            if (changed) {
+                hook = orderHandlerKeys(hook);
                 upgraded++;
             }
             kept.push(hook);

package/dist/commands/instructions.js

@@ -11,7 +11,7 @@ export function registerInstructionsCommand(program, emit) {
     command
         .command("manifest [paths...]")
         .description("Emit a machine-readable bundle manifest for one or more working paths")
-        .option("--adapter <adapter>", "claude-code, cursor, codex, or all", "all")
+        .option("--adapter <adapter>", "claude-code, cursor, codex, opencode, or all", "all")
         .option("--format <type>", "Output format: json or table", "json")
         .option("-o, --output <file>", "Write the complete JSON manifest to a file")
         .action((paths, options) => {
@@ -49,10 +49,11 @@ export function registerInstructionsCommand(program, emit) {
 }
 function parseAdapters(value) {
     if (value === "all")
-        return ["claude-code", "cursor", "codex"];
-    if (value === "claude-code" || value === "cursor" || value === "codex")
+        return ["claude-code", "cursor", "codex", "opencode"];
+    if (value === "claude-code" || value === "cursor" || value === "codex" || value === "opencode") {
         return [value];
-    throw new Error(`unsupported adapter '${value}' (expected claude-code, cursor, codex, or all)`);
+    }
+    throw new Error(`unsupported adapter '${value}' (expected claude-code, cursor, codex, opencode, or all)`);
 }
 function enrichBundle(bundle, coordRoot) {
     const components = bundle.components.map((component) => enrichComponent(component, coordRoot));

package/dist/commands/ledger-v3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ledger-v3.d.ts","sourceRoot":"","sources":["../../src/commands/ledger-v3.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAuC1E,2DAA2D;AAC3D,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,WAAW,EACjB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,IAAI,CAgbN"}
+{"version":3,"file":"ledger-v3.d.ts","sourceRoot":"","sources":["../../src/commands/ledger-v3.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAwC1E,2DAA2D;AAC3D,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,WAAW,EACjB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,IAAI,CAgbN"}

package/dist/commands/ledger-v3.js

@@ -5,6 +5,7 @@ import { resolve } from "node:path";
 import { compressSealedLegacyV1Segments, inventoryLegacyV1Segments, streamLegacyV1Rows, verifyLegacyV1HardFence, writeLegacyV1Canary, } from "../core/events/legacy-storage/index.js";
 import { cleanEventV3Archives, initializeEventLedgerV3, inventoryEventV3Archives, listHookProducerStateRecordsV3, readEventV3ControlState, recoverInvalidEventLedgerV3, sha256V3, } from "../core/events/v3/index.js";
 import { authorizeEventV3SupportReplacement, inventoryEventV3Support, planEventV3SupportReplacement, planEventV3SupportTransaction, readEventV3SupportPackManifest, readEventV3SupportTransaction, streamEventV3SupportPackRecords, unpackEventV3SupportPack, verifyEventV3SupportTransactionShadow, writeEventV3SupportTransactionShadow, } from "../core/events/v3/support-storage/index.js";
+import { stateDirMode } from "../core/storage/modes.js";
 /** Inspect or initialize the universal V3 event ledger. */
 export function registerLedgerV3Command(program, emit, context) {
     const command = program
@@ -210,7 +211,7 @@ export function registerLedgerV3Command(program, emit, context) {
             }
             const root = resolve(options.root ?? coordRoot(context));
             const transactions = transactionRoot(root);
-            mkdirSync(transactions, { recursive: true, mode: 0o700 });
+            mkdirSync(transactions, { recursive: true, mode: stateDirMode() });
             emit.data(await planEventV3SupportTransaction({
                 transaction_root: transactions,
                 authority_root: resolve(options.authorityRoot),

package/dist/commands/rm.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.js";
+export declare function registerRmCommand(program: Command, emit: EmitContext, context?: HarneryProgramContext): void;
+//# sourceMappingURL=rm.d.ts.map

package/dist/commands/rm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rm.d.ts","sourceRoot":"","sources":["../../src/commands/rm.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAU1E,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,WAAW,EACjB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,IAAI,CAgFN"}