@desplega.ai/agent-swarm 1.165.0 → 1.166.0

package/src/tests/script-runs-scrub.test.ts

@@ -0,0 +1,275 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createScriptRun,
+  getDbClient,
+  getRunningScriptRuns,
+  getScriptRunJournalStep,
+  initDb,
+  listScriptRunJournalSteps,
+  recordInlineScriptRun,
+  updateScriptRun,
+  updateScriptRunIfNotTerminal,
+  updateScriptRunIfRunning,
+  upsertScriptRunJournalStep,
+} from "../be/db";
+import { breaksJsonValidity, scrubJsonValue } from "../be/scrub-json";
+import { isSealedJson } from "../be/sealed-json";
+import {
+  localProcessScriptExecutor,
+  type ScriptExecutionResult,
+  type StartScriptExecutionInput,
+} from "../script-workflows/executor";
+import { setScriptRunExecutor, startScriptRunProcess } from "../script-workflows/supervisor";
+import { refreshSecretScrubberCache, scrubSecrets } from "../utils/secret-scrubber";
+import { randomToken, type SyntheticSecret, syntheticSecret } from "./synthetic-secret-helpers";
+
+const TEST_DB_PATH = "./test-script-runs-scrub.sqlite";
+const AGENT_ID = "5c2b0000-0000-4000-8000-0000000012c0";
+// Distinctive non-secret context that must survive redaction.
+const CONTEXT = "wombatlantern";
+
+let known: SyntheticSecret;
+let ghToken: string;
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {}
+  }
+}
+
+/** Free text carrying a registered known value and a structural GitHub token. */
+function secretText(label: string): string {
+  return `${label} ${CONTEXT} known=${known.value} gh=${ghToken} end`;
+}
+
+function expectRedacted(value: string | null | undefined, where: string): void {
+  expect(value, where).toBeString();
+  expect(value!.includes(known.value), `${where} still holds the known value`).toBe(false);
+  expect(value!.includes(ghToken), `${where} still holds the token`).toBe(false);
+  expect(value!, where).toContain("[REDACTED:");
+  expect(value!, where).toContain(CONTEXT);
+}
+
+async function runRow(id: string) {
+  return getDbClient().get<{ args: string; output: string | null; error: string | null }>(
+    "SELECT args, output, error FROM script_runs WHERE id = ?",
+    [id],
+  );
+}
+
+async function seedRun(): Promise<string> {
+  const id = crypto.randomUUID();
+  await createScriptRun({ id, agentId: AGENT_ID, source: "export default () => 1", args: null });
+  await updateScriptRun(id, { status: "running" });
+  return id;
+}
+
+describe("script run writers scrub at write", () => {
+  beforeAll(async () => {
+    await removeDbFiles();
+    initDb(TEST_DB_PATH);
+    ghToken = ["ghp", randomToken(36)].join("_");
+  });
+
+  afterAll(async () => {
+    known.cleanup();
+    refreshSecretScrubberCache();
+    closeDb();
+    await removeDbFiles();
+  });
+
+  beforeEach(async () => {
+    // The test preload clears volatile secrets after every test.
+    known = syntheticSecret("scriptrun");
+    refreshSecretScrubberCache();
+    await getDbClient().run("DELETE FROM script_run_journal");
+    await getDbClient().run("DELETE FROM script_runs");
+  });
+
+  test("recordInlineScriptRun redacts args, output and error", async () => {
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+    await recordInlineScriptRun({
+      id,
+      agentId: AGENT_ID,
+      source: "export default () => 1",
+      args: { note: secretText("args") },
+      status: "failed",
+      output: { lines: [secretText("output")] },
+      error: scrubSecrets(secretText("error")),
+      startedAt: now,
+      finishedAt: now,
+    });
+    const row = await runRow(id);
+    expectRedacted(row?.args, "args");
+    expectRedacted(row?.output, "output");
+    expectRedacted(row?.error, "error");
+    // JSON columns still parse for readers.
+    expect((JSON.parse(row!.args) as { note: string }).note).toContain(CONTEXT);
+    expect((JSON.parse(row!.output!) as { lines: string[] }).lines[0]).toContain(CONTEXT);
+  });
+
+  test("createScriptRun seals args: nothing readable at rest, redacted for callers", async () => {
+    const id = crypto.randomUUID();
+    const args = { note: secretText("launch") };
+    const { run } = await createScriptRun({
+      id,
+      agentId: AGENT_ID,
+      source: "export default () => 1",
+      args,
+    });
+    const stored = (await runRow(id))?.args ?? "";
+    expect(isSealedJson(stored)).toBe(true);
+    expect(stored.includes(known.value)).toBe(false);
+    expect(stored.includes(ghToken)).toBe(false);
+    expect(stored.includes(CONTEXT)).toBe(false);
+    expectRedacted((run.args as { note: string }).note, "run.args");
+  });
+
+  test("a relaunch after restart executes with the exact sealed args", async () => {
+    const id = crypto.randomUUID();
+    const args = { note: secretText("relaunch"), n: 3 };
+    await createScriptRun({ id, agentId: AGENT_ID, source: "export default () => 1", args });
+    await updateScriptRun(id, { status: "running" });
+
+    // A restarted API sees the run as running with no live process and
+    // relaunches it from the row, as reconcileScriptRuns does.
+    const [recovered] = await getRunningScriptRuns();
+    expect(recovered?.id).toBe(id);
+    expectRedacted((recovered!.args as { note: string }).note, "recovered.args");
+
+    let launched: StartScriptExecutionInput | undefined;
+    let exit!: (result: ScriptExecutionResult) => void;
+    setScriptRunExecutor({
+      async start(input) {
+        launched = input;
+        return {
+          pid: null,
+          tmpdir: "/tmp",
+          startedAtMs: Date.now(),
+          exited: new Promise((resolve) => {
+            exit = resolve;
+          }),
+          async terminate() {},
+          async cleanup() {},
+        };
+      },
+      isRunning: () => false,
+      async terminatePid() {},
+    });
+    try {
+      await startScriptRunProcess(recovered!, "http://127.0.0.1:1", "test-key");
+      expect(launched?.run.args).toEqual(args);
+    } finally {
+      exit({ exitCode: 0, stderr: "" });
+      setScriptRunExecutor(localProcessScriptExecutor);
+    }
+  });
+
+  test("updateScriptRun redacts output and error", async () => {
+    const id = await seedRun();
+    await updateScriptRun(id, {
+      status: "failed",
+      output: { summary: secretText("output") },
+      error: secretText("error"),
+    });
+    const row = await runRow(id);
+    expectRedacted(row?.output, "output");
+    expectRedacted(row?.error, "error");
+    expect((JSON.parse(row!.output!) as { summary: string }).summary).toContain(CONTEXT);
+  });
+
+  test("updateScriptRunIfRunning redacts the supervisor's stderr error", async () => {
+    const id = await seedRun();
+    const claimed = await updateScriptRunIfRunning(id, {
+      status: "failed",
+      pid: null,
+      finishedAt: new Date().toISOString(),
+      error: `Traceback\n${secretText("stderr")}\n`,
+    });
+    expect(claimed).toBe(true);
+    expectRedacted((await runRow(id))?.error, "error");
+  });
+
+  test("updateScriptRunIfNotTerminal redacts output", async () => {
+    const id = await seedRun();
+    const claimed = await updateScriptRunIfNotTerminal(id, {
+      status: "completed",
+      output: secretText("output"),
+    });
+    expect(claimed).toBe(true);
+    const output = (await runRow(id))?.output;
+    expectRedacted(output, "output");
+    expect(JSON.parse(output!)).toContain(CONTEXT);
+  });
+
+  test("null error and output still clear the columns", async () => {
+    const id = await seedRun();
+    await updateScriptRun(id, { output: { a: 1 }, error: "boom" });
+    await updateScriptRun(id, { output: undefined, error: null });
+    const row = await runRow(id);
+    expect(row?.output).toBeNull();
+    expect(row?.error).toBeNull();
+  });
+
+  test("upsertScriptRunJournalStep redacts config and error, seals result for replay", async () => {
+    const id = await seedRun();
+    const result = { text: secretText("result") };
+    await upsertScriptRunJournalStep({
+      runId: id,
+      stepKey: "fetch",
+      stepType: "raw-llm",
+      config: { prompt: secretText("config") },
+      status: "failed",
+      result,
+      error: scrubSecrets(secretText("error")),
+    });
+    const row = await getDbClient().get<{
+      config: string;
+      result: string | null;
+      error: string | null;
+    }>("SELECT config, result, error FROM script_run_journal WHERE runId = ?", [id]);
+    expectRedacted(row?.config, "config");
+    expectRedacted(row?.error, "error");
+    expect((JSON.parse(row!.config) as { prompt: string }).prompt).toContain(CONTEXT);
+    // Replay contract: the harness returns this verbatim as the step result,
+    // so it is sealed at rest and opened exactly only on the replay route.
+    expect(isSealedJson(row?.result ?? "")).toBe(true);
+    expect(row!.result!.includes(known.value)).toBe(false);
+    expect(row!.result!.includes(ghToken)).toBe(false);
+    expect((await getScriptRunJournalStep(id, "fetch"))?.result).toEqual(result);
+    const [listed] = await listScriptRunJournalSteps(id);
+    expectRedacted((listed?.result as { text: string }).text, "listed result");
+  });
+});
+
+describe("scrubJsonValue", () => {
+  test("output always parses and keeps non-secret structure", () => {
+    known = syntheticSecret("jsonguard");
+    refreshSecretScrubberCache();
+    try {
+      const value = { a: [`k=${known.value}`, 2], b: { c: CONTEXT }, d: null };
+      const out = scrubJsonValue(value);
+      expect(out.includes(known.value)).toBe(false);
+      expect(out).toContain("[REDACTED:");
+      expect(JSON.parse(out)).toEqual({
+        a: [expect.stringContaining("[REDACTED:"), 2],
+        b: { c: CONTEXT },
+        d: null,
+      });
+    } finally {
+      known.cleanup();
+      refreshSecretScrubberCache();
+    }
+  });
+
+  test("breaksJsonValidity flags only a valid-to-invalid change", () => {
+    expect(breaksJsonValidity('{"a":"x"}', '{"a":"[REDACTED:x]')).toBe(true);
+    expect(breaksJsonValidity('{"a":"x"}', '{"a":"[REDACTED:x]"}')).toBe(false);
+    expect(breaksJsonValidity("not json", "still not")).toBe(false);
+  });
+});

package/src/tests/scripts-http.test.ts

@@ -6,11 +6,16 @@ import { createApp } from "../apps/store";
 import { closeDb, createAgent, getDbClient, initDb } from "../be/db";
 import { getScript, listScripts } from "../be/scripts/db";
 import { setScriptEmbeddingProviderForTests } from "../be/scripts/embeddings";
+import { configSecretName, registerStoredSecret } from "../be/secret-registry";
 import { handleCore } from "../http/core";
 import { handleScripts } from "../http/scripts";
 import { getPathSegments, parseQueryParams } from "../http/utils";
-import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
+import {
+  clearVolatileSecretsForTesting,
+  refreshSecretScrubberCache,
+} from "../utils/secret-scrubber";
 import { SKIP_SANDBOX_SPAWN_TESTS } from "./sandbox-spawn-test-helpers";
+import { randomToken } from "./synthetic-secret-helpers";
 
 const skip = test.skipIf(SKIP_SANDBOX_SPAWN_TESTS);
 
@@ -648,3 +653,79 @@ describe("/api/scripts HTTP", () => {
     expect(result?.argsJsonSchema).not.toBeNull();
   });
 });
+
+describe("script source with an embedded secret is refused at write", () => {
+  const sourceWith = (literal: string) =>
+    `export default async () => ({ auth: ${JSON.stringify(literal)} });`;
+
+  async function storedSourceRows(): Promise<number> {
+    const row = await getDbClient().get<{ n: number }>(
+      `SELECT (SELECT COUNT(*) FROM scripts) + (SELECT COUNT(*) FROM script_versions)
+            + (SELECT COUNT(*) FROM script_runs) AS n`,
+    );
+    return row?.n ?? 0;
+  }
+
+  type Refusal = { error: string; message: string; findings: { kind: string; id: string }[] };
+
+  async function expectRefused(
+    response: TestResponse,
+    secretValue: string,
+    finding: { kind: string; id: string },
+  ): Promise<void> {
+    expect(response.status).toBe(400);
+    expect(response.text).not.toContain(secretValue);
+    const body = (await response.json()) as Refusal;
+    expect(body.error).toBe("source_contains_secret");
+    expect(body.findings).toContainEqual(finding);
+    expect(body.message).toContain(finding.id);
+    expect(body.message).toContain("ctx.swarm.config.get");
+    expect(body.message).toContain("credential binding");
+  }
+
+  afterAll(() => clearVolatileSecretsForTesting());
+
+  test("script-upsert refuses a registered secret in every encoded form, and persists nothing", async () => {
+    const value = `upsert-${randomToken(32)}`;
+    const name = configSecretName("UPSTREAM_TOKEN");
+    registerStoredSecret(value, name);
+    const before = await storedSourceRows();
+    for (const form of [
+      value,
+      Buffer.from(value).toString("base64"),
+      Buffer.from(value).toString("base64url"),
+    ]) {
+      const response = await upsert({ name: "leaky-upsert", source: sourceWith(form) });
+      await expectRefused(response, value, { kind: "registered-secret", id: name });
+      expect(response.text).not.toContain(form);
+    }
+    expect(await storedSourceRows()).toBe(before);
+  });
+
+  test("script-upsert refuses a gitleaks token shape and names the rule", async () => {
+    const token = `ghp_${randomToken(36)}`;
+    const before = await storedSourceRows();
+    const response = await upsert({ name: "leaky-gitleaks", source: sourceWith(token) });
+    await expectRefused(response, token, { kind: "gitleaks-rule", id: "github-pat" });
+    expect(await storedSourceRows()).toBe(before);
+  });
+
+  test("inline script-run refuses before running, saving a scratch script or recording the run", async () => {
+    const value = `inline-${randomToken(32)}`;
+    const name = configSecretName("INLINE_TOKEN");
+    registerStoredSecret(value, name);
+    const before = await storedSourceRows();
+    const response = await dispatch("/api/scripts/run", {
+      method: "POST",
+      agentId: workerId,
+      body: JSON.stringify({ source: sourceWith(value), intent: "leaky inline" }),
+    });
+    await expectRefused(response, value, { kind: "registered-secret", id: name });
+    expect(await storedSourceRows()).toBe(before);
+  });
+
+  test("control: clean source still upserts", async () => {
+    const response = await upsert({ name: "clean-upsert", source: validSource(2) });
+    expect(response.status).toBe(200);
+  });
+});

package/src/tests/scrubbed-text-12e.test.ts

@@ -0,0 +1,289 @@
+/**
+ * Write-time scrub for memory, channel and inbox messages, approval requests,
+ * schedules, task text and agent_log.oldValue. Each test writes a synthetic
+ * secret through the real writer, reads the row back from SQLite, and checks
+ * that the secret is gone while a redaction marker and the surrounding
+ * non-secret text survive.
+ */
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { recordSchedulePreflightFailure } from "../be/automation-preflight";
+import {
+  cancelApprovalRequestById,
+  cancelPendingApprovalRequestsForRun,
+  closeDb,
+  createAgent,
+  createApprovalRequest,
+  createChannel,
+  createInboxMessage,
+  createLogEntry,
+  createScheduledTask,
+  createTask,
+  createTaskExtended,
+  createWorkflow,
+  createWorkflowRun,
+  getApprovalRequestById,
+  getDbClient,
+  initDb,
+  markInboxMessageResponded,
+  postMessage,
+  recordApprovalVotes,
+  resolveApprovalRequest,
+  updateScheduledTask,
+} from "../be/db";
+import { SqliteMemoryStore } from "../be/memory/providers/sqlite-store";
+import { isSealedJson } from "../be/sealed-json";
+import { registerVolatileSecret } from "../utils/secret-scrubber";
+import { type SyntheticSecret, syntheticSecret } from "./synthetic-secret-helpers";
+
+const TEST_DB_PATH = "./test-scrubbed-text-12e.sqlite";
+const agentId = "aaaaaaaa-0000-4000-8000-000000000e12";
+
+let secret: SyntheticSecret;
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {}
+  }
+}
+
+/** Secret absent, a redaction marker present, and the context kept. */
+function expectScrubbed(value: string | null | undefined, context: string): void {
+  expect(value).toBeTruthy();
+  expect(value).not.toContain(secret.value);
+  expect(value).toContain("[REDACTED:");
+  expect(value).toContain(context);
+}
+
+async function column(table: string, col: string, id: string): Promise<string | null> {
+  const row = await getDbClient().get<Record<string, string | null>>(
+    `SELECT "${col}" AS v FROM ${table} WHERE id = ?`,
+    [id],
+  );
+  return row?.v ?? null;
+}
+
+beforeAll(async () => {
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+  await createAgent({ id: agentId, name: "Scrub 12e Agent", isLead: false, status: "idle" });
+  secret = syntheticSecret("scrub12e");
+});
+
+// The test preload clears volatile secrets after every test, so register per test.
+beforeEach(() => registerVolatileSecret(secret.value, secret.name));
+
+afterAll(async () => {
+  secret.cleanup();
+  closeDb();
+  await removeDbFiles();
+});
+
+describe("agent_memory", () => {
+  test("store scrubs name, content, summary, tags, version row and FTS row", async () => {
+    const store = new SqliteMemoryStore();
+    const memory = await store.store({
+      agentId,
+      scope: "agent",
+      name: `deploy note ${secret.value}`,
+      content: `the deploy token is ${secret.value} for staging`,
+      summary: `summary ${secret.value}`,
+      tags: [`tag ${secret.value}`, "plain"],
+      source: "manual",
+    });
+    // Callers embed the returned content, so it must be the scrubbed text.
+    expectScrubbed(memory.content, "for staging");
+    expectScrubbed(await column("agent_memory", "name", memory.id), "deploy note");
+    expectScrubbed(await column("agent_memory", "content", memory.id), "for staging");
+    expectScrubbed(await column("agent_memory", "summary", memory.id), "summary");
+    const tags = await column("agent_memory", "tags", memory.id);
+    expectScrubbed(tags, "plain");
+    expect(JSON.parse(tags!)[0]).toContain("tag ");
+    const version = await getDbClient().get<{ content: string }>(
+      "SELECT content FROM agent_memory_version WHERE memory_id = ?",
+      [memory.id],
+    );
+    expectScrubbed(version?.content, "for staging");
+    const fts = await getDbClient().get<{ content: string }>(
+      "SELECT content FROM memory_fts WHERE memory_id = ?",
+      [memory.id],
+    );
+    if (fts) expectScrubbed(fts.content, "for staging");
+  });
+
+  test("edit scrubs the new content", async () => {
+    const store = new SqliteMemoryStore();
+    const memory = await store.store({
+      agentId,
+      scope: "agent",
+      name: "editable",
+      content: "clean body",
+      source: "manual",
+    });
+    const result = await store.edit({
+      id: memory.id,
+      mode: "replace",
+      content: `edited body ${secret.value} end`,
+      intent: "edit with secret",
+      changedByAgentId: agentId,
+    });
+    expect(result.changed).toBe(true);
+    expectScrubbed(result.memory.content, "edited body");
+    expectScrubbed(await column("agent_memory", "content", memory.id), "edited body");
+  });
+});
+
+describe("agent_tasks.task and agent_log.oldValue", () => {
+  test("createTaskExtended scrubs the task text", async () => {
+    const task = await createTaskExtended(`run the job with ${secret.value} please`, { agentId });
+    expectScrubbed(await column("agent_tasks", "task", task.id), "run the job");
+  });
+
+  test("createTask scrubs the task text", async () => {
+    const task = await createTask(agentId, `legacy create ${secret.value} please`);
+    expectScrubbed(await column("agent_tasks", "task", task.id), "legacy create");
+  });
+
+  test("createLogEntry scrubs oldValue", async () => {
+    const log = await createLogEntry({
+      eventType: "task_status_change",
+      agentId,
+      oldValue: `previous ${secret.value}`,
+      newValue: "next",
+    });
+    expectScrubbed(await column("agent_log", "oldValue", log.id), "previous");
+  });
+});
+
+describe("channel and inbox messages", () => {
+  test("postMessage scrubs content", async () => {
+    const channel = await createChannel(`scrub-12e-${crypto.randomUUID().slice(0, 8)}`);
+    const message = await postMessage(channel.id, agentId, `hello ${secret.value} channel`);
+    expectScrubbed(await column("channel_messages", "content", message.id), "channel");
+  });
+
+  test("createInboxMessage and markInboxMessageResponded scrub free text", async () => {
+    const inbox = await createInboxMessage(agentId, `inbox body ${secret.value}`, {
+      matchedText: `matched ${secret.value}`,
+    });
+    expectScrubbed(await column("inbox_messages", "content", inbox.id), "inbox body");
+    expectScrubbed(await column("inbox_messages", "matchedText", inbox.id), "matched");
+    await markInboxMessageResponded(inbox.id, `reply ${secret.value}`);
+    expectScrubbed(await column("inbox_messages", "responseText", inbox.id), "reply");
+  });
+});
+
+describe("scheduled_tasks", () => {
+  test("create and update scrub description, taskTemplate and lastErrorMessage", async () => {
+    const schedule = await createScheduledTask({
+      name: `scrub-12e-${crypto.randomUUID().slice(0, 8)}`,
+      intervalMs: 60_000,
+      description: `desc ${secret.value}`,
+      taskTemplate: `call the api with ${secret.value}`,
+    });
+    expectScrubbed(await column("scheduled_tasks", "description", schedule.id), "desc");
+    expectScrubbed(await column("scheduled_tasks", "taskTemplate", schedule.id), "call the api");
+
+    await updateScheduledTask(schedule.id, {
+      description: `new desc ${secret.value}`,
+      taskTemplate: `new template ${secret.value}`,
+      lastErrorMessage: `boom ${secret.value}`,
+    });
+    expectScrubbed(await column("scheduled_tasks", "description", schedule.id), "new desc");
+    expectScrubbed(await column("scheduled_tasks", "taskTemplate", schedule.id), "new template");
+    expectScrubbed(await column("scheduled_tasks", "lastErrorMessage", schedule.id), "boom");
+  });
+
+  test("preflight failure scrubs the message and still dedups the same day", async () => {
+    const schedule = await createScheduledTask({
+      name: `scrub-12e-${crypto.randomUUID().slice(0, 8)}`,
+      intervalMs: 60_000,
+      taskTemplate: "work",
+    });
+    const now = new Date();
+    expect(await recordSchedulePreflightFailure(schedule.id, `missing ${secret.value}`, now)).toBe(
+      true,
+    );
+    expectScrubbed(await column("scheduled_tasks", "lastErrorMessage", schedule.id), "missing");
+    // Same raw reason the same day: the scrubbed compare still matches.
+    expect(await recordSchedulePreflightFailure(schedule.id, `missing ${secret.value}`, now)).toBe(
+      false,
+    );
+  });
+});
+
+describe("approval_requests", () => {
+  test("create, vote and resolve scrub title, questions, approvals and resolutionReason, seal responses", async () => {
+    const id = crypto.randomUUID();
+    await createApprovalRequest({
+      id,
+      title: `approve ${secret.value} deploy`,
+      questions: [{ id: "q1", type: "text", label: `paste ${secret.value} here` }],
+      approvers: { users: [], policy: "any" },
+    });
+    expectScrubbed(await column("approval_requests", "title", id), "deploy");
+    const questions = await column("approval_requests", "questions", id);
+    expectScrubbed(questions, "paste");
+    expect(() => JSON.parse(questions!)).not.toThrow();
+
+    const vote = {
+      responder: "operator",
+      approved: true,
+      responses: { q1: `note ${secret.value}` },
+      respondedAt: new Date().toISOString(),
+    };
+    expect(await recordApprovalVotes(id, [vote])).toBe(true);
+    const votes = await column("approval_requests", "approvals", id);
+    expectScrubbed(votes, "note");
+    expect(() => JSON.parse(votes!)).not.toThrow();
+
+    const responses = { q1: `note ${secret.value}` };
+    await resolveApprovalRequest(id, {
+      status: "approved",
+      responses,
+      approvals: [vote],
+      resolutionReason: `because ${secret.value}`,
+    });
+    expectScrubbed(await column("approval_requests", "resolutionReason", id), "because");
+    expectScrubbed(await column("approval_requests", "approvals", id), "note");
+
+    // Responses resume the workflow on recovery, so they stay byte-exact for
+    // the reader and hold no plaintext at rest.
+    const stored = await column("approval_requests", "responses", id);
+    expect(isSealedJson(stored ?? "")).toBe(true);
+    expect(stored).not.toContain(secret.value);
+    expect(stored).not.toContain("note");
+    expect((await getApprovalRequestById(id))?.responses).toEqual(responses);
+  });
+
+  test("cancel paths scrub the reason", async () => {
+    const single = crypto.randomUUID();
+    await createApprovalRequest({
+      id: single,
+      title: "single",
+      questions: [],
+      approvers: { users: [], policy: "any" },
+    });
+    await cancelApprovalRequestById(single, { reason: `stop ${secret.value}`, resolvedBy: null });
+    expectScrubbed(await column("approval_requests", "resolutionReason", single), "stop");
+
+    const workflow = await createWorkflow({
+      name: `scrub-12e-${crypto.randomUUID().slice(0, 8)}`,
+      definition: { nodes: [] },
+    });
+    const runId = crypto.randomUUID();
+    await createWorkflowRun({ id: runId, workflowId: workflow.id });
+    const inRun = crypto.randomUUID();
+    await createApprovalRequest({
+      id: inRun,
+      title: "in run",
+      questions: [],
+      approvers: { users: [], policy: "any" },
+      workflowRunId: runId,
+    });
+    await cancelPendingApprovalRequestsForRun(runId, `run cancelled ${secret.value}`);
+    expectScrubbed(await column("approval_requests", "resolutionReason", inRun), "run cancelled");
+  });
+});