nexu-io
diff --git a/‎apps/daemon/src/acp.ts‎
Lines changed: 40 additions & 9 deletions b/‎apps/daemon/src/acp.ts‎
Lines changed: 40 additions & 9 deletions
diff --git a/‎apps/daemon/src/agent-session-resume.ts‎
Lines changed: 176 additions & 12 deletions b/‎apps/daemon/src/agent-session-resume.ts‎
Lines changed: 176 additions & 12 deletions
@@ -93,6 +93,12 @@ interface AttachAcpSessionOptions {
   stageTimeoutMs?: number;
   executionProfile?: ExecutionProfile;
   modelUnavailableErrorCode?: 'AMR_MODEL_UNAVAILABLE';
+  // When set, resume an existing upstream session instead of creating a new
+  // one: the handshake sends `session/load { sessionId }` (the durable handle
+  // captured from a prior run via `getDurableSessionId()`) rather than
+  // `session/new`. The agent verifies the session and, if it is gone, returns a
+  // structured `resume_failed` error the caller maps to its reseed path.
+  resumeSessionId?: string | null;
   // Subsegment timing markers for spawn->first-token attribution (#3408 §4).
   // `onCliReady` fires once on the first well-formed ACP JSON-RPC message
   // (the CLI is up and speaking the protocol); `onSessionInit` fires once when
@@ -917,6 +923,7 @@ export function attachAcpSession({
   stageTimeoutMs = DEFAULT_STAGE_TIMEOUT_MS,
   executionProfile = 'filesystem',
   modelUnavailableErrorCode,
+  resumeSessionId,
   onCliReady,
   onSessionInit,
 }: AttachAcpSessionOptions) {
@@ -932,6 +939,11 @@ export function attachAcpSession({
   let promptRequestId: JsonRpcId | null = null;
   let setModelRequestId: JsonRpcId | null = null;
   let sessionId: string | null = null;
+  // The durable upstream session handle reported by the agent on session/new or
+  // session/load (vela's `openCodeSessionId`). The caller stores it per
+  // conversation to resume next turn. Distinct from `sessionId`, which is the
+  // ACP wrapper id ("vela-opencode-1").
+  let durableSessionId: string | null = null;
   let activeModel: string | null = null;
   let modelConfigId: string | null = null;
   let emittedThinkingStart = false;
@@ -1477,20 +1489,33 @@ export function attachAcpSession({
     }
     if (expectedId === 1) {
       expectedId = nextId;
-      writeRpc(
-        nextId,
-        'session/new',
-        buildAcpSessionNewParams(
-          effectiveCwd,
-          mcpServers ? { mcpServers, envFormat } : { envFormat },
-        ),
-        'session/new',
-      );
+      if (resumeSessionId) {
+        // Resume the prior upstream session instead of creating a fresh one.
+        writeRpc(
+          nextId,
+          'session/load',
+          { sessionId: resumeSessionId, cwd: effectiveCwd },
+          'session/load',
+        );
+      } else {
+        writeRpc(
+          nextId,
+          'session/new',
+          buildAcpSessionNewParams(
+            effectiveCwd,
+            mcpServers ? { mcpServers, envFormat } : { envFormat },
+          ),
+          'session/new',
+        );
+      }
       nextId += 1;
       return;
     }
     if (expectedId === 2) {
       sessionId = typeof result.sessionId === 'string' ? result.sessionId : null;
+      // The durable handle for resuming this session on the next turn.
+      durableSessionId =
+        typeof result.openCodeSessionId === 'string' ? result.openCodeSessionId : null;
       // session/new acknowledged with a session id = handshake done (#3408 §4).
       if (sessionId) onSessionInit?.();
       const modelConfig = findModelConfigOption(result.configOptions);
@@ -1579,6 +1604,12 @@ export function attachAcpSession({
     hasFatalError() {
       return fatal;
     },
+    // The durable upstream session handle to persist for resume, or null when
+    // none was reported (older agents, or a handshake that never established a
+    // session). Mirrors pi-rpc's getLastSessionPath().
+    getDurableSessionId() {
+      return durableSessionId;
+    },
     completedSuccessfully() {
       // Returns true when the prompt request resolved without a fatal error
       // and was not aborted. The chat consumer treats this as a successful
 
@@ -5,41 +5,119 @@ import type Database from 'better-sqlite3';
 import {
   clearAgentSession,
   getAgentSessionRecord,
+  latestCompletedAssistantMessageId,
   upsertAgentSession,
 } from './db.js';
 
 type SqliteDb = Database.Database;
 
+/**
+ * Why a stored session was NOT resumed this turn. `null` means it WAS resumed
+ * (or there was no stored session to begin with). Surfaced for tests and
+ * analytics; the daemon reseeds the full transcript for every non-null reason.
+ */
+export type ResumeInvalidationReason =
+  | 'model_changed'
+  | 'cwd_changed'
+  | 'conversation_advanced'
+  | 'missing_cursor';
+
 export interface AgentResumeContext {
   /** Stored CLI session id to resume, or null when starting fresh. */
   resumeSessionId: string | null;
   /** Freshly minted UUID to open a new session with when not resuming. */
   newSessionId: string;
-  /** True when a prior session id exists for this (conversation, agent). */
+  /** True when a prior session id exists AND it is still safe to resume. */
   isResuming: boolean;
   /** Hash of the stable instruction block last sent on this session, or null. */
   storedStablePromptHash: string | null;
+  /** Set when a stored session existed but was rejected; see the type. */
+  invalidationReason: ResumeInvalidationReason | null;
 }
 
 export type CapturedAgentSessionResult = 'stored' | 'cleared' | 'skipped';
 
+/**
+ * Resume identity guard. A stored upstream session is only safe to continue
+ * (and to `skipTranscript` for) when the conversation has not changed shape
+ * under it. We reject the resume — forcing a fresh session reseeded with the
+ * full transcript — when:
+ *  - the model changed (the session was built under a different model),
+ *  - the cwd changed (different workspace identity), or
+ *  - the conversation advanced under the session: the assistant message the
+ *    session last produced is no longer the latest completed assistant turn
+ *    (another agent ran in between, or the message was edited/removed).
+ *
+ * The cursor is the session's own last assistant message id. At the next turn's
+ * resolve time the latest completed assistant message — excluding the current
+ * run's in-flight placeholder — must still be that id. A null stored cursor (row
+ * written before this guard shipped) cannot be verified, so it is treated as
+ * unsafe and reseeded once.
+ */
+export function evaluateResumeInvalidation(input: {
+  storedModel: string | null;
+  storedCwd: string | null;
+  storedLastMessageId: string | null;
+  currentModel: string | null;
+  currentCwd: string | null;
+  latestCompletedAssistantId: string | null;
+}): ResumeInvalidationReason | null {
+  if ((input.storedModel ?? null) !== (input.currentModel ?? null)) return 'model_changed';
+  if ((input.storedCwd ?? null) !== (input.currentCwd ?? null)) return 'cwd_changed';
+  if (input.storedLastMessageId == null) return 'missing_cursor';
+  if (input.latestCompletedAssistantId !== input.storedLastMessageId) {
+    return 'conversation_advanced';
+  }
+  return null;
+}
+
 /**
  * Decide whether a resume-capable adapter should continue its stored CLI
  * session or start a new one for this (conversation, agent). Pure read +
- * mint; the caller is responsible for persisting `newSessionId` when it
- * actually spawns a create turn.
+ * mint; the caller is responsible for persisting `newSessionId` (and the
+ * current model/cwd/cursor) when it actually spawns a create turn.
  */
 export function resolveAgentResumeContext(
   db: SqliteDb,
-  input: { conversationId: string; agentId: string },
+  input: {
+    conversationId: string;
+    agentId: string;
+    currentModel?: string | null;
+    currentCwd?: string | null;
+    /** The current run's in-flight assistant placeholder id, excluded from the
+     *  "latest completed assistant" cursor lookup. */
+    currentAssistantMessageId?: string | null;
+  },
 ): AgentResumeContext {
   const record = getAgentSessionRecord(db, input.conversationId, input.agentId);
-  const resumeSessionId = record?.sessionId ?? null;
+  const storedSessionId = record?.sessionId ?? null;
+  const invalidationReason =
+    storedSessionId != null
+      ? evaluateResumeInvalidation({
+          storedModel: record?.model ?? null,
+          storedCwd: record?.cwd ?? null,
+          storedLastMessageId: record?.lastMessageId ?? null,
+          currentModel: input.currentModel ?? null,
+          currentCwd: input.currentCwd ?? null,
+          // Admit the stored session's own last message id through the cursor
+          // filter so a resume-on-failure session (whose last turn FAILED but is
+          // resumable) still matches its cursor; a different later failed turn
+          // stays excluded and genuine advancement is still detected.
+          latestCompletedAssistantId: latestCompletedAssistantMessageId(
+            db,
+            input.conversationId,
+            input.currentAssistantMessageId ?? '',
+            record?.lastMessageId ?? null,
+          ),
+        })
+      : null;
+  const resumable = storedSessionId != null && invalidationReason == null;
   return {
-    resumeSessionId,
+    resumeSessionId: resumable ? storedSessionId : null,
     newSessionId: randomUUID(),
-    isResuming: resumeSessionId != null,
-    storedStablePromptHash: record?.stablePromptHash ?? null,
+    isResuming: resumable,
+    storedStablePromptHash: resumable ? (record?.stablePromptHash ?? null) : null,
+    invalidationReason,
   };
 }
 
@@ -58,6 +136,13 @@ export function persistCapturedAgentSession(
     agentId: string;
     sessionId: string | null;
     stablePromptHash?: string | null;
+    // Resume identity (see resolveAgentResumeContext). Must be stored alongside
+    // the captured session so the next turn can verify the session is still
+    // safe to resume; omitting them leaves a null cursor that the guard treats
+    // as `missing_cursor` and reseeds every turn.
+    model?: string | null;
+    cwd?: string | null;
+    lastMessageId?: string | null;
   },
 ): CapturedAgentSessionResult {
   if (!input.conversationId) return 'skipped';
@@ -67,6 +152,9 @@ export function persistCapturedAgentSession(
       agentId: input.agentId,
       sessionId: input.sessionId,
       stablePromptHash: input.stablePromptHash ?? null,
+      model: input.model ?? null,
+      cwd: input.cwd ?? null,
+      lastMessageId: input.lastMessageId ?? null,
     });
     return 'stored';
   }
@@ -147,9 +235,85 @@ export function computeIncludeStable(
   return !isResuming || storedStableHash !== currentStableHash;
 }
 
-/** True when CLI output indicates a resume target session is missing. */
-export function isClaudeResumeFailure(text: string): boolean {
+/**
+ * True when CLI output indicates a resume target session is missing. Prose
+ * signatures are matched on `stderr` (where Claude prints the failure); the
+ * version-stable structured `result` event is matched on `stdout` (the
+ * stream-json channel). We deliberately do NOT scan ordinary assistant stdout
+ * for the prose phrases — a successful turn whose model text happens to contain
+ * "session not found" must not be mistaken for a resume failure.
+ */
+export function isClaudeResumeFailure(stderr: string, stdout = ''): boolean {
+  if (stderr && CLAUDE_RESUME_FAILURE_PATTERNS.some((re) => re.test(stderr))) return true;
+  return stdout ? hasClaudeResumeFailureResultEvent(stdout) : false;
+}
+
+// Signature codex prints when `exec resume <thread_id>` targets a thread whose
+// rollout file is gone (pruned, ~/.codex/sessions cleared, machine moved):
+//   Error: thread/resume: thread/resume failed: no rollout found for thread id <id>
+// Verified against the installed Codex CLI. Like the Claude case this fails
+// locally before any model call, so clearing the stale handle and re-seeding
+// the transcript next turn is the correct, lossless recovery.
+const CODEX_RESUME_FAILURE_PATTERNS: RegExp[] = [
+  /no rollout found for thread id/i,
+  /thread\/resume failed/i,
+];
+
+/** True when codex CLI output indicates a resume target thread is missing. */
+export function isCodexResumeFailure(text: string): boolean {
+  if (!text) return false;
+  return CODEX_RESUME_FAILURE_PATTERNS.some((re) => re.test(text));
+}
+
+// Signature OpenCode prints when `run -s <id>` targets a session whose store is
+// gone (deleted, corrupted, different machine). Verified against the installed
+// OpenCode CLI: `run -s <well-formed-but-missing-id>` prints `Error: Session
+// not found` to stderr (and the HTTP path returns a `NotFoundError`). Like the
+// other CLIs this fails before any model call, so clearing the stale handle and
+// re-seeding the transcript next turn is the correct, lossless recovery.
+const OPENCODE_RESUME_FAILURE_PATTERNS: RegExp[] = [
+  /session not found/i,
+  /NotFoundError/,
+];
+
+/** True when OpenCode CLI output indicates a resume target session is missing. */
+export function isOpencodeResumeFailure(text: string): boolean {
   if (!text) return false;
-  if (CLAUDE_RESUME_FAILURE_PATTERNS.some((re) => re.test(text))) return true;
-  return hasClaudeResumeFailureResultEvent(text);
+  return OPENCODE_RESUME_FAILURE_PATTERNS.some((re) => re.test(text));
+}
+
+/**
+ * Per-agent dispatch for "the session/thread I asked to resume is gone".
+ * Generalizes the resume-fallback so every `resumesSessionViaCli` adapter
+ * routes through one decision point in server.ts. Unknown agents return false
+ * (no fallback) — a new resume-capable adapter must opt in here explicitly.
+ *
+ * Detection scans only the CLI's FAILURE channel, never successful assistant
+ * output: codex/opencode print their resume-miss to `stderr` (a generic phrase
+ * like OpenCode's "Session not found" must not be matched against the model's
+ * stdout, or a turn that merely *mentions* it would be falsely failed); Claude's
+ * prose is on stderr and its structured `result` marker on stdout.
+ */
+export function isAgentResumeFailure(
+  agentId: string,
+  stderr: string,
+  stdout = '',
+): boolean {
+  if (agentId === 'codex') return isCodexResumeFailure(stderr);
+  if (agentId === 'opencode') return isOpencodeResumeFailure(stderr);
+  if (agentId === 'amr') return isAmrResumeFailure(stdout);
+  // claude + codebuddy share Claude Code's stream-json result shape.
+  return isClaudeResumeFailure(stderr, stdout);
+}
+
+// vela (AMR) reports a missing resumed session as a structured ACP JSON-RPC
+// error `{"error":{"data":{"kind":"resume_failed",...}}}` on stdout (the
+// protocol channel). Match the structured marker — not a bare word — so a
+// model reply that merely mentions "resume_failed" cannot trip it.
+const AMR_RESUME_FAILURE_PATTERN = /"kind"\s*:\s*"resume_failed"/;
+
+/** True when vela's ACP output carries a resume_failed signal. */
+export function isAmrResumeFailure(stdout: string): boolean {
+  if (!stdout) return false;
+  return AMR_RESUME_FAILURE_PATTERN.test(stdout);
 }