@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/__tests__/slack-reaction-approvals.test.ts

@@ -1,77 +1,97 @@
 import { describe, expect, test } from "bun:test";
 
-import { parseReactionCallbackData } from "../runtime/routes/channel-route-shared.js";
+import { reactionDecisionForEmoji } from "../runtime/routes/channel-route-shared.js";
 
 // =============================================================================
-// parseReactionCallbackData
+// reactionDecisionForEmoji
 // =============================================================================
 
-describe("parseReactionCallbackData", () => {
+describe("reactionDecisionForEmoji", () => {
   test("maps +1 emoji to approve_once", () => {
-    const result = parseReactionCallbackData("reaction:+1");
+    const result = reactionDecisionForEmoji("+1");
     expect(result).toEqual({
       action: "approve_once",
-      source: "slack_reaction",
+      source: "reaction",
     });
   });
 
   test("maps thumbsup emoji to approve_once", () => {
-    const result = parseReactionCallbackData("reaction:thumbsup");
+    const result = reactionDecisionForEmoji("thumbsup");
     expect(result).toEqual({
       action: "approve_once",
-      source: "slack_reaction",
+      source: "reaction",
     });
   });
 
   test("maps -1 emoji to reject", () => {
-    const result = parseReactionCallbackData("reaction:-1");
+    const result = reactionDecisionForEmoji("-1");
     expect(result).toEqual({
       action: "reject",
-      source: "slack_reaction",
+      source: "reaction",
     });
   });
 
   test("maps thumbsdown emoji to reject", () => {
-    const result = parseReactionCallbackData("reaction:thumbsdown");
+    const result = reactionDecisionForEmoji("thumbsdown");
     expect(result).toEqual({
       action: "reject",
-      source: "slack_reaction",
+      source: "reaction",
     });
   });
 
   test("alarm_clock emoji maps to approve_once (legacy compat)", () => {
-    const result = parseReactionCallbackData("reaction:alarm_clock");
+    const result = reactionDecisionForEmoji("alarm_clock");
     expect(result).toEqual({
       action: "approve_once",
-      source: "slack_reaction",
+      source: "reaction",
     });
   });
 
   test("white_check_mark emoji maps to approve_once (legacy compat)", () => {
-    const result = parseReactionCallbackData("reaction:white_check_mark");
+    const result = reactionDecisionForEmoji("white_check_mark");
     expect(result).toEqual({
       action: "approve_once",
-      source: "slack_reaction",
+      source: "reaction",
     });
   });
 
-  test("returns null for unknown emoji", () => {
-    const result = parseReactionCallbackData("reaction:tada");
-    expect(result).toBeNull();
+  test("unicode vocabulary: thumbs up, check mark, and alarm clock approve", () => {
+    for (const emoji of ["\u{1F44D}", "\u2705", "\u23F0"]) {
+      expect(reactionDecisionForEmoji(emoji)).toEqual({
+        action: "approve_once",
+        source: "reaction",
+      });
+    }
   });
 
-  test("returns null for empty emoji name", () => {
-    const result = parseReactionCallbackData("reaction:");
+  test("unicode vocabulary: thumbs down rejects", () => {
+    expect(reactionDecisionForEmoji("\u{1F44E}")).toEqual({
+      action: "reject",
+      source: "reaction",
+    });
+  });
+
+  test("a Discord custom emoji in mention form never resolves a decision", () => {
+    // A guild custom emoji can be named after a Slack decision word; the
+    // gateway forwards it as its mention form, which must stay unmapped.
+    expect(
+      reactionDecisionForEmoji("<:white_check_mark:999888777>"),
+    ).toBeNull();
+    expect(reactionDecisionForEmoji("<:thumbsup:999888777>")).toBeNull();
+  });
+
+  test("returns null for unknown emoji", () => {
+    const result = reactionDecisionForEmoji("tada");
     expect(result).toBeNull();
   });
 
-  test("returns null for non-reaction callback data", () => {
-    const result = parseReactionCallbackData("apr:req-1:approve_once");
+  test("returns null for an unmapped emoji", () => {
+    const result = reactionDecisionForEmoji("eyes");
     expect(result).toBeNull();
   });
 
-  test("returns null for plain text", () => {
-    const result = parseReactionCallbackData("yes");
+  test("returns null for an empty emoji name", () => {
+    const result = reactionDecisionForEmoji("");
     expect(result).toBeNull();
   });
 });

package/src/__tests__/slack-reaction-guardian-approval.test.ts

@@ -117,7 +117,11 @@ function reaction(opts: {
       guardianPrincipalId: opts.principal ?? PRINCIPAL,
     },
     conversationId: "guardian-conv",
-    callbackData: `reaction:${opts.emoji}`,
+    reaction: {
+      op: "added" as const,
+      emoji: opts.emoji,
+      targetMessageId: opts.reactedMessageTs ?? "",
+    },
     reactedMessageTs: opts.reactedMessageTs,
     channelDeliveryContext: {
       replyCallbackUrl: "https://gateway.test/deliver",
@@ -162,6 +166,30 @@ describe("routeGuardianReply / reactions", () => {
     expect(hcr.mock.calls[0]?.[1]).toBe("deny");
   });
 
+  test("a person-addressed delivery resolves through the reactor's own id", async () => {
+    // Person-addressed adapters (Discord) record the guardian's user id as
+    // the destination, while the reaction arrives addressed by its chat, so
+    // the chat probe misses and the actor-id probe must find the card.
+    const hcr = seedApproval({
+      requestId: "req-person",
+      ts: "300.3",
+      chatId: GUARDIAN_USER,
+    });
+
+    const result = await routeGuardianReply(
+      reaction({
+        emoji: "white_check_mark",
+        reactedMessageTs: "300.3",
+        chatId: "DM_CHANNEL_9",
+      }),
+    );
+
+    expect(result.consumed).toBe(true);
+    expect(result.decisionApplied).toBe(true);
+    expect(sim.getRequest("req-person")?.status).toBe("approved");
+    expect(hcr).toHaveBeenCalledTimes(1);
+  });
+
   test("reacting on a specific card resolves only that card (disambiguates N>1)", async () => {
     const hcrA = seedApproval({ requestId: "req-A", ts: "100.1" });
     const hcrB = seedApproval({ requestId: "req-B", ts: "200.2" });

package/src/__tests__/subagent-fork-notifications.test.ts

@@ -13,6 +13,8 @@ const capturedNotifications: {
 
 mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => ({
+    isStale: () => false,
+    hasInFlightWork: () => false,
     enqueueMessage: (options: { content: string }) => {
       capturedNotifications.push({
         parentConversationId: id,

package/src/__tests__/subagent-manager-notify.test.ts

@@ -13,6 +13,8 @@ const capturedNotifications: {
 
 mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => ({
+    isStale: () => false,
+    hasInFlightWork: () => false,
     enqueueMessage: (options: { content: string }) => {
       capturedNotifications.push({
         parentConversationId: id,

package/src/__tests__/subagent-notify-parent.test.ts

@@ -56,6 +56,8 @@ mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => {
     capturedParentIds.push(id);
     return {
+      isStale: () => false,
+      hasInFlightWork: () => false,
       enqueueMessage: (options: { content: string }) => {
         capturedMessages.push(options.content);
         return { queued: true };

package/src/__tests__/subagent-notify-stale-rebuild.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Terminal (and other) parent injections rebuild a stale idle parent before
+ * the notification turn, so a reload or credential rotation is visible to
+ * that turn. A parent that still has in-flight work keeps its current
+ * instance so children are not aborted.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const parentState = { stale: false, inFlight: false };
+const rebuilt: string[] = [];
+const delivered: string[] = [];
+
+mock.module("../daemon/conversation-registry.js", () => ({
+  findConversation: (id: string) => {
+    if (id === "missing-parent") {
+      return undefined;
+    }
+    return {
+      isStale: () => parentState.stale,
+      hasInFlightWork: () => parentState.inFlight,
+      enqueueMessage: (options: { content: string }) => {
+        delivered.push(options.content);
+        return { queued: true };
+      },
+      persistUserMessage: async () => ({ id: "mock-msg" }),
+      runAgentLoop: async () => {},
+    };
+  },
+}));
+
+mock.module("../daemon/conversation-store.js", () => ({
+  getOrCreateConversation: async (id: string) => {
+    rebuilt.push(id);
+    return {
+      enqueueMessage: (options: { content: string }) => {
+        delivered.push(`rebuilt:${options.content}`);
+        return { queued: true };
+      },
+      persistUserMessage: async () => ({ id: "rebuilt-msg" }),
+      runAgentLoop: async () => {},
+    };
+  },
+}));
+
+import { injectMessageIntoParent } from "../subagent/notify.js";
+
+describe("injectMessageIntoParent stale rebuild", () => {
+  beforeEach(() => {
+    parentState.stale = false;
+    parentState.inFlight = false;
+    rebuilt.length = 0;
+    delivered.length = 0;
+  });
+
+  test("delivers on the live instance when the parent is not stale", () => {
+    injectMessageIntoParent("parent-1", "child done");
+
+    expect(rebuilt).toEqual([]);
+    expect(delivered).toEqual(["child done"]);
+  });
+
+  test("keeps the live instance while the parent still has in-flight work", () => {
+    parentState.stale = true;
+    parentState.inFlight = true;
+
+    injectMessageIntoParent("parent-1", "child still running");
+
+    expect(rebuilt).toEqual([]);
+    expect(delivered).toEqual(["child still running"]);
+  });
+
+  test("rebuilds a stale idle parent before the notification turn", async () => {
+    parentState.stale = true;
+    parentState.inFlight = false;
+
+    injectMessageIntoParent("parent-1", "child done");
+    const start = Date.now();
+    while (delivered.length === 0 && Date.now() - start < 1000) {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+
+    expect(rebuilt).toEqual(["parent-1"]);
+    expect(delivered).toEqual(["rebuilt:child done"]);
+  });
+});

package/src/__tests__/subagent-tool-gate-mode.test.ts

@@ -271,10 +271,10 @@ describe("createResolveToolsCallback — toolContextPin", () => {
     const names = resolve(EMPTY_HISTORY)
       .map((t) => t.name)
       .sort();
-    // request_system_permission stays out: it keys on
-    // channelCapabilities.clientOS, which desktop HTTP live turns never set
-    // either — exclusion IS parity there. ask_question stays IN: its
-    // macOS-specific hide also keys on clientOS, which the pin leaves unset.
+    // request_system_permission stays out: it keys on the pinned clientOs,
+    // which this pin leaves unset (a pin never falls back to the transport).
+    // ask_question stays IN: its macOS-specific hide keys on
+    // channelCapabilities.clientOS, which the pin also leaves unset.
     expect(names).toEqual(["ask_question", "host_bash", "remember", "ui_show"]);
   });
 

package/src/__tests__/terminal-tools.test.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { afterEach, describe, expect, mock, test } from "bun:test";
 
 // ── Mock modules ────────────────────────────────────────────────────────────
@@ -40,7 +40,11 @@ mock.module("../tools/network/script-proxy/index.js", () => ({
 
 // ── Imports (after mocks) ───────────────────────────────────────────────────
 
-import { formatShellOutput } from "../tools/shared/shell-output.js";
+import {
+  formatShellOutput,
+  MAX_OUTPUT_LENGTH,
+  OUTPUT_TRUNCATED_TAG,
+} from "../tools/shared/shell-output.js";
 import {
   ALWAYS_INJECTED_ENV_VARS,
   buildSanitizedEnv,
@@ -360,12 +364,8 @@ describe("formatShellOutput", () => {
   test("truncates very long output", () => {
     const longOutput = "x".repeat(30_000);
     const result = formatShellOutput(longOutput, "", 0, false, 120);
-    expect(result.content).toContain('limit="20K"');
-    // Extract the file="..." attribute from the truncation tag
-    const fileMatch = result.content.match(/file="([^"]+)"/);
-    expect(fileMatch).not.toBeNull();
-    const filePath = fileMatch![1];
-    expect(existsSync(filePath)).toBe(true);
-    expect(readFileSync(filePath, "utf-8")).toBe(longOutput);
+    expect(result.content).toContain(OUTPUT_TRUNCATED_TAG);
+    expect(result.content).not.toContain("file=");
+    expect(result.content.length).toBeLessThan(MAX_OUTPUT_LENGTH + 80);
   });
 });

package/src/__tests__/tool-result-spool.test.ts

@@ -140,11 +140,12 @@ describe("spoolAndStubOversizedToolResults", () => {
     expect(existsSync(join(convDir, TOOL_RESULT_DIR))).toBe(false);
   });
 
-  test("spools an oversized file read of an ordinary path", () => {
+  test("leaves an oversized file read of an ordinary path inline (explicit self-sized read)", () => {
     const blocks = [
       makeToolResult(LONG, "tu_read"),
       makeToolResult(LONG, "tu_host_read"),
     ];
+    const originals = blocks.map((b) => b);
 
     const count = spoolAndStubOversizedToolResults(blocks, {
       conversationDir: convDir,
@@ -154,13 +155,9 @@ describe("spoolAndStubOversizedToolResults", () => {
           : { name: "host_file_read", input: { path: "/Users/me/notes.md" } },
     });
 
-    expect(count).toBe(2);
-    expect((blocks[0] as { content: string }).content).toContain(
-      TRUNCATION_MARKER,
-    );
-    expect((blocks[1] as { content: string }).content).toContain(
-      TRUNCATION_MARKER,
-    );
+    expect(count).toBe(0);
+    expect(blocks).toEqual(originals);
+    expect(existsSync(join(convDir, TOOL_RESULT_DIR))).toBe(false);
   });
 
   test("leaves a file read of a spooled .tool-results path inline", () => {

package/src/__tests__/usage-attribution.test.ts

@@ -295,6 +295,32 @@ describe("resolveUsageAttribution — single-winner semantics", () => {
     });
   });
 
+  test("compaction observability site still resolves the profile through mainAgent", () => {
+    setLlmConfig({
+      profiles: { mine: completeProfile },
+      activeProfile: "mine",
+      callSites: { compactionAgent: { profile: "cost-optimized" } },
+      defaultProvider: { provider: "anthropic" },
+    });
+
+    const snapshot = resolveUsageAttribution({
+      callSite: "compactionAgent",
+      profileResolutionCallSite: "mainAgent",
+    });
+
+    expect(snapshot.callSite).toBe("compactionAgent");
+    expect(snapshot.appliedProfile).toBe("mine");
+    expect(snapshot.profileSource).toBe("active");
+    expect(snapshot.resolvedModel).toBe("gpt-5.5");
+    expect(
+      resolveUsageAttribution({ callSite: "compactionAgent" }),
+    ).toMatchObject({
+      callSite: "compactionAgent",
+      appliedProfile: "cost-optimized",
+      profileSource: "call_site",
+    });
+  });
+
   test("attribution provider/model agree with the resolver", () => {
     setLlmConfig({
       profiles: { mine: completeProfile },

package/src/acp/__tests__/acp-auth-marker-store.test.ts

@@ -0,0 +1,191 @@
+/**
+ * A credential-failure marker answers for itself whether it is still worth
+ * showing a Connect card for.
+ *
+ * The question is always the same: is the credential this failure names still
+ * the one a spawn would resolve? Nothing is remembered between the failure and
+ * the read, and nothing has to run at the right moment for a repaired failure
+ * to stop rendering, which is what a retirement sweep needed and what a daemon
+ * restart used to lose.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getSqlite } from "../../persistence/db-connection.js";
+import { initializeDb } from "../../persistence/db-init.js";
+import {
+  acpAuthMarkerStillCurrent,
+  claudeTokenDigest,
+  claudeTokenRefusedByClaude,
+  conversationHasCurrentAcpMarker,
+  noteClaudeTokenRefused,
+} from "../acp-auth-marker-store.js";
+import { clearHistory, insertHistoryRow } from "./helpers/acp-history-db.js";
+
+await initializeDb();
+
+describe("acpAuthMarkerStillCurrent", () => {
+  const REFUSED = claudeTokenDigest("sk-ant-oat-refused");
+  const REPLACEMENT = claudeTokenDigest("sk-ant-oat-replacement");
+
+  test("a marker naming the credential still in use is served", () => {
+    expect(acpAuthMarkerStillCurrent(REFUSED, REFUSED)).toBe(true);
+  });
+
+  test("a marker naming a credential since replaced is withheld", () => {
+    // The user completed Connect. The card exists to send them there, so it
+    // has nothing left to say.
+    expect(acpAuthMarkerStillCurrent(REFUSED, REPLACEMENT)).toBe(false);
+  });
+
+  test("a marker with no credential named is served", () => {
+    // Predates the column, or came from a path that had no token to name. An
+    // unknown credential is no evidence the failure was repaired, and this
+    // path fails toward leaving the user a route back to auth.
+    expect(acpAuthMarkerStillCurrent(null, REPLACEMENT)).toBe(true);
+    expect(acpAuthMarkerStillCurrent(undefined, REPLACEMENT)).toBe(true);
+  });
+
+  test("an empty vault serves the marker rather than hiding it", () => {
+    // Nothing replaced the refused token, so the failure it names still
+    // stands.
+    expect(acpAuthMarkerStillCurrent(REFUSED, undefined)).toBe(true);
+  });
+
+  test("the same answer however many times it is asked", () => {
+    // No state advances on a read, so a second client asking gets what the
+    // first did. The sweep this replaced could only be run once.
+    expect(acpAuthMarkerStillCurrent(REFUSED, REPLACEMENT)).toBe(false);
+    expect(acpAuthMarkerStillCurrent(REFUSED, REPLACEMENT)).toBe(false);
+    expect(acpAuthMarkerStillCurrent(REFUSED, REFUSED)).toBe(true);
+  });
+});
+
+describe("claudeTokenDigest", () => {
+  test("is stable and does not carry the token", () => {
+    const token = "sk-ant-oat-example";
+    const digest = claudeTokenDigest(token);
+
+    expect(digest).toBe(claudeTokenDigest(token));
+    expect(digest).not.toContain(token);
+    expect(digest).toHaveLength(32);
+  });
+
+  test("separates one alias's token from another's", () => {
+    expect(claudeTokenDigest("sk-ant-oat-a")).not.toBe(
+      claudeTokenDigest("sk-ant-oat-b"),
+    );
+  });
+});
+
+describe("claudeTokenRefusedByClaude", () => {
+  const CONFIG_TOKEN = "sk-ant-oat-from-config";
+  const DIGEST = claudeTokenDigest(CONFIG_TOKEN);
+
+  beforeEach(() => {
+    clearHistory();
+    getSqlite().run("DELETE FROM acp_refused_credentials");
+  });
+
+  test("reports a token Claude refused", () => {
+    noteClaudeTokenRefused(DIGEST, 1000);
+
+    expect(claudeTokenRefusedByClaude(CONFIG_TOKEN)).toBe(true);
+  });
+
+  test("reports nothing for a token never refused", () => {
+    noteClaudeTokenRefused(DIGEST, 1000);
+
+    expect(claudeTokenRefusedByClaude("sk-ant-oat-never-tried")).toBe(false);
+  });
+
+  test("one alias's refused token says nothing about another's", () => {
+    // A global one-shot would let whichever alias prepared first consume the
+    // record, discarding its own good token and re-trusting the bad one.
+    noteClaudeTokenRefused(DIGEST, 1000);
+
+    expect(claudeTokenRefusedByClaude("sk-ant-oat-other-alias")).toBe(false);
+  });
+
+  test("survives clearing ACP session history", () => {
+    // Deleting a run must not change which credential the next spawn picks.
+    // Held on the run row, a bulk clear (which sweeps failed rows too) would
+    // put the revoked configured token back in play against the vault
+    // replacement the user just connected.
+    noteClaudeTokenRefused(DIGEST, 1000);
+    insertHistoryRow({
+      id: "run-refused",
+      status: "failed",
+      authErrorCode: "acp_claude_auth_required",
+      authErrorCredential: DIGEST,
+    });
+
+    clearHistory();
+
+    expect(claudeTokenRefusedByClaude(CONFIG_TOKEN)).toBe(true);
+  });
+
+  test("recording the same refusal twice is not an error", () => {
+    // Every retry of a revoked configured token refuses the same digest.
+    noteClaudeTokenRefused(DIGEST, 1000);
+    noteClaudeTokenRefused(DIGEST, 2000);
+
+    expect(claudeTokenRefusedByClaude(CONFIG_TOKEN)).toBe(true);
+  });
+
+  test("a run that carried no credential records nothing", () => {
+    noteClaudeTokenRefused(undefined, 1000);
+
+    expect(claudeTokenRefusedByClaude(CONFIG_TOKEN)).toBe(false);
+  });
+});
+
+describe("conversationHasCurrentAcpMarker", () => {
+  const REFUSED = claudeTokenDigest("sk-ant-oat-refused");
+
+  beforeEach(() => {
+    clearHistory();
+  });
+
+  test("false for a conversation that has never failed", async () => {
+    expect(await conversationHasCurrentAcpMarker("conv-clean")).toBe(false);
+  });
+
+  test("true while a marker names the credential a spawn would resolve", async () => {
+    // No vault token in this suite, so the resolver reports none and the
+    // comparison treats an unknown as no evidence of repair.
+    insertHistoryRow({
+      id: "run-marked",
+      parentConversationId: "conv-marked",
+      status: "failed",
+      authErrorCode: "acp_claude_auth_required",
+      authErrorCredential: REFUSED,
+    });
+
+    expect(await conversationHasCurrentAcpMarker("conv-marked")).toBe(true);
+  });
+
+  test("false for a conversation whose rows carry no marker", async () => {
+    insertHistoryRow({
+      id: "run-plain",
+      parentConversationId: "conv-plain",
+      status: "completed",
+    });
+
+    expect(await conversationHasCurrentAcpMarker("conv-plain")).toBe(false);
+  });
+
+  test("scoped to its own conversation", async () => {
+    insertHistoryRow({
+      id: "run-elsewhere",
+      parentConversationId: "conv-other",
+      status: "failed",
+      authErrorCode: "acp_claude_auth_required",
+      authErrorCredential: REFUSED,
+    });
+
+    expect(await conversationHasCurrentAcpMarker("conv-asked-about")).toBe(
+      false,
+    );
+  });
+});