@vellumai/assistant 0.12.2-staging.3 → 0.12.2-staging.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2-staging.3",
+  "version": "0.12.2-staging.4",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/acp/session-snapshot.ts

@@ -0,0 +1,260 @@
+import { desc, eq } from "drizzle-orm";
+
+import { getDb } from "../persistence/db-connection.js";
+import { acpSessionHistory } from "../persistence/schema/index.js";
+import { getLogger } from "../util/logger.js";
+import { acpAuthMarkerStillCurrent } from "./acp-auth-marker-store.js";
+import { getAcpSessionManager } from "./index.js";
+import type { AcpSessionManager } from "./session-manager.js";
+import type { AcpSessionState } from "./types.js";
+
+const log = getLogger("acp:session-snapshot");
+
+export interface AcpSessionSnapshot {
+  id: string;
+  agentId: string;
+  acpSessionId: string;
+  parentConversationId: string;
+  status: string;
+  startedAt: number;
+  completedAt?: number | null;
+  error?: string | null;
+  stopReason?: string | null;
+  task?: string;
+  parentToolUseId?: string;
+  authErrorCode?: string;
+  authErrorCredential?: string;
+  model?: string;
+  availableModels?: AcpSessionState["availableModels"];
+  modelRevisionEpoch?: string;
+  modelRevision?: number;
+  usedTokens?: number;
+  contextSize?: number;
+  costAmount?: number;
+  costCurrency?: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  eventLog?: unknown[];
+  source: "live" | "history";
+  resumable: boolean;
+  cwd?: string | null;
+}
+
+export interface AcpSessionSnapshotPage {
+  sessions: AcpSessionSnapshot[];
+  sawEveryHistoryRow: boolean;
+}
+
+interface SnapshotOptions {
+  includeEventLog?: boolean;
+}
+
+function fromLiveState(
+  state: AcpSessionState,
+  manager: AcpSessionManager,
+  opts: SnapshotOptions,
+): AcpSessionSnapshot {
+  return {
+    id: state.id,
+    agentId: state.agentId,
+    acpSessionId: state.acpSessionId,
+    parentConversationId: state.parentConversationId,
+    status: state.status,
+    startedAt: state.startedAt,
+    completedAt: state.completedAt ?? null,
+    error: state.error ?? null,
+    stopReason: state.stopReason ?? null,
+    task: state.task,
+    parentToolUseId: state.parentToolUseId,
+    authErrorCode: state.authErrorCode,
+    authErrorCredential: state.authErrorCredential,
+    model: state.model,
+    availableModels: state.availableModels,
+    modelRevisionEpoch: state.modelRevisionEpoch,
+    modelRevision: state.modelRevision,
+    usedTokens: state.latestUsage?.usedTokens,
+    contextSize: state.latestUsage?.contextSize,
+    costAmount: state.latestUsage?.costAmount,
+    costCurrency: state.latestUsage?.costCurrency,
+    inputTokens: state.latestUsage?.inputTokens,
+    outputTokens: state.latestUsage?.outputTokens,
+    eventLog: opts.includeEventLog
+      ? manager.getBufferedUpdates(state.id)
+      : undefined,
+    source: "live",
+    resumable: false,
+  };
+}
+
+function isResumableHistoryRow(
+  row: typeof acpSessionHistory.$inferSelect,
+): boolean {
+  return Boolean(row.cwd && row.acpSessionId);
+}
+
+export function snapshotHistoryRow(
+  row: typeof acpSessionHistory.$inferSelect,
+  opts: SnapshotOptions = { includeEventLog: true },
+): AcpSessionSnapshot {
+  let eventLog: unknown[] | undefined;
+  if (opts.includeEventLog !== false) {
+    eventLog = [];
+    try {
+      const parsed = JSON.parse(row.eventLogJson) as unknown;
+      if (Array.isArray(parsed)) {
+        eventLog = parsed;
+      }
+    } catch (err) {
+      log.warn(
+        { id: row.id, err },
+        "Failed to parse event_log_json for ACP session history row",
+      );
+    }
+  }
+
+  return {
+    id: row.id,
+    agentId: row.agentId,
+    acpSessionId: row.acpSessionId,
+    parentConversationId: row.parentConversationId,
+    status: row.status,
+    startedAt: row.startedAt,
+    completedAt: row.completedAt,
+    error: row.error,
+    stopReason: row.stopReason,
+    task: row.task ?? undefined,
+    parentToolUseId: row.parentToolUseId ?? undefined,
+    authErrorCode: row.authErrorCode ?? undefined,
+    authErrorCredential: row.authErrorCredential ?? undefined,
+    usedTokens: row.usedTokens ?? undefined,
+    contextSize: row.contextSize ?? undefined,
+    costAmount: row.costAmount ?? undefined,
+    costCurrency: row.costCurrency ?? undefined,
+    inputTokens: row.inputTokens ?? undefined,
+    outputTokens: row.outputTokens ?? undefined,
+    eventLog,
+    source: "history",
+    resumable: isResumableHistoryRow(row),
+    cwd: row.cwd,
+  };
+}
+
+/**
+ * Blank `authErrorCode` on any session whose marker no longer describes the
+ * credential its agent would resolve.
+ *
+ * This comparison is what retires a Connect card: the marker no longer
+ * describing the credential in use. Applied after merging rather than inside
+ * the query, so live sessions and history rows are judged by the same rule.
+ *
+ * Resolved per agent and memoised across the batch, because precedence is per
+ * agent and each resolution costs a vault read.
+ */
+export async function withCurrentAuthMarkers<
+  T extends {
+    agentId: string;
+    authErrorCode?: string;
+    authErrorCredential?: string;
+  },
+>(
+  sessions: readonly T[],
+  resolvedFor: (agentId: string) => Promise<string | undefined>,
+): Promise<T[]> {
+  if (!sessions.some((session) => session.authErrorCode !== undefined)) {
+    return [...sessions];
+  }
+  const resolvedByAgent = new Map<string, string | undefined>();
+  const resolve = async (agentId: string) => {
+    if (!resolvedByAgent.has(agentId)) {
+      resolvedByAgent.set(agentId, await resolvedFor(agentId));
+    }
+    return resolvedByAgent.get(agentId);
+  };
+  const judged: T[] = [];
+  for (const session of sessions) {
+    if (session.authErrorCode === undefined) {
+      judged.push(session);
+      continue;
+    }
+    const current = acpAuthMarkerStillCurrent(
+      session.authErrorCredential,
+      await resolve(session.agentId),
+    );
+    judged.push(
+      current ? session : { ...session, authErrorCode: undefined },
+    );
+  }
+  return judged;
+}
+
+export function getAcpSessionSnapshot(
+  acpSessionId: string,
+  opts: SnapshotOptions = {},
+): AcpSessionSnapshot | undefined {
+  const manager = getAcpSessionManager();
+  const snapshotOptions = {
+    includeEventLog: opts.includeEventLog ?? true,
+  };
+  const live = (manager.getStatus() as AcpSessionState[]).find(
+    (state) => state.id === acpSessionId,
+  );
+  if (live) {
+    return fromLiveState(live, manager, snapshotOptions);
+  }
+
+  const row = getDb()
+    .select()
+    .from(acpSessionHistory)
+    .where(eq(acpSessionHistory.id, acpSessionId))
+    .get();
+  return row ? snapshotHistoryRow(row, snapshotOptions) : undefined;
+}
+
+export function listAcpSessionSnapshots(opts: {
+  limit: number;
+  conversationId?: string;
+  includeEventLog?: boolean;
+}): AcpSessionSnapshotPage {
+  const manager = getAcpSessionManager();
+  const inMemory = manager.getStatus() as AcpSessionState[];
+  const snapshotOptions = {
+    includeEventLog: opts.includeEventLog ?? true,
+  };
+
+  const merged = new Map<string, AcpSessionSnapshot>();
+  for (const state of inMemory) {
+    if (
+      opts.conversationId &&
+      state.parentConversationId !== opts.conversationId
+    ) {
+      continue;
+    }
+    merged.set(state.id, fromLiveState(state, manager, snapshotOptions));
+  }
+
+  const db = getDb();
+  const baseQuery = db.select().from(acpSessionHistory);
+  const filtered = opts.conversationId
+    ? baseQuery.where(
+        eq(acpSessionHistory.parentConversationId, opts.conversationId),
+      )
+    : baseQuery;
+  const historyLimit = opts.limit + merged.size;
+  const historyRows = filtered
+    .orderBy(desc(acpSessionHistory.startedAt))
+    .limit(historyLimit)
+    .all();
+
+  for (const row of historyRows) {
+    if (!merged.has(row.id)) {
+      merged.set(row.id, snapshotHistoryRow(row, snapshotOptions));
+    }
+  }
+
+  return {
+    sessions: Array.from(merged.values()).sort(
+      (a, b) => b.startedAt - a.startedAt,
+    ),
+    sawEveryHistoryRow: historyRows.length < historyLimit,
+  };
+}

package/src/config/bundled-skills/acp/SKILL.md

@@ -125,5 +125,5 @@ Default to the conversation's current working directory when spawning an agent.
 
 - The spawned agent runs autonomously with its own tools, file editing, and terminal access.
 - Results are streamed back and injected into the conversation when the agent completes.
-- Use `acp_status` to check on running agents and `acp_abort` to stop them.
+- Use `acp_status` to inspect running and idle agents. Use `acp_steer` to attempt follow-up work on an idle session; do not replace it with a new `acp_spawn`.
 - The `cwd` parameter controls where the agent works - set it to the project root the user wants the agent to operate in.

package/src/config/bundled-skills/acp/TOOLS.json

@@ -33,7 +33,7 @@
     },
     {
       "name": "acp_status",
-      "description": "Get the status of a specific ACP session or list all ACP sessions. Only use this when the user explicitly asks about ACP session status - do NOT poll automatically, as you will be notified when sessions complete.",
+      "description": "Get the status of a specific ACP session or list recent ACP sessions. Cleanly completed sessions with durable resume metadata are returned as idle; use `acp_steer` to attempt follow-up work on them instead of starting over with `acp_spawn`. Only use this when the user explicitly asks about ACP session status - do NOT poll automatically, as you will be notified when sessions complete.",
       "category": "orchestration",
       "risk": "low",
       "input_schema": {
@@ -41,7 +41,7 @@
         "properties": {
           "acp_session_id": {
             "type": "string",
-            "description": "Optional ACP session ID to query. If omitted, returns all ACP sessions."
+            "description": "Optional ACP session ID to query. If omitted, returns recent ACP sessions, including active and resumable idle sessions."
           }
         },
         "required": []

package/src/notifications/__tests__/decision-engine.test.ts

@@ -736,3 +736,178 @@ describe("schedule.result pass-through in notification decision engine", () => {
     expect(decision.shouldNotify).toBe(true);
   });
 });
+
+const SCHEDULER_OWNED_REPORT = [
+  "# Daily briefing",
+  "",
+  "## Overnight",
+  "- Calendar is clear until 10:00.",
+  "- Two pull requests are waiting on review.",
+  "",
+  "## Account security",
+  "- Urgent: a sign-in from a new device needs confirmation before the weekly sync.",
+  "",
+  "## This week",
+  "- Project kickoff on Wednesday.",
+  "- Weekly planning on Friday.",
+  "- Follow up on the draft status update.",
+].join("\n");
+
+function makeSchedulerShareSignal(
+  overrides?: Partial<NotificationSignal>,
+): NotificationSignal {
+  return {
+    signalId: "sig-scheduler-share-test-1",
+    createdAt: Date.now(),
+    sourceChannel: "scheduler",
+    sourceContextId: "conv-xyz",
+    sourceEventName: "assistant.share",
+    contextPayload: {
+      requestedMessage: SCHEDULER_OWNED_REPORT,
+      requestedBySource: "scheduler",
+      requestedTitle: "Your day",
+    },
+    attentionHints: {
+      requiresAction: true,
+      urgency: "high",
+      isAsyncBackground: true,
+      visibleInSourceNow: false,
+    },
+    ...overrides,
+  };
+}
+
+describe("scheduler requested-message pass-through in notification decision engine", () => {
+  beforeEach(() => {
+    persistedDecisions = [];
+  });
+
+  test("keeps a scheduler-owned report verbatim on every urgency-selected channel", async () => {
+    const available = [
+      "vellum",
+      "telegram",
+      "platform",
+    ] as NotificationChannel[];
+    const decision = await evaluateSignal(
+      makeSchedulerShareSignal(),
+      available,
+    );
+
+    expect(decision.shouldNotify).toBe(true);
+    expect(decision.selectedChannels).toEqual(available);
+    expect(decision.reasoningSummary).toBe(
+      "scheduler requested-message pass-through",
+    );
+    expect(decision.verbatimCopy).toBe(true);
+    expect(decision.fallbackUsed).toBe(false);
+    for (const ch of available) {
+      expect(decision.renderedCopy[ch]?.title).toBe("Your day");
+      expect(decision.renderedCopy[ch]?.body).toBe(SCHEDULER_OWNED_REPORT);
+      expect(decision.renderedCopy[ch]?.conversationSeedMessage).toBe(
+        SCHEDULER_OWNED_REPORT,
+      );
+    }
+  });
+
+  test("copies the complete report onto the urgency-narrowed channel set", async () => {
+    const available = [
+      "vellum",
+      "telegram",
+      "platform",
+    ] as NotificationChannel[];
+    const decision = await evaluateSignal(
+      makeSchedulerShareSignal({
+        attentionHints: {
+          requiresAction: false,
+          urgency: "medium",
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+      }),
+      available,
+    );
+
+    expect(decision.shouldNotify).toBe(true);
+    expect(decision.selectedChannels).toEqual(["vellum"]);
+    expect(decision.reasoningSummary).toBe(
+      "scheduler requested-message pass-through",
+    );
+    expect(decision.renderedCopy.vellum?.body).toBe(SCHEDULER_OWNED_REPORT);
+    expect(decision.renderedCopy.vellum?.conversationSeedMessage).toBe(
+      SCHEDULER_OWNED_REPORT,
+    );
+    expect(decision.renderedCopy.telegram?.body).toBe(SCHEDULER_OWNED_REPORT);
+    expect(decision.renderedCopy.platform?.body).toBe(SCHEDULER_OWNED_REPORT);
+  });
+
+  test("leaves an unowned scheduler requestedMessage on the model path", async () => {
+    const previousSendMessage = providerSendMessage;
+    let providerCalled = false;
+    providerSendMessage = async () => {
+      providerCalled = true;
+      return {};
+    };
+
+    try {
+      const decision = await evaluateSignal(
+        makeSchedulerShareSignal({
+          contextPayload: {
+            requestedMessage: SCHEDULER_OWNED_REPORT,
+            requestedTitle: "Your day",
+          },
+        }),
+        ["vellum", "telegram", "platform"] as NotificationChannel[],
+      );
+
+      expect(providerCalled).toBe(true);
+      expect(decision.verbatimCopy).toBeUndefined();
+      expect(decision.reasoningSummary).not.toBe(
+        "scheduler requested-message pass-through",
+      );
+    } finally {
+      providerSendMessage = previousSendMessage;
+    }
+  });
+
+  test("leaves scheduler notify-mode without the ownership marker on the model path", async () => {
+    const previousSendMessage = providerSendMessage;
+    let providerCalled = false;
+    providerSendMessage = async () => {
+      providerCalled = true;
+      return {};
+    };
+
+    try {
+      const decision = await evaluateSignal(
+        {
+          signalId: "sig-schedule-notify-test-1",
+          createdAt: Date.now(),
+          sourceChannel: "scheduler",
+          sourceContextId: "sched-notify-1",
+          sourceEventName: "schedule.notify",
+          contextPayload: {
+            scheduleId: "sched-notify-1",
+            label: "Take out the trash",
+            message: "Take out the trash",
+          },
+          attentionHints: {
+            requiresAction: true,
+            urgency: "high",
+            isAsyncBackground: false,
+            visibleInSourceNow: false,
+          },
+        },
+        ["vellum", "telegram", "platform"] as NotificationChannel[],
+      );
+
+      expect(providerCalled).toBe(true);
+      expect(decision.verbatimCopy).toBeUndefined();
+      expect(decision.reasoningSummary).not.toBe(
+        "scheduler requested-message pass-through",
+      );
+      expect(decision.reasoningSummary).not.toBe("schedule_result pass-through");
+    } finally {
+      providerSendMessage = previousSendMessage;
+    }
+  });
+});

package/src/notifications/decision-engine.ts

@@ -833,6 +833,19 @@ function buildPassThroughDecision(params: {
   return decision;
 }
 
+function selectDefaultChannelsByUrgency(
+  urgency: NotificationSignal["attentionHints"]["urgency"],
+  availableChannels: NotificationChannel[],
+): NotificationChannel[] {
+  const isUrgent = urgency === "critical" || urgency === "high";
+  if (isUrgent) {
+    return [...availableChannels];
+  }
+  return availableChannels.includes("vellum")
+    ? ["vellum" as NotificationChannel]
+    : [];
+}
+
 /**
  * The deterministic guards every decision passes through once the model,
  * the assistant-tool pass-through, or the fallback has rendered copy.
@@ -870,14 +883,10 @@ export async function evaluateSignal(
   );
   if (signal.sourceChannel === "assistant_tool" && requestedBody) {
     const payload = signal.contextPayload as Record<string, unknown>;
-    const isUrgent =
-      signal.attentionHints.urgency === "critical" ||
-      signal.attentionHints.urgency === "high";
-    const defaultChannels: NotificationChannel[] = isUrgent
-      ? [...availableChannels]
-      : availableChannels.includes("vellum")
-        ? ["vellum" as NotificationChannel]
-        : [];
+    const defaultChannels = selectDefaultChannelsByUrgency(
+      signal.attentionHints.urgency,
+      availableChannels,
+    );
     // Honor `--preferred-channels` as ADDITIVE push targets on top of
     // the default channel set. The notification center (vellum) is the
     // always-on canonical inbox; preferred channels add push surfaces
@@ -926,6 +935,32 @@ export async function evaluateSignal(
     });
   }
 
+  // Scheduler-owned requested copy: the scheduler already authored the
+  // complete message. Ownership requires both the signal source and the
+  // payload marker so schedule.result (requestedMessage, no
+  // requestedBySource) and notify-mode (message, no requestedBySource)
+  // stay on their existing paths. Urgency still chooses channels; every
+  // selected channel keeps the producer body.
+  const requestedBySource = nonEmpty(
+    readPayloadString(signal.contextPayload, "requestedBySource"),
+  );
+  if (
+    signal.sourceChannel === "scheduler" &&
+    requestedBySource === "scheduler" &&
+    requestedBody
+  ) {
+    return buildPassThroughDecision({
+      signal,
+      availableChannels,
+      selectedChannels: selectDefaultChannelsByUrgency(
+        signal.attentionHints.urgency,
+        availableChannels,
+      ),
+      body: requestedBody,
+      reasoningSummary: "scheduler requested-message pass-through",
+    });
+  }
+
   // Schedule-result pass-through: the body is the run's own reply, which is
   // the whole point of the notification — a briefing, a digest, a report. The
   // classifier rewrites bodies into short alerts, which would throw away the

package/src/runtime/routes/__tests__/acp-routes.test.ts

@@ -302,6 +302,25 @@ describe("GET /v1/acp/sessions — merged in-memory + history", () => {
     ]);
   });
 
+  test("does not expose snapshot-only history metadata", async () => {
+    insertHistoryRow({
+      id: "hist-private",
+      status: "completed",
+      cwd: "/tmp/private-project",
+      authErrorCredential: "credential-digest",
+    });
+
+    const handler = getSessionsHandler();
+    const body = (await handler({})) as ResponseShape;
+    const session = body.sessions.find((entry) => entry.id === "hist-private");
+
+    expect(session).toBeDefined();
+    expect(session).not.toHaveProperty("source");
+    expect(session).not.toHaveProperty("resumable");
+    expect(session).not.toHaveProperty("cwd");
+    expect(session).not.toHaveProperty("authErrorCredential");
+  });
+
   test("returns input/output tokens for live and history sessions", async () => {
     fakeInMemorySessions = [
       {

package/src/runtime/routes/acp-routes.ts

@@ -24,7 +24,13 @@ import {
   AcpResumeError,
   AcpSessionNotFoundError,
 } from "../../acp/session-manager.js";
-import { type AcpSessionState, isLiveAcpStatus } from "../../acp/types.js";
+import {
+  type AcpSessionSnapshot,
+  listAcpSessionSnapshots,
+  snapshotHistoryRow,
+  withCurrentAuthMarkers,
+} from "../../acp/session-snapshot.js";
+import { isLiveAcpStatus } from "../../acp/types.js";
 import {
   AcpSessionModelUpdateEventSchema,
   type AssistantEvent,
@@ -103,11 +109,14 @@ type SessionEntry = z.infer<typeof sessionEntrySchema>;
  * client has no use for it and no way to resolve the other side of the
  * comparison, so serving it would only widen what leaves the daemon.
  */
-type MergedSession = SessionEntry & { authErrorCredential?: string };
+type MergedSession = AcpSessionSnapshot;
 
-/** Drop the comparison's own input before the session goes out on the wire. */
+/** Drop internal snapshot metadata before the session goes out on the wire. */
 function stripMarkerCredential({
-  authErrorCredential: _dropped,
+  authErrorCredential: _credential,
+  source: _source,
+  resumable: _resumable,
+  cwd: _cwd,
   ...session
 }: MergedSession): SessionEntry {
   return session;
@@ -511,7 +520,7 @@ async function listSessions({ queryParams }: RouteHandlerArgs) {
     return resolvedByAgent.get(agentId);
   };
 
-  const { sessions: merged, sawEveryHistoryRow } = listMergedSessions({
+  const { sessions: merged, sawEveryHistoryRow } = listAcpSessionSnapshots({
     limit,
     conversationId,
   });
@@ -552,43 +561,12 @@ async function listSessions({ queryParams }: RouteHandlerArgs) {
   return { sessions: [...page, stripMarkerCredential(marker)] };
 }
 
-/**
- * Blank the failure code on any session whose marker no longer describes the
- * credential its agent would resolve.
- *
- * This comparison is what retires a Connect card: not a sweep that has to run
- * at the right moment, but the marker no longer describing the credential in
- * use. Applied after merging rather than inside the query, so live sessions
- * and history rows are judged by exactly the same rule.
- *
- * Resolved per agent, because precedence is per agent: one alias can carry a
- * configured token while another falls through to the vault. Memoised across
- * the request, since a conversation's marked runs are nearly always one agent
- * and each resolution costs a vault read.
- */
 async function withCurrentMarkersOnly(
   sessions: MergedSession[],
   resolvedFor: (agentId: string) => Promise<string | undefined>,
 ): Promise<SessionEntry[]> {
-  const strip = stripMarkerCredential;
-  if (!sessions.some((s) => s.authErrorCode !== undefined)) {
-    return sessions.map(strip);
-  }
-  const judged: SessionEntry[] = [];
-  for (const session of sessions) {
-    if (session.authErrorCode === undefined) {
-      judged.push(strip(session));
-      continue;
-    }
-    const current = acpAuthMarkerStillCurrent(
-      session.authErrorCredential,
-      await resolvedFor(session.agentId),
-    );
-    judged.push(
-      strip(current ? session : { ...session, authErrorCode: undefined }),
-    );
-  }
-  return judged;
+  const judged = await withCurrentAuthMarkers(sessions, resolvedFor);
+  return judged.map(stripMarkerCredential);
 }
 
 function bulkDeleteSessions({ queryParams }: RouteHandlerArgs) {
@@ -879,128 +857,6 @@ function parseLimit(raw: string | null | undefined): number {
   return Math.min(Math.floor(n), MAX_SESSION_LIMIT);
 }
 
-function listMergedSessions(opts: { limit: number; conversationId?: string }): {
-  sessions: MergedSession[];
-  /**
-   * Whether the history query reached the end of this conversation's rows.
-   *
-   * A short read means there is nothing beyond what was returned, which is the
-   * proof that no marker is hiding outside the page.
-   */
-  sawEveryHistoryRow: boolean;
-} {
-  const manager = getAcpSessionManager();
-  const inMemory = manager.getStatus() as AcpSessionState[];
-
-  const merged = new Map<string, MergedSession>();
-  for (const s of inMemory) {
-    if (opts.conversationId && s.parentConversationId !== opts.conversationId) {
-      continue;
-    }
-    merged.set(s.id, {
-      id: s.id,
-      agentId: s.agentId,
-      acpSessionId: s.acpSessionId,
-      parentConversationId: s.parentConversationId,
-      status: s.status,
-      startedAt: s.startedAt,
-      completedAt: s.completedAt ?? null,
-      error: s.error ?? null,
-      stopReason: s.stopReason ?? null,
-      task: s.task,
-      parentToolUseId: s.parentToolUseId,
-      authErrorCode: s.authErrorCode,
-      authErrorCredential: s.authErrorCredential,
-      model: s.model,
-      availableModels: s.availableModels,
-      modelRevisionEpoch: s.modelRevisionEpoch,
-      modelRevision: s.modelRevision,
-      usedTokens: s.latestUsage?.usedTokens,
-      contextSize: s.latestUsage?.contextSize,
-      costAmount: s.latestUsage?.costAmount,
-      costCurrency: s.latestUsage?.costCurrency,
-      inputTokens: s.latestUsage?.inputTokens,
-      outputTokens: s.latestUsage?.outputTokens,
-      eventLog: manager.getBufferedUpdates(s.id),
-    });
-  }
-
-  const db = getDb();
-  const baseQuery = db.select().from(acpSessionHistory);
-  const filtered = opts.conversationId
-    ? baseQuery.where(
-        eq(acpSessionHistory.parentConversationId, opts.conversationId),
-      )
-    : baseQuery;
-  // Fetch only enough rows to fill the requested page after merging with
-  // in-memory sessions. In-memory entries take precedence on id collision,
-  // so we pad by the count that survived the conversation filter to
-  // guarantee we still surface `limit` distinct rows even when every
-  // in-memory session shadows a DB row — without over-fetching when many
-  // unrelated sessions are in memory.
-  const historyLimit = opts.limit + merged.size;
-  const historyRows = filtered
-    .orderBy(desc(acpSessionHistory.startedAt))
-    .limit(historyLimit)
-    .all();
-
-  for (const row of historyRows) {
-    if (merged.has(row.id)) {
-      continue;
-    }
-    merged.set(row.id, toMergedSession(row));
-  }
-
-  return {
-    sessions: Array.from(merged.values()).sort(
-      (a, b) => b.startedAt - a.startedAt,
-    ),
-    sawEveryHistoryRow: historyRows.length < historyLimit,
-  };
-}
-
-/** Shape a history row for the response, parsing its stored event log. */
-function toMergedSession(
-  row: typeof acpSessionHistory.$inferSelect,
-): MergedSession {
-  let eventLog: unknown[] = [];
-  try {
-    const parsed = JSON.parse(row.eventLogJson) as unknown;
-    if (Array.isArray(parsed)) {
-      eventLog = parsed;
-    }
-  } catch (err) {
-    log.warn(
-      { id: row.id, err },
-      "Failed to parse event_log_json for ACP session history row",
-    );
-  }
-  // Rows predating the usage migration carry NULLs for these columns and
-  // degrade to undefined.
-  return {
-    id: row.id,
-    agentId: row.agentId,
-    acpSessionId: row.acpSessionId,
-    parentConversationId: row.parentConversationId,
-    status: row.status,
-    startedAt: row.startedAt,
-    completedAt: row.completedAt,
-    error: row.error,
-    stopReason: row.stopReason,
-    task: row.task ?? undefined,
-    parentToolUseId: row.parentToolUseId ?? undefined,
-    authErrorCode: row.authErrorCode ?? undefined,
-    authErrorCredential: row.authErrorCredential ?? undefined,
-    usedTokens: row.usedTokens ?? undefined,
-    contextSize: row.contextSize ?? undefined,
-    costAmount: row.costAmount ?? undefined,
-    costCurrency: row.costCurrency ?? undefined,
-    inputTokens: row.inputTokens ?? undefined,
-    outputTokens: row.outputTokens ?? undefined,
-    eventLog,
-  };
-}
-
 /**
  * Reach past the page for the one marked run a client would restore the card
  * from, when the page itself holds none.
@@ -1061,7 +917,7 @@ async function findRecoveryMarker(
         .from(acpSessionHistory)
         .where(eq(acpSessionHistory.id, marker.id))
         .get();
-      return row ? toMergedSession(row) : undefined;
+      return row ? snapshotHistoryRow(row) : undefined;
     }
   }
   return undefined;

package/src/tools/acp/status.test.ts

@@ -1,12 +1,12 @@
 /**
- * Tests for the `acp_status` tool's projection of session state.
+ * Tests for the `acp_status` tool's live and persisted session projection.
  *
- * The state the manager tracks feeds three surfaces with different budgets:
- * the HTTP route, the SSE picker, and this tool, whose output is spent on
- * LLM context. Only the fields an agent can act on belong here.
+ * The session manager owns live process state. Completed sessions move to
+ * durable history, where the status tool must keep them discoverable for
+ * follow-up work without making internal lifecycle guards treat them as live.
  */
 
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AcpSessionState } from "../../acp/types.js";
 import type { ToolContext } from "../types.js";
@@ -26,24 +26,49 @@ const RUNNING_STATE: AcpSessionState = {
   ],
 };
 
-let statusResult: AcpSessionState | AcpSessionState[] = RUNNING_STATE;
+let liveStates: AcpSessionState[] = [];
+let fakeStoredCredential: string | undefined;
 
 const realAcpModule = await import("../../acp/index.js");
 mock.module("../../acp/index.js", () => ({
   ...realAcpModule,
-  getAcpSessionManager: () => ({ getStatus: () => statusResult }),
+  getAcpSessionManager: () => ({
+    getStatus: () => liveStates,
+    getBufferedUpdates: () => [],
+  }),
 }));
 
+const realClaudeOauth = await import("../../acp/acp-claude-oauth.js");
+mock.module("../../acp/acp-claude-oauth.js", () => ({
+  ...realClaudeOauth,
+  storedClaudeTokenDigest: async () => fakeStoredCredential,
+}));
+
+import {
+  clearHistory,
+  insertHistoryRow,
+} from "../../acp/__tests__/helpers/acp-history-db.js";
+import { claudeTokenDigest } from "../../acp/acp-auth-marker-store.js";
+import { initializeDb } from "../../persistence/db-init.js";
+
 const { executeAcpStatus } = await import("./status.js");
 
+await initializeDb();
+
 const context = {
   conversationId: "conv-1",
   workingDir: "/tmp",
 } as unknown as ToolContext;
 
+beforeEach(() => {
+  liveStates = [];
+  fakeStoredCredential = undefined;
+  clearHistory();
+});
+
 describe("executeAcpStatus", () => {
-  test("a single session reports its model but not the picker", async () => {
-    statusResult = RUNNING_STATE;
+  test("a live session reports its model but not the picker", async () => {
+    liveStates = [RUNNING_STATE];
 
     const result = await executeAcpStatus({ acp_session_id: "acp-1" }, context);
 
@@ -62,33 +87,263 @@ describe("executeAcpStatus", () => {
     expect(result.content).not.toContain("Most capable");
   });
 
-  test("the listing drops the picker from every entry", async () => {
-    statusResult = [
-      RUNNING_STATE,
-      { ...RUNNING_STATE, id: "acp-2", model: "sonnet" },
-    ];
+  test("a cleanly completed resumable session is returned as idle", async () => {
+    insertHistoryRow({
+      id: "completed-1",
+      acpSessionId: "proto-completed-1",
+      startedAt: 2000,
+      completedAt: 3000,
+      status: "completed",
+      stopReason: "end_turn",
+      cwd: "/tmp/project",
+      task: "implement the parser",
+      usedTokens: 1200,
+      contextSize: 10000,
+    });
 
-    const result = await executeAcpStatus({}, context);
+    const result = await executeAcpStatus(
+      { acp_session_id: "completed-1" },
+      context,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(JSON.parse(result.content)).toEqual({
+      id: "completed-1",
+      agentId: "claude",
+      acpSessionId: "proto-completed-1",
+      parentConversationId: "conv-1",
+      status: "idle",
+      startedAt: 2000,
+      completedAt: 3000,
+      stopReason: "end_turn",
+      task: "implement the parser",
+      latestUsage: {
+        usedTokens: 1200,
+        contextSize: 10000,
+      },
+      resumable: true,
+      lastRunStatus: "completed",
+    });
+  });
+
+  test("failed and cancelled history rows keep their terminal status", async () => {
+    insertHistoryRow({
+      id: "failed-1",
+      status: "failed",
+      error: "adapter failed",
+      cwd: "/tmp/project",
+    });
+    insertHistoryRow({
+      id: "cancelled-1",
+      status: "cancelled",
+      stopReason: "cancelled",
+      cwd: "/tmp/project",
+    });
 
+    const failed = await executeAcpStatus(
+      { acp_session_id: "failed-1" },
+      context,
+    );
+    const cancelled = await executeAcpStatus(
+      { acp_session_id: "cancelled-1" },
+      context,
+    );
+
+    expect(JSON.parse(failed.content)).toMatchObject({
+      status: "failed",
+      resumable: true,
+      lastRunStatus: "failed",
+      error: "adapter failed",
+    });
+    expect(JSON.parse(cancelled.content)).toMatchObject({
+      status: "cancelled",
+      resumable: true,
+      lastRunStatus: "cancelled",
+    });
+  });
+
+  test("a completed legacy row without cwd stays terminal", async () => {
+    insertHistoryRow({ id: "legacy-1", status: "completed", cwd: null });
+
+    const result = await executeAcpStatus(
+      { acp_session_id: "legacy-1" },
+      context,
+    );
+
+    expect(JSON.parse(result.content)).toMatchObject({
+      status: "completed",
+      resumable: false,
+      lastRunStatus: "completed",
+    });
+  });
+
+  test("a completed run stopped by cancellation stays terminal", async () => {
+    insertHistoryRow({
+      id: "partial-1",
+      status: "completed",
+      stopReason: "cancelled",
+      cwd: "/tmp/project",
+    });
+
+    const result = await executeAcpStatus(
+      { acp_session_id: "partial-1" },
+      context,
+    );
+
+    expect(JSON.parse(result.content)).toMatchObject({
+      status: "completed",
+      resumable: true,
+      lastRunStatus: "completed",
+      stopReason: "cancelled",
+    });
+  });
+
+  test("the listing includes live and persisted idle sessions", async () => {
+    liveStates = [RUNNING_STATE];
+    insertHistoryRow({
+      id: "idle-1",
+      startedAt: 2000,
+      status: "completed",
+      cwd: "/tmp/project",
+    });
+
+    const result = await executeAcpStatus({}, context);
     const payload = JSON.parse(result.content) as Array<
       Record<string, unknown>
     >;
-    expect(payload).toHaveLength(2);
-    expect(payload.map((entry) => entry.model)).toEqual([
-      "claude-opus-4-5",
-      "sonnet",
+
+    expect(payload.map((entry) => [entry.id, entry.status])).toEqual([
+      ["idle-1", "idle"],
+      ["acp-1", "running"],
     ]);
     for (const entry of payload) {
       expect(entry).not.toHaveProperty("availableModels");
+      expect(entry).not.toHaveProperty("eventLog");
+      expect(entry).not.toHaveProperty("cwd");
+      expect(entry).not.toHaveProperty("source");
+      expect(entry).not.toHaveProperty("authErrorCredential");
     }
   });
 
-  test("an empty listing says so rather than rendering an empty array", async () => {
-    statusResult = [];
+  test("live state wins over history for the same id", async () => {
+    liveStates = [RUNNING_STATE];
+    insertHistoryRow({
+      id: RUNNING_STATE.id,
+      status: "completed",
+      cwd: "/tmp/project",
+    });
 
+    const result = await executeAcpStatus(
+      { acp_session_id: RUNNING_STATE.id },
+      context,
+    );
+
+    expect(JSON.parse(result.content)).toMatchObject({
+      id: RUNNING_STATE.id,
+      status: "running",
+      agentId: RUNNING_STATE.agentId,
+    });
+  });
+
+  test("a truly unknown id keeps the not-found error", async () => {
+    const result = await executeAcpStatus(
+      { acp_session_id: "missing-1" },
+      context,
+    );
+
+    expect(result).toEqual({
+      content: 'ACP session "missing-1" not found',
+      isError: true,
+    });
+  });
+
+  test("an empty listing says so rather than rendering an empty array", async () => {
     const result = await executeAcpStatus({}, context);
 
     expect(result.content).toBe("No ACP sessions found.");
     expect(result.isError).toBe(false);
   });
+
+  test("withholds a persisted auth marker after the credential is replaced", async () => {
+    const refused = claudeTokenDigest("sk-ant-oat-refused");
+    insertHistoryRow({
+      id: "auth-failed-1",
+      status: "failed",
+      error: "authentication required",
+      cwd: "/tmp/project",
+      authErrorCode: "acp_claude_auth_required",
+      authErrorCredential: refused,
+    });
+    fakeStoredCredential = claudeTokenDigest("sk-ant-oat-replacement");
+
+    const result = await executeAcpStatus(
+      { acp_session_id: "auth-failed-1" },
+      context,
+    );
+
+    expect(JSON.parse(result.content)).toMatchObject({
+      id: "auth-failed-1",
+      status: "failed",
+      lastRunStatus: "failed",
+    });
+    expect(JSON.parse(result.content).authErrorCode).toBeUndefined();
+    expect(result.content).not.toContain("authErrorCredential");
+  });
+
+  test("keeps a persisted auth marker while the refused credential is current", async () => {
+    const refused = claudeTokenDigest("sk-ant-oat-refused");
+    insertHistoryRow({
+      id: "auth-failed-2",
+      status: "failed",
+      cwd: "/tmp/project",
+      authErrorCode: "acp_claude_auth_required",
+      authErrorCredential: refused,
+    });
+    fakeStoredCredential = refused;
+
+    const result = await executeAcpStatus(
+      { acp_session_id: "auth-failed-2" },
+      context,
+    );
+
+    expect(JSON.parse(result.content)).toMatchObject({
+      id: "auth-failed-2",
+      status: "failed",
+      authErrorCode: "acp_claude_auth_required",
+    });
+    expect(result.content).not.toContain("authErrorCredential");
+  });
+
+  test("keeps an older live session when 50 newer history rows exist", async () => {
+    liveStates = [
+      {
+        ...RUNNING_STATE,
+        id: "old-live",
+        startedAt: 1,
+      },
+    ];
+    for (let i = 0; i < 50; i++) {
+      insertHistoryRow({
+        id: `hist-${i}`,
+        acpSessionId: `proto-hist-${i}`,
+        startedAt: 1000 + i,
+        status: "completed",
+        cwd: "/tmp/project",
+      });
+    }
+
+    const result = await executeAcpStatus({}, context);
+    const payload = JSON.parse(result.content) as Array<{
+      id: string;
+      status: string;
+    }>;
+
+    expect(payload).toHaveLength(50);
+    expect(payload.some((entry) => entry.id === "old-live")).toBe(true);
+    expect(payload.find((entry) => entry.id === "old-live")?.status).toBe(
+      "running",
+    );
+    expect(payload[0]?.id).toBe("hist-49");
+    expect(payload.some((entry) => entry.id === "hist-0")).toBe(false);
+  });
 });

package/src/tools/acp/status.ts

@@ -1,13 +1,37 @@
 import { z } from "zod";
 
-import { getAcpSessionManager } from "../../acp/index.js";
-import type { AcpSessionState } from "../../acp/types.js";
+import { resolvedClaudeCredentialDigest } from "../../acp/prepare-agent-env.js";
+import {
+  type AcpSessionSnapshot,
+  getAcpSessionSnapshot,
+  listAcpSessionSnapshots,
+  withCurrentAuthMarkers,
+} from "../../acp/session-snapshot.js";
 import {
   invalidToolInputResult,
   nullAsOmitted,
 } from "../shared/zod-tool-schema.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
 
+const STATUS_LIST_LIMIT = 50;
+
+/**
+ * Keep every live session visible, then fill remaining capacity from durable
+ * history. An older active run must not be displaced by newer historical rows.
+ */
+function selectStatusSnapshots(
+  sessions: AcpSessionSnapshot[],
+): AcpSessionSnapshot[] {
+  const live = sessions.filter((session) => session.source === "live");
+  const history = sessions
+    .filter((session) => session.source === "history")
+    .sort((a, b) => b.startedAt - a.startedAt);
+  const remaining = Math.max(0, STATUS_LIST_LIMIT - live.length);
+  return [...live, ...history.slice(0, remaining)].sort(
+    (a, b) => b.startedAt - a.startedAt,
+  );
+}
+
 /**
  * Model-input schema, `safeParse`d at the top of {@link executeAcpStatus}.
  * Same in-tool pattern and TOOLS.json drift guard as the other bundled-skill
@@ -24,33 +48,48 @@ export const acpStatusInputSchema = z.looseObject({
  * `AcpSessionState` for those surfaces should not reach this one by default.
  * `model` stays: which model a session is running on is answerable.
  */
-function projectSession(state: AcpSessionState) {
+function projectSession(snapshot: AcpSessionSnapshot) {
+  const fromHistory = snapshot.source === "history";
+  const idle =
+    fromHistory &&
+    snapshot.status === "completed" &&
+    snapshot.stopReason !== "cancelled" &&
+    snapshot.resumable;
+  const latestUsage =
+    snapshot.usedTokens !== undefined && snapshot.contextSize !== undefined
+      ? {
+          usedTokens: snapshot.usedTokens,
+          contextSize: snapshot.contextSize,
+          costAmount: snapshot.costAmount,
+          costCurrency: snapshot.costCurrency,
+          inputTokens: snapshot.inputTokens,
+          outputTokens: snapshot.outputTokens,
+        }
+      : undefined;
   return {
-    id: state.id,
-    agentId: state.agentId,
-    acpSessionId: state.acpSessionId,
-    parentConversationId: state.parentConversationId,
-    status: state.status,
-    startedAt: state.startedAt,
-    completedAt: state.completedAt,
-    error: state.error,
-    stopReason: state.stopReason,
-    task: state.task,
-    parentToolUseId: state.parentToolUseId,
-    authErrorCode: state.authErrorCode,
-    authErrorCredential: state.authErrorCredential,
-    latestUsage: state.latestUsage,
-    model: state.model,
+    id: snapshot.id,
+    agentId: snapshot.agentId,
+    acpSessionId: snapshot.acpSessionId,
+    parentConversationId: snapshot.parentConversationId,
+    status: idle ? "idle" : snapshot.status,
+    startedAt: snapshot.startedAt,
+    completedAt: snapshot.completedAt ?? undefined,
+    error: snapshot.error ?? undefined,
+    stopReason: snapshot.stopReason ?? undefined,
+    task: snapshot.task,
+    parentToolUseId: snapshot.parentToolUseId,
+    authErrorCode: snapshot.authErrorCode,
+    latestUsage,
+    model: snapshot.model,
+    ...(fromHistory
+      ? {
+          resumable: snapshot.resumable,
+          lastRunStatus: snapshot.status,
+        }
+      : {}),
   };
 }
 
-/** Projects either shape `getStatus` answers with. */
-function projectStatus(status: AcpSessionState | AcpSessionState[]): unknown {
-  return Array.isArray(status)
-    ? status.map(projectSession)
-    : projectSession(status);
-}
-
 export async function executeAcpStatus(
   input: Record<string, unknown>,
   _context: ToolContext,
@@ -60,24 +99,51 @@ export async function executeAcpStatus(
     return invalidToolInputResult("acp_status", parsedInput.error);
   }
   const acpSessionId = parsedInput.data.acp_session_id;
-  const manager = getAcpSessionManager();
-
   try {
     if (acpSessionId) {
+      const snapshot = getAcpSessionSnapshot(acpSessionId, {
+        includeEventLog: false,
+      });
+      if (!snapshot) {
+        return {
+          content: `ACP session "${acpSessionId}" not found`,
+          isError: true,
+        };
+      }
+      const judged = (
+        await withCurrentAuthMarkers(
+          [snapshot],
+          resolvedClaudeCredentialDigest,
+        )
+      )[0];
+      if (!judged) {
+        return {
+          content: `ACP session "${acpSessionId}" not found`,
+          isError: true,
+        };
+      }
       return {
-        content: JSON.stringify(projectStatus(manager.getStatus(acpSessionId))),
+        content: JSON.stringify(projectSession(judged)),
         isError: false,
       };
     }
 
-    // List all sessions.
-    const allStates = manager.getStatus();
-    if (Array.isArray(allStates) && allStates.length === 0) {
+    const snapshots = selectStatusSnapshots(
+      listAcpSessionSnapshots({
+        limit: STATUS_LIST_LIMIT,
+        includeEventLog: false,
+      }).sessions,
+    );
+    if (snapshots.length === 0) {
       return { content: "No ACP sessions found.", isError: false };
     }
 
+    const judged = await withCurrentAuthMarkers(
+      snapshots,
+      resolvedClaudeCredentialDigest,
+    );
     return {
-      content: JSON.stringify(projectStatus(allStates)),
+      content: JSON.stringify(judged.map(projectSession)),
       isError: false,
     };
   } catch (err) {