@drisp/cli 0.5.26 → 0.5.28

package/dist/{chunk-YZ7RCBKO.js → chunk-4HWBXCVY.js}

@@ -1,6 +1,7 @@
 import {
   ATHENA_HOOK_SOCKET_ENV,
   createAskUserQuestionResult,
+  createCompactBlockResult,
   createPermissionRequestAllowResult,
   createPermissionRequestDenyResult,
   createPreToolUseAllowResult,
@@ -12,7 +13,7 @@ import {
   isToolEvent,
   isValidHookEventEnvelope,
   resolveHookSocketPath
-} from "./chunk-QYB6N2OT.js";
+} from "./chunk-USK5VSQ7.js";
 import {
   TransportUnreachableError,
   createUdsClientTransport,
@@ -25,10 +26,12 @@ import {
   trackGatewayTransportReconnect,
   writeGatewayTrace,
   wsClientOptionsForEndpoint
-} from "./chunk-3U37HT4T.js";
+} from "./chunk-VAFS446Y.js";
 import {
+  DEFAULT_MAX_TURN_TOKEN_COUNT,
   compileWorkflowPlan,
   createWorkflowRunner,
+  deserializeRunMemory,
   installWorkflowFromSource,
   isMarketplaceRef,
   readConfig,
@@ -38,7 +41,7 @@ import {
   resolveWorkflow,
   resolveWorkflowInstall,
   resolveWorkflowPlugins
-} from "./chunk-73V7GXV6.js";
+} from "./chunk-2QV7YSX6.js";
 
 // src/infra/daemon/stateDir.ts
 import fs from "fs";
@@ -291,10 +294,17 @@ var RULES = {
     defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
     canBlock: false
   },
+  // Decision-bearing for Handover (ADR 0014): a Workflow Run's orchestrator
+  // blocks the compaction and forks the conversation instead. Both claims are
+  // required — `canBlock` alone leaves the event off the decision-waiting
+  // path and the block reply is never sent. The timeout is deliberately a
+  // number, not null: with no decision (non-workflow session, orchestration
+  // failure) the adapter fires a passthrough and Claude proceeds with normal
+  // vendor compaction — Handover degrades, it never hangs.
   "compact.pre": {
-    expectsDecision: false,
+    expectsDecision: true,
     defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
-    canBlock: false
+    canBlock: true
   },
   "user.prompt": {
     expectsDecision: false,
@@ -858,6 +868,8 @@ function mapDecisionToResult(_event, decision) {
       return createPreToolUseDenyResult(intent.reason);
     case "stop_block":
       return createStopBlockResult(intent.reason);
+    case "compact_block":
+      return createCompactBlockResult(intent.reason);
     default:
       return { action: "passthrough" };
   }
@@ -1565,6 +1577,10 @@ var SYNC_HOOK_EVENTS = [
   "TaskCreated",
   "TaskCompleted",
   "ConfigChange",
+  // Handover interception (ADR 0014): the forwarder may reply with a
+  // compaction block. Dispatched async, Claude would ignore the stdout and
+  // silently drop the block.
+  "PreCompact",
   // Teardown — see (2) above.
   "SessionEnd"
 ];
@@ -3417,8 +3433,14 @@ function spawnClaude(options) {
     cwd: projectDir,
     stdio: ["ignore", "pipe", "pipe"],
     env: {
-      // Claude compacts around 95% of this window; 185k keeps the trigger above 175k tokens used.
-      CLAUDE_CODE_AUTO_COMPACT_WINDOW: "185000",
+      // Claude compacts around 95% of this window. The default sits well
+      // under the model window (ADR 0014 §5): Handover needs headroom to
+      // hold the conversation AND emit a Handoff file in the fork — the old
+      // 185k default sat at the window and defeated that. Precedence:
+      // default < process.env < extraEnv, so a workflow's explicit
+      // maxTurnTokenCount (delivered via extraEnv) beats a user env var,
+      // while the bare default stays env-overridable.
+      CLAUDE_CODE_AUTO_COMPACT_WINDOW: String(DEFAULT_MAX_TURN_TOKEN_COUNT),
       ...process.env,
       ...extraEnv ?? {},
       ATHENA_INSTANCE_ID: String(instanceId),
@@ -3564,6 +3586,16 @@ function mergeIsolation(base, pluginMcpConfig, perCommand) {
     ...pluginMcpConfig ? { mcpConfig: pluginMcpConfig } : {}
   };
 }
+function resolveWorkflowSpawnEnv(workflow) {
+  const maxTurnTokenCount = workflow?.loop?.maxTurnTokenCount;
+  if (maxTurnTokenCount === void 0) {
+    return workflow?.env;
+  }
+  return {
+    ...workflow?.env,
+    CLAUDE_CODE_AUTO_COMPACT_WINDOW: String(maxTurnTokenCount)
+  };
+}
 function resolveClaudeSessionId(continuation) {
   if (!continuation || continuation.mode === "fresh") {
     return void 0;
@@ -3788,7 +3820,7 @@ function useClaudeProcess(projectDir, instanceId, isolation, pluginMcpConfig, ve
               pluginMcpConfig,
               perCallIsolation
             ),
-            env: workflow?.env,
+            env: resolveWorkflowSpawnEnv(workflow),
             ...verbose ? {
               jqFilter: JQ_ASSISTANT_TEXT_FILTER,
               onFilteredStdout: (data) => {
@@ -3927,6 +3959,7 @@ function createClaudeSessionController(input) {
       const tokenAccumulator = createTokenAccumulator();
       const messageAccumulator = createAssistantMessageAccumulator();
       let lastStderr = "";
+      let stderrTail = "";
       if (supportsTransportDiagnostics) {
         runtime.beginTurn();
       }
@@ -3945,6 +3978,7 @@ function createClaudeSessionController(input) {
             tokens: tokenAccumulator.getUsage(),
             streamMessage: messageAccumulator.getLastMessage(),
             lastStderr,
+            stderrTail,
             diagnostics: supportsTransportDiagnostics ? { transport: runtime.getTransportStats() } : void 0
           });
         };
@@ -3959,7 +3993,7 @@ function createClaudeSessionController(input) {
               input.pluginMcpConfig,
               configOverride
             ),
-            env: input.workflow?.env,
+            env: resolveWorkflowSpawnEnv(input.workflow),
             onStdout: (data) => {
               tokenAccumulator.feed(data);
               messageAccumulator.feed(data);
@@ -3972,6 +4006,7 @@ function createClaudeSessionController(input) {
               if (!lastStderr) {
                 lastStderr = trimmed;
               }
+              stderrTail = (stderrTail + "\n" + trimmed).slice(-2048).trim();
               if (!input.verbose) return;
               onStderrLine?.(trimmed);
             },
@@ -5796,6 +5831,10 @@ function mapToV2Decision(event, decision) {
       return { decision: wantsSessionApproval ? "acceptForSession" : "accept" };
     case "stop_block":
       return { decision: "cancel" };
+    // Claude-specific Handover interception; Codex has no PreCompact
+    // approval, so an (unexpected) compact_block on an approval request
+    // falls through to accept like any other unmappable intent.
+    case "compact_block":
     default:
       return { decision: wantsSessionApproval ? "acceptForSession" : "accept" };
   }
@@ -6914,7 +6953,7 @@ function resolveIsolation(preset) {
     case "strict":
       return { approvalPolicy: "on-request", sandbox: "read-only" };
     case "permissive":
-      return { approvalPolicy: "auto-edit", sandbox: "danger-full-access" };
+      return { approvalPolicy: "never", sandbox: "danger-full-access" };
     case "minimal":
     case void 0:
       return { approvalPolicy: "on-request", sandbox: "workspace-write" };
@@ -6933,7 +6972,11 @@ function buildCodexPromptOptions(input) {
     agentRoots: input.workflowPlan?.agentRoots && input.workflowPlan.agentRoots.length > 0 ? input.workflowPlan.agentRoots : void 0,
     plugins: resolveCodexWorkflowPlugins(input.workflowPlan),
     config: {
-      model_auto_compact_token_limit: 175e3,
+      // The harness-neutral maxTurnTokenCount (ADR 0014 §5): the bound sits
+      // well under the model window so a Handover has headroom to hold the
+      // conversation and emit a Handoff file — the old 175k default sat at
+      // the window and defeated that.
+      model_auto_compact_token_limit: input.workflowPlan?.workflow.loop?.maxTurnTokenCount ?? DEFAULT_MAX_TURN_TOKEN_COUNT,
       // Steer Codex's history compaction toward a handoff-style summary.
       // `compact_prompt` replaces the default summarization prompt.
       compact_prompt: HANDOFF_COMPACT_PROMPT,
@@ -7638,6 +7681,89 @@ function shouldResolveWorkflow({
   return Boolean(workflowName);
 }
 
+// src/core/workflows/builtins/handoffSkill.ts
+import fs16 from "fs";
+import os11 from "os";
+import path14 from "path";
+var DEFAULT_HANDOFF_FILE_PATH = ".athena/handoff.md";
+var PLUGIN_MANIFEST = `{
+	"name": "athena-handoff",
+	"description": "Athena's first-party handoff skill: distill the current conversation into a Handoff file",
+	"version": "1.0.0"
+}
+`;
+var SKILL_CONTENT = `---
+name: handoff
+description: Distill the current conversation into a Handoff file on disk so a fresh agent session can continue the work without re-reading the history. Use when asked to hand off, or before context is reset.
+argument-hint: '[output-path] \u2014 where to write the Handoff file (default: ${DEFAULT_HANDOFF_FILE_PATH})'
+user-invocable: false
+---
+
+# Handoff
+
+Write a **Handoff file**: a distillation of this conversation that lets a fresh
+agent session \u2014 with none of your context \u2014 continue the work seamlessly.
+
+## Output path
+
+Write the file to: \`$ARGUMENTS\`
+
+If no path was provided above (it reads "(none provided)"), write to
+\`${DEFAULT_HANDOFF_FILE_PATH}\` relative to the current working directory.
+Create parent directories as needed. Overwrite an existing file at that path.
+
+## What the file must contain
+
+Structure the Handoff file with these sections, in this order:
+
+1. **Task and status** \u2014 what we are trying to accomplish, and exactly where it
+   stands right now: what is done and verified, what is in flight, what has not
+   been started. Include the concrete state of any in-flight step (e.g. "test X
+   written but failing on Y").
+2. **Decisions and rationale** \u2014 every decision already made, each with the
+   *why*. A fresh session that doesn't know why a decision was made will
+   re-litigate it and may silently reverse it.
+3. **Open questions** \u2014 anything unresolved, ambiguous, or awaiting an answer,
+   including from whom or where the answer should come.
+4. **Files touched** \u2014 every file read, written, or relevant, referenced **by
+   path** (repo-relative where possible). Never paste file contents \u2014 the next
+   session can read the files itself.
+5. **Suggested next steps / skills** \u2014 what the next session should do first,
+   and which skills, commands, or workflows to invoke for it.
+
+## Rules
+
+- **Reference, don't duplicate.** Point to existing artifacts \u2014 PRDs, plans,
+  ADRs, issues, PRs, commits, diffs, trackers \u2014 by path or URL instead of
+  copying their content into the Handoff file.
+- **Redact secrets.** Never write API keys, passwords, tokens, credentials, or
+  personally identifiable information into the file. Replace any such value
+  with \`[REDACTED]\` and, if needed, name where the real value lives (e.g. an
+  env var name).
+- **Be selective, not exhaustive.** The file is a briefing, not a transcript.
+  Everything the next session needs; nothing it can rediscover cheaply.
+- After writing the file, reply with only the absolute path of the file you
+  wrote \u2014 no other prose.
+`;
+function writeIfChanged(filePath, content) {
+  if (!fs16.existsSync(filePath) || fs16.readFileSync(filePath, "utf-8") !== content) {
+    fs16.mkdirSync(path14.dirname(filePath), { recursive: true });
+    fs16.writeFileSync(filePath, content, "utf-8");
+  }
+}
+function ensureHandoffSkillPlugin(baseDir = path14.join(os11.homedir(), ".config", "athena", "builtins")) {
+  const pluginDir = path14.join(baseDir, "handoff");
+  writeIfChanged(
+    path14.join(pluginDir, ".claude-plugin", "plugin.json"),
+    PLUGIN_MANIFEST
+  );
+  writeIfChanged(
+    path14.join(pluginDir, "skills", "handoff", "SKILL.md"),
+    SKILL_CONTENT
+  );
+  return pluginDir;
+}
+
 // src/app/runtime/createRuntime.ts
 var DEFAULT_HARNESS = "claude-code";
 function createRuntime(input) {
@@ -7708,6 +7834,15 @@ function bootstrapRuntimeConfig({
     workflowPluginDirs = workflowResolvedPlugins.map(
       (plugin) => plugin.claudeArtifactDir
     );
+    if (pluginDelivery.mergeWorkflowPluginDirs) {
+      try {
+        workflowPluginDirs.push(ensureHandoffSkillPlugin());
+      } catch (error) {
+        warnings.push(
+          `Failed to materialize the handoff skill plugin: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
   }
   const globalPluginResolution = resolvePluginDirs(globalConfig.plugins);
   const projectPluginResolution = resolvePluginDirs(projectConfig.plugins);
@@ -7807,7 +7942,7 @@ var EXEC_EXIT_CODE = {
 
 // src/app/exec/runner.ts
 import crypto2 from "crypto";
-import path17 from "path";
+import path18 from "path";
 
 // src/core/feed/entities.ts
 var ActorRegistry = class {
@@ -8180,27 +8315,27 @@ function generateNeutralTitle(event, g) {
 }
 
 // src/core/feed/transcript.ts
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 function createTranscriptReader() {
   const offsets = /* @__PURE__ */ new Map();
   function readNewAssistantMessages(transcriptPath) {
     const offset = offsets.get(transcriptPath) ?? 0;
     let fileSize;
     try {
-      fileSize = fs16.statSync(transcriptPath).size;
+      fileSize = fs17.statSync(transcriptPath).size;
       if (fileSize <= offset) return [];
     } catch {
       return [];
     }
     let fd;
     try {
-      fd = fs16.openSync(transcriptPath, "r");
+      fd = fs17.openSync(transcriptPath, "r");
     } catch {
       return [];
     }
     try {
       const buf = Buffer.alloc(fileSize - offset);
-      const bytesRead = fs16.readSync(fd, buf, 0, buf.length, offset);
+      const bytesRead = fs17.readSync(fd, buf, 0, buf.length, offset);
       let lastNewline = -1;
       for (let i = bytesRead - 1; i >= 0; i--) {
         if (buf[i] === 10) {
@@ -8244,7 +8379,7 @@ function createTranscriptReader() {
       }
       return messages;
     } finally {
-      fs16.closeSync(fd);
+      fs17.closeSync(fd);
     }
   }
   function getOffset(transcriptPath) {
@@ -10313,8 +10448,34 @@ function createFeedMapper(bootstrap) {
   };
 }
 
+// src/core/feed/syntheticEvents.ts
+var HOOK_NAME_BY_KIND = {
+  "task.created": "TaskCreated",
+  "task.completed": "TaskCompleted"
+};
+function buildSyntheticTaskEvent(kind, sessionId, data) {
+  const hookName = HOOK_NAME_BY_KIND[kind];
+  return {
+    id: `${kind}-${generateId()}`,
+    timestamp: Date.now(),
+    kind,
+    data,
+    hookName,
+    sessionId,
+    context: { cwd: "", transcriptPath: "" },
+    interaction: { expectsDecision: false },
+    payload: {
+      hook_event_name: hookName,
+      session_id: sessionId,
+      transcript_path: "",
+      cwd: "",
+      ...data
+    }
+  };
+}
+
 // src/infra/sessions/schema.ts
-var SCHEMA_VERSION = 7;
+var SCHEMA_VERSION = 9;
 var applySessionSchema = (db, fromVersion) => {
   db.exec(`
 		CREATE TABLE IF NOT EXISTS session (
@@ -10377,6 +10538,18 @@ var applySessionSchema = (db, fromVersion) => {
 			status TEXT NOT NULL DEFAULT 'running',
 			stop_reason TEXT,
 			tracker_path TEXT,
+			-- Vendor session id (Claude Code session / Codex thread) of the Run's
+			-- most recent Turn's Agent Session. Every resume- and fork-based
+			-- transition (Nudge, Retry, human-resume, Handover) depends on it
+			-- surviving a process restart (ADR 0014).
+			adapter_session_id TEXT,
+			-- Opaque JSON snapshot of the run-loop reducer's RunMemory (nudge/
+			-- retry streaks, last tracker hash, in-flight stop prompt/
+			-- continuation), so a resumed or woken process rehydrates the
+			-- reducer instead of restarting its counters (ADR 0016). Written
+			-- and read only by runMachine.ts's serializeRunMemory/
+			-- deserializeRunMemory \u2014 this layer stores it opaquely.
+			run_memory_json TEXT,
 			FOREIGN KEY (session_id) REFERENCES session(id)
 		);
 
@@ -10476,6 +10649,26 @@ var applySessionSchema = (db, fromVersion) => {
 			UPDATE schema_version SET version = 7;
 		`);
   }
+  const versionAfterV7 = db.prepare("SELECT version FROM schema_version").get().version;
+  if (versionAfterV7 === 7) {
+    const hasColumn = db.prepare(
+      `SELECT COUNT(*) AS n FROM pragma_table_info('workflow_runs') WHERE name = 'adapter_session_id'`
+    ).get().n > 0;
+    if (!hasColumn) {
+      db.exec("ALTER TABLE workflow_runs ADD COLUMN adapter_session_id TEXT;");
+    }
+    db.exec("UPDATE schema_version SET version = 8;");
+  }
+  const versionAfterV8 = db.prepare("SELECT version FROM schema_version").get().version;
+  if (versionAfterV8 === 8) {
+    const hasRunMemoryColumn = db.prepare(
+      `SELECT COUNT(*) AS n FROM pragma_table_info('workflow_runs') WHERE name = 'run_memory_json'`
+    ).get().n > 0;
+    if (!hasRunMemoryColumn) {
+      db.exec("ALTER TABLE workflow_runs ADD COLUMN run_memory_json TEXT;");
+    }
+    db.exec("UPDATE schema_version SET version = 9;");
+  }
 };
 var SESSION_SCHEMA = {
   version: SCHEMA_VERSION,
@@ -10546,13 +10739,15 @@ function createSessionStore(opts) {
     "UPDATE session SET event_count = event_count + ? WHERE id = ?"
   );
   const upsertRun = db.prepare(
-    `INSERT INTO workflow_runs (id, session_id, workflow_name, started_at, iteration, max_iterations, status, stop_reason, tracker_path)
-		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `INSERT INTO workflow_runs (id, session_id, workflow_name, started_at, iteration, max_iterations, status, stop_reason, tracker_path, adapter_session_id, run_memory_json)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 		 ON CONFLICT(id) DO UPDATE SET
 		   iteration = excluded.iteration,
 		   status = excluded.status,
 		   stop_reason = excluded.stop_reason,
-		   ended_at = CASE WHEN excluded.status != 'running' THEN ? ELSE ended_at END`
+		   adapter_session_id = COALESCE(excluded.adapter_session_id, adapter_session_id),
+		   run_memory_json = COALESCE(excluded.run_memory_json, run_memory_json),
+		   ended_at = CASE WHEN excluded.status NOT IN ('running', 'awaiting_attention') THEN ? ELSE ended_at END`
   );
   const selectLatestRun = db.prepare(
     `SELECT * FROM workflow_runs WHERE session_id = ? ORDER BY started_at DESC, rowid DESC LIMIT 1`
@@ -10718,7 +10913,7 @@ function createSessionStore(opts) {
   }
   function persistRun(snapshot) {
     const now2 = Date.now();
-    const endedAt = snapshot.status !== "running" ? now2 : null;
+    const endedAt = snapshot.status !== "running" && snapshot.status !== "awaiting_attention" ? now2 : null;
     upsertRun.run(
       snapshot.runId,
       snapshot.sessionId,
@@ -10729,6 +10924,8 @@ function createSessionStore(opts) {
       snapshot.status,
       snapshot.stopReason ?? null,
       snapshot.trackerPath ?? null,
+      snapshot.adapterSessionId ?? null,
+      snapshot.runMemoryJson ?? null,
       endedAt
     );
   }
@@ -10745,7 +10942,9 @@ function createSessionStore(opts) {
       maxIterations: row.max_iterations,
       status: row.status,
       stopReason: row.stop_reason ?? void 0,
-      trackerPath: row.tracker_path ?? void 0
+      trackerPath: row.tracker_path ?? void 0,
+      adapterSessionId: row.adapter_session_id ?? void 0,
+      runMemoryJson: row.run_memory_json ?? void 0
     };
   }
   function linkAdapterSession(adapterSessionId, runId) {
@@ -11453,8 +11652,8 @@ var PRIMARY_INPUT_EXTRACTORS = {
     return compactText(colonIdx >= 0 ? name.slice(colonIdx + 1) : name, 80);
   },
   NotebookEdit: (input) => {
-    const path21 = String(input.notebook_path ?? "");
-    return path21 ? shortenPath(path21) : "";
+    const path22 = String(input.notebook_path ?? "");
+    return path22 ? shortenPath(path22) : "";
   },
   AskUserQuestion: (input) => {
     const questions = input.questions;
@@ -12734,16 +12933,16 @@ function extractDomain(url) {
   }
 }
 function filePathSegments(input) {
-  const path21 = prop2(input, "file_path") ?? prop2(input, "notebook_path") ?? "";
-  if (typeof path21 !== "string" || !path21) return [];
-  const { prefix, filename } = shortenPathStructured(path21);
+  const path22 = prop2(input, "file_path") ?? prop2(input, "notebook_path") ?? "";
+  if (typeof path22 !== "string" || !path22) return [];
+  const { prefix, filename } = shortenPathStructured(path22);
   if (prefix && filename) {
     return [
       { text: prefix, role: "target" },
       { text: filename, role: "filename" }
     ];
   }
-  return [{ text: filename || path21, role: "filename" }];
+  return [{ text: filename || path22, role: "filename" }];
 }
 function grepSegments(input) {
   const pattern = String(prop2(input, "pattern") ?? "");
@@ -13911,6 +14110,30 @@ function openSessionDbReadonly(dbPath, options = {}) {
       for (const row of rows) counts[row.hook_name] = row.count;
       return counts;
     },
+    latestWorkflowRun() {
+      try {
+        const row = db.prepare(
+          "SELECT * FROM workflow_runs ORDER BY started_at DESC, rowid DESC LIMIT 1"
+        ).get();
+        if (!row) return void 0;
+        return {
+          id: row["id"],
+          sessionId: row["session_id"],
+          workflowName: row["workflow_name"] ?? void 0,
+          startedAt: row["started_at"],
+          endedAt: row["ended_at"] ?? void 0,
+          iteration: row["iteration"],
+          maxIterations: row["max_iterations"],
+          status: row["status"],
+          stopReason: row["stop_reason"] ?? void 0,
+          trackerPath: row["tracker_path"] ?? void 0,
+          adapterSessionId: row["adapter_session_id"] ?? void 0,
+          runMemoryJson: row["run_memory_json"] ?? void 0
+        };
+      } catch {
+        return void 0;
+      }
+    },
     feedEvents() {
       const rows = db.prepare("SELECT data FROM feed_events ORDER BY seq").all();
       return rows.map((r) => JSON.parse(r.data));
@@ -13922,17 +14145,17 @@ function openSessionDbReadonly(dbPath, options = {}) {
 }
 
 // src/infra/sessions/registry.ts
-import fs17 from "fs";
-import os11 from "os";
-import path14 from "path";
+import fs18 from "fs";
+import os12 from "os";
+import path15 from "path";
 function sessionsDir() {
-  return path14.join(os11.homedir(), ".config", "athena", "sessions");
+  return path15.join(os12.homedir(), ".config", "athena", "sessions");
 }
 function sessionDbPath(sessionId) {
-  return path14.join(sessionsDir(), sessionId, "session.db");
+  return path15.join(sessionsDir(), sessionId, "session.db");
 }
 function readSessionFromDb(dbPath) {
-  if (!fs17.existsSync(dbPath)) return null;
+  if (!fs18.existsSync(dbPath)) return null;
   let reader;
   try {
     reader = openSessionDbReadonly(dbPath);
@@ -13959,12 +14182,12 @@ function readSessionFromDb(dbPath) {
 }
 function listSessions(projectDir) {
   const dir = sessionsDir();
-  if (!fs17.existsSync(dir)) return [];
-  const entries = fs17.readdirSync(dir, { withFileTypes: true });
+  if (!fs18.existsSync(dir)) return [];
+  const entries = fs18.readdirSync(dir, { withFileTypes: true });
   const sessions = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const dbPath = path14.join(dir, entry.name, "session.db");
+    const dbPath = path15.join(dir, entry.name, "session.db");
     const session = readSessionFromDb(dbPath);
     if (session && (session.eventCount ?? 0) > 0) {
       if (!projectDir || session.projectDir === projectDir) {
@@ -13981,6 +14204,44 @@ function getMostRecentAthenaSession(projectDir) {
   const sessions = listSessions(projectDir);
   return sessions[0] ?? null;
 }
+function getLatestRunForSession(sessionId, baseDir) {
+  const dbPath = path15.join(baseDir ?? sessionsDir(), sessionId, "session.db");
+  if (!fs18.existsSync(dbPath)) return null;
+  let reader;
+  try {
+    reader = openSessionDbReadonly(dbPath);
+    return reader.latestWorkflowRun() ?? null;
+  } catch {
+    return null;
+  } finally {
+    reader?.close();
+  }
+}
+function listAwaitingAttentionRuns(projectDir, baseDir) {
+  const dir = baseDir ?? sessionsDir();
+  if (!fs18.existsSync(dir)) return [];
+  const results = [];
+  for (const entry of fs18.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const dbPath = path15.join(dir, entry.name, "session.db");
+    const session = readSessionFromDb(dbPath);
+    if (!session) continue;
+    if (projectDir && session.projectDir !== projectDir) continue;
+    const run = getLatestRunForSession(entry.name, dir);
+    if (!run || run.status !== "awaiting_attention") continue;
+    results.push({
+      athenaSessionId: session.id,
+      projectDir: session.projectDir,
+      runId: run.id,
+      workflowName: run.workflowName,
+      stopReason: run.stopReason,
+      adapterSessionId: run.adapterSessionId,
+      startedAt: run.startedAt,
+      sessionUpdatedAt: session.updatedAt
+    });
+  }
+  return results.sort((a, b) => b.sessionUpdatedAt - a.sessionUpdatedAt);
+}
 
 // src/app/channels/relayAdapter.ts
 function createRelayPermissionCallback(bridge, runtime) {
@@ -14321,9 +14582,9 @@ function defaultLoadToken(tokenPath) {
 }
 
 // src/infra/config/gatewayClient.ts
-import fs18 from "fs";
-import os12 from "os";
-import path15 from "path";
+import fs19 from "fs";
+import os13 from "os";
+import path16 from "path";
 
 // src/shared/gateway-protocol/endpoint.ts
 function parseRuntimeEndpoint(value) {
@@ -14378,17 +14639,17 @@ function isRecord2(value) {
 
 // src/infra/config/gatewayClient.ts
 function resolveGatewayClientConfigPath(env = process.env) {
-  const home = env["HOME"] ?? os12.homedir();
-  return path15.join(home, ".config", "athena", "gateway.json");
+  const home = env["HOME"] ?? os13.homedir();
+  return path16.join(home, ".config", "athena", "gateway.json");
 }
 function readGatewayClientConfig(env = process.env) {
   const configPath = resolveGatewayClientConfigPath(env);
-  if (!fs18.existsSync(configPath)) {
+  if (!fs19.existsSync(configPath)) {
     return { mode: "local" };
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs18.readFileSync(configPath, "utf-8"));
+    parsed = JSON.parse(fs19.readFileSync(configPath, "utf-8"));
   } catch (err) {
     throw new Error(
       `gateway client config ${configPath} is invalid JSON: ${err instanceof Error ? err.message : String(err)}`
@@ -14405,16 +14666,16 @@ function readGatewayClientConfig(env = process.env) {
 function writeGatewayClientConfig(config, env = process.env) {
   const parsed = parseRuntimeEndpoint(config);
   const configPath = resolveGatewayClientConfigPath(env);
-  const dir = path15.dirname(configPath);
-  fs18.mkdirSync(dir, { recursive: true, mode: 448 });
-  fs18.writeFileSync(configPath, JSON.stringify(parsed, null, 2) + "\n", {
+  const dir = path16.dirname(configPath);
+  fs19.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs19.writeFileSync(configPath, JSON.stringify(parsed, null, 2) + "\n", {
     encoding: "utf-8",
     mode: 384
   });
   if (process.platform !== "win32") {
     try {
-      fs18.chmodSync(dir, 448);
-      fs18.chmodSync(configPath, 384);
+      fs19.chmodSync(dir, 448);
+      fs19.chmodSync(configPath, 384);
     } catch {
     }
   }
@@ -15202,6 +15463,20 @@ function handleEvent(event, cb) {
       }
     };
   }
+  if (eventKind2 === "compact.pre" && cb.interceptCompaction) {
+    const reason = cb.interceptCompaction(event);
+    if (reason !== null) {
+      return {
+        handled: true,
+        decision: {
+          type: "json",
+          source: "rule",
+          intent: { kind: "compact_block", reason }
+        }
+      };
+    }
+    return { handled: false };
+  }
   return { handled: false };
 }
 
@@ -15382,8 +15657,8 @@ function exitCodeFromFailure(failure) {
 }
 
 // src/app/exec/output.ts
-import fs19 from "fs/promises";
-import path16 from "path";
+import fs20 from "fs/promises";
+import path17 from "path";
 
 // src/app/exec/jsonl.ts
 function createExecJsonlEvent(type, data, ts = Date.now()) {
@@ -15426,9 +15701,9 @@ function createExecOutputWriter(options) {
       writeLine(options.stdout, message);
     },
     async writeLastMessage(filePath, message) {
-      const absPath = path16.resolve(filePath);
-      await fs19.mkdir(path16.dirname(absPath), { recursive: true });
-      await fs19.writeFile(absPath, message, "utf-8");
+      const absPath = path17.resolve(filePath);
+      await fs20.mkdir(path17.dirname(absPath), { recursive: true });
+      await fs20.writeFile(absPath, message, "utf-8");
     }
   };
 }
@@ -15471,12 +15746,29 @@ function formatCapabilityConflictNotice(summary) {
     "; "
   )}`;
 }
-function workflowFailure(state, message) {
-  return {
-    kind: "workflow",
-    state,
-    message
-  };
+function describeAttentionRequest(event) {
+  const data = event.data;
+  const toolInput = data["tool_input"];
+  const questions = typeof toolInput === "object" && toolInput !== null ? toolInput["questions"] : void 0;
+  if (Array.isArray(questions)) {
+    const texts = questions.map(
+      (q) => typeof q === "object" && q !== null ? q["question"] : void 0
+    ).filter((q) => typeof q === "string");
+    if (texts.length > 0) {
+      return `agent asked a question with no human attached to answer: ${texts.join(" | ")}`;
+    }
+  }
+  if (event.kind === "permission.request" && event.toolName !== "user_input") {
+    return `agent requested sandbox approval (${event.toolName ?? "unknown tool"}) with no human attached to answer \u2014 rerun with a more permissive --isolation, or wake with guidance`;
+  }
+  return "agent asked a question with no human attached to answer";
+}
+function isQuestionEvent(event) {
+  return event.kind === "tool.pre" && event.toolName === "AskUserQuestion" || // ANY permission request, not just Codex's 'user_input': a sandbox
+  // approval (e.g. item/fileChange/requestApproval under a read-only
+  // sandbox) is equally unanswerable unattended — observed live hanging a
+  // headless codex workflow run forever on the null-timeout decision.
+  event.kind === "permission.request" || event.kind === "elicitation.request";
 }
 function buildEarlyFailureResult(input) {
   return {
@@ -15530,12 +15822,13 @@ async function runExec(options) {
   let adapterSessionId = null;
   let activeRunId = null;
   let beforeTerminalCompletionRan = false;
+  let attentionRequest = null;
   let store;
   try {
     store = sessionStoreFactory({
       sessionId: athenaSessionId,
       projectDir: options.projectDir,
-      dbPath: options.ephemeral ? ":memory:" : path17.join(sessionsDir(), athenaSessionId, "session.db")
+      dbPath: options.ephemeral ? ":memory:" : path18.join(sessionsDir(), athenaSessionId, "session.db")
     });
   } catch (error) {
     const message = `Failed to initialize session store: ${error instanceof Error ? error.message : String(error)}`;
@@ -15611,6 +15904,26 @@ async function runExec(options) {
     defaultAgentId: "main",
     ...options.signal ? { signal: options.signal } : {}
   }) : null;
+  let handoverRequest = null;
+  let handoverForkInProgress = false;
+  const handoverDegradedSessions = /* @__PURE__ */ new Set();
+  const interceptCompaction = (event) => {
+    const handle = event.sessionId;
+    if (!handle) return null;
+    if (handoverDegradedSessions.has(handle)) return null;
+    if (handoverForkInProgress) {
+      return "Handover fork in progress \u2014 compaction stays blocked while the Handoff file is written.";
+    }
+    if (handoverRequest === null) {
+      handoverRequest = { handle };
+      output.notice(
+        `handover: context bound reached \u2014 forking session ${handle} to write a Handoff file`
+      );
+      output.emitJsonEvent("run.handover", { adapterSessionId: handle });
+      void sessionController.kill();
+    }
+    return "Handover in progress \u2014 Athena forks the conversation instead of compacting.";
+  };
   const controllerCallbacks = {
     getRules: () => rules,
     // No UI queue in exec; with no bridge attached, the runtime never
@@ -15623,6 +15936,10 @@ async function runExec(options) {
       relayPermission: createRelayPermissionCallback(bridge, runtime),
       relayQuestion: createRelayQuestionCallback(bridge, runtime)
     } : {},
+    // Handover interception is Claude-only for now: the fork transition
+    // rides --fork-session, which Codex has no equivalent for. Non-workflow
+    // sessions never intercept — vendor compaction proceeds unchanged.
+    ...options.harness === "claude-code" && options.workflow?.loop?.enabled ? { interceptCompaction } : {},
     ...options.signal ? { signal: options.signal } : {}
   };
   const dashboardDecisionInbox = options.dashboardDecisionInbox;
@@ -15696,6 +16013,10 @@ async function runExec(options) {
     },
     onEventReceived: (runtimeEvent) => {
       adapterSessionId = runtimeEvent.sessionId;
+      if (options.workflow?.loop?.enabled && !bridge && attentionRequest === null && isQuestionEvent(runtimeEvent)) {
+        attentionRequest = describeAttentionRequest(runtimeEvent);
+        void sessionController.kill();
+      }
       if (runtimeEvent.sessionId && activeRunId && !linkedAdapterSessions.has(runtimeEvent.sessionId)) {
         linkedAdapterSessions.add(runtimeEvent.sessionId);
         safePersist(
@@ -15792,6 +16113,15 @@ async function runExec(options) {
       loopEnabled: workflow?.loop?.enabled ?? false
     });
     const nextContinuation = options.adapterResumeSessionId ? { mode: "resume", handle: options.adapterResumeSessionId } : { mode: "fresh" };
+    let resumedRunMemory;
+    let resumedStopReason;
+    if (options.resumeRunId) {
+      const resumedRun = store.getLatestRun();
+      if (resumedRun?.id === options.resumeRunId) {
+        resumedRunMemory = deserializeRunMemory(resumedRun.runMemoryJson) ?? void 0;
+        resumedStopReason = resumedRun.stopReason;
+      }
+    }
     const handle = createWorkflowRunner({
       sessionId: athenaSessionId,
       projectDir: options.projectDir,
@@ -15799,6 +16129,9 @@ async function runExec(options) {
       workflow,
       prompt: options.prompt,
       initialContinuation: nextContinuation,
+      resumeRunId: options.resumeRunId,
+      resumedRunMemory,
+      resumedStopReason,
       startTurn: async (turnInput) => {
         const turnResult = await sessionController.startTurn({
           prompt: turnInput.prompt,
@@ -15828,32 +16161,88 @@ async function runExec(options) {
           "persistRun failed"
         );
       },
+      checkSuspension: () => attentionRequest !== null ? { reason: attentionRequest } : null,
+      currentAdapterSessionId,
+      handover: {
+        takeRequest: () => {
+          const request = handoverRequest;
+          handoverRequest = null;
+          return request;
+        },
+        onForkStateChange: (forking) => {
+          handoverForkInProgress = forking;
+        },
+        onDegraded: (handle2) => {
+          handoverDegradedSessions.add(handle2);
+          output.warn(
+            `handover failed for session ${handle2} \u2014 falling back to normal vendor compaction`
+          );
+          output.emitJsonEvent("run.handover.degraded", {
+            adapterSessionId: handle2
+          });
+        }
+      },
       abortCurrentTurn: () => void sessionController.kill(),
       onIterationComplete: (runSnapshot) => {
         output.emitJsonEvent("iteration.complete", {
           iteration: runSnapshot.iteration,
           status: runSnapshot.status
         });
+      },
+      // Task-tool projection (ADR 0015 §7): the Tracker's `## Units` table +
+      // unit-record frontmatter, diffed against what the Feed already knows
+      // and reconciled through the same `task.created`/`task.completed`
+      // path a live TodoWrite/TaskCreate/TaskUpdate call would take.
+      projectTasks: (tasks) => {
+        const known = new Map(
+          mapper.getTasks().filter((task) => task.taskId).map((task) => [task.taskId, task])
+        );
+        const newEvents = [];
+        for (const task of tasks) {
+          const existing = known.get(task.taskId);
+          if (!existing) {
+            newEvents.push(
+              ...mapper.mapEvent(
+                buildSyntheticTaskEvent("task.created", athenaSessionId, {
+                  task_id: task.taskId,
+                  task_subject: task.content
+                })
+              )
+            );
+          }
+          if (task.status === "completed" && existing?.status !== "completed") {
+            newEvents.push(
+              ...mapper.mapEvent(
+                buildSyntheticTaskEvent("task.completed", athenaSessionId, {
+                  task_id: task.taskId,
+                  task_subject: task.content
+                })
+              )
+            );
+          }
+        }
+        if (newEvents.length > 0) {
+          safePersist(
+            store,
+            () => store.recordFeedEvents(newEvents),
+            (message) => output.warn(message),
+            "recordFeedEvents failed"
+          );
+        }
       }
     });
     activeRunId = handle.runId;
     const runResult = await handle.result;
     cumulativeTokens = runResult.tokens;
     if (!latch.hasFailure()) {
-      if (runResult.status === "blocked") {
-        latch.register(
-          workflowFailure(
-            "blocked",
-            runResult.stopReason ? `Workflow blocked: ${runResult.stopReason}` : "Workflow blocked."
-          )
-        );
-      } else if (runResult.status === "exhausted") {
-        latch.register(
-          workflowFailure(
-            "exhausted",
-            `Workflow reached the maximum of ${workflow?.loop?.maxIterations ?? 0} iterations.`
-          )
-        );
+      if (runResult.status === "awaiting_attention") {
+        const reason = runResult.stopReason ?? "awaiting attention";
+        output.notice(`workflow run suspended \u2014 ${reason}`);
+        output.emitJsonEvent("run.suspended", {
+          runId: runResult.runId,
+          status: "awaiting_attention",
+          stopReason: runResult.stopReason ?? null
+        });
       } else if (runResult.status === "failed") {
         latch.register({
           kind: "process",
@@ -16494,8 +16883,8 @@ async function createRemoteRunEventPublisher({
 // src/app/dashboard/artifactCapture.ts
 import { execFile } from "child_process";
 import crypto3 from "crypto";
-import fs20 from "fs/promises";
-import path18 from "path";
+import fs21 from "fs/promises";
+import path19 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 function parseArtifactUploadSpec(value) {
@@ -16678,21 +17067,21 @@ async function collectArtifactPayloads(input) {
   return payloads;
 }
 async function readWorkspaceFile(projectDir, rel) {
-  const absolute = path18.resolve(projectDir, rel);
-  const workspaceRoot = await fs20.realpath(projectDir);
+  const absolute = path19.resolve(projectDir, rel);
+  const workspaceRoot = await fs21.realpath(projectDir);
   let stat;
   try {
-    stat = await fs20.lstat(absolute);
+    stat = await fs21.lstat(absolute);
   } catch {
     return null;
   }
   if (!stat.isFile() || stat.isSymbolicLink()) return null;
-  const real = await fs20.realpath(absolute);
-  const relativeToRoot = path18.relative(workspaceRoot, real);
-  if (relativeToRoot === ".." || relativeToRoot.startsWith(`..${path18.sep}`) || path18.isAbsolute(relativeToRoot)) {
+  const real = await fs21.realpath(absolute);
+  const relativeToRoot = path19.relative(workspaceRoot, real);
+  if (relativeToRoot === ".." || relativeToRoot.startsWith(`..${path19.sep}`) || path19.isAbsolute(relativeToRoot)) {
     return null;
   }
-  return fs20.readFile(absolute);
+  return fs21.readFile(absolute);
 }
 async function gitDiffForAllowedPaths(input) {
   const paths = splitNul(await git(input.projectDir, input.nameArgs)).filter(
@@ -16783,13 +17172,13 @@ var DEFAULT_HARD_DENY = [
   ".ssh/**"
 ];
 function isAllowedRelativePath(rel, hardDeny) {
-  if (path18.isAbsolute(rel) || rel.includes("\0")) return false;
-  const normalized = path18.posix.normalize(rel.replaceAll(path18.sep, "/"));
+  if (path19.isAbsolute(rel) || rel.includes("\0")) return false;
+  const normalized = path19.posix.normalize(rel.replaceAll(path19.sep, "/"));
   if (normalized === ".." || normalized.startsWith("../")) return false;
   return !hardDeny.some((pattern) => matchesDenyPattern(normalized, pattern));
 }
 function matchesDenyPattern(rel, pattern) {
-  const normalized = pattern.replaceAll(path18.sep, "/");
+  const normalized = pattern.replaceAll(path19.sep, "/");
   if (normalized.includes("*") || normalized.includes("?")) {
     return globToRegExp(normalized).test(rel);
   }
@@ -17186,18 +17575,18 @@ async function executeRemoteAssignment({
 
 // src/infra/config/attachmentMirror.ts
 import crypto4 from "crypto";
-import fs21 from "fs";
-import os13 from "os";
-import path19 from "path";
+import fs22 from "fs";
+import os14 from "os";
+import path20 from "path";
 function attachmentMirrorPath(env = process.env) {
-  const home = env["HOME"] ?? os13.homedir();
-  return path19.join(home, ".config", "athena", "attachments.json");
+  const home = env["HOME"] ?? os14.homedir();
+  return path20.join(home, ".config", "athena", "attachments.json");
 }
 function readAttachmentMirror(env = process.env) {
   const file = attachmentMirrorPath(env);
   let raw;
   try {
-    raw = fs21.readFileSync(file, "utf-8");
+    raw = fs22.readFileSync(file, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -17221,29 +17610,29 @@ function readAttachmentMirror(env = process.env) {
 function writeAttachmentMirror(mirror, env = process.env) {
   const validated = parseAttachmentMirror(mirror);
   const file = attachmentMirrorPath(env);
-  const dir = path19.dirname(file);
-  fs21.mkdirSync(dir, { recursive: true, mode: 448 });
+  const dir = path20.dirname(file);
+  fs22.mkdirSync(dir, { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.${crypto4.randomBytes(4).toString("hex")}.tmp`;
-  const fd = fs21.openSync(tmp, "w", 384);
+  const fd = fs22.openSync(tmp, "w", 384);
   try {
-    fs21.writeSync(fd, JSON.stringify(validated, null, 2) + "\n");
-    fs21.fsyncSync(fd);
+    fs22.writeSync(fd, JSON.stringify(validated, null, 2) + "\n");
+    fs22.fsyncSync(fd);
   } finally {
-    fs21.closeSync(fd);
+    fs22.closeSync(fd);
   }
   try {
-    fs21.renameSync(tmp, file);
+    fs22.renameSync(tmp, file);
   } catch (err) {
     try {
-      fs21.unlinkSync(tmp);
+      fs22.unlinkSync(tmp);
     } catch {
     }
     throw err;
   }
   if (process.platform !== "win32") {
     try {
-      fs21.chmodSync(dir, 448);
-      fs21.chmodSync(file, 384);
+      fs22.chmodSync(dir, 448);
+      fs22.chmodSync(file, 384);
     } catch {
     }
   }
@@ -17251,7 +17640,7 @@ function writeAttachmentMirror(mirror, env = process.env) {
 function removeAttachmentMirror(env = process.env) {
   const file = attachmentMirrorPath(env);
   try {
-    fs21.unlinkSync(file);
+    fs22.unlinkSync(file);
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -17655,9 +18044,9 @@ function createDashboardPairedExecution(options) {
 }
 
 // src/app/dashboard/remoteWorkspaceResolver.ts
-import fs22 from "fs";
-import os14 from "os";
-import path20 from "path";
+import fs23 from "fs";
+import os15 from "os";
+import path21 from "path";
 function resolveRemoteWorkspace(assignment, options = {}) {
   const { spec, runId, runnerId } = assignment;
   if (spec.projectDir) {
@@ -17666,14 +18055,14 @@ function resolveRemoteWorkspace(assignment, options = {}) {
   const sessionId = spec.athenaSessionId ?? spec.sessionId;
   const deploymentSlug = deploymentSlugFromUrl(options.dashboardUrl);
   const stateDir = daemonStatePaths(options.env).dir;
-  const projectDir = sessionId ? path20.join(
+  const projectDir = sessionId ? path21.join(
     stateDir,
     "remote-workspaces",
     deploymentSlug,
     sanitizePathSegment(runnerId),
     "sessions",
     sanitizePathSegment(sessionId)
-  ) : path20.join(
+  ) : path21.join(
     stateDir,
     "remote-workspaces",
     deploymentSlug,
@@ -17682,10 +18071,10 @@ function resolveRemoteWorkspace(assignment, options = {}) {
     sanitizePathSegment(runId)
   );
   try {
-    fs22.mkdirSync(projectDir, { recursive: true, mode: 448 });
+    fs23.mkdirSync(projectDir, { recursive: true, mode: 448 });
     if (process.platform !== "win32") {
       try {
-        fs22.chmodSync(projectDir, 448);
+        fs23.chmodSync(projectDir, 448);
       } catch {
       }
     }
@@ -17701,8 +18090,8 @@ function resolveRemoteWorkspace(assignment, options = {}) {
   return validateProjectDir(projectDir, options.env);
 }
 function validateProjectDir(projectDir, env = process.env) {
-  const resolved = path20.resolve(projectDir);
-  if (!path20.isAbsolute(projectDir)) {
+  const resolved = path21.resolve(projectDir);
+  if (!path21.isAbsolute(projectDir)) {
     return {
       kind: "rejected",
       rejection: {
@@ -17711,7 +18100,7 @@ function validateProjectDir(projectDir, env = process.env) {
       }
     };
   }
-  const home = path20.resolve(env["HOME"] ?? os14.homedir());
+  const home = path21.resolve(env["HOME"] ?? os15.homedir());
   if (resolved === home) {
     return {
       kind: "rejected",
@@ -17723,7 +18112,7 @@ function validateProjectDir(projectDir, env = process.env) {
   }
   let stat;
   try {
-    stat = fs22.statSync(resolved);
+    stat = fs23.statSync(resolved);
   } catch {
     return {
       kind: "rejected",
@@ -18168,18 +18557,18 @@ async function runDashboardRuntimeDaemon(options = {}) {
 }
 
 // src/infra/daemon/pidLock.ts
-import fs23 from "fs";
+import fs24 from "fs";
 function acquirePidLock(pidPath) {
   const ownPid = process.pid;
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const fd = fs23.openSync(pidPath, "wx", 384);
+      const fd = fs24.openSync(pidPath, "wx", 384);
       try {
-        fs23.writeSync(fd, `${ownPid}
+        fs24.writeSync(fd, `${ownPid}
 `);
-        fs23.fsyncSync(fd);
+        fs24.fsyncSync(fd);
       } finally {
-        fs23.closeSync(fd);
+        fs24.closeSync(fd);
       }
       return makeHandle(pidPath, ownPid);
     } catch (err) {
@@ -18193,7 +18582,7 @@ function acquirePidLock(pidPath) {
     }
     if (existing.state === "stale") {
       try {
-        fs23.unlinkSync(pidPath);
+        fs24.unlinkSync(pidPath);
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
       }
@@ -18207,7 +18596,7 @@ function acquirePidLock(pidPath) {
 function readPidLock(pidPath) {
   let raw;
   try {
-    raw = fs23.readFileSync(pidPath, "utf-8");
+    raw = fs24.readFileSync(pidPath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { state: "absent" };
@@ -18231,9 +18620,9 @@ function makeHandle(pidPath, pid) {
       if (released) return;
       released = true;
       try {
-        const raw = fs23.readFileSync(pidPath, "utf-8").trim();
+        const raw = fs24.readFileSync(pidPath, "utf-8").trim();
         if (raw === String(pid)) {
-          fs23.unlinkSync(pidPath);
+          fs24.unlinkSync(pidPath);
         }
       } catch (err) {
         if (err.code !== "ENOENT") {
@@ -18259,7 +18648,7 @@ function isProcessAlive(pid) {
 }
 
 // src/infra/daemon/udsIpc.ts
-import fs24 from "fs";
+import fs25 from "fs";
 import net2 from "net";
 
 // src/infra/daemon/udsFrameCodec.ts
@@ -18304,7 +18693,7 @@ async function startUdsServer(socketPath, handler, log) {
   });
   if (process.platform !== "win32") {
     try {
-      fs24.chmodSync(socketPath, 384);
+      fs25.chmodSync(socketPath, 384);
     } catch {
     }
   }
@@ -18314,7 +18703,7 @@ async function startUdsServer(socketPath, handler, log) {
         server.close(() => resolve());
       });
       try {
-        fs24.unlinkSync(socketPath);
+        fs25.unlinkSync(socketPath);
       } catch (err) {
         if (err.code !== "ENOENT") {
         }
@@ -18432,7 +18821,7 @@ async function sendUdsRequest(socketPath, request, options = {}) {
 async function unlinkStaleSocket(socketPath) {
   let stat;
   try {
-    stat = fs24.statSync(socketPath);
+    stat = fs25.statSync(socketPath);
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -18459,7 +18848,7 @@ async function unlinkStaleSocket(socketPath) {
       `uds path ${socketPath} is in use by another process; aborting`
     );
   }
-  fs24.unlinkSync(socketPath);
+  fs25.unlinkSync(socketPath);
 }
 
 export {
@@ -18489,6 +18878,8 @@ export {
   listSessions,
   getSessionMeta,
   getMostRecentAthenaSession,
+  getLatestRunForSession,
+  listAwaitingAttentionRuns,
   resolveClaudeBinary,
   detectClaudeVersion,
   resolveHookForwarderCommand,
@@ -18560,4 +18951,4 @@ export {
   startUdsServer,
   sendUdsRequest
 };
-//# sourceMappingURL=chunk-YZ7RCBKO.js.map
+//# sourceMappingURL=chunk-4HWBXCVY.js.map