harnery 0.34.0 → 0.35.0

package/dist/core/hooks/cli.js

@@ -24,19 +24,20 @@ import { buildInstructionBundle } from "../../lib/instructions/bundle.js";
 import { coordBinPath } from "../agents/coord-bin.js";
 import { classifyWriteClaimFinalization, formatWriteClaimFinalizationDenial, } from "../agents/finalization.js";
 import { evaluateStopHook, STOP_REMEDIATION_MARKER } from "../agents/rules/stop-hook.js";
-import { assistantTextStartsWithSessionNameBlock, isSessionNameRemediationCommand, sessionNameDisplayInstruction, sessionNameDisplayPending, toolResponseMintedSessionName, } from "../agents/session-name-display.js";
+import { assistantTextStartsWithSessionNameBlock, isSessionNameRemediationCommand, sessionNameDisplayInstruction, sessionNameDisplayPending, sessionNameDisplayRecoveryInstruction, toolResponseMintedSessionName, } from "../agents/session-name-display.js";
 import { stampSessionNameSeen } from "../agents/state/heartbeat-writer.js";
-import { readLiveCoordinationRow } from "../agents/state/live-coordination-view.js";
+import { ensureLiveCoordinationHeartbeat, readLiveCoordinationRow, } from "../agents/state/live-coordination-view.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 { recordLiveHookSignalV3, resolveLiveEventLedgerRouteV3, } from "../events/v3/live-routing.js";
+import { liveHookSignalDefersDrainV3, recordLiveDelegatedChildSessionV3, recordLiveHookSignalV3, resolveLiveEventLedgerRouteV3, } from "../events/v3/live-routing.js";
 import { captureSpanClockV3 } from "../events/v3/span-state.js";
 import { fetchPresence } from "../presence/index.js";
 import { stableScopeId } from "../workflow/scope-id.js";
 import { detectAdapter, shouldSkipHookAdapter } from "./adapter/detect.js";
 import { extractBashCommand, extractToolDescription, normalizeEventName, parsePayload, } from "./adapter/parse.js";
+import { discoverCodexSessionTranscript } from "./adapter/runtime-telemetry.js";
 import { codexWslFileLinkTelemetry, inspectCodexWslBridge, isWslUncPath, renderCodexWslFileLinkContext, } from "./codex-wsl-bridge.js";
 import { captureImages, detectPresence, imageJanitor, journalArchive, journalJanitor, journalRecoveryCue, playSound, recordImageArtifactsV3, resetSoundCounters, runSessionSyncExtension, soundForEvent, } from "./effects/index.js";
 import { toolInputHash, toolTargetHash } from "./events/input-hash.js";
@@ -45,7 +46,7 @@ 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 { inspectSessionNameDisplayImmediately, scanAssistantTextIncludes, scanSessionNameDisplayedImmediately, scanStatusBoxPresent, scanTranscriptModel, } from "./resolve/transcript.js";
+import { inspectSessionNameDisplayImmediately, scanAssistantTextIncludes, scanSessionNameDisplayedImmediately, scanStatusBoxPresent, scanTranscriptRuntime, } from "./resolve/transcript.js";
 import { sessionNamePresence } from "./session-name-presence.js";
 import { unsafeCrossShellReason } from "./unsafe-cross-shell.js";
 function parseArgv(argv) {
@@ -221,7 +222,7 @@ function buildEventData(eventType, ctx) {
                 // Claude Code's SessionStart payload omits `model` (Codex + Cursor
                 // supply it). Fall back to the transcript, populated on `resume`, and
                 // backfilled later by `turn.completed` for a fresh startup session.
-                model: p?.model ?? scanTranscriptModel(p?.transcript_path),
+                model: p?.model ?? scanTranscriptRuntime(p?.transcript_path)?.model,
                 pid: adapterPid,
                 source: p?.source,
                 platform: adapterPlatform,
@@ -282,7 +283,7 @@ function buildEventData(eventType, ctx) {
                 // Backfill the model for adapters that omit it at session.started
                 // (Claude Code). The transcript is populated with assistant turns by
                 // Stop-hook time, so this resolves even for fresh `startup` sessions.
-                model: p?.model ?? scanTranscriptModel(p?.transcript_path),
+                model: p?.model ?? scanTranscriptRuntime(p?.transcript_path)?.model,
                 // Phase 2: tool_call_count + text_length aren't cheaply available
                 // from the Stop payload alone (they'd require a transcript scan that
                 // races with the JSONL flush). Emit `-1` / `0` sentinels and let
@@ -296,22 +297,26 @@ function buildEventData(eventType, ctx) {
                 // the verdict now sees because agent-hook emits this turn.completed itself
                 // (the previous path passed those via the no-history fail-open).
                 status_box_present: scanStatusBoxPresent(p?.transcript_path) || lastAssistantMessage.includes("┌─ agent-"),
-                // Shadow measurement for the rule-2/3 detector: the loose scan above
+                // Assistant-text evidence 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.
+                // 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-"),
                 // 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, (name) => scanSessionNameDisplayedImmediately(p?.transcript_path, name, assistantTextStartsWithSessionNameBlock)),
+                ...sessionNamePresence(ctx.coordRoot, ctx.instanceId, (name) => scanSessionNameDisplayedImmediately(
+                // Codex stops carry no transcript_path; discover the rollout by
+                // session id so the naming ritual can verify and stamp there too.
+                p?.transcript_path ??
+                    (ctx.adapter === "codex"
+                        ? discoverCodexSessionTranscript(p?.session_id ?? ctx.instanceId)
+                        : undefined), name, assistantTextStartsWithSessionNameBlock)),
                 ...(fileLinkTelemetry ?? {}),
                 stop_hook_active: p?.stop_hook_active,
             };
@@ -321,7 +326,8 @@ function buildEventData(eventType, ctx) {
             // Subagents inherit parent's name via the resolve-name session_id path
             // (agent-coord/state/names.ts → kind=transient). Use the call ID as the
             // instance_id input; assignName falls through to transient.
-            const assigned = assignNameViaAgentCoord(ctx.coordRoot, ctx.instanceId, "subagent");
+            const childInstanceId = subagentCallId ?? ctx.instanceId;
+            const assigned = assignNameViaAgentCoord(ctx.coordRoot, childInstanceId, "subagent");
             return {
                 agent_type: p?.raw.agent_type ??
                     p?.raw.subagent_type ??
@@ -329,7 +335,7 @@ function buildEventData(eventType, ctx) {
                 prompt_summary: p?.raw.prompt_summary,
                 name: assigned?.name,
                 kind: "subagent",
-                agent_id: ctx.instanceId,
+                agent_id: childInstanceId,
                 subagent_call_id: subagentCallId,
                 parent_session_id: p?.parent_session_id,
             };
@@ -475,14 +481,21 @@ async function main() {
             const repoRoot = findCoordRoot(process.cwd());
             if (repoRoot) {
                 let sid = "";
+                let stopContinuation = false;
                 try {
                     const j = JSON.parse(raw);
                     sid = j.session_id ?? j.conversation_id ?? "";
+                    // A stop with stop_hook_active is a remediation continuation of a
+                    // turn that already chimed; replaying the sound on every bounce
+                    // turns a blocked-stop loop into a repeating alarm.
+                    stopContinuation = eventName === "stop" && j.stop_hook_active === true;
                 }
                 catch {
                     // non-JSON payload: play unkeyed (rate-limit just won't dedup)
                 }
-                playSound(repoRoot, s.sound, sid, s.maxPlays);
+                if (!stopContinuation) {
+                    playSound(repoRoot, s.sound, sid, s.maxPlays);
+                }
             }
         }
     }
@@ -571,6 +584,7 @@ async function main() {
             logError(coordRoot, err, { phase: "image-capture" });
         }
     }
+    const deferV3Drain = liveHookSignalDefersDrainV3(eventName, coordEnv("EXPERIMENT_DEFER_V3_DRAIN"));
     const v3Result = recordLiveHookSignalV3({
         coordRoot,
         route: ledgerRoute,
@@ -593,13 +607,39 @@ async function main() {
         monotonic_ns: hookClock.monotonic_ns,
         ...(stopRemediation ? { stop_remediation: true } : {}),
         ...(turnRitual ? { turn_ritual: turnRitual } : {}),
-        ...(coordEnv("EXPERIMENT_DEFER_V3_DRAIN") === "1" ? { defer_drain: true } : {}),
+        ...(deferV3Drain ? { defer_drain: true } : {}),
     });
     const v3EventId = v3Result && "event" in v3Result
         ? v3Result.event.event_id
         : v3Result && "event_id" in v3Result
             ? v3Result.event_id
             : undefined;
+    if (norm.event_type === "agent.started" &&
+        payload &&
+        v3Result?.state === "recorded" &&
+        v3Result.event.event_type === "agent.started") {
+        try {
+            const childResult = recordLiveDelegatedChildSessionV3({
+                coordRoot,
+                route: ledgerRoute,
+                parentEvent: v3Result.event,
+                payload,
+                adapter,
+                ...(adapter === "codex" && isWslUncPath(payload.cwd)
+                    ? { bridge: "codex-wsl" }
+                    : {}),
+                monotonic_ns: hookClock.monotonic_ns,
+            });
+            const nativeChild = payload.subagent_id ?? payload.agent_id;
+            if (nativeChild &&
+                (childResult.state === "recorded" || childResult.state === "already_started")) {
+                ensureLiveCoordinationHeartbeat(coordRoot, nativeChild, sessionId, adapter, payload.model);
+            }
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "subagent-child-session-start" });
+        }
+    }
     if (v3Result?.state === "recorded" && capturedImages.length > 0) {
         try {
             recordImageArtifactsV3(coordRoot, v3Result.event, capturedImages);
@@ -744,11 +784,12 @@ async function main() {
             runSessionSyncExtension(coordRoot, true);
         }
     }
-    // Phase 8: SubagentStart: sync-project to create the subagent heartbeat,
-    // log the lifecycle event, and emit a context message announcing the
-    // subagent (claude-code + cursor; codex doesn't fan out subagents today).
+    // Phase 8: SubagentStart: the child generation was opened above from the
+    // native delegation identity. Refresh its disposable projection, log the
+    // lifecycle event, and emit a context message announcing the subagent.
     if (norm.event_type === "agent.started") {
         try {
+            const childInstanceId = data.agent_id ?? owner.instance_id;
             const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
             if (existsSync(agentCoordBin)) {
                 spawnSync(agentCoordBin, ["project"], {
@@ -758,12 +799,12 @@ async function main() {
                 });
                 spawnSync(agentCoordBin, [
                     "log",
-                    `SUBAGENT_START  agent_type=${data.agent_type ?? "unknown"} agent_id=${owner.instance_id.slice(0, 8)} platform=${adapterPlatform(adapter)}`,
+                    `SUBAGENT_START  agent_type=${data.agent_type ?? "unknown"} agent_id=${childInstanceId.slice(0, 8)} platform=${adapterPlatform(adapter)}`,
                     "--instance",
-                    owner.instance_id,
+                    childInstanceId,
                 ], { encoding: "utf8", timeout: 2000, env: childEnv(coordRoot) });
             }
-            emitSubagentStartContext(coordRoot, owner.instance_id, sessionId, data, adapter);
+            emitSubagentStartContext(coordRoot, childInstanceId, sessionId, data, adapter);
         }
         catch (err) {
             logError(coordRoot, err, { phase: "subagent-start-project" });
@@ -772,16 +813,19 @@ async function main() {
     // Phase 8: SubagentStop: delete subagent heartbeat + log.
     if (norm.event_type === "agent.completed") {
         try {
-            cleanupSessionEnd(coordRoot, owner.instance_id, data.reason ?? "unknown");
+            const childInstanceId = payload?.subagent_id ?? payload?.agent_id ?? owner.instance_id;
+            cleanupSessionEnd(coordRoot, childInstanceId, data.reason ?? "unknown");
             const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
             if (existsSync(agentCoordBin)) {
                 spawnSync(agentCoordBin, [
                     "log",
-                    `SUBAGENT_STOP   agent_id=${owner.instance_id.slice(0, 8)} platform=${adapterPlatform(adapter)}`,
+                    `SUBAGENT_STOP   agent_id=${childInstanceId.slice(0, 8)} platform=${adapterPlatform(adapter)}`,
                     "--instance",
-                    owner.instance_id,
+                    childInstanceId,
                 ], { encoding: "utf8", timeout: 2000, env: childEnv(coordRoot) });
             }
+            const { reconcileSessionFinalizationV3 } = await import("../agents/session-finalizer-v3.js");
+            reconcileSessionFinalizationV3(coordRoot, { archive_observations: [] });
         }
         catch (err) {
             logError(coordRoot, err, { phase: "subagent-stop-cleanup" });
@@ -853,12 +897,32 @@ async function main() {
             workflow_child: coordEnv("WORKFLOW_CHILD") === "1",
         });
         if (!verdict.allow) {
-            // Adapter-aware enforcement channel: Claude Code honors exit-2 + stderr
-            // as a turn block; Cursor ignores exit codes and re-prompts only via a
-            // `followup_message` it auto-submits. Codex returned observe-only above.
-            // emitStopBlock writes the right shape and returns the exit code to use.
-            const { emitStopBlock } = await import("./adapter/output.js");
-            return emitStopBlock(adapter, verdict, coordRoot);
+            // Backstop for sessions whose evidence can never land (e.g. a headless
+            // child whose status command resolves to a different owner): after
+            // `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)) {
+                appendDebug(coordRoot, {
+                    ...debugBase,
+                    skipped: "stop-remediation-cap-exhausted",
+                    blocked_rule: verdict.rule,
+                    session_id: sessionId,
+                });
+            }
+            else {
+                // Adapter-aware enforcement channel: Claude Code honors exit-2 + stderr
+                // as a turn block; Cursor ignores exit codes and re-prompts only via a
+                // `followup_message` it auto-submits. Codex returned observe-only above.
+                // emitStopBlock writes the right shape and returns the exit code to use.
+                const { emitStopBlock } = await import("./adapter/output.js");
+                return emitStopBlock(adapter, verdict, coordRoot);
+            }
+        }
+        else {
+            const { clearRemediationCount } = await import("./remediation-cap.js");
+            clearRemediationCount(sessionId);
         }
         // An explicit end requested from inside this turn cannot be authoritative
         // until the adapter has committed turn.completed above. Reconcile only
@@ -944,8 +1008,9 @@ async function main() {
             return 0;
     }
     if (norm.event_type === "tool.completed" && eventName === "post-tool-use") {
-        // Inject only at the successful tool boundary that actually minted a name:
-        // the first non-empty set-task or the transition to lifecycle done. The
+        // Inject only at the successful tool boundary that actually minted or
+        // retried a name: the first non-empty set-task, a pending-name set-task
+        // retry, or the transition to lifecycle done. The
         // coordination row intentionally remains pending until transcript evidence
         // catches up; reading that latch alone here would re-inject after every
         // later tool and make the agent print the same block repeatedly.
@@ -979,24 +1044,35 @@ async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter,
     const command = extractBashCommand(payload?.tool_name, payload?.tool_input);
     if (isSessionNameRemediationCommand(command, resolveBinName(coordRoot)))
         return true;
-    const inspection = payload?.agent_message !== undefined
+    const inspection = adapter === "cursor" && payload?.agent_message !== undefined
         ? {
             state: assistantTextStartsWithSessionNameBlock(payload.agent_message, name)
                 ? "present"
                 : "absent",
         }
-        : inspectSessionNameDisplayImmediately(payload?.transcript_path, name, assistantTextStartsWithSessionNameBlock);
+        : inspectSessionNameDisplayImmediately(
+        // Codex hook payloads omit transcript_path on every event, which
+        // left this inspection permanently unavailable and the latch never
+        // stamped. Discover the rollout by session id; the scan only runs
+        // while a name is pending, so the latch closes after one success.
+        payload?.transcript_path ??
+            (adapter === "codex"
+                ? discoverCodexSessionTranscript(payload?.session_id ?? instanceId)
+                : undefined), name, assistantTextStartsWithSessionNameBlock);
     if (inspection.state === "present") {
         stampSessionNameSeen(coordRoot, instanceId, name);
         return true;
     }
     if (inspection.state === "unavailable") {
-        const { emitContext } = await import("./adapter/output.js");
-        emitContext(adapter, "PreToolUse", "Harnery could not verify the pending session-name display because the adapter transcript is unavailable or not flushed yet. This tool is allowed so the session cannot deadlock; display the requested block before later work. Verification remains pending.");
+        // PostToolUse already delivered the exact block for this mint. An
+        // unavailable transcript cannot become evidence, and repeating a generic
+        // reminder on every tool creates an unbounded Codex loop. Keep the latch
+        // honestly pending and fail open without another instruction. A later
+        // readable transcript can still verify it.
         return true;
     }
     const { emitDeny } = await import("./adapter/output.js");
-    emitDeny(adapter, sessionNameDisplayInstruction(name));
+    emitDeny(adapter, sessionNameDisplayRecoveryInstruction(name, resolveBinName(coordRoot)));
     return false;
 }
 async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapter) {

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

@@ -0,0 +1,34 @@
+/**
+ * Per-session cap on consecutive blocked Stop remediations.
+ *
+ * The Stop verdict re-blocks until the ledger shows the end-of-turn evidence,
+ * which assumes the agent CAN produce it. A session whose evidence can never
+ * land (e.g. a headless child whose status command resolves to a different
+ * owner) bounces forever: every retry replays the stop cycle until the budget
+ * or the operator kills it. This counter is the backstop: once a single stop
+ * cycle has been blocked `cap` times in a row, the verdict is allowed through
+ * so the session can terminate.
+ *
+ * A "stop cycle" is delimited by the adapter's continuation flag (Claude
+ * Code's `stop_hook_active`): a stop without the flag starts a fresh cycle and
+ * resets the count. Adapters that never set the flag (Cursor) reset on every
+ * stop, so the cap never engages there and behavior is unchanged.
+ *
+ * State is a tmpdir counter file keyed by session id — deliberately outside
+ * the ledger, because remediation stops do not land fresh `turn.completed`
+ * events (the turn span is already closed), so ledger evidence cannot count
+ * them.
+ */
+export declare const DEFAULT_STOP_REMEDIATION_CAP = 5;
+/**
+ * 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 declare function remediationCapExceeded(sessionId: string, continuation: boolean, cap?: number): boolean;
+/** 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

@@ -0,0 +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"}

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

@@ -0,0 +1,71 @@
+/**
+ * Per-session cap on consecutive blocked Stop remediations.
+ *
+ * The Stop verdict re-blocks until the ledger shows the end-of-turn evidence,
+ * which assumes the agent CAN produce it. A session whose evidence can never
+ * land (e.g. a headless child whose status command resolves to a different
+ * owner) bounces forever: every retry replays the stop cycle until the budget
+ * or the operator kills it. This counter is the backstop: once a single stop
+ * cycle has been blocked `cap` times in a row, the verdict is allowed through
+ * so the session can terminate.
+ *
+ * A "stop cycle" is delimited by the adapter's continuation flag (Claude
+ * Code's `stop_hook_active`): a stop without the flag starts a fresh cycle and
+ * resets the count. Adapters that never set the flag (Cursor) reset on every
+ * stop, so the cap never engages there and behavior is unchanged.
+ *
+ * State is a tmpdir counter file keyed by session id — deliberately outside
+ * the ledger, because remediation stops do not land fresh `turn.completed`
+ * events (the turn span is already closed), so ledger evidence cannot count
+ * them.
+ */
+import { readFileSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import { join } from "node:path";
+export const DEFAULT_STOP_REMEDIATION_CAP = 5;
+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) {
+    const path = counterPath(sessionId);
+    let count = 1;
+    if (continuation) {
+        let prior = 0;
+        try {
+            prior = Number.parseInt(readFileSync(path, "utf8"), 10);
+        }
+        catch {
+            // No counter yet (cycle started before the counter existed): treat the
+            // continuation itself as evidence of one earlier blocked stop, so an
+            // already-running loop still converges on the cap.
+            prior = 1;
+        }
+        count = Number.isFinite(prior) && prior >= 0 ? prior + 1 : 1;
+    }
+    try {
+        writeFileSync(path, String(count), "utf8");
+    }
+    catch {
+        // Counter IO must never turn into a block or a crash; fail open (no cap).
+        return false;
+    }
+    return count > cap;
+}
+/** Clear the cycle counter after an allowed stop. */
+export function clearRemediationCount(sessionId) {
+    try {
+        rmSync(counterPath(sessionId), { force: true });
+    }
+    catch {
+        // best-effort
+    }
+}

package/dist/core/hooks/resolve/transcript.d.ts

@@ -55,19 +55,35 @@ export declare function inspectSessionNameDisplayImmediately(transcriptPath: str
  * file is mounted at `/mnt/c/...`.
  */
 export declare function transcriptPathCandidates(transcriptPath: string | undefined): string[];
+/** Runtime identity read from one transcript row: the model plus the tuning
+ * values that row reported alongside it. */
+export interface TranscriptRuntimeScan {
+    model: string;
+    /** CC stamps the effective effort level on each assistant row; absent when
+     * the model has no effort dial (verified: haiku rows omit it entirely). */
+    effort?: string;
+    /** CC reports the response speed tier inside `message.usage`. */
+    speed?: string;
+}
 /**
- * Resolve the agent's model from a CC-style JSONL transcript by reading the
- * most-recent assistant message's `message.model`. Claude Code's SessionStart
- * payload omits `model` (Codex + Cursor supply it directly), so this is the
- * fallback that lets `session.started` / `turn.completed` populate the cache's
- * model field once the transcript has at least one assistant turn.
+ * Resolve the agent's runtime identity from a CC-style JSONL transcript by
+ * reading the most-recent assistant row. Claude Code's SessionStart payload
+ * omits `model` and `effort` (Codex + Cursor supply model directly), so this
+ * is the fallback that lets `session.started` / `turn.completed` populate
+ * model and tuning once the transcript has at least one assistant turn.
+ *
+ * Model, effort, and speed are read from the SAME row, never independently:
+ * effort varies with model inside one transcript (a mid-session model swap
+ * changes both), so pairing the newest model with a separately scanned newest
+ * effort can mislabel the session.
  *
  * Tail-reads the same 256KB window as the status-box scan and walks lines from
- * the end, returning the first real model id found. Synthetic placeholders
- * (`<synthetic>`) and empty values are skipped. Returns undefined when the
- * transcript is missing/empty (e.g. a fresh session's first SessionStart).
+ * the end, returning the first row with a real model id. Synthetic
+ * placeholders (`<synthetic>`) and empty values are skipped. Returns undefined
+ * when the transcript is missing/empty (e.g. a fresh session's first
+ * SessionStart).
  */
-export declare function scanTranscriptModel(transcriptPath: string | undefined): string | undefined;
+export declare function scanTranscriptRuntime(transcriptPath: string | undefined): TranscriptRuntimeScan | undefined;
 /**
  * Detect the parent session of a forked CC conversation from its transcript.
  *

package/dist/core/hooks/resolve/transcript.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/resolve/transcript.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAQhF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,MAAM,EAAE,MAAM,GACb,OAAO,CAiCT;AAED,kFAAkF;AAClF,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAgB9F;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CACjD,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,GAC/D,OAAO,CAIT;AAED,MAAM,MAAM,4BAA4B,GACpC;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,GACpB;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,GACnB;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,oBAAoB,GAAG,sBAAsB,CAAA;CAAE,CAAC;AAEpF;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAClD,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,GAC/D,4BAA4B,CAsB9B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAUrF;AAwDD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAuB1F;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAkDpB"}
+{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/resolve/transcript.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAQhF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,MAAM,EAAE,MAAM,GACb,OAAO,CAiCT;AAED,kFAAkF;AAClF,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAgB9F;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CACjD,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,GAC/D,OAAO,CAIT;AAED,MAAM,MAAM,4BAA4B,GACpC;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,GACpB;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,GACnB;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,oBAAoB,GAAG,sBAAsB,CAAA;CAAE,CAAC;AAEpF;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAClD,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,GAC/D,4BAA4B,CA0B9B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAUrF;AAwDD;4CAC4C;AAC5C,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd;+EAC2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,qBAAqB,GAAG,SAAS,CA8BnC;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAkDpB"}

package/dist/core/hooks/resolve/transcript.js

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+import { toolResponseMintedSessionName } from "../../agents/session-name-display.js";
 /**
  * Scan a CC-style JSONL transcript for the `┌─ agent-` status-box prefix in
  * the most-recent assistant turn. Used by `turn.completed` events to populate
@@ -123,21 +124,26 @@ export function inspectSessionNameDisplayImmediately(transcriptPath, name, start
     if (!text)
         return { state: "unavailable", reason: "transcript_not_ready" };
     let sawMintResult = false;
+    let awaitingReply = false;
     for (const line of text.split("\n")) {
-        if (!sawMintResult) {
-            if (line.includes(name) && line.includes("suggested_session_name"))
-                sawMintResult = true;
-            continue;
-        }
         const row = parseTranscriptRow(line);
         if (!row)
             continue;
+        if (toolResponseMintedSessionName(row, name)) {
+            sawMintResult = true;
+            awaitingReply = true;
+            continue;
+        }
+        if (!awaitingReply)
+            continue;
         const assistantText = assistantTextFromRow(row);
         if (assistantText !== null) {
-            return { state: startsWithBlock(assistantText, name) ? "present" : "absent" };
+            if (startsWithBlock(assistantText, name))
+                return { state: "present" };
+            awaitingReply = false;
         }
     }
-    return sawMintResult
+    return sawMintResult && awaitingReply
         ? { state: "unavailable", reason: "transcript_not_ready" }
         : { state: "absent" };
 }
@@ -210,18 +216,24 @@ function textFromContent(content) {
     return parts.join("\n");
 }
 /**
- * Resolve the agent's model from a CC-style JSONL transcript by reading the
- * most-recent assistant message's `message.model`. Claude Code's SessionStart
- * payload omits `model` (Codex + Cursor supply it directly), so this is the
- * fallback that lets `session.started` / `turn.completed` populate the cache's
- * model field once the transcript has at least one assistant turn.
+ * Resolve the agent's runtime identity from a CC-style JSONL transcript by
+ * reading the most-recent assistant row. Claude Code's SessionStart payload
+ * omits `model` and `effort` (Codex + Cursor supply model directly), so this
+ * is the fallback that lets `session.started` / `turn.completed` populate
+ * model and tuning once the transcript has at least one assistant turn.
+ *
+ * Model, effort, and speed are read from the SAME row, never independently:
+ * effort varies with model inside one transcript (a mid-session model swap
+ * changes both), so pairing the newest model with a separately scanned newest
+ * effort can mislabel the session.
  *
  * Tail-reads the same 256KB window as the status-box scan and walks lines from
- * the end, returning the first real model id found. Synthetic placeholders
- * (`<synthetic>`) and empty values are skipped. Returns undefined when the
- * transcript is missing/empty (e.g. a fresh session's first SessionStart).
+ * the end, returning the first row with a real model id. Synthetic
+ * placeholders (`<synthetic>`) and empty values are skipped. Returns undefined
+ * when the transcript is missing/empty (e.g. a fresh session's first
+ * SessionStart).
  */
-export function scanTranscriptModel(transcriptPath) {
+export function scanTranscriptRuntime(transcriptPath) {
     const readablePath = resolveTranscriptPath(transcriptPath);
     if (!readablePath)
         return undefined;
@@ -237,7 +249,13 @@ export function scanTranscriptModel(transcriptPath) {
             const obj = JSON.parse(line);
             const model = obj.message?.model ?? obj.model;
             if (typeof model === "string" && model.length > 0 && !model.startsWith("<")) {
-                return model;
+                const effort = obj.effort;
+                const speed = obj.message?.usage?.speed;
+                return {
+                    model,
+                    ...(typeof effort === "string" && effort.length > 0 ? { effort } : {}),
+                    ...(typeof speed === "string" && speed.length > 0 ? { speed } : {}),
+                };
             }
         }
         catch {

package/dist/core/semantic/adapters.d.ts

@@ -0,0 +1,34 @@
+import type { TSchema } from "@sinclair/typebox";
+import { type SemanticConfiguredModel, type SemanticHarness } from "./contract.js";
+import type { SemanticReaderResolution } from "./storage.js";
+export interface SemanticReaderRoute {
+    harness: SemanticHarness;
+    binary: string;
+    configured_model: SemanticConfiguredModel;
+    invocation_model_id: string;
+}
+export interface SemanticAdapterSuccess {
+    ok: true;
+    text: string;
+    resolved_model_id: string;
+    model_attestation: "verified" | "requested-only";
+    duration_ms: number;
+    output_bytes: number;
+}
+export interface SemanticAdapterFailure {
+    ok: false;
+    reason_code: "harness_unavailable" | "authentication_unavailable" | "model_unavailable" | "model_mismatch";
+    resolved_model_id?: string;
+    model_attestation?: "verified" | "requested-only";
+    duration_ms: number;
+}
+export type SemanticAdapterResult = SemanticAdapterSuccess | SemanticAdapterFailure;
+export interface SemanticAdapter {
+    readonly route: SemanticReaderRoute;
+    discover(now?: () => Date): SemanticReaderResolution;
+    invoke(prompt: string, timeoutMs?: number, responseSchema?: TSchema): Promise<SemanticAdapterResult>;
+}
+export declare const SEMANTIC_READER_ROUTES: Record<SemanticHarness, SemanticReaderRoute>;
+export declare function createSemanticAdapters(): Record<SemanticHarness, SemanticAdapter>;
+export declare function discoverSemanticReaders(adapters?: Record<SemanticHarness, SemanticAdapter>): Record<SemanticHarness, SemanticReaderResolution>;
+//# sourceMappingURL=adapters.d.ts.map

package/dist/core/semantic/adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../../../src/core/semantic/adapters.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EAErB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAM7D,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,eAAe,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,uBAAuB,CAAC;IAC1C,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,UAAU,GAAG,gBAAgB,CAAC;IACjD,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,KAAK,CAAC;IACV,WAAW,EACP,qBAAqB,GACrB,4BAA4B,GAC5B,mBAAmB,GACnB,gBAAgB,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,UAAU,GAAG,gBAAgB,CAAC;IAClD,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,qBAAqB,GAAG,sBAAsB,GAAG,sBAAsB,CAAC;AAEpF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC;IACpC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,IAAI,GAAG,wBAAwB,CAAC;IACrD,MAAM,CACJ,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,OAAO,GACvB,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACnC;AAED,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,eAAe,EAAE,mBAAmB,CAmB/E,CAAC;AAEF,wBAAgB,sBAAsB,IAAI,MAAM,CAAC,eAAe,EAAE,eAAe,CAAC,CAMjF;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,GAAE,MAAM,CAAC,eAAe,EAAE,eAAe,CAA4B,GAC5E,MAAM,CAAC,eAAe,EAAE,wBAAwB,CAAC,CAMnD"}