@desplega.ai/agent-swarm 2.4.1 → 2.4.3

package/src/tests/claude-stop-hook.test.ts

@@ -371,6 +371,53 @@ describe("runStopHookSessionSummary", () => {
     expect(consoleErrors.length).toBe(0);
   });
 
+  test.each(["true", "TRUE"])("SKIP_SESSION_SUMMARY=%s → no runSummarize call", async (value) => {
+    const transcriptPath = await writeTempTranscript(longTranscript());
+
+    let runSummarizeCalled = false;
+    const deps: RunStopHookSessionSummaryDeps = {
+      runSummarize: async () => {
+        runSummarizeCalled = true;
+        throw new Error("should not be called");
+      },
+    };
+
+    await runStopHookSessionSummary(
+      {
+        agentId: "agent-claude-1",
+        transcriptPath,
+        env: makeEnv({ SKIP_SESSION_SUMMARY: value }),
+      },
+      deps,
+    );
+
+    expect(runSummarizeCalled).toBe(false);
+    expect(fetchCalls.length).toBe(0);
+  });
+
+  test.each(["0", "false"])("SKIP_SESSION_SUMMARY=%s → summary still runs", async (value) => {
+    const transcriptPath = await writeTempTranscript(longTranscript());
+
+    let runSummarizeCalled = false;
+    const deps: RunStopHookSessionSummaryDeps = {
+      runSummarize: async () => {
+        runSummarizeCalled = true;
+        return null;
+      },
+    };
+
+    await runStopHookSessionSummary(
+      {
+        agentId: "agent-claude-1",
+        transcriptPath,
+        env: makeEnv({ SKIP_SESSION_SUMMARY: value }),
+      },
+      deps,
+    );
+
+    expect(runSummarizeCalled).toBe(true);
+  });
+
   test("short transcript (≤100 chars) → no runSummarize call, no POST", async () => {
     const transcriptPath = await writeTempTranscript("tiny");
 

package/src/tests/codex-adapter.test.ts

@@ -2294,6 +2294,48 @@ describe("CodexSession session-end summarization", () => {
     expect(indexCalls.length).toBe(0);
   });
 
+  test.each(["true", "TRUE"])("SKIP_SESSION_SUMMARY=%s → no runSummarize call", async (value) => {
+    process.env.SKIP_SESSION_SUMMARY = value;
+    const events = buildSummaryEvents();
+
+    let runSummarizeCalls = 0;
+    const deps: SummarizeSessionForCodexDeps = {
+      runSummarize: async () => {
+        runSummarizeCalls += 1;
+        return null;
+      },
+    };
+
+    const config = testConfig({
+      logFile: join(tmpLogDir, `skip-${value}.log`),
+      cwd: "",
+    });
+    await runSessionWithFakeThreadAndDeps(events, config, deps);
+
+    expect(runSummarizeCalls).toBe(0);
+  });
+
+  test.each(["0", "false"])("SKIP_SESSION_SUMMARY=%s → summary still runs", async (value) => {
+    process.env.SKIP_SESSION_SUMMARY = value;
+    const events = buildSummaryEvents();
+
+    let runSummarizeCalls = 0;
+    const deps: SummarizeSessionForCodexDeps = {
+      runSummarize: async () => {
+        runSummarizeCalls += 1;
+        return null;
+      },
+    };
+
+    const config = testConfig({
+      logFile: join(tmpLogDir, `no-skip-${value}.log`),
+      cwd: "",
+    });
+    await runSessionWithFakeThreadAndDeps(events, config, deps);
+
+    expect(runSummarizeCalls).toBe(1);
+  });
+
   test("missing taskId → no runSummarize call, no POST", async () => {
     const events = buildSummaryEvents();
 

package/src/tests/db-task-read-contract.test.ts

@@ -111,6 +111,7 @@ value:ReservedAgentRoleError
 value:SESSION_ACTIVITY_REFRESH_MIN_INTERVAL_MS
 value:SKILL_FILE_LIMITS
 value:SUPERSEDED_RESUME_REPAIR_WINDOW_MS
+value:TASK_LINEAGE_LIMITS
 value:UNATTRIBUTED_USER_ID
 value:__resetSqliteVecExtensionPathCacheForTests
 value:abandonSlackOutcomeDelivery
@@ -412,6 +413,7 @@ value:getSystemDefaultSkills
 value:getTaskAttachments
 value:getTaskById
 value:getTaskByWorkflowRunStepId
+value:getTaskLineage
 value:getTaskStats
 value:getTasksByAgentId
 value:getTasksByStatus
@@ -612,6 +614,7 @@ type:ExistingTrackerContextWorkReason
 type:PendingChatRelay
 type:TaskFilters
 value:SUPERSEDED_RESUME_REPAIR_WINDOW_MS
+value:TASK_LINEAGE_LIMITS
 value:findCompletedTaskInThread
 value:findExistingLinearTrackerContextWork
 value:findRecentCancelledTaskInThread
@@ -639,6 +642,7 @@ value:getSlackTasksMissingTree
 value:getSupersededTasksWithUnsettledDependents
 value:getSupersededTasksWithoutResume
 value:getTaskById
+value:getTaskLineage
 value:getTaskStats
 value:getTasksByAgentId
 value:getTasksByStatus

package/src/tests/db-task-write-contract.test.ts

@@ -134,6 +134,7 @@ value:ReservedAgentRoleError
 value:SESSION_ACTIVITY_REFRESH_MIN_INTERVAL_MS
 value:SKILL_FILE_LIMITS
 value:SUPERSEDED_RESUME_REPAIR_WINDOW_MS
+value:TASK_LINEAGE_LIMITS
 value:UNATTRIBUTED_USER_ID
 value:__resetSqliteVecExtensionPathCacheForTests
 value:abandonSlackOutcomeDelivery
@@ -435,6 +436,7 @@ value:getSystemDefaultSkills
 value:getTaskAttachments
 value:getTaskById
 value:getTaskByWorkflowRunStepId
+value:getTaskLineage
 value:getTaskStats
 value:getTasksByAgentId
 value:getTasksByStatus

package/src/tests/docs-index-footprint.test.js

@@ -103,8 +103,8 @@ describe("docs API index footprint", () => {
     expect(spec.paths["/api/agents/{id}/runtime"]?.get).toBeDefined();
 
     const generatedKeys = await generatedOperationKeys();
-    expect(operationKeys).toHaveLength(436);
-    expect(generatedKeys).toHaveLength(436);
+    expect(operationKeys).toHaveLength(437);
+    expect(generatedKeys).toHaveLength(437);
     expect(new Set(generatedKeys)).toEqual(new Set(operationKeys));
   });
 

package/src/tests/env-flag.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { validateConfigValue } from "../be/swarm-config-guard";
-import { isEnvFlagEnabled, parseEnvFlag } from "../utils/env-flag";
+import { isEnvFlagEnabled, isSessionSummarySkipped, parseEnvFlag } from "../utils/env-flag";
 
 describe("parseEnvFlag", () => {
   test("accepts both truthy serializations", () => {
@@ -199,3 +199,17 @@ describe("swarm-config-guard: Configuration-page value validation", () => {
     expect(validateConfigValue("SOME_RANDOM_KEY", "whatever")).toBeNull();
   });
 });
+
+describe("isSessionSummarySkipped", () => {
+  test.each(["1", "true", "TRUE", " True "])("SKIP_SESSION_SUMMARY=%p skips", (value) => {
+    expect(isSessionSummarySkipped({ SKIP_SESSION_SUMMARY: value })).toBe(true);
+  });
+
+  test.each(["0", "false", "FALSE", ""])("SKIP_SESSION_SUMMARY=%p keeps the summary", (value) => {
+    expect(isSessionSummarySkipped({ SKIP_SESSION_SUMMARY: value })).toBe(false);
+  });
+
+  test("unset keeps the summary", () => {
+    expect(isSessionSummarySkipped({})).toBe(false);
+  });
+});

package/src/tests/github-handlers-cancel-config.test.ts

@@ -6,8 +6,8 @@
  *   github.cancelOnUnassign              — PR unassigned + issue unassigned
  *   github.cancelOnReviewRequestRemoved  — PR review_request_removed
  *
- * Absent / any value ≠ "false" → cancel (current behavior, default).
- * Value "false" → leave task untouched, return { created: false }.
+ * Absent / empty / unrecognized values → cancel (default).
+ * Values "false" / "0" (case-insensitive, trimmed) → leave task untouched.
  */
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
@@ -122,8 +122,15 @@ describe("PR unassigned — github.cancelOnUnassign", () => {
     expect(await getTaskStatus(taskId)).toBe("failed");
   });
 
-  test("config = 'false': unassign leaves task untouched", async () => {
-    await setConfigFlag("github.cancelOnUnassign", "false");
+  test.each([
+    "false",
+    "FALSE",
+    "False",
+    "0",
+    " false ",
+    " 0 ",
+  ])("config = %j: unassign leaves task untouched", async (value) => {
+    await setConfigFlag("github.cancelOnUnassign", value);
     const taskId = await seedTask(BASE_PR.number, "pr");
     expect(await getTaskStatus(taskId)).toBe("pending");
 
@@ -162,8 +169,15 @@ describe("issue unassigned — github.cancelOnUnassign", () => {
     expect(await getTaskStatus(taskId)).toBe("failed");
   });
 
-  test("config = 'false': unassign leaves task untouched", async () => {
-    await setConfigFlag("github.cancelOnUnassign", "false");
+  test.each([
+    "false",
+    "FALSE",
+    "False",
+    "0",
+    " false ",
+    " 0 ",
+  ])("config = %j: unassign leaves task untouched", async (value) => {
+    await setConfigFlag("github.cancelOnUnassign", value);
     const taskId = await seedTask(BASE_ISSUE.number, "issue");
     expect(await getTaskStatus(taskId)).toBe("pending");
 
@@ -201,8 +215,15 @@ describe("PR review_request_removed — github.cancelOnReviewRequestRemoved", ()
     expect(await getTaskStatus(taskId)).toBe("failed");
   });
 
-  test("config = 'false': review removal leaves task untouched", async () => {
-    await setConfigFlag("github.cancelOnReviewRequestRemoved", "false");
+  test.each([
+    "false",
+    "FALSE",
+    "False",
+    "0",
+    " false ",
+    " 0 ",
+  ])("config = %j: review removal leaves task untouched", async (value) => {
+    await setConfigFlag("github.cancelOnReviewRequestRemoved", value);
     const taskId = await seedTask(BASE_PR.number, "pr");
     expect(await getTaskStatus(taskId)).toBe("pending");
 

package/src/tests/github-handlers-inline-comments.test.ts

@@ -573,9 +573,16 @@ describe("no-op approved reviews", () => {
     }
   });
 
-  test("GITHUB_SKIP_NOOP_APPROVALS=false: empty-body approval still creates a task", async () => {
+  test.each([
+    "false",
+    "FALSE",
+    "False",
+    "0",
+    " false ",
+    " 0 ",
+  ])("GITHUB_SKIP_NOOP_APPROVALS=%j: empty-body approval still creates a task", async (value) => {
     const previous = process.env.GITHUB_SKIP_NOOP_APPROVALS;
-    process.env.GITHUB_SKIP_NOOP_APPROVALS = "false";
+    process.env.GITHUB_SKIP_NOOP_APPROVALS = value;
     const fetchSpy = mockFetchForApproval({ reviews: [APPROVED_BY_REVIEWER] });
 
     try {

package/src/tests/runner-harness-telemetry-env.test.ts

@@ -11,6 +11,12 @@ const TELEMETRY_PATH = join(import.meta.dir, "..", "telemetry.ts");
 // leaves the process), and print the environment the event carries.
 const BOOT_SCRIPT = `
 const t = await import(${JSON.stringify(TELEMETRY_PATH)});
+const { mkdtempSync, rmSync } = await import("node:fs");
+const { tmpdir } = await import("node:os");
+const { pathToFileURL } = await import("node:url");
+const root = mkdtempSync(tmpdir() + "/telemetry-package-");
+t.getTelemetryEnvironment(pathToFileURL(root + "/"));
+rmSync(root, { recursive: true, force: true });
 let body;
 globalThis.fetch = async (_url, init) => {
   body = JSON.parse(init.body);

package/src/tests/script-connections.test.ts

@@ -634,6 +634,8 @@ describe("script connections", () => {
       markMigrationApplied(database, "220_model_profiles.sql");
       // 227 alters inbox_item_state, which this migration-112-only fixture does not create.
       markMigrationApplied(database, "227_inbox_item_state_last_read_at.sql");
+      // 231 indexes agent_tasks columns that this fixture's id-only agent_tasks lacks.
+      markMigrationApplied(database, "231_slack_tasks_last_updated_index.sql");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();

package/src/tests/skill-script-refs.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+import { join, relative } from "node:path";
+import { SEED_SCRIPTS } from "../be/seed-scripts";
+
+// A shipped skill that tells agents to `script-run` a named script must name a
+// script this repo ships in SEED_SCRIPTS. Otherwise the skill works only on a
+// swarm that happens to hold that script in its catalog, and every other
+// deployment hits "Script not found" at that step.
+
+const REPO_ROOT = join(import.meta.dir, "../..");
+// Seeded skills, baked plugin commands/agents/skills, and public operator skills.
+const SKILL_DIRS = ["templates/skills", "plugin", "skills"].map((d) => join(REPO_ROOT, d));
+
+// `script-run name="x"` and the prose forms "`script-run` with name `x`" / "`script-run` on `x`".
+const REF_PATTERNS = [
+  /script-run\s+name=["']([a-z0-9][a-z0-9-]*)["']/g,
+  /`script-run`\s+(?:with\s+name|on)\s+`([a-z0-9][a-z0-9-]*)`/g,
+];
+
+function findScriptRefs(text: string): string[] {
+  const names = new Set<string>();
+  for (const re of REF_PATTERNS) {
+    for (const m of text.matchAll(re)) if (m[1]) names.add(m[1]);
+  }
+  return [...names];
+}
+
+async function collectRefs(): Promise<{ file: string; name: string }[]> {
+  const refs: { file: string; name: string }[] = [];
+  for (const dir of SKILL_DIRS) {
+    for await (const path of new Bun.Glob("**/*.md").scan({ cwd: dir, absolute: true })) {
+      const text = await Bun.file(path).text();
+      for (const name of findScriptRefs(text)) refs.push({ file: relative(REPO_ROOT, path), name });
+    }
+  }
+  return refs;
+}
+
+describe("shipped skills only script-run scripts the repo ships", () => {
+  test("the reference scanner matches each call form and ignores prose", () => {
+    expect(
+      findScriptRefs(
+        [
+          'Run `script-run name="internal-only-gate" scope="global" args=<draft>`.',
+          "Run `script-run` with name `boot-triage`.",
+          "Preview with `script-run` on `heartbeat-jev-gate`.",
+          "Seed scripts (`script-run` with `name` and `args`):",
+          "Inline `script-run` for a one-off.",
+        ].join("\n"),
+      ).sort(),
+    ).toEqual(["boot-triage", "heartbeat-jev-gate", "internal-only-gate"]);
+  });
+
+  test("every script-run name in a shipped skill is in SEED_SCRIPTS", async () => {
+    const refs = await collectRefs();
+    // Positive control: the scan must see heartbeat-runbook's boot-triage reference, or it is blind.
+    expect(refs.some((r) => r.name === "boot-triage")).toBe(true);
+
+    const shipped = new Set(SEED_SCRIPTS.map((s) => s.name));
+    const missing = refs.filter((r) => !shipped.has(r.name)).map((r) => `${r.file}: ${r.name}`);
+    expect(missing).toEqual([]);
+  });
+});

package/src/tests/slack-render-v2-query-plans.test.ts

@@ -0,0 +1,147 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getDb,
+  getDbClient,
+  getResolvableDeferralOutcomes,
+  initDb,
+  recordSlackMessage,
+} from "../be/db";
+import { getSlackTasksMissingTree } from "../be/db/tasks/read";
+import { completeTask, startTask } from "../be/db/tasks/write";
+
+// Both queries run on every Slack watcher tick. The DB has no sqlite_stat1, so
+// the planner works from heuristics; these pin the plans that keep each tick
+// proportional to Slack rows instead of every task.
+
+async function capturedSql(run: () => Promise<unknown>): Promise<string> {
+  const client = getDbClient();
+  const seen: string[] = [];
+  const original = client.query.bind(client);
+  const spy = spyOn(client, "query").mockImplementation(((sql: string, params?: unknown[]) => {
+    seen.push(sql);
+    return original(sql, params);
+  }) as typeof client.query);
+  try {
+    await run();
+  } finally {
+    spy.mockRestore();
+  }
+  expect(seen).toHaveLength(1);
+  return seen[0]!;
+}
+
+function plan(sql: string, params: unknown[] = []): string {
+  return getDb()
+    .query<{ detail: string }, any[]>(`EXPLAIN QUERY PLAN ${sql}`)
+    .all(...params)
+    .map((row) => row.detail)
+    .join("\n");
+}
+
+async function deferredAsk(label: string, leadId: string) {
+  const ask = await createTaskExtended(`ask ${label}`, {
+    agentId: leadId,
+    source: "slack",
+    slackChannelId: `C_${label}`,
+    slackThreadTs: `${label}.0`,
+  });
+  await startTask(ask.id);
+  await completeTask(ask.id, "Checking back later", {
+    addTags: ["deferred"],
+    deferredAt: new Date().toISOString(),
+  });
+  const card = await recordSlackMessage({
+    contextKey: `slack:C_${label}:${label}.0`,
+    channelId: `C_${label}`,
+    threadTs: `${label}.0`,
+    ts: `${label}.1`,
+    kind: "outcome",
+    taskId: ask.id,
+    finalized: true,
+  });
+  return { ask, card };
+}
+
+async function wake(parentTaskId: string, leadId: string, opts: { deferAgain?: boolean } = {}) {
+  await Bun.sleep(2);
+  const task = await createTaskExtended("wake", {
+    agentId: leadId,
+    parentTaskId,
+    taskType: "deferred",
+  });
+  await startTask(task.id);
+  await completeTask(
+    task.id,
+    "done",
+    opts.deferAgain ? { deferredAt: new Date().toISOString() } : {},
+  );
+  return task;
+}
+
+describe("slack render-v2 watcher queries", () => {
+  beforeEach(() => {
+    initDb(":memory:");
+    getDb().run(
+      "INSERT OR IGNORE INTO slack_render_v2_state (id, activated_at) VALUES (1, '2000-01-01T00:00:00.000Z')",
+    );
+  });
+
+  afterEach(() => {
+    closeDb();
+  });
+
+  test("deferral resolution drives from the chain, not from every task", async () => {
+    const sql = await capturedSql(() => getResolvableDeferralOutcomes());
+    const detail = plan(sql, [50]);
+    expect(detail).toContain(
+      "SEARCH wake USING INDEX idx_agent_tasks_parentTaskId (parentTaskId=?)",
+    );
+    expect(detail).not.toContain("idx_agent_tasks_taskType");
+    expect(detail).not.toContain("idx_agent_tasks_status_last_updated");
+  });
+
+  test("missing-tree scan reads only Slack tasks", async () => {
+    const sql = await capturedSql(() => getSlackTasksMissingTree());
+    const detail = plan(sql);
+    expect(detail).toContain("SCAN task USING INDEX idx_agent_tasks_slack_last_updated");
+    expect(detail).not.toContain("idx_agent_tasks_last_updated");
+  });
+
+  test("deferral resolution returns the latest terminal wake of each open chain", async () => {
+    const lead = await createAgent({ name: "Plan Lead", isLead: true, status: "idle" });
+
+    const single = await deferredAsk("SINGLE", lead.id);
+    const singleWake = await wake(single.ask.id, lead.id);
+
+    const chained = await deferredAsk("CHAIN", lead.id);
+    const firstWake = await wake(chained.ask.id, lead.id, { deferAgain: true });
+    const lastWake = await wake(firstWake.id, lead.id);
+
+    const pending = await deferredAsk("PENDING", lead.id);
+    const running = await createTaskExtended("still running", {
+      agentId: lead.id,
+      parentTaskId: pending.ask.id,
+      taskType: "deferred",
+    });
+    await startTask(running.id);
+
+    const plainChild = await deferredAsk("PLAIN", lead.id);
+    const notDeferred = await createTaskExtended("ordinary child", {
+      agentId: lead.id,
+      parentTaskId: plainChild.ask.id,
+    });
+    await startTask(notDeferred.id);
+    await completeTask(notDeferred.id, "done");
+
+    const rows = await getResolvableDeferralOutcomes();
+    expect(rows.map((row) => [row.card.id, row.deferredTaskId, row.wakeTaskId]).sort()).toEqual(
+      [
+        [single.card.id, single.ask.id, singleWake.id],
+        [chained.card.id, chained.ask.id, lastWake.id],
+      ].sort(),
+    );
+  });
+});