@cydm/pie 2.6.6 → 2.6.8

package/dist/chunks/{chunk-H6BAM2N4.js → chunk-DFWWHVJL.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from "node:module"; const require =
 import {
   Agent,
   getToolCallerIdentity
-} from "./chunk-KEARZX6F.js";
+} from "./chunk-PAC62XU4.js";
 import {
   AssistantMessageEventStream,
   FileSystemGateway,
@@ -12,7 +12,7 @@ import {
   getPlatformConfig,
   hashText,
   streamSimple
-} from "./chunk-G5B6D35K.js";
+} from "./chunk-7B4IIBVS.js";
 import {
   Type
 } from "./chunk-XXGYUYXI.js";
@@ -1138,6 +1138,74 @@ function withSubagentResponseRecovery(stream, backoffMs = 2e3) {
   };
 }
 
+// ../../packages/shared-headless-capabilities/src/subagent-sessions.ts
+var SUBAGENT_SESSION_RECORD_VERSION = 1;
+var DEFAULT_MAX_LIVE_SESSIONS = 8;
+var DEFAULT_SESSION_STORE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var DEFAULT_SESSION_STORE_MAX_RECORDS = 64;
+var SESSION_TRANSCRIPT_WARN_CHARS = 24e4;
+var SESSION_RECORD_MAX_CHARS = 4e6;
+function touchLiveSession(registry, id) {
+  const session = registry.get(id);
+  if (!session) return void 0;
+  registry.delete(id);
+  registry.set(id, session);
+  return session;
+}
+function retainLiveSession(registry, session, cap) {
+  registry.delete(session.id);
+  registry.set(session.id, session);
+  while (registry.size > Math.max(1, cap)) {
+    let evicted = false;
+    for (const [key, candidate] of registry) {
+      if (candidate.busy) continue;
+      registry.delete(key);
+      evicted = true;
+      break;
+    }
+    if (!evicted) {
+      break;
+    }
+  }
+}
+function toSessionRecord(session, messages) {
+  return {
+    version: SUBAGENT_SESSION_RECORD_VERSION,
+    id: session.id,
+    name: session.name,
+    mode: session.mode,
+    priority: session.priority,
+    originalTask: session.originalTask,
+    modelOverride: session.modelOverride,
+    thinkingLevel: session.thinkingLevel,
+    timeoutSeconds: session.timeoutSeconds,
+    createdAt: session.createdAt,
+    lastUsedAt: session.lastUsedAt,
+    runCount: session.runCount,
+    revision: session.revision,
+    messages
+  };
+}
+function estimateTranscriptChars(messages) {
+  let total = 0;
+  for (const message of messages) {
+    try {
+      total += JSON.stringify(message)?.length ?? 0;
+    } catch {
+      total += SESSION_TRANSCRIPT_WARN_CHARS;
+    }
+  }
+  return total;
+}
+function transplantMessages(target, messages) {
+  const mutable = target;
+  if (typeof mutable.replaceMessages === "function") {
+    mutable.replaceMessages(messages);
+  } else {
+    mutable.state.messages = messages;
+  }
+}
+
 // ../../packages/shared-headless-capabilities/src/bash-policy.ts
 var DESTRUCTIVE_PATTERNS = [
   { pattern: /\bgit\s+reset\s+--hard\b/, warning: "may discard uncommitted changes", commandClass: "git_destructive" },
@@ -1623,6 +1691,23 @@ function buildSubagentPlan(deps, task, name, priority, timeoutSeconds, modelOver
 function subagentOutputBudget(model) {
   return Math.min(model.maxTokens || 8192, 16384);
 }
+function buildSubagentSystemPrompt(mode, skills) {
+  return `You are a specialized subagent focused on one bounded task.
+
+Task boundary:
+- Work only on the assigned task.
+- Use available tools to gather evidence before making claims.
+${mode === "edit" ? "- You may edit files and run tests using the inherited parent tools and permissions. This is a shared workspace, not an isolated sandbox. Preserve existing user changes. Do not commit or automatically roll back changes. Report changed files, tests actually run, and remaining work for parent review." : "- Do not edit files; if writing is needed, say what the parent agent should change."}
+- Return a concise answer with evidence and uncertainty.
+
+Output:
+- Answer
+- Evidence
+- Uncertainty: low, medium, or high
+- Parent follow-up needed, if any
+
+${formatSkillsForPrompt(skills ?? [])}`;
+}
 function createAgentInstance(deps, systemPrompt, tools, model, apiKey, thinkingLevel) {
   const streamFn = withSubagentResponseRecovery((streamModel, context, options) => streamSimple(streamModel, context, {
     ...options,
@@ -1692,7 +1777,114 @@ function inferUncertainty(text, signals) {
 function isParentHandoffRequired(task) {
   return task.mode === "edit" || task.needsParentWrite || task.status === "timeout" || task.status === "failed" || task.confidenceSignals.some((signal) => signal.type === "tool_error" || signal.type === "no_tool_use" || signal.type === "no_text_report");
 }
-async function runSubagentWithProgress(deps, task, reportProgress, signal) {
+function shellFromRecord(record) {
+  return {
+    id: record.id,
+    name: record.name,
+    mode: record.mode,
+    priority: record.priority,
+    originalTask: record.originalTask,
+    modelOverride: record.modelOverride,
+    thinkingLevel: record.thinkingLevel,
+    timeoutSeconds: record.timeoutSeconds,
+    agent: null,
+    pendingMessages: record.messages,
+    createdAt: record.createdAt,
+    lastUsedAt: record.lastUsedAt,
+    runCount: record.runCount,
+    // The restored record IS our durable base line: its revision (0 for
+    // legacy records that predate the field) is both our current revision
+    // and our known-persisted revision.
+    revision: record.revision ?? 0,
+    persistedRevision: record.revision ?? 0,
+    busy: true
+  };
+}
+async function resolveRecallSession(deps, id, sessions, maxLiveSessions) {
+  let live = sessions ? touchLiveSession(sessions, id) : void 0;
+  if (live?.busy) throw new Error(`Subagent session "${id}" is busy with another task; wait for it to settle.`);
+  let record;
+  if (deps.sessionStore) {
+    try {
+      record = await deps.sessionStore.load(id);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      deps.debugLog?.("session", "session store load failed", { id, error: detail });
+      throw new Error(`Subagent session "${id}" could not be read from the session store (${detail}); refusing to recall without verifying session freshness. Retry the recall, or spawn a fresh task.`);
+    }
+  }
+  if (record && typeof record.version === "number" && record.version !== SUBAGENT_SESSION_RECORD_VERSION) {
+    throw new Error(`Subagent session "${id}" is persisted in record format version ${record.version}, which this build cannot read (supported: ${SUBAGENT_SESSION_RECORD_VERSION}); refusing to recall so the newer record is not overwritten. Use the matching Pie version, or spawn a fresh task.`);
+  }
+  if (record && (record.version !== SUBAGENT_SESSION_RECORD_VERSION || record.id !== id || !Array.isArray(record.messages))) {
+    record = void 0;
+  }
+  live = sessions ? touchLiveSession(sessions, id) : void 0;
+  if (live?.busy) throw new Error(`Subagent session "${id}" is busy with another task; wait for it to settle.`);
+  if (live) {
+    const liveTranscriptLength = live.agent?.state.messages.length ?? live.pendingMessages?.length ?? 0;
+    const recordIsNewer = record !== void 0 && (record.revision !== void 0 ? record.revision > live.revision : record.runCount > live.runCount || record.runCount === live.runCount && record.lastUsedAt > live.lastUsedAt || record.runCount === live.runCount && record.lastUsedAt === live.lastUsedAt && record.messages.length > liveTranscriptLength);
+    const forked = record?.revision !== void 0 && record.revision > (live.persistedRevision ?? 0) && live.revision > (live.persistedRevision ?? 0);
+    if (forked && record?.revision !== void 0) {
+      deps.debugLog?.("session", "live and durable sessions diverged after failed persistence", {
+        id,
+        liveRevision: live.revision,
+        persistedRevision: record.revision,
+        lastSharedRevision: live.persistedRevision
+      });
+      sessions?.delete(id);
+      throw new Error(`Subagent session "${id}" diverged across processes: this process holds unsaved work (revision ${live.revision}, last durable sync ${live.persistedRevision ?? 0}) while another process advanced the stored record (revision ${record.revision}). The diverged in-memory branch was discarded; recall again to continue from the last durable transcript, or spawn a fresh task.`);
+    }
+    if (recordIsNewer && record) {
+      deps.debugLog?.("session", "live session behind the durable record; adopting the persisted record", {
+        id,
+        liveMessages: liveTranscriptLength,
+        persistedMessages: record.messages.length,
+        liveRevision: live.revision,
+        persistedRevision: record.revision,
+        liveRunCount: live.runCount,
+        persistedRunCount: record.runCount,
+        liveLastUsedAt: live.lastUsedAt,
+        persistedLastUsedAt: record.lastUsedAt
+      });
+      const shell2 = shellFromRecord(record);
+      if (sessions) {
+        retainLiveSession(sessions, shell2, maxLiveSessions);
+      }
+      return { session: shell2, restored: true };
+    }
+    live.busy = true;
+    return { session: live, restored: false };
+  }
+  if (!record) return void 0;
+  const shell = shellFromRecord(record);
+  if (sessions) {
+    retainLiveSession(sessions, shell, maxLiveSessions);
+  }
+  return { session: shell, restored: true };
+}
+async function persistSubagentSession(deps, session, task) {
+  const messages = session.agent?.state.messages ?? session.pendingMessages ?? [];
+  const transcriptChars = estimateTranscriptChars(messages);
+  if (task.status === "completed" && task.result && transcriptChars > SESSION_TRANSCRIPT_WARN_CHARS) {
+    task.result += `
+
+[Session growth warning: session ${session.id} now carries ~${Math.round(transcriptChars / 4)} tokens of transcript; every recall pays for the whole history. For the next round, consider a fresh subagent with a compact brief instead of recalling.]`;
+  }
+  if (!deps.sessionStore) return;
+  if (transcriptChars > SESSION_RECORD_MAX_CHARS) {
+    deps.debugLog?.("session", "skipping session persist: transcript over the size cap", { id: session.id, transcriptChars });
+    return;
+  }
+  try {
+    const saved = await deps.sessionStore.save(toSessionRecord(session, messages));
+    task.sessionPersisted = saved === true;
+    if (saved === true) session.persistedRevision = session.revision;
+  } catch (error) {
+    deps.debugLog?.("session", "session persist failed", { id: session.id, error: error instanceof Error ? error.message : String(error) });
+  }
+}
+async function runSubagentWithProgress(deps, task, reportProgress, signal, sessions) {
   const startTime = Date.now();
   task.status = "running";
   let timedOut = false;
@@ -1706,6 +1898,11 @@ async function runSubagentWithProgress(deps, task, reportProgress, signal) {
   const heartbeatIntervalMs = deps.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
   deps.debugLog?.("run", "runSubagentWithProgress START", { taskName: task.name, yoloMode: deps.yoloMode });
   let heartbeat;
+  let session;
+  let runStarted = false;
+  let pendingRun;
+  let agentSettled = true;
+  let releaseLease;
   if (heartbeatIntervalMs > 0) {
     heartbeat = setInterval(() => {
       try {
@@ -1718,46 +1915,134 @@ async function runSubagentWithProgress(deps, task, reportProgress, signal) {
       }
     }, Math.max(50, Math.min(1e3, heartbeatIntervalMs / 2)));
   }
+  if (task.sessionId) task.wasRecall = true;
   try {
     report({ message: `[${task.name}] Starting...`, increment: 5 });
-    const { plan, tools, apiKey, model } = buildSubagentPlan(deps, task.task, task.name, task.priority, task.timeoutSeconds, task.modelOverride, task.thinkingLevel, task.mode);
-    task.plan = plan;
-    task.needsParentWrite = task.mode === "read" && needsParentWrite(task.task);
-    for (const excluded of plan.toolsExcluded) {
-      if (excluded.reason === "unclassified_tool") {
-        task.confidenceSignals.push({ type: "unclassified_tool", message: `${excluded.name} inherited without risk metadata` });
+    let subagent;
+    let baseline = 0;
+    let plan;
+    let runTimeoutSeconds = task.timeoutSeconds;
+    if (task.sessionId) {
+      if (sessions?.get(task.sessionId)?.busy) {
+        throw new Error(`Subagent session "${task.sessionId}" is busy with another task; wait for it to settle.`);
+      }
+      releaseLease = await deps.sessionStore?.acquire?.(task.sessionId);
+      const resolved = await resolveRecallSession(deps, task.sessionId, sessions, Math.max(1, deps.maxLiveSessions ?? DEFAULT_MAX_LIVE_SESSIONS));
+      if (!resolved) {
+        throw new Error(`Unknown or expired subagent session "${task.sessionId}": it is neither live in this process nor in the session store (evicted, swept, or never persisted). Spawn a fresh task instead of recalling.`);
+      }
+      const owned = resolved.session;
+      session = owned;
+      if (task.requestedTimeoutSeconds !== void 0) {
+        session.timeoutSeconds = task.requestedTimeoutSeconds;
+      }
+      const nextMode = task.requestedMode ?? session.mode;
+      if (nextMode === "edit" && (task.batchSize ?? 1) > 1) {
+        throw new Error(`Recalling session "${session.id}" resolves to edit mode, and an edit delegation must contain exactly one task (the workspace is shared). Retry it alone.`);
+      }
+      const nextModelOverride = task.modelOverride ?? session.modelOverride;
+      const nextThinking = task.thinkingLevel ?? session.thinkingLevel;
+      const mustRebuild = session.agent === null || task.requestedMode !== void 0 || task.modelOverride !== void 0 || task.thinkingLevel !== void 0;
+      if (!mustRebuild) {
+        subagent = session.agent;
+        baseline = subagent.state.messages.length;
+      } else {
+        let built = buildSubagentPlan(deps, session.originalTask, session.name, session.priority, session.timeoutSeconds, nextModelOverride, nextThinking, nextMode);
+        let effectiveOverride = nextModelOverride;
+        if (task.modelOverride && !built.plan.modelOverrideApplied && session.modelOverride && session.modelOverride !== task.modelOverride) {
+          const missReason = built.plan.modelFallbackReason ?? `model override "${task.modelOverride}" could not be resolved`;
+          built = buildSubagentPlan(deps, session.originalTask, session.name, session.priority, session.timeoutSeconds, session.modelOverride, nextThinking, nextMode);
+          built.plan.modelFallbackReason = built.plan.modelFallbackReason ? `${missReason}; ${built.plan.modelFallbackReason}` : missReason;
+          effectiveOverride = session.modelOverride;
+        }
+        plan = built.plan;
+        task.plan = plan;
+        for (const excluded of plan.toolsExcluded) {
+          if (excluded.reason === "unclassified_tool") {
+            task.confidenceSignals.push({ type: "unclassified_tool", message: `${excluded.name} inherited without risk metadata` });
+          }
+        }
+        if (plan.modelFallbackReason) {
+          task.confidenceSignals.push({ type: "model_fallback", message: plan.modelFallbackReason });
+        }
+        if (!built.apiKey) {
+          throw new Error("No API key available for subagent execution.");
+        }
+        if (!built.model) {
+          throw new Error("No model configured for subagent execution.");
+        }
+        const priorMessages = session.agent ? session.agent.state.messages : session.pendingMessages ?? [];
+        const rebuilt = createAgentInstance(deps, buildSubagentSystemPrompt(nextMode, deps.skills), built.tools, built.model, built.apiKey, plan.thinkingLevel);
+        transplantMessages(rebuilt, priorMessages);
+        baseline = priorMessages.length;
+        subagent = rebuilt;
+        session.agent = subagent;
+        session.pendingMessages = void 0;
+        session.mode = nextMode;
+        session.modelOverride = effectiveOverride;
+        session.thinkingLevel = plan.thinkingLevel;
+      }
+      if (plan) {
+        runTimeoutSeconds = plan.timeoutSeconds;
+      } else {
+        runTimeoutSeconds = session.timeoutSeconds;
       }
+      task.mode = session.mode;
+      task.needsParentWrite = task.mode === "read" && needsParentWrite(task.task);
+      deps.log(`[Subagent ${task.name}] Recalling session ${session.id} (run ${session.runCount + 1}, mode=${session.mode}${resolved.restored ? ", restored from disk" : ""}${mustRebuild ? ", reconfigured" : ""})`);
+    } else {
+      const built = buildSubagentPlan(deps, task.task, task.name, task.priority, task.timeoutSeconds, task.modelOverride, task.thinkingLevel, task.mode);
+      plan = built.plan;
+      task.plan = plan;
+      const { tools, apiKey, model } = built;
+      task.needsParentWrite = task.mode === "read" && needsParentWrite(task.task);
+      for (const excluded of plan.toolsExcluded) {
+        if (excluded.reason === "unclassified_tool") {
+          task.confidenceSignals.push({ type: "unclassified_tool", message: `${excluded.name} inherited without risk metadata` });
+        }
+      }
+      if (plan.modelFallbackReason) {
+        task.confidenceSignals.push({ type: "model_fallback", message: plan.modelFallbackReason });
+      }
+      if (!apiKey) {
+        throw new Error("No API key available for subagent execution.");
+      }
+      if (!model) {
+        throw new Error("No model configured for subagent execution.");
+      }
+      if (signal?.aborted) {
+        throw new Error("Subagent aborted by parent");
+      }
+      deps.log(`[Subagent ${task.name}] Plan: ${plan.complexity}/${plan.modelClass}${plan.modelOverride ? `, model=${plan.modelOverrideApplied ? plan.modelOverride : "override failed"}` : ""}, ${tools.length} tools`);
+      deps.debugLog?.("plan", "SubagentPlan", plan);
+      subagent = createAgentInstance(deps, buildSubagentSystemPrompt(task.mode, deps.skills), tools, model, apiKey, plan.thinkingLevel);
+      session = {
+        id: task.id,
+        name: task.name,
+        mode: task.mode,
+        priority: task.priority,
+        originalTask: task.task,
+        modelOverride: task.modelOverride,
+        thinkingLevel: plan.thinkingLevel,
+        timeoutSeconds: task.timeoutSeconds,
+        agent: subagent,
+        createdAt: Date.now(),
+        lastUsedAt: Date.now(),
+        runCount: 0,
+        revision: 0,
+        busy: true
+      };
+      task.sessionId = session.id;
     }
-    if (plan.modelFallbackReason) {
-      task.confidenceSignals.push({ type: "model_fallback", message: plan.modelFallbackReason });
-    }
-    if (!apiKey) {
-      throw new Error("No API key available for subagent execution.");
-    }
-    if (!model) {
-      throw new Error("No model configured for subagent execution.");
-    }
-    if (signal?.aborted) {
-      throw new Error("Subagent aborted by parent");
+    if (!task.wasRecall) {
+      try {
+        releaseLease = await deps.sessionStore?.acquire?.(session.id);
+      } catch (error) {
+        session = void 0;
+        throw error;
+      }
     }
-    deps.log(`[Subagent ${task.name}] Plan: ${plan.complexity}/${plan.modelClass}${plan.modelOverride ? `, model=${plan.modelOverrideApplied ? plan.modelOverride : "override failed"}` : ""}, ${tools.length} tools`);
-    deps.debugLog?.("plan", "SubagentPlan", plan);
-    const systemPrompt = `You are a specialized subagent focused on one bounded task.
-
-Task boundary:
-- Work only on the assigned task.
-- Use available tools to gather evidence before making claims.
-${task.mode === "edit" ? "- You may edit files and run tests using the inherited parent tools and permissions. This is a shared workspace, not an isolated sandbox. Preserve existing user changes. Do not commit or automatically roll back changes. Report changed files, tests actually run, and remaining work for parent review." : "- Do not edit files; if writing is needed, say what the parent agent should change."}
-- Return a concise answer with evidence and uncertainty.
-
-Output:
-- Answer
-- Evidence
-- Uncertainty: low, medium, or high
-- Parent follow-up needed, if any
-
-${formatSkillsForPrompt(deps.skills ?? [])}`;
-    const subagent = createAgentInstance(deps, systemPrompt, tools, model, apiKey, plan.thinkingLevel);
+    if (sessions) retainLiveSession(sessions, session, Math.max(1, deps.maxLiveSessions ?? DEFAULT_MAX_LIVE_SESSIONS));
     let assistantTurns = 0;
     let toolCalls = 0;
     let rejectTimeout = () => void 0;
@@ -1769,10 +2054,10 @@ ${formatSkillsForPrompt(deps.skills ?? [])}`;
     });
     timeout = setTimeout(() => {
       timedOut = true;
-      const timeoutMessage = `Subagent timed out after ${plan.timeoutSeconds} seconds`;
+      const timeoutMessage = `Subagent timed out after ${runTimeoutSeconds} seconds`;
       subagent.abort?.();
       rejectTimeout(new Error(timeoutMessage));
-    }, plan.timeoutSeconds * 1e3);
+    }, runTimeoutSeconds * 1e3);
     const abortPromise = new Promise((_, reject) => {
       if (!signal) return;
       const abortSubagent = () => {
@@ -1809,17 +2094,33 @@ ${formatSkillsForPrompt(deps.skills ?? [])}`;
       }
     });
     let prompt = task.task;
+    if (task.wasRecall && session) {
+      prompt = `This task CONTINUES subagent session "${session.name}" (${session.id}); your earlier transcript is retained. Build on it instead of redoing completed investigation, and re-verify anything the workspace may have changed since your last run.
+
+New instruction:
+${task.task}`;
+    }
     if (task.mode === "read") {
       prompt += "\n\nThis delegation is read mode. Do not write files. If changes are needed, describe them for the parent.";
     }
     prompt += "\n\nReturn evidence for your conclusion and state uncertainty as low, medium, or high.";
-    report({ message: `[${task.name}] Running plan ${plan.complexity}/${plan.modelClass}...`, increment: 20 });
+    const runLabel = plan ? `plan ${plan.complexity}/${plan.modelClass}` : `session ${session?.id ?? ""} (run ${(session?.runCount ?? 0) + 1})`;
+    report({ message: `[${task.name}] Running ${runLabel}...`, increment: 20 });
+    runStarted = true;
+    agentSettled = false;
+    const runPromise = (async () => {
+      try {
+        await subagent.prompt(prompt);
+        await subagent.waitForIdle?.();
+      } finally {
+        agentSettled = true;
+      }
+    })();
+    const settledRun = runPromise.catch(() => void 0);
+    pendingRun = settledRun;
     try {
       await Promise.race([
-        (async () => {
-          await subagent.prompt(prompt);
-          await subagent.waitForIdle?.();
-        })(),
+        runPromise,
         timeoutPromise,
         abortPromise
       ]);
@@ -1829,9 +2130,19 @@ ${formatSkillsForPrompt(deps.skills ?? [])}`;
       }
       removeAbortListener?.();
       unsubscribe?.();
+      if (!agentSettled) {
+        const graceMs = deps.sessionSettleGraceMs ?? 2e3;
+        if (graceMs > 0) {
+          await Promise.race([
+            settledRun,
+            new Promise((resolve3) => setTimeout(resolve3, graceMs))
+          ]);
+        }
+      }
     }
-    const messages = subagent.state.messages;
-    deps.log(`[Subagent ${task.name}] Total messages: ${messages.length}`);
+    const allMessages = subagent.state.messages;
+    const messages = allMessages.slice(baseline);
+    deps.log(`[Subagent ${task.name}] Total messages: ${allMessages.length} (${messages.length} new)`);
     const lastAssistant = [...messages].reverse().find((m) => m?.role === "assistant");
     const terminalStopReason = lastAssistant?.stopReason;
     const terminalError = typeof lastAssistant?.errorMessage === "string" ? lastAssistant.errorMessage : void 0;
@@ -1891,6 +2202,29 @@ ${formatSkillsForPrompt(deps.skills ?? [])}`;
     if (heartbeat) {
       clearInterval(heartbeat);
     }
+    const finalize = async () => {
+      try {
+        if (session) {
+          if (runStarted) session.runCount++;
+          session.lastUsedAt = Date.now();
+          session.revision++;
+          task.sessionRunCount = session.runCount;
+          await persistSubagentSession(deps, session, task);
+        }
+      } finally {
+        await releaseLease?.();
+        if (session) {
+          session.busy = false;
+          if (sessions) retainLiveSession(sessions, session, Math.max(1, deps.maxLiveSessions ?? DEFAULT_MAX_LIVE_SESSIONS));
+        }
+      }
+    };
+    if (!agentSettled && pendingRun) {
+      task.sessionBusy = true;
+      void pendingRun.then(finalize).catch((error) => deps.debugLog?.("session", "late session cleanup failed", { error: String(error) }));
+    } else {
+      await finalize();
+    }
   }
 }
 function buildParallelResult(tasks, totalDuration) {
@@ -1927,6 +2261,12 @@ function buildParallelResult(tasks, totalDuration) {
       resultText += `Evidence: ${task.evidence.slice(0, 5).map((entry) => `${entry.type}:${entry.value}`).join("; ")}
 `;
     }
+    if (task.sessionId) {
+      resultText += task.sessionBusy ? `Session: ${task.sessionId} (busy \u2014 previous run is still settling; recall will fail until it settles` : `Session: ${task.sessionId} (resumable \u2014 pass as "sessionId" in a later spawn to continue this subagent with its accumulated context`;
+      if (task.sessionRunCount) resultText += `; run ${task.sessionRunCount}`;
+      if (task.sessionPersisted) resultText += "; persisted to disk, survives restarts";
+      resultText += ")\n";
+    }
     if (task.mode === "edit") {
       resultText += "Parent follow-up: review changes and validate reported tests. Partial edits are preserved on failure; no automatic rollback or task retry.\n";
     } else if (task.needsParentWrite) {
@@ -1951,7 +2291,8 @@ function normalizeTaskDefs(args) {
     return { error: "Invalid spawn_subagents_parallel arguments: tasks must be a non-empty array." };
   }
   const normalized = [];
-  const allowedFields = [...TASK_FIELD_ALIASES, "name", "priority", "timeout", "model", "thinkingLevel", "mode"];
+  const allowedFields = [...TASK_FIELD_ALIASES, "name", "priority", "timeout", "model", "thinkingLevel", "mode", "sessionId"];
+  const seenSessionIds = /* @__PURE__ */ new Set();
   for (const [index, def] of taskDefs.entries()) {
     if (!def || typeof def !== "object") {
       return { error: `Invalid task #${index + 1}: expected an object with the objective in "task" (aliases "description"/"prompt"/"objective" accepted).` };
@@ -1984,6 +2325,16 @@ function normalizeTaskDefs(args) {
     if (def.thinkingLevel !== void 0 && (typeof def.thinkingLevel !== "string" || !SUBAGENT_THINKING_LEVELS.includes(def.thinkingLevel))) {
       return { error: `Invalid task #${index + 1}: "thinkingLevel" must be one of ${SUBAGENT_THINKING_LEVELS.map((level) => `"${level}"`).join(", ")}.` };
     }
+    const sessionId = typeof def.sessionId === "string" && def.sessionId.trim() ? def.sessionId.trim() : void 0;
+    if (def.sessionId !== void 0 && !sessionId) {
+      return { error: `Invalid task #${index + 1}: "sessionId" must be a non-empty session id from an earlier result's Session line.` };
+    }
+    if (sessionId) {
+      if (seenSessionIds.has(sessionId)) {
+        return { error: `Invalid task #${index + 1}: duplicate "sessionId" "${sessionId}" \u2014 recalls to the same session must run in separate calls.` };
+      }
+      seenSessionIds.add(sessionId);
+    }
     normalized.push({
       name: typeof def.name === "string" && def.name.trim() ? def.name.trim() : void 0,
       task,
@@ -1991,7 +2342,10 @@ function normalizeTaskDefs(args) {
       mode: def.mode ?? "read",
       timeoutSeconds,
       modelOverride,
-      thinkingLevel: def.thinkingLevel
+      thinkingLevel: def.thinkingLevel,
+      sessionId,
+      requestedMode: def.mode,
+      requestedTimeoutSeconds: "timeout" in def ? timeoutSeconds : void 0
     });
   }
   if (normalized.length !== 1 && normalized.some((task) => task.mode === "edit")) {
@@ -2000,6 +2354,7 @@ function normalizeTaskDefs(args) {
   return normalized;
 }
 var DEFAULT_MAX_CONCURRENT_SUBAGENTS = 4;
+var taskIdCounter = 0;
 async function runWithConcurrencyLimit(jobs, limit) {
   let next = 0;
   const workers = Array.from({ length: Math.max(1, Math.min(limit, jobs.length)) }, async () => {
@@ -2011,6 +2366,13 @@ async function runWithConcurrencyLimit(jobs, limit) {
   await Promise.all(workers);
 }
 function createSubagentCapability(deps) {
+  const liveSessions = /* @__PURE__ */ new Map();
+  if (deps.sessionStore?.sweep) {
+    try {
+      void Promise.resolve(deps.sessionStore.sweep({ maxAgeMs: DEFAULT_SESSION_STORE_MAX_AGE_MS, maxRecords: DEFAULT_SESSION_STORE_MAX_RECORDS })).catch(() => void 0);
+    } catch {
+    }
+  }
   const spawnParallelTool = {
     name: "spawn_subagents_parallel",
     label: "Spawn Subagents",
@@ -2023,7 +2385,9 @@ Arguments shape (each tasks[] item puts the objective in "task" \u2014 "descript
 
 "model" overrides the automatic model-class selection for that task when the user explicitly asks for a specific model (e.g. "anthropic/claude-..."). Prefer "provider/model-id"; a bare model id works only when it is unambiguous across providers. When the override cannot be resolved, the task falls back to automatic selection and reports why.
 
-"thinkingLevel" defaults to "medium"; set it only when the user asks (e.g. "xhigh" for deep review) or for cheap lookup tasks ("off"). Non-reasoning models ignore it.`,
+"thinkingLevel" defaults to "medium"; set it only when the user asks (e.g. "xhigh" for deep review) or for cheap lookup tasks ("off"). Non-reasoning models ignore it.
+
+Sessions: every task that starts execution returns a Session id (persisted to disk when the host supports it). Pass "sessionId" in a later call to continue that subagent with its accumulated context \u2014 cheaper than re-briefing a fresh agent for iterative work on the same area. A recall may override "mode" (including upgrading read\u2192edit), "model", and "thinkingLevel": the session is reconfigured with freshly resolved tools and credentials. Recalls never replay on failure, and a session runs one task at a time. Prefer a FRESH task for independent reviews \u2014 accumulated context anchors judgment, and each recall carries the whole transcript.`,
     parameters: Type.Object({
       tasks: Type.Array(
         Type.Object(
@@ -2037,9 +2401,10 @@ Arguments shape (each tasks[] item puts the objective in "task" \u2014 "descript
             priority: Type.Optional(Type.Union([Type.Literal("fast"), Type.Literal("thorough")], { description: "fast uses lower-cost defaults; thorough raises model class when needed." })),
             model: Type.Optional(Type.String({ description: 'Explicit model override for this task, e.g. "provider/model-id". Only set when the user explicitly requests a specific model; otherwise Pie picks the model class automatically.' })),
             thinkingLevel: Type.Optional(Type.Union([Type.Literal("off"), Type.Literal("minimal"), Type.Literal("low"), Type.Literal("medium"), Type.Literal("high"), Type.Literal("xhigh")], { description: `Reasoning level for this task. Default: "medium". Only override when the user asks (e.g. "xhigh" for deep review tasks, "off" for cheap lookups). Ignored by non-reasoning models.` })),
-            timeout: Type.Optional(Type.Number({ description: "Timeout in seconds. Default: 1200s (20 minutes). For longer tasks, explicitly set a higher value, e.g. 3600." }))
+            timeout: Type.Optional(Type.Number({ description: "Timeout in seconds. Default: 1200s (20 minutes). For longer tasks, explicitly set a higher value, e.g. 3600." })),
+            sessionId: Type.Optional(Type.String({ description: "Resume a previous subagent session by id (from an earlier result's Session line). The session's accumulated transcript is reused \u2014 cheaper for iterative work on the same area. Optional mode/model/thinkingLevel on a recall RECONFIGURE the session with freshly resolved tools and credentials (read sessions may be upgraded to edit). Recalls never replay on failure and must target an idle session." }))
           },
-          { additionalProperties: false, description: "Objective goes in 'task' (or an accepted alias); plus optional name/priority/model/thinkingLevel/timeout." }
+          { additionalProperties: false, description: "Objective goes in 'task' (or an accepted alias); plus optional name/priority/model/thinkingLevel/timeout/sessionId." }
         ),
         { description: "Array of tasks to run in parallel; at least one of task/description/prompt/objective must be a non-empty string per item.", minItems: 1, maxItems: 10 }
       )
@@ -2066,7 +2431,9 @@ Arguments shape (each tasks[] item puts the objective in "task" \u2014 "descript
         };
       }
       const tasks = normalized.map((def, index) => ({
-        id: `subagent-${Date.now()}-${index}`,
+        // Date.now()+index alone collides when two spawn calls land in the
+        // same millisecond (ids double as session ids and store filenames).
+        id: `subagent-${Date.now().toString(36)}-${(++taskIdCounter).toString(36)}${Math.random().toString(36).slice(2, 6)}-${index}`,
         name: def.name || `Task-${index + 1}`,
         status: "pending",
         task: def.task,
@@ -2075,6 +2442,10 @@ Arguments shape (each tasks[] item puts the objective in "task" \u2014 "descript
         timeoutSeconds: def.timeoutSeconds,
         modelOverride: def.modelOverride,
         thinkingLevel: def.thinkingLevel,
+        sessionId: def.sessionId,
+        requestedMode: def.requestedMode,
+        requestedTimeoutSeconds: def.requestedTimeoutSeconds,
+        batchSize: normalized.length,
         evidence: [],
         confidenceSignals: [],
         uncertainty: "medium",
@@ -2088,8 +2459,8 @@ Arguments shape (each tasks[] item puts the objective in "task" \u2014 "descript
       toolContext.reportProgress?.({ message: `Launching ${tasks.length} parallel subagents...`, increment: 5 });
       const startTime = Date.now();
       const runTask = async (task) => {
-        await runSubagentWithProgress(deps, task, toolContext.reportProgress, signal);
-        if (task.mode !== "read" || task.status !== "failed" || !task.error) return;
+        await runSubagentWithProgress(deps, task, toolContext.reportProgress, signal, liveSessions);
+        if (task.wasRecall || task.mode !== "read" || task.status !== "failed" || !task.error) return;
         if (signal?.aborted) return;
         if (!isRetryableSubagentFailure(task.error)) return;
         const settleMs = Math.max(0, (deps.transientRetryBackoffMs ?? 2e3) * 10);
@@ -2104,7 +2475,10 @@ Arguments shape (each tasks[] item puts the objective in "task" \u2014 "descript
         task.result = void 0;
         task.details = void 0;
         task.parentHandoffRequired = false;
-        await runSubagentWithProgress(deps, task, toolContext.reportProgress, signal);
+        task.sessionId = void 0;
+        task.requestedMode = void 0;
+        task.wasRecall = void 0;
+        await runSubagentWithProgress(deps, task, toolContext.reportProgress, signal, liveSessions);
       };
       await runWithConcurrencyLimit(
         tasks.map((task) => () => runTask(task)),
@@ -2122,6 +2496,9 @@ Arguments shape (each tasks[] item puts the objective in "task" \u2014 "descript
             name: task.name,
             status: task.status,
             mode: task.mode,
+            sessionId: task.sessionId,
+            sessionRunCount: task.sessionRunCount,
+            sessionPersisted: task.sessionPersisted,
             task: task.task,
             timeoutSeconds: task.timeoutSeconds,
             plan: task.plan,
@@ -5967,6 +6344,7 @@ var AgentSessionRetryController = class {
   /** Total attempts across kinds in this recovery episode, for reporting. */
   totalRetryAttempts = 0;
   retryTimer;
+  retryEpoch = 0;
   pendingRetry;
   resolvePendingRetry;
   get policy() {
@@ -6022,18 +6400,26 @@ var AgentSessionRetryController = class {
     const rawDelayMs = (this.retry.baseDelayMs ?? 2e3) * 2 ** (attempt - 1);
     const delayMs = this.retry.maxDelayMs !== void 0 ? Math.min(rawDelayMs, this.retry.maxDelayMs) : rawDelayMs;
     this.ensurePending();
+    const epoch = this.retryEpoch;
+    const pending = this.pendingRetry;
     this.setRecoveryState("retry_pending");
     this.emit({ type: "turn_recovery_pending", recovery: "retry", failure, attempt, maxRetries, delayMs });
+    if (epoch !== this.retryEpoch) return;
     this.emit({ type: "retry_scheduled", errorMessage: failure.message, attempt, maxRetries, delayMs });
+    if (epoch !== this.retryEpoch) return;
     this.cancelTimerOnly();
     const setTimer = this.retry.setTimeout ?? defaultSetTimeout4;
     this.retryTimer = setTimer(() => {
+      if (epoch !== this.retryEpoch) return;
       this.retryTimer = void 0;
       this.setRecoveryState("retrying");
       this.emit({ type: "retry_start", attempt, maxRetries });
+      if (epoch !== this.retryEpoch) return;
       this.emit({ type: "turn_retry_started", attempt, maxRetries, failure });
+      if (epoch !== this.retryEpoch) return;
       this.removeTrailingAssistantError();
       void this.continueTurn().catch((error) => {
+        if (epoch !== this.retryEpoch || pending !== this.pendingRetry) return;
         const errorMessage = error instanceof Error ? error.message : String(error);
         const terminalFailure = asTerminalFailure(failure, errorMessage);
         this.emit({
@@ -6045,7 +6431,7 @@ var AgentSessionRetryController = class {
         this.emit({ type: "turn_settled" });
         this.resetAttempts();
         this.setRecoveryState("terminal");
-        this.resolvePending();
+        this.resolvePending(pending);
       });
     }, delayMs);
   }
@@ -6077,6 +6463,7 @@ var AgentSessionRetryController = class {
     this.resolvePending();
   }
   cancel() {
+    this.retryEpoch++;
     this.cancelTimerOnly();
     this.resetAttempts();
     this.resolvePending();
@@ -6101,7 +6488,8 @@ var AgentSessionRetryController = class {
       this.resolvePendingRetry = resolve3;
     });
   }
-  resolvePending() {
+  resolvePending(expected = this.pendingRetry) {
+    if (expected !== this.pendingRetry) return;
     const resolve3 = this.resolvePendingRetry;
     this.pendingRetry = void 0;
     this.resolvePendingRetry = void 0;
@@ -6435,6 +6823,8 @@ async function handleAgentSessionTurnEndRuntimePolicies(params) {
   if (params.disposed || params.runtimeGuardTriggered) {
     return;
   }
+  const startedGeneration = params.getCurrentGeneration?.();
+  const isStale = () => params.getCurrentGeneration !== void 0 && params.getCurrentGeneration() !== startedGeneration;
   const failure = classifyControllerTurnFailure({
     message: params.message,
     retry: params.retry,
@@ -6454,6 +6844,7 @@ async function handleAgentSessionTurnEndRuntimePolicies(params) {
     message: params.message,
     messages: params.agent.state.messages.slice()
   });
+  if (isStale()) return;
   if (failure?.compactable) {
     params.scheduleAutoCompact(compactDecision ?? { reason: "overflow", willRetry: true }, failure);
     return;
@@ -6472,14 +6863,18 @@ async function handleAgentSessionTurnEndRuntimePolicies(params) {
       return;
     }
     await params.handleRetryTurnEnd(params.message, failure);
+    if (isStale()) return;
     params.setRecoveryState("terminal");
     params.emit({ type: "turn_failed_terminal", failure: asTerminalFailure(failure), message: params.message });
+    if (isStale()) return;
     params.emit({ type: "turn_settled" });
     return;
   }
   await params.handleRetryTurnEnd(params.message);
+  if (isStale()) return;
   if (isAssistantTerminalCompletion(params.message)) {
     params.emit({ type: "turn_completed", message: params.message, toolResults: params.toolResults });
+    if (isStale()) return;
     const postTurnCompactDecision = compactDecision ?? params.getAutoCompactDecision?.({
       agent: params.agent,
       sessionManager: params.sessionManager,
@@ -6487,6 +6882,7 @@ async function handleAgentSessionTurnEndRuntimePolicies(params) {
       message: params.message,
       messages: params.agent.state.messages.slice()
     });
+    if (isStale()) return;
     if (postTurnCompactDecision?.reason === "threshold") {
       params.scheduleAutoCompact(postTurnCompactDecision);
       return;
@@ -6734,6 +7130,8 @@ var AgentSessionController = class {
     try {
       this.generation++;
       this.cancelScheduledWork();
+      this.recoveryState = "none";
+      this.pendingCompactionFailure = void 0;
       this.pendingEndOperations.clear();
       const activeSession = this.sessionManager.getActiveSession();
       this.agent.sessionId = activeSession?.id;
@@ -6964,16 +7362,20 @@ var AgentSessionController = class {
         this.emit({ type: "turn_policy_error", message: String(error) });
       }));
       this.recordLifecycle({ type: "turn_end_success" });
-      this.pendingEndOperations.track(() => this.handleTurnEndRuntimePolicies(event.message, event.toolResults).catch((error) => handleTurnEndPolicyThrow((event2) => this.emit(event2), error, {
-        recoveryWasActive: this.isRecoveryActive(),
-        cancelPendingRecovery: () => {
-          this.retryController.cancel();
-          this.autoCompact.cancel();
-        },
-        markRecoveryTerminal: () => {
-          this.recoveryState = "terminal";
-        }
-      })));
+      const generation = this.generation;
+      this.pendingEndOperations.track(() => this.handleTurnEndRuntimePolicies(event.message, event.toolResults).catch((error) => {
+        if (generation !== this.generation || this.disposed) return;
+        handleTurnEndPolicyThrow((event2) => this.emit(event2), error, {
+          recoveryWasActive: this.isRecoveryActive(),
+          cancelPendingRecovery: () => {
+            this.retryController.cancel();
+            this.autoCompact.cancel();
+          },
+          markRecoveryTerminal: () => {
+            this.recoveryState = "terminal";
+          }
+        });
+      }));
     }
     if (event.type === "agent_end") {
       this.recordLifecycle({ type: "agent_end" });
@@ -7027,6 +7429,7 @@ var AgentSessionController = class {
       getAutoCompactDecision: this.getAutoCompactDecision,
       classifyFailure: this.classifyFailure,
       retry: this.retryController.policy,
+      getCurrentGeneration: () => this.generation,
       emit: (event) => this.emit(event),
       setRecoveryState: (state) => {
         this.recoveryState = state;
@@ -7348,10 +7751,11 @@ var AttentionCoordinator = class {
     this.userWork = false;
     if (event.outcome === "cancelled") this.clear();
     else if (event.outcome === "failed" || event.outcome === "blocked") this.request(event, event.outcome);
-    else if (this.policy.completion === "accepted-user-work" && userWork) this.request(event, "completed");
+    else if (this.policy.completion === "always" || this.policy.completion === "user-initiated" && userWork) this.request(event, "completed");
   }
-  /** Call at actual accepted human delivery, including steer/retry; never infer from message role. */
-  acceptUserWork(identity) {
+  /** Record accepted human delivery for "user-initiated" completion attention
+   * (including steer/retry); never infer from a message role. */
+  markUserInitiated(identity) {
     if (this.disposed || !same(this.current, identity) || this.consumed) return false;
     this.userWork = true;
     return true;
@@ -10352,6 +10756,9 @@ function leadingWhitespace(line) {
   const match2 = line.match(/^[ \t]*/);
   return match2 ? match2[0] : "";
 }
+function stripLeadingWhitespace(line) {
+  return line.replace(/^[ \t]*/, "");
+}
 var RelaxedWindow;
 ((RelaxedWindow2) => {
   RelaxedWindow2.EMPTY_MAP = /* @__PURE__ */ new Map();
@@ -10495,7 +10902,7 @@ function reindentNewText(newText, qLines, fileLines, window) {
     }
     const nPos = nPosOfLine.get(i) ?? 0;
     const qPos = counterpart.get(nPos) ?? 0;
-    result.push(qIndent(qIdx[qPos] ?? qIdx[0]) + newLines[i].trim());
+    result.push(qIndent(qIdx[qPos] ?? qIdx[0]) + stripLeadingWhitespace(newLines[i]));
   }
   return result.join("\n");
 }
@@ -17347,6 +17754,7 @@ export {
   modalityForReadFileUnderstandingKind,
   createReadFileUnderstandingHandler,
   formatSkillSummariesForPrompt,
+  SUBAGENT_SESSION_RECORD_VERSION,
   classifyShellCommand,
   interpretShellExit,
   createSubagentCapability,