harnery 0.31.6 → 0.32.0

package/dist/core/hooks/cli.js

@@ -1,6 +1,5 @@
 /**
- * `agent-hook` CLI entry point. Phase 2: real canonical-event emission
- * alongside the legacy stream.
+ * `agent-hook` CLI entry point for canonical event emission.
  *
  * Flow:
  *   1. Parse argv → event-name + adapter.
@@ -24,14 +23,17 @@ import { coordEnv } from "../../lib/env.js";
 import { replayCodexJsonl } from "../agents/codex-replay.js";
 import { coordBinPath } from "../agents/coord-bin.js";
 import { consumeSince, writeCursor } from "../agents/events/consume.js";
+import { classifyWriteClaimFinalization, formatWriteClaimFinalizationDenial, } from "../agents/finalization.js";
 import { evaluateStopHook } from "../agents/rules/stop-hook.js";
 import { projectHeartbeats } from "../agents/state/heartbeat-projector.js";
 import { writePidmapRow } from "../agents/state/pidmap.js";
 import { shellMutationPaths } from "../agents/state/shell-mutation.js";
+import { agentsRequireGitFinalization, resolveBinName } from "../config.js";
 import { checkpointContext, completeContextRecovery, extractContextSample, markContextCompactionCompleted, prepareContextRecovery, readContextState, recordContextSample, } from "../context/index.js";
 import { ensureRelayDaemon, fetchPresence, publishPresence } from "../presence/index.js";
 import { detectAdapter } from "./adapter/detect.js";
 import { extractBashCommand, extractToolDescription, normalizeEventName, parsePayload, } from "./adapter/parse.js";
+import { codexWslFileLinkTelemetry, inspectCodexWslBridge, isWslUncPath, renderCodexWslFileLinkContext, } from "./codex-wsl-bridge.js";
 import { captureImages, detectPresence, imageJanitor, journalArchive, journalJanitor, journalRecoveryCue, playSound, resetSoundCounters, runSessionSyncExtension, runTurnSummary, soundForEvent, } from "./effects/index.js";
 import { emit } from "./events/emit.js";
 import { canonicalize } from "./guard-path.js";
@@ -39,16 +41,18 @@ import { adapterPidFromEnv, parsePsChainLine, selectAnchorPid } from "./resolve/
 import { findCoordRoot } from "./resolve/coord-root.js";
 import { extractIntentComment, resolveIntent } from "./resolve/intent.js";
 import { resolveOwner } from "./resolve/owner.js";
-import { scanStatusBoxPresent, scanTranscriptModel } from "./resolve/transcript.js";
+import { detectForkParent, scanAssistantTextIncludes, scanStatusBoxPresent, scanTranscriptModel, } from "./resolve/transcript.js";
+import { sessionNamePresence } from "./session-name-presence.js";
+import { unsafeCrossShellReason } from "./unsafe-cross-shell.js";
 function parseArgv(argv) {
     const out = { eventName: null, extra: [] };
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
-        if (arg === "--adapter" || arg === "--harness") {
+        if (arg === "--adapter") {
             i++; // detectAdapter will re-parse; just consume the value here.
             continue;
         }
-        if (arg.startsWith("--adapter=") || arg.startsWith("--harness="))
+        if (arg.startsWith("--adapter="))
             continue;
         if (!out.eventName && !arg.startsWith("--")) {
             out.eventName = arg;
@@ -118,12 +122,15 @@ function logError(coordRoot, err, context) {
  * Lives at agent-hooks side (not agent-coord) to keep emitter/consumer
  * separation: we spawn rather than import.
  */
-function assignNameViaAgentCoord(coordRoot, instanceId, kind) {
+function assignNameViaAgentCoord(coordRoot, instanceId, kind, forkedFrom) {
     const binary = coordBinPath("agent-coord", coordRoot) ?? "";
     if (!existsSync(binary))
         return null;
     try {
-        const result = spawnSync(binary, ["assign-name", instanceId, kind], {
+        const args = ["assign-name", instanceId, kind];
+        if (forkedFrom)
+            args.push("--forked-from", forkedFrom);
+        const result = spawnSync(binary, args, {
             encoding: "utf8",
             timeout: 2000,
             env: childEnv(coordRoot),
@@ -178,13 +185,21 @@ function buildEventData(eventType, ctx) {
     switch (eventType) {
         case "session.start": {
             const adapterPlatform = ctx.adapter === "claude-code"
-                ? "claude_code"
+                ? "claude-code"
                 : ctx.adapter === "cursor"
                     ? "cursor"
                     : "codex";
+            // Recorded fork lineage is NOT detected here. On claude-code a fork
+            // never fires its own session.start — SessionStart fires under the
+            // PARENT's session id (source=resume) before the fork id is minted
+            // (verified 2026-08-05) — so detection at this point can only mislabel
+            // the resumed parent. The fork's new instance is caught by the
+            // tool.pre_use heal path instead. The forkedFrom plumbing below stays
+            // for adapters that DO report a parent at session start.
+            const forkedFrom = undefined;
             // Assign (or recover) name + kind via agent-coord. Idempotent: resume
             // returns the original name; new owner consumes a counter slot.
-            const assigned = assignNameViaAgentCoord(ctx.coordRoot, ctx.instanceId, "session");
+            const assigned = assignNameViaAgentCoord(ctx.coordRoot, ctx.instanceId, "session", forkedFrom);
             // Write the adapter pid-map row so `harn agents whoami` ppid-walks find
             // this owner. Prefer the payload pid (the actual claude binary), then the
             // anchor walk (the `node` ancestor for Cursor, which has no payload pid),
@@ -208,6 +223,10 @@ function buildEventData(eventType, ctx) {
                 name: assigned?.name,
                 kind: "session",
                 agent_id: ctx.instanceId,
+                // Recorded fork lineage rides the canonical event too, so full replay
+                // and derived readers converge on the same parent linkage that
+                // .name-history carries (the ADR 0017 dual-write pattern).
+                ...(forkedFrom ? { forked_from: forkedFrom } : {}),
                 // Workflow-child linkage: `workflow run` children carry the run id in
                 // env (spawn adapters set it via buildChildEnv), so their sessions and
                 // heartbeats join back to the run transcript + /workflows web view.
@@ -235,6 +254,10 @@ function buildEventData(eventType, ctx) {
             return { prompt_text: value, ...(truncated ? { truncated: true } : {}) };
         }
         case "turn.stop": {
+            const lastAssistantMessage = p?.raw.last_assistant_message ?? "";
+            const fileLinkTelemetry = ctx.adapter === "codex"
+                ? codexWslFileLinkTelemetry(ctx.coordRoot, p?.cwd, lastAssistantMessage)
+                : null;
             return {
                 // Backfill the model for adapters that omit it at session.start
                 // (Claude Code). The transcript is populated with assistant turns by
@@ -252,8 +275,24 @@ function buildEventData(eventType, ctx) {
                 // text-only stop (box in last_assistant_message, no transcript), which
                 // the verdict now sees because agent-hook emits this turn.stop itself
                 // (the previous path passed those via the no-history fail-open).
-                status_box_present: scanStatusBoxPresent(p?.transcript_path) ||
-                    (p?.raw.last_assistant_message ?? "").includes("┌─ agent-"),
+                status_box_present: scanStatusBoxPresent(p?.transcript_path) || lastAssistantMessage.includes("┌─ agent-"),
+                // Shadow measurement for the rule-2/3 detector: the loose scan above
+                // matches the box prefix ANYWHERE in the transcript tail, including
+                // the tool_result row the status command itself writes, so it can
+                // report a paste that never happened. The strict variant counts
+                // assistant text only (same window, same scanner as the session-name
+                // detection). Telemetry-only: the Stop verdict still reads
+                // status_box_present. Once the divergence rate between the two fields
+                // is known, the gate either flips to strict or the rule gets
+                // reconsidered; either way this field decides it with data.
+                status_box_present_strict: scanAssistantTextIncludes(p?.transcript_path, "┌─ agent-") ||
+                    lastAssistantMessage.includes("┌─ agent-"),
+                // Whether the session's suggested name is satisfied as of this turn,
+                // and which name that refers to. Reported on every stop while a name
+                // exists (the stop-hook.session_name verdict reads it per turn); the
+                // transcript scan itself stops once the name has been sighted.
+                ...sessionNamePresence(ctx.coordRoot, ctx.instanceId, lastAssistantMessage, (name) => scanAssistantTextIncludes(p?.transcript_path, name)),
+                ...(fileLinkTelemetry ?? {}),
                 stop_hook_active: p?.stop_hook_active,
             };
         }
@@ -694,7 +733,7 @@ async function main() {
             }
         }
         try {
-            const injected = await emitUserPromptSubmitSystemMessage(coordRoot, owner.instance_id, sessionId, adapter, recovery?.briefing ?? "");
+            const injected = await emitUserPromptSubmitSystemMessage(coordRoot, owner.instance_id, sessionId, adapter, payload?.cwd, recovery?.briefing ?? "");
             if (injected && recovery) {
                 completeRecoveryInjection(coordRoot, owner.instance_id, sessionId, adapter, recovery, "UserPromptSubmit");
             }
@@ -778,7 +817,7 @@ async function main() {
             // re-prompts only via a `followup_message` it auto-submits. emitStopBlock
             // writes the right shape and returns the exit code to use.
             const { emitStopBlock } = await import("./adapter/output.js");
-            return emitStopBlock(adapter, verdict);
+            return emitStopBlock(adapter, verdict, coordRoot);
         }
     }
     // Phase 7: PreToolUse: heartbeat + pid-map self-heal on every tool call.
@@ -792,7 +831,19 @@ async function main() {
     // call was restored here afterward.
     if (norm.event_type === "tool.pre_use") {
         try {
-            healHeartbeatViaCli(coordRoot, owner.instance_id, sessionId, adapter);
+            // Recorded fork lineage, heal-path flavor. A forked CC conversation
+            // never fires its own session.start (SessionStart fires under the
+            // PARENT's session id with source=resume, before the fork id is
+            // minted; verified 2026-08-05), so the fork's new instance first
+            // materializes right here. Gate detection on "no heartbeat yet" so the
+            // transcript scan runs once per instance lifetime, not per tool call.
+            let forkedFrom;
+            if (adapter === "claude-code" &&
+                payload?.transcript_path &&
+                !existsSync(join(coordRoot, ".harnery", "active", `${owner.instance_id}.json`))) {
+                forkedFrom = detectForkParent(payload.transcript_path, owner.instance_id);
+            }
+            healHeartbeatViaCli(coordRoot, owner.instance_id, sessionId, adapter, forkedFrom);
             refreshPidmap(coordRoot, owner.instance_id, adapter, payload?.pid);
         }
         catch (err) {
@@ -813,6 +864,28 @@ async function main() {
         catch (err) {
             logError(coordRoot, err, { phase: "pre-tool-use-image-capture" });
         }
+        // Windows-native Codex + WSL UNC only: block the one cross-shell shape
+        // proven to corrupt argument boundaries. Normal WSL argv calls, literal
+        // bash -s scripts, native Linux/macOS sessions, and every other adapter
+        // pass through. The host instructions name its concrete safe bridge.
+        const unsafeShellReason = unsafeCrossShellReason({
+            adapter,
+            cwd: payload?.cwd,
+            toolName: payload?.tool_name,
+            toolInput: payload?.tool_input,
+        });
+        if (unsafeShellReason) {
+            emit(coordRoot, {
+                event_type: "decision.block",
+                instance_id: owner.instance_id,
+                session_id: sessionId,
+                adapter,
+                data: { rule: "unsafe_cross_shell", reason: unsafeShellReason },
+            });
+            const { emitDeny } = await import("./adapter/output.js");
+            emitDeny(adapter, unsafeShellReason);
+            return 0;
+        }
         // G-guard for ALL adapters. Claude Code previously ran this via a
         // pre-tool-use bash adapter (which called `agent-coord verdict --rule=claim`);
         // that adapter is now deleted, so agent-hook owns the deny for every adapter.
@@ -903,14 +976,40 @@ async function main() {
 }
 async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapter) {
     const toolName = data.tool_name ?? "";
-    const targets = collectGuardTargets(toolName, data)
-        .map((p) => canonicalize(coordRoot, p))
-        .filter((p) => p !== null);
+    const rawTargets = collectGuardTargets(toolName, data);
+    if (rawTargets.length === 0)
+        return;
+    let targets;
+    if (agentsRequireGitFinalization(coordRoot)) {
+        const decisions = rawTargets.map((path) => classifyWriteClaimFinalization(coordRoot, path));
+        const denied = decisions.find((decision) => !decision.allow);
+        if (denied && !denied.allow) {
+            const { emitDeny } = await import("./adapter/output.js");
+            emitDeny(adapter, formatWriteClaimFinalizationDenial(denied, resolveBinName(coordRoot)));
+            return;
+        }
+        const allowed = decisions.filter((decision) => decision.allow);
+        targets = allowed.map((decision) => ({
+            path: decision.path,
+            finalization: decision.descriptor,
+        }));
+    }
+    else {
+        targets = rawTargets
+            .map((path) => canonicalize(coordRoot, path))
+            .filter((path) => path !== null)
+            .map((path) => ({ path }));
+    }
     if (targets.length === 0)
         return;
     const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
-    if (!existsSync(agentCoordBin))
+    if (!existsSync(agentCoordBin)) {
+        if (agentsRequireGitFinalization(coordRoot)) {
+            const { emitDeny } = await import("./adapter/output.js");
+            emitDeny(adapter, "Harnery denied the write before mutation because the claim coordinator is unavailable; repair the project's Harnery installation and retry.");
+        }
         return;
+    }
     // For apply_patch (multi-file), collect siblings so the deny reason names
     // them. For single-file tools the array has one entry.
     for (const target of targets) {
@@ -918,7 +1017,7 @@ async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapte
             rule: "claim",
             instance_id: instanceId,
             session_id: sessionId,
-            path: target,
+            path: target.path,
         });
         const result = spawnSync(agentCoordBin, ["verdict"], {
             input: verdictReq,
@@ -936,10 +1035,11 @@ async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapte
             continue;
         }
         if (parsed.allow === false) {
-            let reason = parsed.reason ?? `Path ${target} is currently being edited by another agent.`;
+            let reason = parsed.reason ?? `Path ${target.path} is currently being edited by another agent.`;
             if (targets.length > 1) {
                 const siblings = targets
-                    .filter((p) => p !== target)
+                    .filter((candidate) => candidate !== target)
+                    .map((candidate) => candidate.path)
                     .slice(0, 3)
                     .join(", ");
                 if (siblings) {
@@ -950,6 +1050,23 @@ async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapte
             emitDeny(adapter, reason);
             return;
         }
+        // The verdict mutates the live heartbeat immediately, but that file is a
+        // projection and can be rebuilt at any later hook. Persist the acquisition
+        // in the canonical stream too. This matters most for Codex apply_patch:
+        // one tool call can claim several files, and tool.pre_use's clamped payload
+        // is not a durable ownership representation for those targets.
+        emit(coordRoot, {
+            event_type: "claim.acquire",
+            instance_id: instanceId,
+            session_id: sessionId,
+            adapter,
+            source: "agent-hooks",
+            data: {
+                path: target.path,
+                mode: "write",
+                ...(target.finalization ? { finalization: target.finalization } : {}),
+            },
+        });
     }
 }
 /** Canonicalize a path to monorepo-relative form. Absolute paths under
@@ -1008,15 +1125,19 @@ function parseApplyPatchPaths(data) {
     }
     return out;
 }
-function healHeartbeatViaCli(coordRoot, instanceId, sessionId, adapter) {
+function healHeartbeatViaCli(coordRoot, instanceId, sessionId, adapter, forkedFrom) {
     const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
     if (!existsSync(agentCoordBin))
         return;
     // Pass the detected adapter so a pruned Cursor/Codex heartbeat is recreated
     // with the correct platform; without it, healHeartbeat defaults to
-    // claude_code and the dashboard mislabels the agent. See
-    // heartbeat-writer.healHeartbeat.
-    spawnSync(agentCoordBin, ["heal-heartbeat", instanceId, sessionId, `--adapter=${adapter}`], {
+    // claude-code and the dashboard mislabels the agent. See
+    // heartbeat-writer.healHeartbeat. --forked-from carries detected fork
+    // lineage for an instance that never session.started (the CC fork flow).
+    const args = ["heal-heartbeat", instanceId, sessionId, `--adapter=${adapter}`];
+    if (forkedFrom)
+        args.push(`--forked-from=${forkedFrom}`);
+    spawnSync(agentCoordBin, args, {
         encoding: "utf8",
         timeout: 2000,
         env: childEnv(coordRoot),
@@ -1238,7 +1359,7 @@ function cleanupSessionEnd(coordRoot, instanceId, reason) {
         spawnSync(agentCoordBin, ["log", `SESSION_END     reason=${reason}`, "--instance", instanceId], { encoding: "utf8", timeout: 2000 });
     }
 }
-async function emitUserPromptSubmitSystemMessage(coordRoot, instanceId, sessionId, adapter, recoveryBriefing = "") {
+async function emitUserPromptSubmitSystemMessage(coordRoot, instanceId, sessionId, adapter, workspaceCwd, recoveryBriefing = "") {
     const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
     let additionalContext = "";
     if (existsSync(agentCoordBin)) {
@@ -1272,6 +1393,12 @@ async function emitUserPromptSubmitSystemMessage(coordRoot, instanceId, sessionI
         if (result.status === 0 && result.stdout)
             additionalContext = result.stdout.trim();
     }
+    if (adapter === "codex") {
+        const fileLinkContext = renderCodexWslFileLinkContext(coordRoot, workspaceCwd);
+        if (fileLinkContext) {
+            additionalContext = [additionalContext, fileLinkContext].filter(Boolean).join("\n\n");
+        }
+    }
     if (recoveryBriefing) {
         additionalContext = [additionalContext, recoveryBriefing].filter(Boolean).join("\n\n");
     }
@@ -1310,7 +1437,7 @@ function emitSubagentStartContext(coordRoot, instanceId, sessionId, data, adapte
 }
 function adapterPlatform(adapter) {
     if (adapter === "claude-code")
-        return "claude_code";
+        return "claude-code";
     return adapter;
 }
 async function emitSessionStartSystemMessage(coordRoot, instanceId, sessionId, emittedData, adapter, recoveryBriefing = "") {
@@ -1359,6 +1486,21 @@ async function emitSessionStartSystemMessage(coordRoot, instanceId, sessionId, e
     if (recoveryBriefing) {
         additionalContext = [additionalContext, recoveryBriefing].filter(Boolean).join("\n\n");
     }
+    if (adapter === "codex" && isWslUncPath(emittedData.cwd)) {
+        const fileLinkContext = renderCodexWslFileLinkContext(coordRoot, emittedData.cwd);
+        if (fileLinkContext) {
+            additionalContext = [additionalContext, fileLinkContext].filter(Boolean).join("\n\n");
+        }
+        const bridge = inspectCodexWslBridge(process.env, { expected: true });
+        if (bridge && !bridge.ok) {
+            additionalContext = [
+                additionalContext,
+                `Harnery hybrid warning: ${bridge.detail}. Run \`${resolveBinName(coordRoot)} doctor\` for the repair hint.`,
+            ]
+                .filter(Boolean)
+                .join("\n\n");
+        }
+    }
     if (!additionalContext)
         return false;
     const { emitContext } = await import("./adapter/output.js");

package/dist/core/hooks/codex-wsl-bridge.d.ts

@@ -0,0 +1,46 @@
+export interface CodexWslBridgeStatus {
+    ok: boolean;
+    detail: string;
+    threadIdPresent: boolean;
+    wslenvForwardsThreadId: boolean;
+}
+export interface CodexWslBridgeOptions {
+    /** The caller already knows this is a Codex adapter process. */
+    expected?: boolean;
+}
+export interface CodexWslWorkspaceLinkMapping {
+    /** Absolute path seen by Linux-side tools. */
+    linuxRoot: string;
+    /** Forward-slash UNC path that Codex Desktop can use as a Markdown destination. */
+    hostRoot: string;
+    distro: string;
+}
+export interface CodexWslFileLinkTelemetry {
+    /** Markdown destinations that still use the Linux root in a Windows-hosted WSL task. */
+    wsl_linux_file_link_count: number;
+    /** Bounded examples for local diagnosis; omitted when the count is zero. */
+    wsl_linux_file_link_examples?: string[];
+}
+/** Whether an adapter-reported workspace is a Linux path exposed through WSL UNC. */
+export declare function isWslUncPath(value: unknown): boolean;
+/**
+ * Derive the Linux-to-host path pair from the actual adapter workspace. The
+ * roots must overlap so an unrelated WSL UNC path cannot authorize a mapping
+ * for some other checkout.
+ */
+export declare function codexWslWorkspaceLinkMapping(coordRootRaw: string, workspaceCwd: unknown): CodexWslWorkspaceLinkMapping | null;
+/** Fresh adapter context for the model. Shell paths stay Linux-native; only
+ * Markdown destinations use the host-visible root. */
+export declare function renderCodexWslFileLinkContext(coordRoot: string, workspaceCwd: unknown): string;
+/**
+ * Count Markdown links that point at the Linux workspace root even though the
+ * adapter workspace is Windows-visible UNC. This is telemetry only: the Stop
+ * hook must not replace or retry an otherwise complete Codex reply.
+ */
+export declare function codexWslFileLinkTelemetry(coordRoot: string, workspaceCwd: unknown, assistantMessage: string): CodexWslFileLinkTelemetry | null;
+/**
+ * Inspect the environment contract used when Windows-native Codex launches a
+ * Harnery hook or shell inside WSL. Returns null outside that hybrid mode.
+ */
+export declare function inspectCodexWslBridge(env?: NodeJS.ProcessEnv, options?: CodexWslBridgeOptions): CodexWslBridgeStatus | null;
+//# sourceMappingURL=codex-wsl-bridge.d.ts.map

package/dist/core/hooks/codex-wsl-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-wsl-bridge.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/codex-wsl-bridge.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;IACzB,sBAAsB,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,4BAA4B;IAC3C,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,yBAAyB;IACxC,wFAAwF;IACxF,yBAAyB,EAAE,MAAM,CAAC;IAClC,4EAA4E;IAC5E,4BAA4B,CAAC,EAAE,MAAM,EAAE,CAAC;CACzC;AAED,qFAAqF;AACrF,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMpD;AA2BD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,OAAO,GACpB,4BAA4B,GAAG,IAAI,CAarC;AAED;sDACsD;AACtD,wBAAgB,6BAA6B,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,GAAG,MAAM,CAS9F;AAmCD;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,OAAO,EACrB,gBAAgB,EAAE,MAAM,GACvB,yBAAyB,GAAG,IAAI,CAYlC;AAOD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,OAAO,GAAE,qBAA0B,GAClC,oBAAoB,GAAG,IAAI,CAsB7B"}

package/dist/core/hooks/codex-wsl-bridge.js

@@ -0,0 +1,137 @@
+/** Whether an adapter-reported workspace is a Linux path exposed through WSL UNC. */
+export function isWslUncPath(value) {
+    if (typeof value !== "string")
+        return false;
+    return (/^\\\\(?:wsl\.localhost|wsl\$)\\/i.test(value) ||
+        /^\\\\\?\\unc\\(?:wsl\.localhost|wsl\$)\\/i.test(value));
+}
+function parseWslUncPath(value) {
+    if (typeof value !== "string")
+        return null;
+    const ordinary = value.replace(/^\\\\\?\\UNC\\/i, "\\\\");
+    const match = ordinary.match(/^\\\\(wsl\.localhost|wsl\$)\\([^\\]+)(?:\\(.*))?$/i);
+    if (!match)
+        return null;
+    const host = match[1];
+    const distro = match[2];
+    const tail = (match[3] ?? "").split("\\").filter(Boolean).join("/");
+    return { host, distro, linuxPath: tail ? `/${tail}` : "/" };
+}
+function trimTrailingSlash(path) {
+    return path === "/" ? path : path.replace(/\/+$/, "");
+}
+function isWithinOrEqual(path, root) {
+    return path === root || path.startsWith(`${root}/`);
+}
+/**
+ * Derive the Linux-to-host path pair from the actual adapter workspace. The
+ * roots must overlap so an unrelated WSL UNC path cannot authorize a mapping
+ * for some other checkout.
+ */
+export function codexWslWorkspaceLinkMapping(coordRootRaw, workspaceCwd) {
+    const parsed = parseWslUncPath(workspaceCwd);
+    const linuxRoot = trimTrailingSlash(coordRootRaw.replace(/\\/g, "/"));
+    if (!parsed || !linuxRoot.startsWith("/"))
+        return null;
+    const linuxCwd = trimTrailingSlash(parsed.linuxPath);
+    if (!isWithinOrEqual(linuxCwd, linuxRoot) && !isWithinOrEqual(linuxRoot, linuxCwd)) {
+        return null;
+    }
+    return {
+        linuxRoot,
+        hostRoot: `//${parsed.host}/${parsed.distro}${linuxRoot}`,
+        distro: parsed.distro,
+    };
+}
+/** Fresh adapter context for the model. Shell paths stay Linux-native; only
+ * Markdown destinations use the host-visible root. */
+export function renderCodexWslFileLinkContext(coordRoot, workspaceCwd) {
+    const mapping = codexWslWorkspaceLinkMapping(coordRoot, workspaceCwd);
+    if (!mapping)
+        return "";
+    return ("Codex WSL file links: this task is hosted by Windows while tools run inside WSL. " +
+        `For clickable local-file Markdown links, replace the Linux workspace root \`${mapping.linuxRoot}\` with the host-visible root \`${mapping.hostRoot}\`. ` +
+        `Example: \`[label](<${mapping.hostRoot}/path/to/file>)\`. ` +
+        "Keep Linux paths unchanged in shell commands and tool inputs.");
+}
+function withoutMarkdownCode(text) {
+    const output = [];
+    let fence = null;
+    for (const line of text.split(/\r?\n/)) {
+        const candidate = line.match(/^\s{0,3}(`{3,}|~{3,})/);
+        if (fence) {
+            if (candidate && candidate[1][0] === fence.marker && candidate[1].length >= fence.length) {
+                fence = null;
+            }
+            output.push("");
+            continue;
+        }
+        if (candidate) {
+            fence = { marker: candidate[1][0], length: candidate[1].length };
+            output.push("");
+            continue;
+        }
+        output.push(line.replace(/(`+)([^`\n]*?)\1/g, ""));
+    }
+    return output.join("\n");
+}
+function markdownDestinations(text) {
+    const out = [];
+    const visible = withoutMarkdownCode(text);
+    const re = /!?\[[^\]\n]*\]\(\s*(?:<([^>\n]+)>|([^\s)\n]+))/g;
+    for (const match of visible.matchAll(re)) {
+        const target = match[1] ?? match[2];
+        if (target)
+            out.push(target);
+    }
+    return out;
+}
+/**
+ * Count Markdown links that point at the Linux workspace root even though the
+ * adapter workspace is Windows-visible UNC. This is telemetry only: the Stop
+ * hook must not replace or retry an otherwise complete Codex reply.
+ */
+export function codexWslFileLinkTelemetry(coordRoot, workspaceCwd, assistantMessage) {
+    const mapping = codexWslWorkspaceLinkMapping(coordRoot, workspaceCwd);
+    if (!mapping)
+        return null;
+    const mismatches = markdownDestinations(assistantMessage).filter((target) => isWithinOrEqual(target, mapping.linuxRoot));
+    return {
+        wsl_linux_file_link_count: mismatches.length,
+        ...(mismatches.length > 0
+            ? { wsl_linux_file_link_examples: mismatches.slice(0, 3).map((path) => path.slice(0, 240)) }
+            : {}),
+    };
+}
+function wslenvForwards(wslenv, variable) {
+    if (!wslenv)
+        return false;
+    return wslenv.split(":").some((entry) => entry.split("/", 1)[0] === variable);
+}
+/**
+ * Inspect the environment contract used when Windows-native Codex launches a
+ * Harnery hook or shell inside WSL. Returns null outside that hybrid mode.
+ */
+export function inspectCodexWslBridge(env = process.env, options = {}) {
+    const inWsl = Boolean(env.WSL_DISTRO_NAME?.trim() || env.WSL_INTEROP?.trim());
+    if (!inWsl)
+        return null;
+    const threadIdPresent = Boolean(env.CODEX_THREAD_ID?.trim());
+    const wslenvForwardsThreadId = wslenvForwards(env.WSLENV, "CODEX_THREAD_ID");
+    if (!options.expected && !threadIdPresent && !wslenvForwardsThreadId)
+        return null;
+    const problems = [];
+    if (!threadIdPresent)
+        problems.push("CODEX_THREAD_ID did not reach WSL");
+    if (!wslenvForwardsThreadId)
+        problems.push("WSLENV does not forward CODEX_THREAD_ID");
+    const distro = env.WSL_DISTRO_NAME?.trim();
+    return {
+        ok: problems.length === 0,
+        detail: problems.length === 0
+            ? `thread identity forwarded through WSLENV${distro ? ` (${distro})` : ""}`
+            : problems.join("; "),
+        threadIdPresent,
+        wslenvForwardsThreadId,
+    };
+}

package/dist/core/hooks/effects/index.d.ts

@@ -40,7 +40,7 @@ export declare function journalArchive(repoRoot: string, owner: string): void;
  * Fire the optional host session-sync extension on turn stop / session end.
  * harnery core has no session-telemetry sink of its own; a host that wants one
  * drops an executable at
- * `scripts/hooks/adapter/claude_code/extensions/session-sync.sh` under the coord
+ * `scripts/hooks/harness/claude-code/extensions/session-sync.sh` under the coord
  * root, and core runs it detached + unref'd so a slow sink never blocks the
  * hook. `force` arrives as argv $1 ("1" on session end, "0" on turn stop) so the
  * host can rate-limit the stop path and force-flush on end. No-op when the

package/dist/core/hooks/effects/index.js

@@ -113,7 +113,7 @@ export function journalArchive(repoRoot, owner) {
  * Fire the optional host session-sync extension on turn stop / session end.
  * harnery core has no session-telemetry sink of its own; a host that wants one
  * drops an executable at
- * `scripts/hooks/adapter/claude_code/extensions/session-sync.sh` under the coord
+ * `scripts/hooks/harness/claude-code/extensions/session-sync.sh` under the coord
  * root, and core runs it detached + unref'd so a slow sink never blocks the
  * hook. `force` arrives as argv $1 ("1" on session end, "0" on turn stop) so the
  * host can rate-limit the stop path and force-flush on end. No-op when the
@@ -123,7 +123,7 @@ export function journalArchive(repoRoot, owner) {
  */
 export function runSessionSyncExtension(repoRoot, force) {
     try {
-        const script = join(repoRoot, "scripts", "hooks", "adapter", "claude_code", "extensions", "session-sync.sh");
+        const script = join(repoRoot, "scripts", "hooks", "harness", "claude-code", "extensions", "session-sync.sh");
         if (!existsSync(script))
             return;
         const child = spawn("bash", [script, force ? "1" : "0"], {
@@ -147,7 +147,7 @@ export function runTurnSummary(repoRoot, owner, sessionId, transcriptPath) {
     try {
         if (!transcriptPath || !existsSync(transcriptPath))
             return;
-        const script = join(repoRoot, "scripts", "hooks", "adapter", "claude_code", "extensions", "turn-summary.sh");
+        const script = join(repoRoot, "scripts", "hooks", "harness", "claude-code", "extensions", "turn-summary.sh");
         if (!existsSync(script))
             return;
         const child = spawn("bash", [script, owner, sessionId, transcriptPath], {

package/dist/core/hooks/events/schema.d.ts

@@ -69,6 +69,24 @@ export type TurnStop = EventEnvelope<"turn.stop", {
     tool_call_count: number;
     text_length: number;
     status_box_present: boolean;
+    /** Strict variant of status_box_present: assistant text blocks only, so a
+     * tool_result carrying the box (the status command's own output) does not
+     * count. Shadow telemetry while the rule-2/3 detector decision is open;
+     * the Stop verdict does not read it yet. */
+    status_box_present_strict?: boolean;
+    /** Whether the session's suggested name is satisfied as of this turn:
+     * either this reply showed it, or an earlier reply did. Present whenever a
+     * suggested name exists, since the Stop verdict reads it per turn. */
+    session_name_present?: boolean;
+    /** Which suggested name `session_name_present` refers to. A projector
+     * rebuild attributes the sighting to this name instead of to whichever
+     * name is current during the replay. */
+    session_name_present_for?: string;
+    /** Shadow telemetry for Windows-hosted Codex workspaces: Markdown link
+     * destinations that still use the Linux coordination root. */
+    wsl_linux_file_link_count?: number;
+    /** Up to three bounded examples for diagnosing the mismatches locally. */
+    wsl_linux_file_link_examples?: string[];
 }>;
 export type CommandStart = EventEnvelope<"command.start", {
     cmd_id: string;
@@ -164,6 +182,10 @@ export type ContextRecoveryInjected = EventEnvelope<"context.recovery.injected",
 export type ClaimAcquire = EventEnvelope<"claim.acquire", {
     path: string;
     mode: "read" | "write";
+    finalization?: {
+        disposition: "git" | "output";
+        root: string;
+    };
 }>;
 export type ClaimRelease = EventEnvelope<"claim.release", {
     path: string;
@@ -177,6 +199,11 @@ export type ClaimConflict = EventEnvelope<"claim.conflict", {
 export type StateTaskSet = EventEnvelope<"state.task_set", {
     task: string;
     cleared: boolean;
+    /** True exactly when this call produced the session name (first non-empty
+     * declaration of a human-facing session); never true with a null name. */
+    first_of_session?: boolean;
+    /** The name produced by this call, for the Stop-hook naming rule. */
+    suggested_session_name?: string | null;
 }>;
 export type StateStatusChecked = EventEnvelope<"state.status_checked", {
     format: "box" | "json" | "table";