@drisp/cli 0.5.24 → 0.5.28

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

@@ -1,6 +1,7 @@
 import {
   ATHENA_HOOK_SOCKET_ENV,
   createAskUserQuestionResult,
+  createCompactBlockResult,
   createPermissionRequestAllowResult,
   createPermissionRequestDenyResult,
   createPreToolUseAllowResult,
@@ -12,30 +13,35 @@ import {
   isToolEvent,
   isValidHookEventEnvelope,
   resolveHookSocketPath
-} from "./chunk-BTKQ67RE.js";
+} from "./chunk-USK5VSQ7.js";
 import {
   TransportUnreachableError,
   createUdsClientTransport,
+  createWsClientTransport,
   generateChannelRequestId,
   openVersionedDb,
   readDashboardClientConfig,
   refreshDashboardAccessToken,
   resolveGatewayPaths,
-  traceGatewayFrame,
   trackGatewayTransportReconnect,
-  writeGatewayTrace
-} from "./chunk-YU2WMPRC.js";
+  writeGatewayTrace,
+  wsClientOptionsForEndpoint
+} from "./chunk-VAFS446Y.js";
 import {
+  DEFAULT_MAX_TURN_TOKEN_COUNT,
   compileWorkflowPlan,
   createWorkflowRunner,
+  deserializeRunMemory,
   installWorkflowFromSource,
+  isMarketplaceRef,
   readConfig,
   readGlobalConfig,
   resolveActiveWorkflow,
+  resolveMarketplacePlugin,
   resolveWorkflow,
   resolveWorkflowInstall,
   resolveWorkflowPlugins
-} from "./chunk-7UUPLAP4.js";
+} from "./chunk-2QV7YSX6.js";
 
 // src/infra/daemon/stateDir.ts
 import fs from "fs";
@@ -238,6 +244,16 @@ var RULES = {
     defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
     canBlock: false
   },
+  // Observation-only: the batch fires after every call in it has already
+  // resolved, so nothing downstream produces a decision or block for it. The
+  // claim is not cosmetic — hook dispatch keeps every decision-capable event
+  // on Claude's critical path, so a false `canBlock` would make every
+  // parallel tool batch wait on the forwarder for a reply never sent.
+  "tool.batch": {
+    expectsDecision: false,
+    defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
+    canBlock: false
+  },
   "tool.delta": {
     expectsDecision: false,
     defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
@@ -278,16 +294,33 @@ 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,
     defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
     canBlock: true
   },
+  // Observation-only: nothing in the pipeline produces a decision or a block
+  // for an expansion, so it must not claim `canBlock`. The claim is not
+  // cosmetic — hook dispatch keeps every decision-capable event on Claude's
+  // critical path, so a false `canBlock` would make every slash command wait
+  // on the forwarder for a reply that is never sent.
+  "prompt.expansion": {
+    expectsDecision: false,
+    defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
+    canBlock: false
+  },
   "turn.start": {
     expectsDecision: false,
     defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
@@ -420,6 +453,15 @@ function asRecord(value) {
   }
   return {};
 }
+function readToolBatchCalls(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "object" && entry !== null).map((entry) => asRecord(entry)).map((call) => ({
+    tool_name: call["tool_name"],
+    tool_input: call["tool_input"],
+    tool_use_id: call["tool_use_id"],
+    tool_response: call["tool_response"]
+  }));
+}
 function translateClaudeEnvelope(envelope) {
   const payload = asRecord(envelope.payload);
   let toolName;
@@ -444,7 +486,9 @@ function translateClaudeEnvelope(envelope) {
         kind: "session.start",
         data: {
           source: payload["source"],
-          agent_type: payload["agent_type"]
+          model: payload["model"],
+          agent_type: payload["agent_type"],
+          session_title: payload["session_title"]
         }
       };
     case "SessionEnd":
@@ -458,6 +502,22 @@ function translateClaudeEnvelope(envelope) {
       return {
         kind: "user.prompt",
         data: {
+          prompt: payload["prompt"],
+          cwd: payload["cwd"],
+          permission_mode: payload["permission_mode"]
+        }
+      };
+    // Fires immediately before UserPromptSubmit, sharing its prompt_id,
+    // when a typed command expands into a prompt. Field names are pinned
+    // to the payload captured in the #116 spike.
+    case "UserPromptExpansion":
+      return {
+        kind: "prompt.expansion",
+        data: {
+          expansion_type: payload["expansion_type"],
+          command_name: payload["command_name"],
+          command_args: payload["command_args"],
+          command_source: payload["command_source"],
           prompt: payload["prompt"],
           permission_mode: payload["permission_mode"]
         }
@@ -485,6 +545,18 @@ function translateClaudeEnvelope(envelope) {
           tool_response: payload["tool_response"]
         }
       };
+    // Fires once per assistant tool batch, after every PostToolUse in it.
+    // Field names are pinned to the payload captured in the #116 spike;
+    // note that `tool_calls[].tool_response` is a STRING there, unlike
+    // PostToolUse's structured `tool_response`.
+    case "PostToolBatch":
+      return {
+        kind: "tool.batch",
+        data: {
+          tool_calls: readToolBatchCalls(payload["tool_calls"]),
+          permission_mode: payload["permission_mode"]
+        }
+      };
     case "PostToolUseFailure":
       return {
         kind: "tool.failure",
@@ -495,7 +567,10 @@ function translateClaudeEnvelope(envelope) {
           tool_input: payload["tool_input"] ?? {},
           tool_use_id: toolUseId,
           error: payload["error"],
-          is_interrupt: payload["is_interrupt"]
+          is_interrupt: payload["is_interrupt"],
+          exit_code: payload["exit_code"],
+          output: payload["output"],
+          error_code: payload["error_code"]
         }
       };
     case "PermissionRequest":
@@ -721,6 +796,12 @@ function buildClaudeDisplay(kind, data) {
 }
 
 // src/harnesses/claude/runtime/mapper.ts
+function readEffortLevel(payload) {
+  const effort = payload["effort"];
+  if (typeof effort !== "object" || effort === null) return void 0;
+  const level = effort["level"];
+  return typeof level === "string" ? level : void 0;
+}
 function mapEnvelopeToRuntimeEvent(envelope) {
   const payload = envelope.payload;
   const safePayload = typeof payload === "object" && payload !== null ? payload : { value: payload };
@@ -738,6 +819,13 @@ function mapEnvelopeToRuntimeEvent(envelope) {
     data: translated.data,
     hookName: envelope.hook_event_name,
     sessionId: envelope.session_id,
+    // prompt_id is a Claude common input field (v2.1.196+) on every hook
+    // payload; carried harness-neutrally as the Prompt identity (ADR 0009).
+    promptId: safePayloadRecord["prompt_id"],
+    // `effort` is likewise a common input field ({level}), observed on
+    // PostToolUse-class payloads and never on SessionStart, so it is read here
+    // rather than in any one hook's translation.
+    effortLevel: readEffortLevel(safePayloadRecord),
     toolName: translated.toolName,
     toolUseId: translated.toolUseId,
     agentId: translated.agentId,
@@ -780,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" };
   }
@@ -855,9 +945,23 @@ function extractResultText(content) {
   }
   return parts.join("\n");
 }
-function createStreamJsonToolParser(onToolResult, onToolUse) {
+function extractAssistantText(content) {
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "object" && block !== null) {
+      const rec = block;
+      if (rec["type"] === "text" && typeof rec["text"] === "string") {
+        parts.push(rec["text"]);
+      }
+    }
+  }
+  return parts.join("");
+}
+function createStreamJsonToolParser(onToolResult, onToolUse, onMessageDelta, onMessageComplete) {
   let buffer = "";
   const toolNameById = /* @__PURE__ */ new Map();
+  let currentMessageId;
   function processLine(line) {
     const trimmed = line.trim();
     if (!trimmed) return;
@@ -868,6 +972,19 @@ function createStreamJsonToolParser(onToolResult, onToolUse) {
       return;
     }
     const record = parsed.type === "stream_event" && parsed.event ? parsed.event : parsed;
+    if (record.type === "message_start") {
+      const id = record.message?.["id"];
+      if (typeof id === "string") currentMessageId = id;
+    }
+    if (record.type === "content_block_delta") {
+      const delta = record["delta"];
+      if (typeof delta === "object" && delta !== null) {
+        const d = delta;
+        if (d["type"] === "text_delta" && typeof d["text"] === "string") {
+          onMessageDelta?.({ item_id: currentMessageId, delta: d["text"] });
+        }
+      }
+    }
     const contentBlocks = (record.type === "assistant" ? record.message?.content : record.type === "message" && record.role === "assistant" ? record.content : void 0) ?? [];
     for (const block of contentBlocks) {
       if (typeof block !== "object" || block === null) continue;
@@ -877,6 +994,14 @@ function createStreamJsonToolParser(onToolResult, onToolUse) {
         onToolUse?.({ tool_use_id: rec["id"], tool_name: rec["name"] });
       }
     }
+    if (record.type === "assistant" || record.type === "message" && record.role === "assistant") {
+      const messageText = extractAssistantText(contentBlocks);
+      if (messageText) {
+        const idValue = record.type === "assistant" ? record.message?.["id"] : record["id"];
+        const itemId = typeof idValue === "string" ? idValue : currentMessageId;
+        onMessageComplete?.({ item_id: itemId, message: messageText });
+      }
+    }
     if (record.type === "tool_result") {
       const toolUseId = typeof record.tool_use_id === "string" ? record.tool_use_id : void 0;
       const text = extractResultText(record.content);
@@ -975,6 +1100,38 @@ function createServer2(opts) {
     },
     () => {
       transportStats.streamToolUses++;
+    },
+    (messageDelta) => {
+      emit({
+        id: `stream-msg-delta-${messageDelta.item_id ?? "unknown"}-${Date.now()}`,
+        timestamp: Date.now(),
+        kind: "message.delta",
+        data: {
+          item_id: messageDelta.item_id,
+          delta: messageDelta.delta
+        },
+        hookName: "stream-json",
+        sessionId,
+        context: { cwd: projectDir, transcriptPath: "" },
+        interaction: getInteractionHints("message.delta"),
+        payload: null
+      });
+    },
+    (messageComplete) => {
+      emit({
+        id: `stream-msg-complete-${messageComplete.item_id ?? "unknown"}-${Date.now()}`,
+        timestamp: Date.now(),
+        kind: "message.complete",
+        data: {
+          item_id: messageComplete.item_id,
+          message: messageComplete.message
+        },
+        hookName: "stream-json",
+        sessionId,
+        context: { cwd: projectDir, transcriptPath: "" },
+        interaction: getInteractionHints("message.complete"),
+        payload: null
+      });
     }
   );
   function emit(event) {
@@ -1375,6 +1532,10 @@ var TOOL_HOOK_EVENTS = [
   "PreToolUse",
   "PostToolUse",
   "PostToolUseFailure",
+  // Batch-level, not per-tool, but Claude accepts (and requires) a matcher
+  // here: the #116 capture registered it with `matcher: '*'` and it fired in
+  // every run. Matcher-less registration is unverified.
+  "PostToolBatch",
   "PermissionRequest",
   "PermissionDenied",
   "Elicitation",
@@ -1389,6 +1550,7 @@ var NON_TOOL_HOOK_EVENTS = [
   "SubagentStart",
   "SubagentStop",
   "UserPromptSubmit",
+  "UserPromptExpansion",
   "PreCompact",
   "PostCompact",
   "Setup",
@@ -1401,6 +1563,31 @@ var NON_TOOL_HOOK_EVENTS = [
   "WorktreeCreate",
   "WorktreeRemove"
 ];
+var SYNC_HOOK_EVENTS = [
+  // Decision/blocking — kept in step with `runtime/interactionRules.ts`.
+  "PreToolUse",
+  "PermissionRequest",
+  "UserPromptSubmit",
+  "Stop",
+  "StopFailure",
+  "SubagentStop",
+  "Elicitation",
+  "ElicitationResult",
+  "TeammateIdle",
+  "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"
+];
+var SYNC_HOOK_EVENT_SET = new Set(SYNC_HOOK_EVENTS);
+function isAsyncHookEvent(event) {
+  return !SYNC_HOOK_EVENT_SET.has(event);
+}
 function quoteShellArg(value) {
   return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
@@ -1448,23 +1635,20 @@ function generateHookSettings(tempDir, authOverlay) {
   if (process.env["ATHENA_DEBUG"]) {
     console.error("[athena-debug] Hook forwarder path:", hookForwarder.command);
   }
-  const hookCommand = {
-    type: "command",
-    command: hookForwarder.command
-  };
+  const hookCommandFor = (event) => isAsyncHookEvent(event) ? { type: "command", command: hookForwarder.command, async: true } : { type: "command", command: hookForwarder.command };
   const hooks = {};
   for (const event of TOOL_HOOK_EVENTS) {
     hooks[event] = [
       {
         matcher: "*",
-        hooks: [hookCommand]
+        hooks: [hookCommandFor(event)]
       }
     ];
   }
   for (const event of NON_TOOL_HOOK_EVENTS) {
     hooks[event] = [
       {
-        hooks: [hookCommand]
+        hooks: [hookCommandFor(event)]
       }
     ];
   }
@@ -2824,6 +3008,17 @@ import os8 from "os";
 import path10 from "path";
 
 // src/harnesses/claude/config/isolation.ts
+var CLAUDE_EFFORT_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function normalizeEffort(value) {
+  if (value === void 0) return void 0;
+  return CLAUDE_EFFORT_LEVELS.includes(value) ? value : void 0;
+}
 var DISALLOWED_FIRST_PARTY_MCPS = [
   "mcp__claude_ai_Gmail__*",
   "mcp__claude_ai_Google_Calendar__*",
@@ -2934,6 +3129,7 @@ var FLAG_REGISTRY = [
   { field: "additionalDirectories", flag: "--add-dir", kind: "array" },
   // === Model & Agent ===
   { field: "model", flag: "--model", kind: "value" },
+  { field: "effort", flag: "--effort", kind: "value" },
   { field: "fallbackModel", flag: "--fallback-model", kind: "value" },
   { field: "agent", flag: "--agent", kind: "value" },
   { field: "agents", flag: "--agents", kind: "json" },
@@ -3237,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),
@@ -3384,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;
@@ -3608,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) => {
@@ -3747,6 +3959,7 @@ function createClaudeSessionController(input) {
       const tokenAccumulator = createTokenAccumulator();
       const messageAccumulator = createAssistantMessageAccumulator();
       let lastStderr = "";
+      let stderrTail = "";
       if (supportsTransportDiagnostics) {
         runtime.beginTurn();
       }
@@ -3765,6 +3978,7 @@ function createClaudeSessionController(input) {
             tokens: tokenAccumulator.getUsage(),
             streamMessage: messageAccumulator.getLastMessage(),
             lastStderr,
+            stderrTail,
             diagnostics: supportsTransportDiagnostics ? { transport: runtime.getTransportStats() } : void 0
           });
         };
@@ -3779,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);
@@ -3792,6 +4006,7 @@ function createClaudeSessionController(input) {
               if (!lastStderr) {
                 lastStderr = trimmed;
               }
+              stderrTail = (stderrTail + "\n" + trimmed).slice(-2048).trim();
               if (!input.verbose) return;
               onStderrLine?.(trimmed);
             },
@@ -3831,20 +4046,49 @@ function buildClaudeCompatibleIsolationConfig({
   additionalDirectories,
   pluginDirs,
   verbose,
-  configuredModel
+  configuredModel,
+  configuredEffort
 }) {
   return {
     preset: isolationPreset,
     additionalDirectories,
     pluginDirs: pluginDirs.length > 0 ? pluginDirs : void 0,
     debug: verbose,
-    model: configuredModel
+    model: configuredModel,
+    effort: normalizeEffort(configuredEffort)
   };
 }
+var CLAUDE_MODEL_OPTIONS = [
+  {
+    value: "sonnet",
+    label: "Sonnet",
+    description: "Balanced default for day-to-day coding work."
+  },
+  {
+    value: "opus",
+    label: "Opus",
+    description: "Stronger reasoning for complex architecture and debugging."
+  },
+  {
+    value: "haiku",
+    label: "Haiku",
+    description: "Fastest option for lighter tasks."
+  },
+  {
+    value: "opusplan",
+    label: "OpusPlan",
+    description: "Uses Opus for planning and Sonnet for execution."
+  }
+];
 var CLAUDE_CONFIG_PROFILE = {
   harness: "claude-code",
   buildIsolationConfig: buildClaudeCompatibleIsolationConfig,
-  resolveModelName: ({ projectDir, configuredModel }) => resolveClaudeModel({ projectDir, configuredModel })
+  resolveModelName: ({ projectDir, configuredModel }) => resolveClaudeModel({ projectDir, configuredModel }),
+  pluginDelivery: {
+    mergeWorkflowPluginDirs: true,
+    registrationBuildsMcpConfig: true,
+    workflowPluginsVia: "registration"
+  }
 };
 var claudeHarnessAdapter = {
   id: "claude-code",
@@ -3854,7 +4098,9 @@ var claudeHarnessAdapter = {
     conversationModel: "fresh_per_turn",
     killWaitsForTurnSettlement: true,
     supportsEphemeralSessions: false,
-    supportsConfigurableIsolation: true
+    supportsConfigurableIsolation: true,
+    emitsStartupDiagnostics: true,
+    extraAllowedTools: []
   },
   verify: () => verifyClaudeHarness(),
   createRuntime: (input) => createClaudeHookRuntime({
@@ -3890,7 +4136,8 @@ var claudeHarnessAdapter = {
     };
     return controller;
   },
-  resolveConfigProfile: () => CLAUDE_CONFIG_PROFILE
+  resolveConfigProfile: () => CLAUDE_CONFIG_PROFILE,
+  listModels: async () => CLAUDE_MODEL_OPTIONS
 };
 
 // src/harnesses/codex/runtime/appServerManager.ts
@@ -5584,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" };
   }
@@ -6702,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" };
@@ -6721,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,
@@ -7029,7 +7284,12 @@ var CODEX_CONFIG_PROFILE = {
     preset: isolationPreset,
     model: configuredModel
   }),
-  resolveModelName: ({ configuredModel }) => configuredModel ?? null
+  resolveModelName: ({ configuredModel }) => configuredModel ?? null,
+  pluginDelivery: {
+    mergeWorkflowPluginDirs: false,
+    registrationBuildsMcpConfig: false,
+    workflowPluginsVia: "generated-mcp"
+  }
 };
 var codexHarnessAdapter = {
   id: "openai-codex",
@@ -7039,7 +7299,12 @@ var codexHarnessAdapter = {
     conversationModel: "persistent_thread",
     killWaitsForTurnSettlement: true,
     supportsEphemeralSessions: true,
-    supportsConfigurableIsolation: true
+    supportsConfigurableIsolation: true,
+    emitsStartupDiagnostics: false,
+    // Codex auto-approves Bash/Edit (outside-sandbox commandExecution /
+    // fileChange) and the scoped 'Permissions' capability, on top of the
+    // shared 'mcp__*' baseline seeded via allowedTools (see buildInitialRules).
+    extraAllowedTools: ["Permissions", "Bash", "Edit"]
   },
   verify: () => verifyCodexHarness(),
   createRuntime: (input) => createCodexRuntime({
@@ -7066,8 +7331,23 @@ var codexHarnessAdapter = {
     };
     return controller;
   },
-  resolveConfigProfile: () => CODEX_CONFIG_PROFILE
+  resolveConfigProfile: () => CODEX_CONFIG_PROFILE,
+  listModels: async (runtime) => {
+    if (!isCodexRuntimeWithModels(runtime)) {
+      throw new Error("Codex runtime is not available");
+    }
+    const models = await runtime.listModels();
+    return models.map((model) => ({
+      value: model.model,
+      label: model.displayName,
+      description: model.description,
+      isDefault: model.isDefault
+    }));
+  }
 };
+function isCodexRuntimeWithModels(runtime) {
+  return Boolean(runtime && "listModels" in runtime);
+}
 
 // src/harnesses/registry.ts
 function buildClaudeCompatibleIsolationConfig2({
@@ -7093,7 +7373,9 @@ var opencodeHarnessAdapter = {
     conversationModel: "fresh_per_turn",
     killWaitsForTurnSettlement: true,
     supportsEphemeralSessions: false,
-    supportsConfigurableIsolation: false
+    supportsConfigurableIsolation: false,
+    emitsStartupDiagnostics: false,
+    extraAllowedTools: []
   },
   createRuntime: (input) => claudeHarnessAdapter.createRuntime(input),
   createSessionController: (input) => claudeHarnessAdapter.createSessionController(input),
@@ -7101,8 +7383,14 @@ var opencodeHarnessAdapter = {
   resolveConfigProfile: () => ({
     harness: "opencode",
     buildIsolationConfig: (input) => buildClaudeCompatibleIsolationConfig2(input),
-    resolveModelName: ({ configuredModel }) => configuredModel ?? null
-  })
+    resolveModelName: ({ configuredModel }) => configuredModel ?? null,
+    pluginDelivery: {
+      mergeWorkflowPluginDirs: true,
+      registrationBuildsMcpConfig: true,
+      workflowPluginsVia: "registration"
+    }
+  }),
+  listModels: async () => []
 };
 var HARNESS_ADAPTERS = [
   claudeHarnessAdapter,
@@ -7218,6 +7506,28 @@ function loadPlugin(pluginDir) {
   }
   return commands2;
 }
+function loadPersonalSkills(skills) {
+  const commands2 = [];
+  for (const skill of skills) {
+    const skillPath = path12.join(skill.path, "SKILL.md");
+    if (!fs14.existsSync(skillPath)) {
+      console.warn(
+        `Skipping personal skill '${skill.name}' [${skill.sourceLayer}]: SKILL.md not found at ${skill.path}`
+      );
+      continue;
+    }
+    try {
+      const parsed = parseFrontmatter(fs14.readFileSync(skillPath, "utf-8"));
+      commands2.push(skillToCommand(parsed.frontmatter, parsed.body));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(
+        `Skipping personal skill '${skill.name}' [${skill.sourceLayer}]: ${message}`
+      );
+    }
+  }
+  return commands2;
+}
 function skillToCommand(frontmatter, body, mcpConfigPath) {
   const args = frontmatter["argument-hint"] ? [
     {
@@ -7241,8 +7551,9 @@ function skillToCommand(frontmatter, body, mcpConfigPath) {
 }
 
 // src/infra/plugins/register.ts
-function buildPluginMcpConfig(pluginDirs, mcpServerOptions) {
+function buildPluginMcpConfig(pluginDirs, mcpServerOptions, personalMcpServers = []) {
   const mergedServers = {};
+  const conflicts = [];
   for (const dir of pluginDirs) {
     const mcpPath = path13.join(dir, ".mcp.json");
     if (!fs15.existsSync(mcpPath)) {
@@ -7268,22 +7579,99 @@ function buildPluginMcpConfig(pluginDirs, mcpServerOptions) {
       mergedServers[serverName] = rest;
     }
   }
+  for (const personal of personalMcpServers) {
+    const { name, sourceLayer: _sourceLayer, ...server } = personal;
+    if (name in mergedServers) {
+      conflicts.push(personal);
+      continue;
+    }
+    mergedServers[name] = server;
+  }
   if (Object.keys(mergedServers).length === 0) {
-    return void 0;
+    return { mcpConfig: void 0, conflicts };
   }
   const mcpConfig = path13.join(os10.tmpdir(), `athena-mcp-${process.pid}.json`);
   fs15.writeFileSync(mcpConfig, JSON.stringify({ mcpServers: mergedServers }));
-  return mcpConfig;
+  return { mcpConfig, conflicts };
 }
-function registerPlugins(pluginDirs, mcpServerOptions, includeMcpConfig = true) {
+function registerPlugins(pluginDirs, mcpServerOptions, includeMcpConfig = true, personalMcpServers = [], personalSkills = []) {
   for (const dir of pluginDirs) {
     const commands2 = loadPlugin(dir);
     for (const command of commands2) {
       register(command);
     }
   }
-  const mcpConfig = includeMcpConfig ? buildPluginMcpConfig(pluginDirs, mcpServerOptions) : void 0;
-  return { mcpConfig };
+  const skillByName = new Map(personalSkills.map((skill) => [skill.name, skill]));
+  const skillConflicts = [];
+  for (const command of loadPersonalSkills(personalSkills)) {
+    if (get(command.name)) {
+      const shadowed = skillByName.get(command.name);
+      if (shadowed) {
+        skillConflicts.push(shadowed);
+      }
+      continue;
+    }
+    register(command);
+  }
+  const mcpResult = includeMcpConfig ? buildPluginMcpConfig(pluginDirs, mcpServerOptions, personalMcpServers) : { mcpConfig: void 0, conflicts: [] };
+  return {
+    mcpConfig: mcpResult.mcpConfig,
+    conflicts: { mcpServers: mcpResult.conflicts, skills: skillConflicts }
+  };
+}
+
+// src/infra/plugins/pluginRefResolution.ts
+function resolvePluginDirs(entries) {
+  const dirs = [];
+  const warnings = [];
+  for (const entry of entries) {
+    if (!isMarketplaceRef(entry)) {
+      dirs.push(entry);
+      continue;
+    }
+    try {
+      dirs.push(resolveMarketplacePlugin(entry));
+    } catch (error) {
+      warnings.push(`Skipping plugin "${entry}": ${error.message}`);
+    }
+  }
+  return { dirs, warnings };
+}
+
+// src/infra/capabilities/effective.ts
+function resolveEffectiveCapabilities(input) {
+  const { globalConfig, projectConfig } = input;
+  return {
+    mcpServers: mergeMcpServers(
+      globalConfig.mcpServers,
+      projectConfig.mcpServers
+    ),
+    skills: mergeSkills(globalConfig.skills, projectConfig.skills)
+  };
+}
+function mergeMcpServers(global, project) {
+  const projectNames = new Set(Object.keys(project ?? {}));
+  const result = [];
+  for (const [name, server] of Object.entries(global ?? {})) {
+    if (projectNames.has(name)) continue;
+    result.push({ name, ...server, sourceLayer: "global" });
+  }
+  for (const [name, server] of Object.entries(project ?? {})) {
+    result.push({ name, ...server, sourceLayer: "project" });
+  }
+  return result;
+}
+function mergeSkills(global, project) {
+  const projectNames = new Set((project ?? []).map((s) => s.name));
+  const result = [];
+  for (const skill of global ?? []) {
+    if (projectNames.has(skill.name)) continue;
+    result.push({ ...skill, sourceLayer: "global" });
+  }
+  for (const skill of project ?? []) {
+    result.push({ ...skill, sourceLayer: "project" });
+  }
+  return result;
 }
 
 // src/setup/shouldResolveWorkflow.ts
@@ -7293,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) {
@@ -7339,6 +7810,9 @@ function bootstrapRuntimeConfig({
   const projectConfig = providedProjectConfig ?? readConfig(projectDir);
   const warnings = [];
   const harness = harnessOverride ?? projectConfig.harness ?? globalConfig.harness ?? DEFAULT_HARNESS;
+  const harnessConfigProfile = resolveHarnessConfigProfile(harness);
+  const pluginDelivery = harnessConfigProfile.pluginDelivery;
+  const workflowPluginsAsGeneratedMcp = pluginDelivery.workflowPluginsVia === "generated-mcp";
   const activeWorkflowSelection = resolveActiveWorkflow({
     globalConfig,
     projectConfig,
@@ -7360,35 +7834,55 @@ 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);
+  warnings.push(
+    ...globalPluginResolution.warnings,
+    ...projectPluginResolution.warnings
+  );
   const pluginDirs = mergePluginDirs({
-    workflowPluginDirs: harness === "openai-codex" ? [] : workflowPluginDirs,
-    globalPlugins: globalConfig.plugins,
-    projectPlugins: projectConfig.plugins,
+    workflowPluginDirs: pluginDelivery.mergeWorkflowPluginDirs ? workflowPluginDirs : [],
+    globalPlugins: globalPluginResolution.dirs,
+    projectPlugins: projectPluginResolution.dirs,
     pluginFlags
   });
-  const pluginResult = pluginDirs.length > 0 ? registerPlugins(
+  const effectiveCapabilities = harness === "openai-codex" ? { mcpServers: [], skills: [] } : resolveEffectiveCapabilities({ globalConfig, projectConfig });
+  const personalMcpServers = effectiveCapabilities.mcpServers;
+  const personalSkills = effectiveCapabilities.skills;
+  const pluginResult = pluginDirs.length > 0 || personalMcpServers.length > 0 || personalSkills.length > 0 ? registerPlugins(
     pluginDirs,
     workflowToResolve ? activeWorkflowConfig.workflowSelections?.[workflowToResolve]?.mcpServerOptions : void 0,
-    harness !== "openai-codex"
-  ) : { mcpConfig: void 0 };
-  const workflowPluginMcpConfig = harness === "openai-codex" ? buildPluginMcpConfig(
+    pluginDelivery.registrationBuildsMcpConfig,
+    personalMcpServers,
+    personalSkills
+  ) : { mcpConfig: void 0, conflicts: { mcpServers: [], skills: [] } };
+  const workflowPluginMcpConfig = workflowPluginsAsGeneratedMcp ? buildPluginMcpConfig(
     workflowPluginDirs,
     workflowToResolve ? activeWorkflowConfig.workflowSelections?.[workflowToResolve]?.mcpServerOptions : void 0
-  ) : void 0;
-  const pluginMcpConfig = harness === "openai-codex" ? void 0 : pluginResult.mcpConfig;
+  ).mcpConfig : void 0;
+  const pluginMcpConfig = workflowPluginsAsGeneratedMcp ? void 0 : pluginResult.mcpConfig;
   const activeWorkflow = resolvedWorkflow;
   const additionalDirectories = [
     ...globalConfig.additionalDirectories,
     ...projectConfig.additionalDirectories
   ];
-  const harnessConfigProfile = resolveHarnessConfigProfile(harness);
   const workflowPlan = compileWorkflowPlan({
     workflow: activeWorkflow,
     resolvedPlugins: activeWorkflow && resolvedWorkflow?.name === activeWorkflow.name ? workflowResolvedPlugins : void 0,
-    pluginMcpConfig: harness === "openai-codex" && activeWorkflow && resolvedWorkflow?.name === activeWorkflow.name ? workflowPluginMcpConfig : pluginResult.mcpConfig
+    pluginMcpConfig: workflowPluginsAsGeneratedMcp && activeWorkflow && resolvedWorkflow?.name === activeWorkflow.name ? workflowPluginMcpConfig : pluginResult.mcpConfig
   });
   const configModel = projectConfig.model || globalConfig.model || activeWorkflow?.model;
+  const configEffort = activeWorkflow?.effort;
   let isolationPreset = initialIsolationPreset;
   if (activeWorkflow?.isolation) {
     const presetOrder = ["strict", "minimal", "permissive"];
@@ -7407,7 +7901,8 @@ function bootstrapRuntimeConfig({
     additionalDirectories,
     pluginDirs,
     verbose,
-    configuredModel: configModel
+    configuredModel: configModel,
+    configuredEffort: configEffort
   });
   const modelName = harnessConfigProfile.resolveModelName({
     projectDir,
@@ -7423,6 +7918,9 @@ function bootstrapRuntimeConfig({
     workflow: activeWorkflow,
     workflowPlan,
     modelName,
+    personalMcpServers,
+    personalSkills,
+    capabilityConflicts: pluginResult.conflicts,
     warnings
   };
 }
@@ -7444,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 {
@@ -7635,8 +8133,10 @@ function generateTitle(event, ascii = false) {
 }
 function generateNeutralTitle(event, g) {
   switch (event.kind) {
-    case "session.start":
-      return `Session started (${event.data.source})`;
+    case "session.start": {
+      const sessionTitle = event.data.session_title?.trim();
+      return sessionTitle ? truncate(sessionTitle) : `Session started (${event.data.source})`;
+    }
     case "session.end":
       return `Session ended (${event.data.reason})`;
     case "run.start":
@@ -7645,6 +8145,8 @@ function generateNeutralTitle(event, g) {
       return `Run ${event.data.status}`;
     case "user.prompt":
       return truncate(event.data.prompt);
+    case "prompt.expansion":
+      return event.data.command_name ? truncate(`Expanded /${event.data.command_name}`) : "Prompt expanded";
     case "plan.update":
       return truncate(
         event.data.explanation || event.data.delta || "Plan updated"
@@ -7659,6 +8161,10 @@ function generateNeutralTitle(event, g) {
       return `${g["tool.bullet"]} ${event.data.tool_name}`;
     case "tool.post":
       return `${g["tool.gutter"]} ${event.data.tool_name} result`;
+    case "tool.batch": {
+      const n = event.data.tool_calls.length;
+      return `Batch of ${n} tool call${n === 1 ? "" : "s"}`;
+    }
     case "tool.failure":
       return truncate(
         `${g["status.blocked"]} ${event.data.tool_name} failed: ${event.data.error}`
@@ -7809,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) {
@@ -7873,7 +8379,7 @@ function createTranscriptReader() {
       }
       return messages;
     } finally {
-      fs16.closeSync(fd);
+      fs17.closeSync(fd);
     }
   }
   function getOffset(transcriptPath) {
@@ -7889,6 +8395,7 @@ function createRunLifecycle(boundary) {
   let currentRun = null;
   let seq = 0;
   let runSeq = 0;
+  let currentPromptId;
   function getRunId() {
     const sessId = currentSession?.session_id ?? "unknown";
     return `${sessId}:R${runSeq}`;
@@ -7937,7 +8444,13 @@ function createRunLifecycle(boundary) {
     );
   }
   function beginRun(runtimeEvent, triggerType = "other", promptPreview) {
-    if (currentRun && triggerType === "other") return [];
+    const promptId = runtimeEvent.promptId;
+    const isExplicitContextTrigger = triggerType === "resume" || triggerType === "clear" || triggerType === "compact";
+    if (promptId !== void 0 && !isExplicitContextTrigger) {
+      if (currentRun && promptId === currentPromptId) return [];
+    } else if (promptId === void 0 && currentRun && triggerType === "other") {
+      return [];
+    }
     const results = [];
     const closeEvt = closeRunIntoEvent(runtimeEvent, "completed");
     if (closeEvt) results.push(closeEvt);
@@ -7948,6 +8461,7 @@ function createRunLifecycle(boundary) {
       triggerType,
       promptPreview
     );
+    currentPromptId = promptId;
     results.push(
       makeEvent(
         "run.start",
@@ -8027,6 +8541,7 @@ function createRunLifecycle(boundary) {
           if (e.kind === "tool.failure") currentRun.counters.tool_failures++;
           if (e.kind === "permission.request")
             currentRun.counters.permission_requests++;
+          if (e.prompt_id !== void 0) currentPromptId = e.prompt_id;
         }
       }
     }
@@ -8538,6 +9053,15 @@ function toolUseCause(toolUseId, parentId) {
     ...parentId ? { parent_event_id: parentId } : {}
   };
 }
+function readToolBatchCalls2(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "object" && entry !== null).map((entry) => readObject(entry)).map((call) => ({
+    tool_name: readString(call["tool_name"]),
+    tool_input: readObject(call["tool_input"]),
+    tool_use_id: readString(call["tool_use_id"]),
+    tool_response: readString(call["tool_response"])
+  }));
+}
 function createToolProjection(args) {
   const {
     ensureRunArray,
@@ -8594,6 +9118,21 @@ function createToolProjection(args) {
   return {
     mapToolEvent(event, data) {
       const results = ensureRunArray(event);
+      if (event.kind === "tool.batch") {
+        results.push(
+          makeEvent(
+            "tool.batch",
+            "info",
+            resolveToolActor(),
+            {
+              tool_calls: readToolBatchCalls2(data["tool_calls"]),
+              permission_mode: readString(data["permission_mode"])
+            },
+            event
+          )
+        );
+        return results;
+      }
       const toolUseId = resolveToolUseId(event, data);
       const toolName = event.toolName ?? readString(data["tool_name"]) ?? "Unknown";
       const toolInput = readObject(data["tool_input"]);
@@ -9372,7 +9911,8 @@ function createRunSessionProjection(args) {
             {
               source,
               agent_type: readString(data["agent_type"]),
-              model: readString(data["model"])
+              model: readString(data["model"]),
+              session_title: readString(data["session_title"])
             },
             event
           )
@@ -9417,6 +9957,34 @@ function createRunSessionProjection(args) {
         );
         return results;
       }
+      if (event.kind === "prompt.expansion") {
+        if (event.promptId !== void 0) {
+          results.push(
+            ...ensureRunArray(
+              event,
+              "user_prompt_submit",
+              readString(data["prompt"])?.slice(0, 80)
+            )
+          );
+        }
+        results.push(
+          makeEvent(
+            "prompt.expansion",
+            "info",
+            "user",
+            {
+              expansion_type: readString(data["expansion_type"]),
+              command_name: readString(data["command_name"]),
+              command_args: readString(data["command_args"]),
+              command_source: readString(data["command_source"]),
+              prompt: readString(data["prompt"]),
+              permission_mode: event.context.permissionMode ?? readString(data["permission_mode"])
+            },
+            event
+          )
+        );
+        return results;
+      }
       if (event.kind === "turn.start") {
         agentMessageStream.clearPending();
         const prompt = readString(data["prompt"]);
@@ -9649,6 +10217,7 @@ var RUN_SESSION_EVENT_KINDS = /* @__PURE__ */ new Set([
   "session.start",
   "session.end",
   "user.prompt",
+  "prompt.expansion",
   "turn.start",
   "message.delta",
   "message.complete",
@@ -9661,6 +10230,7 @@ var TOOL_EVENT_KINDS = /* @__PURE__ */ new Set([
   "tool.delta",
   "tool.pre",
   "tool.post",
+  "tool.batch",
   "tool.failure"
 ]);
 var DECISION_EVENT_KINDS = /* @__PURE__ */ new Set([
@@ -9722,6 +10292,8 @@ function createFeedMapper(bootstrap) {
       ts: runtimeEvent.timestamp,
       session_id: runtimeEvent.sessionId,
       run_id: runId,
+      prompt_id: runtimeEvent.promptId,
+      effort_level: runtimeEvent.effortLevel,
       kind,
       level,
       actor_id: actorId,
@@ -9876,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 = 6;
+var SCHEMA_VERSION = 9;
 var applySessionSchema = (db, fromVersion) => {
   db.exec(`
 		CREATE TABLE IF NOT EXISTS session (
@@ -9907,6 +10505,10 @@ var applySessionSchema = (db, fromVersion) => {
 			actor_id TEXT NOT NULL,
 			timestamp INTEGER NOT NULL,
 			data JSON NOT NULL,
+			-- Harness-native Prompt identity (Claude prompt_id): a nullable
+			-- correlation key, NOT the Run identity (that stays run_id). Unset for
+			-- pre-prompt bootstrap + harnesses/versions without it (ADR 0009).
+			prompt_id TEXT,
 			FOREIGN KEY (runtime_event_id) REFERENCES runtime_events(id)
 		);
 
@@ -9936,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)
 		);
 
@@ -9960,6 +10574,11 @@ var applySessionSchema = (db, fromVersion) => {
 		CREATE INDEX IF NOT EXISTS idx_workflow_runs_session ON workflow_runs(session_id);
 		CREATE INDEX IF NOT EXISTS idx_outbox_due ON channel_outbox(next_attempt_at);
 	`);
+  if (fromVersion === void 0 || fromVersion >= 7) {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_feed_prompt ON feed_events(prompt_id);"
+    );
+  }
   if (fromVersion === void 0) return;
   if (fromVersion >= SCHEMA_VERSION) return;
   if (fromVersion < 2) {
@@ -10022,6 +10641,34 @@ var applySessionSchema = (db, fromVersion) => {
 			UPDATE schema_version SET version = 6;
 		`);
   }
+  const versionAfterV6 = db.prepare("SELECT version FROM schema_version").get().version;
+  if (versionAfterV6 === 6) {
+    db.exec(`
+			ALTER TABLE feed_events ADD COLUMN prompt_id TEXT;
+			CREATE INDEX IF NOT EXISTS idx_feed_prompt ON feed_events(prompt_id);
+			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,
@@ -10078,8 +10725,8 @@ function createSessionStore(opts) {
 		 VALUES (?, ?, ?, ?, ?, ?)`
   );
   const insertFeedEvent = db.prepare(
-    `INSERT OR IGNORE INTO feed_events (event_id, runtime_event_id, seq, kind, run_id, actor_id, timestamp, data)
-		 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    `INSERT OR IGNORE INTO feed_events (event_id, runtime_event_id, seq, kind, run_id, actor_id, timestamp, data, prompt_id)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
   );
   const insertAdapterSession = db.prepare(
     `INSERT OR IGNORE INTO adapter_sessions (session_id, started_at)
@@ -10092,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`
@@ -10134,7 +10783,8 @@ function createSessionStore(opts) {
           fe.run_id,
           fe.actor_id,
           fe.ts,
-          JSON.stringify(fe)
+          JSON.stringify(fe),
+          fe.prompt_id ?? null
         );
       }
       updateEventCount.run(feedEvents.length, opts.sessionId);
@@ -10150,7 +10800,8 @@ function createSessionStore(opts) {
         fe.run_id,
         fe.actor_id,
         fe.ts,
-        JSON.stringify(fe)
+        JSON.stringify(fe),
+        fe.prompt_id ?? null
       );
     }
     updateEventCount.run(feedEvents.length, opts.sessionId);
@@ -10262,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,
@@ -10273,6 +10924,8 @@ function createSessionStore(opts) {
       snapshot.status,
       snapshot.stopReason ?? null,
       snapshot.trackerPath ?? null,
+      snapshot.adapterSessionId ?? null,
+      snapshot.runMemoryJson ?? null,
       endedAt
     );
   }
@@ -10289,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) {
@@ -10997,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;
@@ -11984,6 +12639,13 @@ var stopFailure = defaultRenderer(
 var permissionDenied = defaultRenderer(
   (event) => `${event.data.tool_name}${event.data.reason ? `: ${event.data.reason}` : ""}`
 );
+var promptExpansion = defaultRenderer(
+  (event) => event.data.command_name ? `/${event.data.command_name}${event.data.command_args ? ` ${event.data.command_args}` : ""}` : event.data.expansion_type ?? ""
+);
+var toolBatch = defaultRenderer((event) => {
+  const names = event.data.tool_calls.map((call) => call.tool_name).filter((name) => Boolean(name));
+  return names.length > 0 ? names.join(", ") : "";
+});
 var elicitationRequest = defaultRenderer((event) => `elicitation from ${event.data.mcp_server}`);
 var elicitationResult = defaultRenderer(
   (event) => `${event.data.mcp_server} \u2192 ${event.data.action}`
@@ -12032,6 +12694,7 @@ var RENDERERS = {
   "tool.delta": toolDelta,
   "tool.pre": toolPre,
   "tool.post": toolPost,
+  "tool.batch": toolBatch,
   "tool.failure": toolFailure,
   "permission.request": permissionRequest,
   "permission.decision": permissionDecision,
@@ -12071,6 +12734,7 @@ var RENDERERS = {
   "worktree.remove": worktreeRemove,
   "stop.failure": stopFailure,
   "permission.denied": permissionDenied,
+  "prompt.expansion": promptExpansion,
   "elicitation.request": elicitationRequest,
   "elicitation.result": elicitationResult,
   "channel.permission.relayed": channelPermissionRelayed,
@@ -12269,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") ?? "");
@@ -12912,6 +13576,7 @@ function resolveEventToolColumn(event) {
     case "tool.delta":
     case "tool.pre":
     case "tool.post":
+    case "tool.batch":
     case "tool.failure":
     case "permission.decision":
     case "permission.denied":
@@ -12939,6 +13604,7 @@ function resolveEventToolColumn(event) {
     case "todo.done":
     case "agent.message":
     case "teammate.idle":
+    case "prompt.expansion":
     case "task.created":
     case "task.completed":
     case "config.change":
@@ -13444,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));
@@ -13455,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);
@@ -13492,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) {
@@ -13514,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) {
@@ -13642,7 +14370,7 @@ function extractRelayQuestions(event) {
 }
 
 // src/app/channels/gatewayControlClient.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 
 // src/gateway/control/client.ts
 import crypto from "crypto";
@@ -13750,6 +14478,7 @@ async function connect(opts) {
     preHelloResolve = (frame) => {
       clearTimeout(timer);
       preHelloAbort = null;
+      helloAcked = true;
       resolve(frame);
     };
     preHelloAbort = (err) => {
@@ -13772,7 +14501,6 @@ async function connect(opts) {
     }
     throw new GatewayProtocolError(String(msg));
   }
-  helloAcked = true;
   const request = async (kind, payload, reqOpts) => {
     const requestId = crypto.randomUUID();
     const envelope = {
@@ -13793,9 +14521,6 @@ async function connect(opts) {
     );
     connection.send(envelope);
     const res = await responsePromise;
-    if (res.request_id !== requestId) {
-      throw new GatewayProtocolError("response request_id mismatch");
-    }
     if (!res.ok) {
       throw new GatewayProtocolError(
         `${res.error.code}: ${res.error.message}`,
@@ -13832,93 +14557,6 @@ function isStringRecord(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 
-// src/gateway/transport/wsClient.ts
-import { WebSocket } from "ws";
-import { readFileSync as readFileSync2 } from "fs";
-function createWsClientTransport(opts) {
-  return {
-    kind: "ws",
-    connect: () => connectWs(opts)
-  };
-}
-function wsClientOptionsForEndpoint(input) {
-  return {
-    url: input.url,
-    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
-    ...input.tlsCaPath !== void 0 ? { tlsCaPath: input.tlsCaPath } : {}
-  };
-}
-async function connectWs(opts) {
-  const timeoutMs = opts.timeoutMs ?? 5e3;
-  const wsOpts = opts.tlsCaPath ? { ca: readFileSync2(opts.tlsCaPath) } : {};
-  const ws = new WebSocket(opts.url, wsOpts);
-  await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      ws.close();
-      reject(
-        new TransportUnreachableError(`connect timed out after ${timeoutMs}ms`)
-      );
-    }, timeoutMs);
-    ws.once("open", () => {
-      clearTimeout(timer);
-      resolve();
-    });
-    ws.once("error", (err) => {
-      clearTimeout(timer);
-      reject(
-        new TransportUnreachableError(
-          `gateway not reachable at ${opts.url}: ${err.message}`
-        )
-      );
-    });
-  });
-  return createWsConnection(ws, opts.url);
-}
-function createWsConnection(ws, peer) {
-  const frameHandlers = /* @__PURE__ */ new Set();
-  const closeHandlers = /* @__PURE__ */ new Set();
-  const errorHandlers = /* @__PURE__ */ new Set();
-  ws.on("message", (data) => {
-    let parsed;
-    try {
-      parsed = JSON.parse(data.toString());
-    } catch {
-      ws.close();
-      return;
-    }
-    traceGatewayFrame("ws-client", peer, "in", parsed);
-    for (const handler of frameHandlers) handler(parsed);
-  });
-  ws.on("error", (err) => {
-    for (const handler of errorHandlers) handler(err);
-  });
-  ws.on("close", () => {
-    for (const handler of closeHandlers) handler();
-  });
-  return {
-    kind: "ws",
-    peer,
-    send: (frame) => {
-      if (ws.readyState !== ws.OPEN) return;
-      traceGatewayFrame("ws-client", peer, "out", frame);
-      ws.send(JSON.stringify(frame));
-    },
-    close: () => ws.close(),
-    onFrame: (cb) => {
-      frameHandlers.add(cb);
-      return () => frameHandlers.delete(cb);
-    },
-    onClose: (cb) => {
-      closeHandlers.add(cb);
-      return () => closeHandlers.delete(cb);
-    },
-    onError: (cb) => {
-      errorHandlers.add(cb);
-      return () => errorHandlers.delete(cb);
-    }
-  };
-}
-
 // src/app/channels/gatewayControlClient.ts
 async function connectGatewayControlClient(opts) {
   const loadToken = opts.loadToken ?? defaultLoadToken;
@@ -13940,13 +14578,13 @@ async function connectGatewayControlClient(opts) {
   });
 }
 function defaultLoadToken(tokenPath) {
-  return readFileSync3(tokenPath, "utf8").trim();
+  return readFileSync2(tokenPath, "utf8").trim();
 }
 
 // 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) {
@@ -14001,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)}`
@@ -14028,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 {
     }
   }
@@ -14825,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 };
 }
 
@@ -15005,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()) {
@@ -15034,6 +15686,10 @@ function createExecOutputWriter(options) {
       if (!options.verbose) return;
       writeLine(options.stderr, `[athena exec] ${message}`);
     },
+    notice(message) {
+      if (options.json) return;
+      writeLine(options.stderr, `[athena exec] ${message}`);
+    },
     warn(message) {
       writeLine(options.stderr, `[athena exec] warning: ${message}`);
     },
@@ -15045,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");
     }
   };
 }
@@ -15062,12 +15718,57 @@ var NULL_TOKENS3 = {
   contextSize: null,
   contextWindowSize: null
 };
-function workflowFailure(state, message) {
-  return {
-    kind: "workflow",
-    state,
-    message
-  };
+function formatPersonalCapabilityNotice(summary) {
+  const parts = [];
+  if (summary.mcpServers.length > 0) {
+    const list = summary.mcpServers.map((server) => `${server.name} [${server.sourceLayer}]`).join(", ");
+    parts.push(`mcp servers: ${list}`);
+  }
+  if (summary.skills.length > 0) {
+    const list = summary.skills.map((skill) => `${skill.name} [${skill.sourceLayer}]`).join(", ");
+    parts.push(`skills: ${list}`);
+  }
+  if (parts.length === 0) return null;
+  return `personal capabilities active \u2014 ${parts.join("; ")}`;
+}
+function formatCapabilityConflictNotice(summary) {
+  const parts = [];
+  if (summary.mcpServers.length > 0) {
+    const list = summary.mcpServers.map((server) => `${server.name} [${server.sourceLayer}]`).join(", ");
+    parts.push(`mcp servers: ${list}`);
+  }
+  if (summary.skills.length > 0) {
+    const list = summary.skills.map((skill) => `${skill.name} [${skill.sourceLayer}]`).join(", ");
+    parts.push(`skills: ${list}`);
+  }
+  if (parts.length === 0) return null;
+  return `personal capability conflicts \u2014 workflow plugin wins; shadowed: ${parts.join(
+    "; "
+  )}`;
+}
+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 {
@@ -15121,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)}`;
@@ -15202,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
@@ -15214,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;
@@ -15287,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(
@@ -15336,11 +16066,29 @@ async function runExec(options) {
       });
     }, options.timeoutMs);
   }
+  const personalCapabilities = options.personalCapabilities ?? {
+    mcpServers: [],
+    skills: []
+  };
+  const capabilityConflicts = options.capabilityConflicts ?? {
+    mcpServers: [],
+    skills: []
+  };
   output.emitJsonEvent("exec.started", {
     projectDir: options.projectDir,
     harness: options.harness,
-    athenaSessionId: options.ephemeral ? null : athenaSessionId
+    athenaSessionId: options.ephemeral ? null : athenaSessionId,
+    personalCapabilities,
+    capabilityConflicts
   });
+  const personalCapabilityNotice = formatPersonalCapabilityNotice(personalCapabilities);
+  if (personalCapabilityNotice) {
+    output.notice(personalCapabilityNotice);
+  }
+  const capabilityConflictNotice = formatCapabilityConflictNotice(capabilityConflicts);
+  if (capabilityConflictNotice) {
+    output.notice(capabilityConflictNotice);
+  }
   try {
     await runtime.start();
     runtimeStarted = true;
@@ -15365,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,
@@ -15372,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,
@@ -15401,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",
@@ -15497,7 +16313,7 @@ async function runExec(options) {
 }
 
 // src/app/dashboard/instanceSocketClient.ts
-import { WebSocket as WebSocket2 } from "ws";
+import { WebSocket } from "ws";
 var DEFAULT_HEARTBEAT_MS = 3e4;
 var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
 function instanceSocketUrl(dashboardUrl, instanceId) {
@@ -15514,7 +16330,7 @@ function createInstanceSocketClient(opts) {
   const log = opts.log ?? (() => {
   });
   const now = opts.now ?? (() => Date.now());
-  const makeWebSocket = opts.makeWebSocket ?? ((url, accessToken) => new WebSocket2(url, [accessToken]));
+  const makeWebSocket = opts.makeWebSocket ?? ((url, accessToken) => new WebSocket(url, [accessToken]));
   const frameHandlers = /* @__PURE__ */ new Set();
   const closeHandlers = /* @__PURE__ */ new Set();
   let ws = null;
@@ -15714,7 +16530,7 @@ function normalizeHarnessOverride(value) {
 }
 
 // src/app/dashboard/runStreamClient.ts
-import { WebSocket as WebSocket3 } from "ws";
+import { WebSocket as WebSocket2 } from "ws";
 var DEFAULT_RECONNECT_DELAYS_MS = [250, 1e3, 2e3, 5e3, 15e3];
 var DEFAULT_HEARTBEAT_MS2 = 3e4;
 var DEFAULT_WATCHDOG_MS = 9e4;
@@ -15727,7 +16543,7 @@ function createRunStreamClient(opts) {
   const heartbeatMs = opts.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS2;
   const watchdogMs = opts.watchdogTimeoutMs ?? DEFAULT_WATCHDOG_MS;
   const maxQueueSize = opts.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
-  const makeWebSocket = opts.makeWebSocket ?? ((url) => new WebSocket3(url));
+  const makeWebSocket = opts.makeWebSocket ?? ((url) => new WebSocket2(url));
   const setTimer = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
   const clearTimer = opts.clearTimer ?? ((t) => clearTimeout(t));
   let nextSeq = 1;
@@ -16067,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) {
@@ -16251,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(
@@ -16356,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);
   }
@@ -16759,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;
@@ -16794,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 {
     }
   }
@@ -16824,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;
   }
@@ -17228,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) {
@@ -17239,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,
@@ -17255,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 {
       }
     }
@@ -17274,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: {
@@ -17284,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",
@@ -17296,7 +18112,7 @@ function validateProjectDir(projectDir, env = process.env) {
   }
   let stat;
   try {
-    stat = fs22.statSync(resolved);
+    stat = fs23.statSync(resolved);
   } catch {
     return {
       kind: "rejected",
@@ -17741,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) {
@@ -17766,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;
       }
@@ -17780,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" };
@@ -17804,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") {
@@ -17832,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
@@ -17877,7 +18693,7 @@ async function startUdsServer(socketPath, handler, log) {
   });
   if (process.platform !== "win32") {
     try {
-      fs24.chmodSync(socketPath, 384);
+      fs25.chmodSync(socketPath, 384);
     } catch {
     }
   }
@@ -17887,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") {
         }
@@ -18005,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;
@@ -18032,7 +18848,7 @@ async function unlinkStaleSocket(socketPath) {
       `uds path ${socketPath} is in use by another process; aborting`
     );
   }
-  fs24.unlinkSync(socketPath);
+  fs25.unlinkSync(socketPath);
 }
 
 export {
@@ -18062,6 +18878,8 @@ export {
   listSessions,
   getSessionMeta,
   getMostRecentAthenaSession,
+  getLatestRunForSession,
+  listAwaitingAttentionRuns,
   resolveClaudeBinary,
   detectClaudeVersion,
   resolveHookForwarderCommand,
@@ -18092,8 +18910,6 @@ export {
   GatewayUnreachableError,
   GatewayUnauthorizedError,
   connect,
-  createWsClientTransport,
-  wsClientOptionsForEndpoint,
   isSupportedGatewayUrl,
   readGatewayClientConfig,
   writeGatewayClientConfig,
@@ -18121,6 +18937,8 @@ export {
   isBashToolResponse,
   resolveToolColumn,
   IndexedTimeline,
+  parseFrontmatter,
+  resolveEffectiveCapabilities,
   bootstrapRuntimeConfig,
   EXEC_EXIT_CODE,
   runExec,
@@ -18133,4 +18951,4 @@ export {
   startUdsServer,
   sendUdsRequest
 };
-//# sourceMappingURL=chunk-QBMYQJFX.js.map
+//# sourceMappingURL=chunk-4HWBXCVY.js.map