@desplega.ai/agent-swarm 2.4.2 → 2.4.4

package/src/tests/apps-action-parent-task.test.ts

@@ -0,0 +1,295 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import { parseAppDefinition } from "../apps/definition";
+import { createApp } from "../apps/store";
+import {
+  closeDb,
+  createAgent,
+  createTask,
+  createTaskExtended,
+  createUser,
+  getTaskById,
+  initDb,
+} from "../be/db";
+import { type IdentityActor, mintToken } from "../be/users";
+import { handleApps } from "../http/apps";
+import { resolveHttpRequestAuth } from "../http/auth";
+import { SESSION_WRITE_DENIED } from "../http/session-access";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { setRequestAuth } from "../utils/request-auth-context";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = `/private/tmp/test-apps-action-parent-task-${process.pid}.sqlite`;
+const API_KEY = "example-apps-action-parent-task-key";
+const OPERATOR_ACTOR: IdentityActor = { kind: "operator", id: "apps-action-parent-task-test" };
+/** Non-lead worker: the default caller. */
+const AGENT_ID = crypto.randomUUID();
+const LEAD_ID = crypto.randomUUID();
+/** Owns the parent task the worker has no context for. */
+const OTHER_AGENT_ID = crypto.randomUUID();
+const TASK_ACTION = "generateScreen";
+const SYNC_ACTION = "syncNotes";
+const CHAIN_ISSUE = "$row, $rowIndex, $form, and $chain bindings are only allowed in action params";
+
+let server: Server;
+let base = "";
+/** A user with no share on anyone else's session. */
+let userToken = "";
+let previousApiKey: string | undefined;
+
+function createTestServer(): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    setRequestAuth(req, await resolveHttpRequestAuth(req, API_KEY));
+    res.setHeader("Content-Type", "application/json");
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    const handled = await handleApps(req, res, pathSegments, queryParams, myAgentId);
+    if (!handled) {
+      res.writeHead(404);
+      res.end(JSON.stringify({ error: "not found" }));
+    }
+  });
+}
+
+/** Runs an action as an agent (default: the worker) or, with `bearer`, as a token holder. */
+async function runAction<T>(
+  appId: string,
+  body: Record<string, unknown>,
+  options: { agentId?: string; bearer?: string; action?: string } = {},
+): Promise<{ status: number; body: T }> {
+  const action = options.action ?? TASK_ACTION;
+  const response = await fetch(`${base}/api/apps/${appId}/actions/${action}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(options.bearer
+        ? { Authorization: `Bearer ${options.bearer}` }
+        : { "X-Agent-ID": options.agentId ?? AGENT_ID }),
+    },
+    body: JSON.stringify(body),
+  });
+  return { status: response.status, body: (await response.json()) as T };
+}
+
+/** A page whose Button chains a task-kind action under the chain scope's leaf task. */
+function chainedButtonPage() {
+  return {
+    root: "root",
+    elements: {
+      root: { type: "Container", props: {}, children: ["send"] },
+      send: {
+        type: "Button",
+        props: { label: "Send" },
+        on: {
+          press: [
+            {
+              action: "app.action",
+              params: {
+                name: TASK_ACTION,
+                input: { prompt: "next step" },
+                parentTaskId: { $chain: "leafTaskId" },
+              },
+            },
+          ],
+        },
+      },
+    },
+  };
+}
+
+function definitionWith(page: Record<string, unknown>) {
+  return {
+    models: {
+      note: {
+        columns: { title: { kind: "string" } },
+        // The sync action needs one (model x source) pair to be valid.
+        sources: { tracker: { connector: "swarm-tasks", joinKey: "title" } },
+      },
+    },
+    queries: { allNotes: { model: "note" } },
+    actions: {
+      [TASK_ACTION]: { kind: "task", prompt: "Generate the next screen" },
+      // A non-task action, to show parentTaskId is rejected rather than dropped.
+      [SYNC_ACTION]: { kind: "sync" },
+    },
+    pages: { main: page },
+    defaultPage: "main",
+  };
+}
+
+/** Stores the chained-Button app the way the API does: validated first. */
+async function createChainedApp(): Promise<string> {
+  const parsed = await parseAppDefinition(definitionWith(chainedButtonPage()));
+  if (!parsed.success) throw new Error(JSON.stringify(parsed.issues));
+  const app = await createApp({
+    name: `Chained ${crypto.randomUUID()}`,
+    definition: parsed.definition,
+  });
+  return app.id;
+}
+
+beforeAll(async () => {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+  // Safe to mutate: CI runs one process per test file (`bun test --parallel=4`)
+  // and afterAll restores the previous value.
+  previousApiKey = process.env.AGENT_SWARM_API_KEY;
+  process.env.AGENT_SWARM_API_KEY = API_KEY;
+  initDb(TEST_DB_PATH);
+  const user = await createUser({ name: "Parent Task User" });
+  userToken = (await mintToken(user.id, "apps-action-parent-task", OPERATOR_ACTOR)).plaintext;
+  await createAgent({ id: AGENT_ID, name: "parent-task-worker", isLead: false, status: "idle" });
+  await createAgent({ id: LEAD_ID, name: "parent-task-lead", isLead: true, status: "idle" });
+  await createAgent({
+    id: OTHER_AGENT_ID,
+    name: "parent-task-other",
+    isLead: false,
+    status: "idle",
+  });
+  server = createTestServer();
+  const port = await listenOnFreePort(server, "127.0.0.1");
+  base = `http://127.0.0.1:${port}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+  if (previousApiKey === undefined) delete process.env.AGENT_SWARM_API_KEY;
+  else process.env.AGENT_SWARM_API_KEY = previousApiKey;
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+describe("$chain sentinel in the page validator", () => {
+  test("accepts parentTaskId: { $chain } inside an app.action step's params", async () => {
+    const parsed = await parseAppDefinition(definitionWith(chainedButtonPage()));
+    expect(parsed.success).toBe(true);
+  });
+
+  test("accepts a $chain sentinel nested deeper inside app.action params", async () => {
+    const page = chainedButtonPage();
+    page.elements.send.on.press[0]!.params = {
+      name: TASK_ACTION,
+      input: { context: { parentTaskId: { $chain: "leafTaskId" } } },
+    };
+    const parsed = await parseAppDefinition(definitionWith(page));
+    expect(parsed.success).toBe(true);
+  });
+
+  test("rejects a $chain sentinel used as a plain prop value", async () => {
+    const page = chainedButtonPage();
+    page.elements = {
+      ...page.elements,
+      echo: { type: "Text", props: { content: { $chain: "leafTaskId" } } },
+    } as typeof page.elements;
+    page.elements.root.children = ["send", "echo"];
+    const parsed = await parseAppDefinition(definitionWith(page));
+    expect(parsed.success).toBe(false);
+    if (parsed.success) return;
+    expect(parsed.issues.some((entry) => entry.message === CHAIN_ISSUE)).toBe(true);
+  });
+});
+
+describe("POST /api/apps/:id/actions/:name with parentTaskId", () => {
+  test("chains the created task under the given parent", async () => {
+    const appId = await createChainedApp();
+    const parent = await createTask(AGENT_ID, "Previous turn of the chain");
+
+    const started = await runAction<{ ok: boolean; taskId: string; status: string }>(appId, {
+      input: { prompt: "next step" },
+      parentTaskId: parent.id,
+    });
+    expect(started.status).toBe(200);
+    expect(started.body).toMatchObject({ ok: true, status: "pending" });
+
+    const created = await getTaskById(started.body.taskId);
+    expect(created?.parentTaskId).toBe(parent.id);
+  });
+
+  test("answers 404 for an unknown parent instead of storing a dangling id", async () => {
+    const appId = await createChainedApp();
+    const missing = await runAction<{ error: string }>(appId, {
+      input: {},
+      parentTaskId: crypto.randomUUID(),
+    });
+    expect(missing.status).toBe(404);
+    expect(missing.body.error).toBe("parent task not found");
+  });
+
+  test("denies an agent caller without context for the parent, as POST /api/tasks does", async () => {
+    const appId = await createChainedApp();
+    const foreign = await createTask(OTHER_AGENT_ID, "Someone else's thread");
+
+    const denied = await runAction<{ error: string }>(appId, {
+      input: {},
+      parentTaskId: foreign.id,
+    });
+    expect(denied.status).toBe(403);
+    expect(denied.body.error).toBe(`You don't have context for parent task ${foreign.id}.`);
+
+    // A lead keeps its `task.parent.attach` grant: the gate is about identity, not the route.
+    const asLead = await runAction<{ taskId: string }>(
+      appId,
+      { input: {}, parentTaskId: foreign.id },
+      { agentId: LEAD_ID },
+    );
+    expect(asLead.status).toBe(200);
+    expect((await getTaskById(asLead.body.taskId))?.parentTaskId).toBe(foreign.id);
+  });
+
+  test("denies a user caller without a write share on the parent's session", async () => {
+    const appId = await createChainedApp();
+    const owner = await createUser({ name: "Session Owner" });
+    const theirs = await createTaskExtended("Someone else's session", {
+      agentId: OTHER_AGENT_ID,
+      requestedByUserId: owner.id,
+    });
+
+    const denied = await runAction<{ error: string }>(
+      appId,
+      { input: {}, parentTaskId: theirs.id },
+      { bearer: userToken },
+    );
+    expect(denied.status).toBe(403);
+    expect(denied.body.error).toBe(SESSION_WRITE_DENIED);
+  });
+
+  test("rejects parentTaskId on a non-task action instead of dropping it", async () => {
+    const appId = await createChainedApp();
+    const parent = await createTask(AGENT_ID, "Previous turn of the chain");
+
+    const rejected = await runAction<{ error: string }>(
+      appId,
+      { input: {}, parentTaskId: parent.id },
+      { action: SYNC_ACTION },
+    );
+    expect(rejected.status).toBe(400);
+    expect(rejected.body.error).toBe("parentTaskId is only supported for task-kind actions");
+  });
+
+  test("rejects an empty parentTaskId", async () => {
+    const appId = await createChainedApp();
+    const rejected = await runAction<{ error: string }>(appId, { input: {}, parentTaskId: "" });
+    expect(rejected.status).toBe(400);
+  });
+
+  test("still creates a parentless task when parentTaskId is omitted", async () => {
+    const appId = await createChainedApp();
+    const started = await runAction<{ ok: boolean; taskId: string }>(appId, { input: {} });
+    expect(started.status).toBe(200);
+    expect((await getTaskById(started.body.taskId))?.parentTaskId ?? null).toBeNull();
+  });
+});

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/codex-oauth-keep-warm.test.ts

@@ -10,7 +10,8 @@ import { afterAll, afterEach, beforeAll, describe, expect, it } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { closeDb, initDb, upsertKv } from "../be/db";
-import { handleCodexOAuthKeepWarm } from "../http/codex-oauth-keep-warm";
+import { validateConfigValue } from "../be/swarm-config-guard";
+import { handleCodexOAuthKeepWarm, keepWarmMaxAgeMs } from "../http/codex-oauth-keep-warm";
 import { handleOAuthLocks } from "../http/oauth-locks";
 import { resetFetchForTesting, setFetchForTesting } from "../providers/codex-oauth/flow.js";
 import type { CodexOAuthCredentials } from "../providers/codex-oauth/types.js";
@@ -176,6 +177,70 @@ describe("POST /api/oauth/keep-warm/codex", () => {
     expect(slots.get(1)?.access).toBe("example-at_keepwarm");
   });
 
+  it("refreshes a 6-day-old slot by default, before the ~6d20h point where OpenAI ended a session", async () => {
+    const slots = new Map<number, CodexOAuthCredentials>([
+      [
+        0,
+        {
+          access: "at_six_days",
+          refresh: "rt_six_days",
+          expires: Date.now() + 4 * 24 * 60 * 60 * 1000, // issued ~6 days ago (10d TTL)
+          accountId: "acc-six",
+        },
+      ],
+    ]);
+    installMockTransport(slots);
+    setFetchForTesting(
+      async () =>
+        new Response(
+          JSON.stringify({
+            access_token: "example-at_six_days_new",
+            refresh_token: "example-rt_six_days_new",
+            expires_in: 864000,
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } },
+        ),
+    );
+
+    const { req, res, captured } = fakeReqRes();
+    await handleCodexOAuthKeepWarm(req, res, ["api", "oauth", "keep-warm", "codex"]);
+
+    const body = JSON.parse(captured.body) as { results: Array<Record<string, unknown>> };
+    expect(body.results[0]).toMatchObject({ slot: 0, outcome: "refreshed" });
+    expect(slots.get(0)?.refresh).toBe("example-rt_six_days_new");
+  });
+
+  it("honors CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS read at sweep time", async () => {
+    const saved = process.env.CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS;
+    process.env.CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS = "168";
+    try {
+      const slots = new Map<number, CodexOAuthCredentials>([
+        [
+          0,
+          {
+            access: "at_six_days",
+            refresh: "rt_six_days",
+            expires: Date.now() + 4 * 24 * 60 * 60 * 1000, // issued ~6 days ago, under 168h
+            accountId: "acc-six",
+          },
+        ],
+      ]);
+      installMockTransport(slots);
+      setFetchForTesting(async () => {
+        throw new Error("no /oauth/token exchange should happen under a 168h threshold");
+      });
+
+      const { req, res, captured } = fakeReqRes();
+      await handleCodexOAuthKeepWarm(req, res, ["api", "oauth", "keep-warm", "codex"]);
+
+      const body = JSON.parse(captured.body) as { results: Array<Record<string, unknown>> };
+      expect(body.results[0]).toMatchObject({ slot: 0, outcome: "warm" });
+    } finally {
+      if (saved === undefined) delete process.env.CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS;
+      else process.env.CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS = saved;
+    }
+  });
+
   it("skips a slot with an active codex-auth-watch bench marker", async () => {
     const keySuffix = "c-old"; // last 5 of accountId (no chatgpt_user_id in this fixture's access token)
     await upsertKv({
@@ -284,6 +349,25 @@ describe("POST /api/oauth/keep-warm/codex", () => {
     }
   });
 
+  it("keepWarmMaxAgeMs defaults to 120h and ignores invalid or out-of-range values", () => {
+    const hour = 60 * 60 * 1000;
+    expect(keepWarmMaxAgeMs({})).toBe(120 * hour);
+    expect(keepWarmMaxAgeMs({ CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS: " 72 " })).toBe(72 * hour);
+    expect(keepWarmMaxAgeMs({ CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS: "216" })).toBe(216 * hour);
+    for (const bad of ["0", "217", "1.5", "-3", "abc", ""]) {
+      expect(keepWarmMaxAgeMs({ CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS: bad })).toBe(120 * hour);
+    }
+  });
+
+  it("the config API rejects the values keepWarmMaxAgeMs would fall back from", () => {
+    const key = "CODEX_OAUTH_KEEP_WARM_MAX_AGE_HOURS";
+    expect(validateConfigValue(key, "1")).toBeNull();
+    expect(validateConfigValue(key, "216")).toBeNull();
+    expect(validateConfigValue(key, "0")).toContain("between 1 and 216");
+    expect(validateConfigValue(key, "217")).toContain("between 1 and 216");
+    expect(validateConfigValue(key, "1.5")).toContain("integer");
+  });
+
   it("does not match unrelated paths", async () => {
     const { req, res } = fakeReqRes();
     const handled = await handleCodexOAuthKeepWarm(req, res, [

package/src/tests/config-session-auth.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { createServer, type Server } from "node:http";
 import { closeDb, createAgent, initDb, upsertSwarmConfig } from "../be/db";
+import { mintAgentToken, revokeAgentTokens } from "../be/users";
 import { handleConfig } from "../http/config";
 import { handleCore } from "../http/core";
 import { handleSessions } from "../http/sessions";
@@ -116,6 +117,19 @@ describe("config HTTP session-token authorization", () => {
     expect((await response.json()).configs[0].value).toBe("global");
   });
 
+  test("agent token resolved config without agentId reads its own agent scope", async () => {
+    const token = await mintAgentToken(workerId);
+    try {
+      const response = await fetch(`${baseUrl}/api/config/resolved?includeSecrets=true`, {
+        headers: headers(token.plaintext),
+      });
+      expect(response.status).toBe(200);
+      expect(await response.text()).toContain(SECRET);
+    } finally {
+      await revokeAgentTokens(workerId);
+    }
+  });
+
   for (const method of ["PUT", "DELETE"] as const) {
     test(`${method} cannot escalate a non-lead session by changing only X-Agent-ID`, async () => {
       const token = await mint(workerId);

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(437);
-    expect(generatedKeys).toHaveLength(437);
+    expect(operationKeys).toHaveLength(440);
+    expect(generatedKeys).toHaveLength(440);
     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 {