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

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) {