harnery 0.35.0 → 0.36.0

package/dist/core/hooks/cli.js

@@ -16,24 +16,28 @@
  * `.harnery/debug/agent-hook.errors.ndjson` for audit but never break the
  * adapter flow.
  */
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { coordEnv } from "../../lib/env.js";
 import { buildInstructionBundle } from "../../lib/instructions/bundle.js";
 import { coordBinPath } from "../agents/coord-bin.js";
+import { resolveCoordRoot } from "../agents/coord-client.js";
 import { classifyWriteClaimFinalization, formatWriteClaimFinalizationDenial, } from "../agents/finalization.js";
+import { restoreLiveCoordinationStateAfterEpochV3 } from "../agents/live-authority-v3.js";
 import { evaluateStopHook, STOP_REMEDIATION_MARKER } from "../agents/rules/stop-hook.js";
 import { assistantTextStartsWithSessionNameBlock, isSessionNameRemediationCommand, sessionNameDisplayInstruction, sessionNameDisplayPending, sessionNameDisplayRecoveryInstruction, toolResponseMintedSessionName, } from "../agents/session-name-display.js";
-import { stampSessionNameSeen } from "../agents/state/heartbeat-writer.js";
-import { ensureLiveCoordinationHeartbeat, readLiveCoordinationRow, } from "../agents/state/live-coordination-view.js";
+import { readHeartbeat, stampSessionNameSeen } from "../agents/state/heartbeat-writer.js";
+import { readLiveCoordinationRow } from "../agents/state/live-coordination-view.js";
+import { ensureLiveCoordinationHeartbeat } from "../agents/state/live-coordination-writer.js";
 import { writePidmapRow } from "../agents/state/pidmap.js";
 import { agentsRequireGitFinalization, resolveBinName } from "../config.js";
 import { checkpointContext, completeContextRecovery, extractContextSample, markContextCompactionCompleted, prepareContextRecovery, readContextState, recordContextSample, } from "../context/index.js";
 import { tryWriteLiveDisplayV3 } from "../events/v3/live-feed.js";
-import { liveHookSignalDefersDrainV3, recordLiveDelegatedChildSessionV3, recordLiveHookSignalV3, resolveLiveEventLedgerRouteV3, } from "../events/v3/live-routing.js";
+import { liveHookSignalDefersDrainV3, reconcileLivePendingRuntimeContextV3, recordLiveDelegatedChildSessionV3, recordLiveHookSignalV3, resolveLiveEventLedgerRouteV3, } from "../events/v3/live-routing.js";
 import { captureSpanClockV3 } from "../events/v3/span-state.js";
-import { fetchPresence } from "../presence/index.js";
+import { ensureRelayDaemon, fetchPresence, publishPresence } from "../presence/index.js";
+import { closeProcessLoggers, legacyLogFields, processLogger } from "../storage/logger.js";
 import { stableScopeId } from "../workflow/scope-id.js";
 import { detectAdapter, shouldSkipHookAdapter } from "./adapter/detect.js";
 import { extractBashCommand, extractToolDescription, normalizeEventName, parsePayload, } from "./adapter/parse.js";
@@ -43,10 +47,9 @@ import { captureImages, detectPresence, imageJanitor, journalArchive, journalJan
 import { toolInputHash, toolTargetHash } from "./events/input-hash.js";
 import { canonicalize } from "./guard-path.js";
 import { adapterPidFromEnv, parsePsChainLine, selectAnchorPid } from "./resolve/anchor.js";
-import { findCoordRoot } from "./resolve/coord-root.js";
 import { extractIntentComment, resolveIntent } from "./resolve/intent.js";
 import { resolveOwner } from "./resolve/owner.js";
-import { inspectSessionNameDisplayImmediately, scanAssistantTextIncludes, scanSessionNameDisplayedImmediately, scanStatusBoxPresent, scanTranscriptRuntime, } from "./resolve/transcript.js";
+import { inspectSessionNameDisplayImmediately, scanAssistantStatusBoxPresent, scanSessionNameDisplayedImmediately, scanStatusBoxPresent, scanTranscriptRuntime, } from "./resolve/transcript.js";
 import { sessionNamePresence } from "./session-name-presence.js";
 import { unsafeCrossShellReason } from "./unsafe-cross-shell.js";
 function parseArgv(argv) {
@@ -68,6 +71,10 @@ function parseArgv(argv) {
     }
     return out;
 }
+function extraArg(extra, name) {
+    const index = extra.indexOf(name);
+    return index >= 0 ? extra[index + 1] : undefined;
+}
 async function readStdin() {
     if (process.stdin.isTTY)
         return "";
@@ -93,6 +100,15 @@ function childEnv(coordRoot) {
     return { ...process.env, HARNERY_COORD_ROOT_OVERRIDE: coordRoot };
 }
 function appendDebug(coordRoot, entry) {
+    if (coordEnv("SHARED_LOGS") !== "0") {
+        try {
+            processLogger(coordRoot, "agent-hook").debug("agent_hook.diagnostic", legacyLogFields(entry));
+            return;
+        }
+        catch {
+            /* fall through to the rollback writer */
+        }
+    }
     const path = join(coordRoot, ".harnery", "debug", "agent-hook.ndjson");
     try {
         mkdirSync(dirname(path), { recursive: true });
@@ -105,6 +121,15 @@ function appendDebug(coordRoot, entry) {
 function logError(coordRoot, err, context) {
     if (!coordRoot)
         return;
+    if (coordEnv("SHARED_LOGS") !== "0") {
+        try {
+            processLogger(coordRoot, "agent-hook").error("agent_hook.error", legacyLogFields(context), err);
+            return;
+        }
+        catch {
+            /* fall through to the rollback writer */
+        }
+    }
     const path = join(coordRoot, ".harnery", "debug", "agent-hook.errors.ndjson");
     try {
         mkdirSync(dirname(path), { recursive: true });
@@ -304,8 +329,7 @@ function buildEventData(eventType, ctx) {
                 // assistant text only (same window, same scanner as the session-name
                 // detection). The Stop verdict enforces this field; the loose field is
                 // retained as diagnostic telemetry for the measured detector divergence.
-                status_box_present_strict: scanAssistantTextIncludes(p?.transcript_path, "┌─ agent-") ||
-                    lastAssistantMessage.includes("┌─ agent-"),
+                status_box_present_strict: scanAssistantStatusBoxPresent(p?.transcript_path, lastAssistantMessage),
                 // 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
@@ -454,7 +478,7 @@ async function main() {
     // `--adapter cursor` dispatch of the same payload carries the session.
     if (shouldSkipHookAdapter(adapter, raw)) {
         if (coordEnv("AGENT_COORD_OFF") !== "1") {
-            const coordRoot = findCoordRoot(process.cwd());
+            const coordRoot = resolveCoordRoot(process.cwd());
             if (coordRoot) {
                 appendDebug(coordRoot, {
                     ts: new Date().toISOString(),
@@ -478,7 +502,7 @@ async function main() {
     if (adapter === "claude-code" && eventName) {
         const s = soundForEvent(eventName);
         if (s) {
-            const repoRoot = findCoordRoot(process.cwd());
+            const repoRoot = resolveCoordRoot(process.cwd());
             if (repoRoot) {
                 let sid = "";
                 let stopContinuation = false;
@@ -505,9 +529,12 @@ async function main() {
     // bypass during incident triage.
     if (coordEnv("AGENT_COORD_OFF") === "1")
         return 0;
-    const coordRoot = findCoordRoot(process.cwd());
+    const coordRoot = resolveCoordRoot(process.cwd());
     if (!coordRoot)
         return 0;
+    if (eventName === "runtime-context-retry") {
+        return runRuntimeContextRetryWorker(coordRoot, adapter, extra);
+    }
     const ledgerRoute = resolveLiveEventLedgerRouteV3(coordRoot);
     // Always log a breadcrumb, useful when an event_type maps to null or owner
     // resolution fails. Stays cheap (one append) and self-prunes via repo log
@@ -526,6 +553,30 @@ async function main() {
         appendDebug(coordRoot, { ...debugBase, skipped: "missing-event-or-adapter" });
         return 0;
     }
+    // Cursor's preToolUse `agent_message` is only the current narration before
+    // that tool. It is not a transcript and therefore cannot prove that an
+    // earlier assistant response omitted the required session-name block.
+    // afterAgentResponse is the one native boundary that carries the completed
+    // assistant text, so stamp a positive sighting here without retaining or
+    // emitting the response body into V3.
+    if (adapter === "cursor" && eventName === "after-agent-response") {
+        const payload = parsePayload(raw, adapter);
+        const owner = resolveOwner({ payload: payload?.raw ?? null, coordRoot });
+        if (!owner) {
+            appendDebug(coordRoot, { ...debugBase, skipped: "no-owner-resolved" });
+            return 0;
+        }
+        const name = sessionNameDisplayPending(readLiveCoordinationRow(coordRoot, owner.instance_id));
+        const text = typeof payload?.raw.text === "string" ? payload.raw.text : "";
+        if (name && assistantTextStartsWithSessionNameBlock(text, name)) {
+            stampSessionNameSeen(coordRoot, owner.instance_id, name);
+            appendDebug(coordRoot, { ...debugBase, effect: "session-name-display-stamped" });
+        }
+        else {
+            appendDebug(coordRoot, { ...debugBase, skipped: "no-session-name-sighting" });
+        }
+        return 0;
+    }
     const norm = normalizeEventName(eventName);
     if (!norm) {
         appendDebug(coordRoot, { ...debugBase, skipped: "non-canonical-event" });
@@ -545,6 +596,7 @@ async function main() {
         return 0;
     }
     const sessionId = payload?.session_id ?? payload?.conversation_id ?? owner.instance_id;
+    const priorCoordination = readHeartbeat(coordRoot, owner.instance_id);
     const data = buildEventData(norm.event_type, {
         coordRoot,
         payload,
@@ -609,6 +661,24 @@ async function main() {
         ...(turnRitual ? { turn_ritual: turnRitual } : {}),
         ...(deferV3Drain ? { defer_drain: true } : {}),
     });
+    const recordedGenerationId = v3Result && "event" in v3Result && "generation_id" in v3Result.event.scope
+        ? v3Result.event.scope.generation_id
+        : undefined;
+    if (v3Result?.state === "recorded" || v3Result?.state === "already_started") {
+        try {
+            restoreLiveCoordinationStateAfterEpochV3({
+                coordRoot,
+                owner: owner.instance_id,
+                nativeSessionId: sessionId,
+                adapter,
+                prior: priorCoordination,
+                currentGenerationId: recordedGenerationId,
+            });
+        }
+        catch (error) {
+            logError(coordRoot, error, { phase: "epoch-coordination-restore" });
+        }
+    }
     const v3EventId = v3Result && "event" in v3Result
         ? v3Result.event.event_id
         : v3Result && "event_id" in v3Result
@@ -642,7 +712,7 @@ async function main() {
     }
     if (v3Result?.state === "recorded" && capturedImages.length > 0) {
         try {
-            recordImageArtifactsV3(coordRoot, v3Result.event, capturedImages);
+            recordImageArtifactsV3(coordRoot, v3Result.event, capturedImages, ledgerRoute.genesis_id);
         }
         catch (err) {
             logError(coordRoot, err, { phase: "image-artifact-observation" });
@@ -733,6 +803,35 @@ async function main() {
         if (adapter === "claude-code")
             journalJanitor(coordRoot);
         imageJanitor(coordRoot);
+        // Session start is the only caller of the artifact janitor and the storage
+        // maintenance pass, so both load here instead of on every tool call.
+        const { autoCleanArtifacts } = await import("../artifacts/index.js");
+        const { createAutomaticMaintenanceComposition, runAutomaticMaintenancePass } = await import("../storage/maintenance-providers.js");
+        // Effect: throttled daily sweep of expired artifact workspaces (guarded,
+        // managed-expired only; see autoCleanArtifacts). Best-effort like every
+        // janitor here: a failure logs and never blocks session start.
+        try {
+            autoCleanArtifacts(coordRoot);
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "artifact-auto-clean" });
+        }
+        // Plan one bounded, claim-first global slice from cached pressure only.
+        // Existing owner janitors above remain the only active executors until
+        // each provider receives a separate production activation.
+        try {
+            await runAutomaticMaintenancePass(createAutomaticMaintenanceComposition(coordRoot, {
+                journal: () => {
+                    if (adapter === "claude-code")
+                        journalJanitor(coordRoot);
+                },
+                images: () => imageJanitor(coordRoot),
+                artifacts: () => autoCleanArtifacts(coordRoot),
+            }));
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "storage-maintenance-auto" });
+        }
         let recovery = null;
         if (payload?.source === "compact") {
             try {
@@ -759,10 +858,13 @@ async function main() {
         catch (err) {
             logError(coordRoot, err, { phase: "session-start-systemMessage" });
         }
-        // Pull advisory cross-machine presence. V3 never publishes from the
-        // disposable heartbeat cache.
+        // Cross-machine presence is derived from the authority-safe V3 projection,
+        // not the disposable heartbeat cache. Announce this session, pull peers,
+        // and keep the optional live relay connected.
         try {
+            publishPresence(coordRoot);
             fetchPresence(coordRoot);
+            ensureRelayDaemon(coordRoot);
         }
         catch (err) {
             logError(coordRoot, err, { phase: "session-start-presence" });
@@ -783,6 +885,14 @@ async function main() {
             journalArchive(coordRoot, owner.instance_id);
             runSessionSyncExtension(coordRoot, true);
         }
+        // Publish the post-cleanup V3 projection so remote machines see this
+        // session disappear without waiting for the stale window.
+        try {
+            publishPresence(coordRoot);
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "session-end-presence" });
+        }
     }
     // Phase 8: SubagentStart: the child generation was opened above from the
     // native delegation identity. Refresh its disposable projection, log the
@@ -885,6 +995,16 @@ async function main() {
         if (adapter === "claude-code") {
             runSessionSyncExtension(coordRoot, false);
         }
+        // Publish after the canonical turn event has landed so the blob carries
+        // current task, activity, and claim state. Re-ensure the relay here because
+        // its daemon intentionally exits when a machine has no live sessions.
+        try {
+            publishPresence(coordRoot);
+            ensureRelayDaemon(coordRoot);
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "stop-presence" });
+        }
         // Stop verdict (V3 ritual + task/status gate). Direct in-process call: the
         // rule lives in Harnery. agent-hook already emitted this turn.completed
         // with privacy-safe ritual observations, so the evidence is in the stream.
@@ -893,6 +1013,8 @@ async function main() {
             instance_id: owner.instance_id,
             session_id: sessionId,
             adapter,
+            stop_hook_active: payload?.stop_hook_active === true,
+            status_box_present_strict: data.status_box_present_strict === true,
             bypass: coordEnv("AGENT_COORD_BYPASS_STOP") === "1",
             workflow_child: coordEnv("WORKFLOW_CHILD") === "1",
         });
@@ -902,13 +1024,16 @@ async function main() {
             // `cap` consecutive blocked stops in one cycle, allow the stop instead
             // of bouncing the model forever. Cycle boundaries come from the
             // adapter's continuation flag, so adapters without one are unaffected.
-            const { remediationCapExceeded } = await import("./remediation-cap.js");
-            if (remediationCapExceeded(sessionId, payload?.stop_hook_active === true)) {
+            const { recordRemediationBlock } = await import("./remediation-cap.js");
+            const remediation = recordRemediationBlock(sessionId, payload?.stop_hook_active === true);
+            if (remediation.exceeded) {
                 appendDebug(coordRoot, {
                     ...debugBase,
                     skipped: "stop-remediation-cap-exhausted",
                     blocked_rule: verdict.rule,
+                    blocked_count: remediation.count,
                     session_id: sessionId,
+                    remediation_cycle_anchor: verdict.remediation_cycle_anchor,
                 });
             }
             else {
@@ -937,6 +1062,8 @@ async function main() {
         catch (err) {
             logError(coordRoot, err, { phase: "stop-explicit-session-finalization" });
         }
+        if (adapter === "codex")
+            scheduleCodexRuntimeContextRetry(coordRoot, sessionId);
     }
     // Phase 7: PreToolUse: heartbeat + pid-map self-heal on every tool call.
     // Adapter-agnostic: both writes have the same shape regardless of who fired.
@@ -964,10 +1091,13 @@ async function main() {
         // runs before a name exists; every later tool waits until the exact block
         // is the first assistant text after the mint result. Cursor supplies
         // agent_message directly; Claude Code and Codex are resolved from their
-        // JSONL transcripts. Later commentary must not erase an already-correct
-        // display, and an unreadable transcript must not deadlock every tool.
+        // JSONL transcripts. Cursor's current narration can provide positive
+        // evidence, but cannot disprove an earlier response; afterAgentResponse
+        // stamps that durable sighting. Later commentary must not erase an
+        // already-correct display, and unavailable evidence must not deadlock
+        // every tool.
         try {
-            const displayAllowed = await enforcePendingSessionNameDisplay(coordRoot, owner.instance_id, adapter, payload);
+            const displayAllowed = await enforcePendingSessionNameDisplay(coordRoot, owner.instance_id, adapter, payload, generationBoundHeartbeat(readHeartbeat(coordRoot, owner.instance_id), recordedGenerationId));
             if (!displayAllowed)
                 return 0;
         }
@@ -1037,8 +1167,45 @@ async function main() {
     }
     return 0;
 }
-async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter, payload) {
-    const name = sessionNameDisplayPending(readLiveCoordinationRow(coordRoot, instanceId));
+function scheduleCodexRuntimeContextRetry(coordRoot, nativeSessionId) {
+    const modulePath = process.argv[1];
+    if (!modulePath)
+        return;
+    try {
+        const child = spawn(process.execPath, [modulePath, "runtime-context-retry", "--adapter", "codex", "--session-id", nativeSessionId], {
+            cwd: coordRoot,
+            detached: true,
+            stdio: "ignore",
+            env: childEnv(coordRoot),
+        });
+        child.unref();
+    }
+    catch (err) {
+        logError(coordRoot, err, { phase: "runtime-context-retry-spawn" });
+    }
+}
+async function runRuntimeContextRetryWorker(coordRoot, adapter, extra) {
+    const nativeSessionId = extraArg(extra, "--session-id");
+    if (adapter !== "codex" || !nativeSessionId)
+        return 0;
+    for (const [index, delayMs] of [400, 1_000].entries()) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        const route = resolveLiveEventLedgerRouteV3(coordRoot);
+        if (route.state !== "v3")
+            return 0;
+        const result = reconcileLivePendingRuntimeContextV3({
+            coordRoot,
+            route,
+            nativeSessionId,
+            finalAttempt: index === 1,
+        });
+        if (result.state !== "pending" && result.state !== "busy")
+            return 0;
+    }
+    return 0;
+}
+async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter, payload, coordination) {
+    const name = sessionNameDisplayPending(coordination);
     if (!name)
         return true;
     const command = extractBashCommand(payload?.tool_name, payload?.tool_input);
@@ -1048,7 +1215,7 @@ async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter,
         ? {
             state: assistantTextStartsWithSessionNameBlock(payload.agent_message, name)
                 ? "present"
-                : "absent",
+                : "unavailable",
         }
         : inspectSessionNameDisplayImmediately(
         // Codex hook payloads omit transcript_path on every event, which
@@ -1075,6 +1242,9 @@ async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter,
     emitDeny(adapter, sessionNameDisplayRecoveryInstruction(name, resolveBinName(coordRoot)));
     return false;
 }
+function generationBoundHeartbeat(heartbeat, generationId) {
+    return generationId && heartbeat?.v3_generation_id === generationId ? heartbeat : null;
+}
 async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapter) {
     const toolName = data.tool_name ?? "";
     const rawTargets = collectGuardTargets(toolName, data);
@@ -1397,17 +1567,25 @@ async function emitUserPromptSubmitSystemMessage(coordRoot, instanceId, sessionI
         // Every human-facing adapter gets the first-session naming reminder from
         // the shared hook path. Cursor + Codex additionally get ongoing set-task
         // staleness nudges; Claude Code enforces those via its Stop transcript.
+        // Codex also gets the optional project-owned prompt reminder. Claude Code
+        // already has native output-style reminders, so duplicating it would add
+        // noise. Cursor's current beforeSubmitPrompt output can allow or block but
+        // cannot inject model context; an Always Apply rule is its durable carrier.
+        // Only the boolean route travels through argv, never the host's text.
+        if (adapter === "codex")
+            args.push("--host-prompt-reminder");
         // Codex gets a fresh status-footer reminder on every prompt. Its Stop hook
         // stays observe-only, so missing the footer never replaces the answer.
-        // Claude Code + Cursor (the Stop-ENFORCING adapters) get a fresh per-turn
-        // ritual reminder: satisfying the contract up front is far cheaper than
-        // the bounce-and-retry the Stop hook otherwise forces.
+        // Claude Code gets a fresh per-turn ritual reminder: satisfying the
+        // contract up front is far cheaper than the bounce-and-retry the Stop hook
+        // otherwise forces. Cursor's beforeSubmitPrompt cannot inject context, so
+        // its Stop follow-up remains the supported enforcement channel.
         args.push("--session-name-nudge");
         if (adapter === "cursor" || adapter === "codex")
             args.push("--task-nudge");
         if (adapter === "codex")
             args.push("--status-footer-nudge");
-        if (adapter === "claude-code" || adapter === "cursor")
+        if (adapter === "claude-code")
             args.push("--turn-ritual-nudge", adapter);
         const result = spawnSync(agentCoordBin, args, { encoding: "utf8", timeout: 3000 });
         if (result.status === 0 && result.stdout)
@@ -1543,11 +1721,15 @@ function completeRecoveryInjection(coordRoot, instanceId, sessionId, recovery) {
     void recovery;
 }
 main()
-    .then((code) => process.exit(code))
-    .catch((err) => {
-    logError(findCoordRoot(process.cwd()), err, {
+    .then(async (code) => {
+    await closeProcessLoggers();
+    process.exit(code);
+})
+    .catch(async (err) => {
+    logError(resolveCoordRoot(process.cwd()), err, {
         argv: process.argv.slice(2),
         pid: process.pid,
     });
+    await closeProcessLoggers();
     process.exit(0);
 });

package/dist/core/hooks/effects/image-capture.d.ts

@@ -22,7 +22,7 @@ export declare function captureImages(coordRoot: string, eventType: "tool.reques
  * Each observation uses a one-event producer boot, which preserves independent
  * producer sequence continuity while the ledger writer serializes appends.
  */
-export declare function recordImageArtifactsV3(coordRoot: string, sourceEvent: EventV3, artifacts: readonly CapturedImageArtifact[]): void;
+export declare function recordImageArtifactsV3(coordRoot: string, sourceEvent: EventV3, artifacts: readonly CapturedImageArtifact[], expectedGenesisId?: `gex_${string}`): void;
 export declare function buildImageArtifactEventV3(sourceEvent: EventV3, artifact: CapturedImageArtifact): EventV3;
 /** Prune the bounded blob store by age and total size, oldest first. */
 export declare function imageJanitor(coordRoot: string): void;

package/dist/core/hooks/effects/image-capture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-capture.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/effects/image-capture.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAeH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAgBzD,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAQD,mFAAmF;AACnF,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,gBAAgB,GAAG,gBAAgB,EAC9C,OAAO,EAAE,aAAa,GAAG,IAAI,GAC5B,qBAAqB,EAAE,CA0BzB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,SAAS,qBAAqB,EAAE,GAC1C,IAAI,CAKN;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,OAAO,EACpB,QAAQ,EAAE,qBAAqB,GAC9B,OAAO,CA4CT;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CA0CpD"}
+{"version":3,"file":"image-capture.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/effects/image-capture.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAeH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAgBzD,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAQD,mFAAmF;AACnF,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,gBAAgB,GAAG,gBAAgB,EAC9C,OAAO,EAAE,aAAa,GAAG,IAAI,GAC5B,qBAAqB,EAAE,CA0BzB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,SAAS,qBAAqB,EAAE,EAC3C,iBAAiB,CAAC,EAAE,OAAO,MAAM,EAAE,GAClC,IAAI,CAON;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,OAAO,EACpB,QAAQ,EAAE,qBAAqB,GAC9B,OAAO,CA4CT;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CA0CpD"}

package/dist/core/hooks/effects/image-capture.js

@@ -58,11 +58,13 @@ export function captureImages(coordRoot, eventType, payload) {
  * Each observation uses a one-event producer boot, which preserves independent
  * producer sequence continuity while the ledger writer serializes appends.
  */
-export function recordImageArtifactsV3(coordRoot, sourceEvent, artifacts) {
+export function recordImageArtifactsV3(coordRoot, sourceEvent, artifacts, expectedGenesisId) {
     if (!("generation_id" in sourceEvent.scope) || !sourceEvent.attestation_id)
         return;
     for (const artifact of artifacts) {
-        writeEventV3(coordRoot, buildImageArtifactEventV3(sourceEvent, artifact));
+        writeEventV3(coordRoot, buildImageArtifactEventV3(sourceEvent, artifact), {
+            ...(expectedGenesisId ? { expectedGenesisId } : {}),
+        });
     }
 }
 export function buildImageArtifactEventV3(sourceEvent, artifact) {

package/dist/core/hooks/remediation-cap.d.ts

@@ -25,10 +25,15 @@ export declare const DEFAULT_STOP_REMEDIATION_CAP = 5;
  *
  * Call only when the Stop verdict blocked. `continuation` is the adapter's
  * "this stop follows a stop-hook block" flag; false starts a fresh cycle.
- * Returns true when this cycle has already been blocked `cap` times, meaning
- * the caller should allow the stop instead of blocking again.
+ * Returns the retained block count and whether this cycle has already been
+ * blocked `cap` times, meaning the caller should allow the stop instead of
+ * blocking again.
  */
-export declare function remediationCapExceeded(sessionId: string, continuation: boolean, cap?: number): boolean;
+export interface RemediationBlockRecord {
+    count: number;
+    exceeded: boolean;
+}
+export declare function recordRemediationBlock(sessionId: string, continuation: boolean, cap?: number): RemediationBlockRecord;
 /** Clear the cycle counter after an allowed stop. */
 export declare function clearRemediationCount(sessionId: string): void;
 //# sourceMappingURL=remediation-cap.d.ts.map

package/dist/core/hooks/remediation-cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remediation-cap.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/remediation-cap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAMH,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAO9C;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,OAAO,EACrB,GAAG,SAA+B,GACjC,OAAO,CAsBT;AAED,qDAAqD;AACrD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAM7D"}
+{"version":3,"file":"remediation-cap.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/remediation-cap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAMH,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAO9C;;;;;;;;GAQG;AACH,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,OAAO,EACrB,GAAG,SAA+B,GACjC,sBAAsB,CAsBxB;AAED,qDAAqD;AACrD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAM7D"}

package/dist/core/hooks/remediation-cap.js

@@ -27,15 +27,7 @@ function counterPath(sessionId) {
     const key = (sessionId || "default").replace(/[^A-Za-z0-9_-]/g, "_");
     return join(os.tmpdir(), `harnery-stop-remediation-${key}.count`);
 }
-/**
- * Record one blocked stop and report whether the cap is exhausted.
- *
- * Call only when the Stop verdict blocked. `continuation` is the adapter's
- * "this stop follows a stop-hook block" flag; false starts a fresh cycle.
- * Returns true when this cycle has already been blocked `cap` times, meaning
- * the caller should allow the stop instead of blocking again.
- */
-export function remediationCapExceeded(sessionId, continuation, cap = DEFAULT_STOP_REMEDIATION_CAP) {
+export function recordRemediationBlock(sessionId, continuation, cap = DEFAULT_STOP_REMEDIATION_CAP) {
     const path = counterPath(sessionId);
     let count = 1;
     if (continuation) {
@@ -56,9 +48,9 @@ export function remediationCapExceeded(sessionId, continuation, cap = DEFAULT_ST
     }
     catch {
         // Counter IO must never turn into a block or a crash; fail open (no cap).
-        return false;
+        return { count, exceeded: false };
     }
-    return count > cap;
+    return { count, exceeded: count > cap };
 }
 /** Clear the cycle counter after an allowed stop. */
 export function clearRemediationCount(sessionId) {

package/dist/core/hooks/resolve/coord-root.d.ts

@@ -1,12 +1,12 @@
 /**
- * The hooks-side name for THE coordination-root resolution.
+ * Resolve the coordination root from path evidence only.
  *
- * Delegates to `resolveCoordRoot()` so the hooks and the CLI cannot resolve
- * different roots. They used to: this walked up from `CLAUDE_PROJECT_DIR` or
- * cwd while the CLI's `monorepoRoot()` asked git for the superproject first, so
- * with a shell inside a submodule that carries its own `.harnery/`, the CLI's
- * `coord.status_observed` landed in a stream this side never read and rule 1/3
- * blocked every turn.
+ * This path-only resolver deliberately does not inspect live producer state.
+ * Code that reads or writes coordination authority must use
+ * `resolveCoordRoot()` from `agents/coord-client.ts`, which disambiguates
+ * nested coordination roots through the registered session. Keeping the two
+ * responsibilities separate lets configuration and other path-only consumers
+ * avoid loading the event recorder and its contract graph.
  *
  * Resolution precedence (see `resolveCoordRoot` for the full rationale):
  *   1. HARNERY_COORD_ROOT_OVERRIDE — explicit pin (tests, git hooks).
@@ -15,8 +15,21 @@
  *      submodules that may carry a `.harnery/` of their own (or none at all,
  *      e.g. a journal dir under /tmp). The session's coordination home is the
  *      project the adapter opened, not wherever the shell happens to sit.
- *   3. The root that already holds this session's heartbeat.
- *   4. The nearest enclosing `.harnery/`, then a git-derived root.
+ *   3. The nearest enclosing `.harnery/`.
+ *   4. A git-derived root when no `.harnery/` exists yet.
  */
 export declare function findCoordRoot(start?: string): string | null;
+/** Nearest enclosing directory carrying `.harnery/`, or null. */
+export declare function nearestCoordRoot(start: string): string | null;
+/** Every enclosing directory carrying `.harnery/`, nearest first. */
+export declare function ancestorCoordRoots(start: string): string[];
+/**
+ * Git-derived roots carrying `.harnery/`, in superproject-first order.
+ *
+ * Spawns use `start` as cwd so a call about another checkout cannot inherit
+ * this process's repository. The common-dir fallback recovers a superproject
+ * from a submodule worktree, where Git reports no direct superproject path.
+ */
+export declare function gitCoordRoots(start: string): string[];
+export declare function gitToplevel(start: string): string | null;
 //# sourceMappingURL=coord-root.d.ts.map

package/dist/core/hooks/resolve/coord-root.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coord-root.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/resolve/coord-root.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,KAAK,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAE1E"}
+{"version":3,"file":"coord-root.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/resolve/coord-root.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,KAAK,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAa1E;AAED,iEAAiE;AACjE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE7D;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAU1D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAcrD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAExD"}