quadwork 1.4.0 → 1.5.0

package/server/routes.js

@@ -1118,11 +1118,13 @@ router.get("/api/github/merged-prs", (req, res) => {
 // deterministic from issue/PR state — no agent inference.
 //
 // Progress mapping (from upstream issue):
-//   queued    0%   issue exists, no linked PR
+//   queued    0%   issue OPEN, no linked PR
 //   in_review 20%  PR open, 0 approvals
 //   approved1 50%  PR open, 1 approval
 //   ready     80%  PR open, 2+ approvals
 //   merged   100%  PR merged AND issue closed
+//   closed   100%  issue CLOSED with no linked PR (superseded,
+//                  not planned, or runbook-only tasks) — #350
 //
 // Cached for 10s per project to avoid hammering gh on every poll.
 
@@ -1153,6 +1155,55 @@ function writeBatchSnapshot(projectId, snapshot) {
     // Non-fatal — panel still works from the live parse.
   }
 }
+function deleteBatchSnapshot(projectId) {
+  try {
+    fs.unlinkSync(batchSnapshotPath(projectId));
+  } catch {
+    // Non-fatal — file may already be gone.
+  }
+}
+
+// #334: verify the snapshot's first issue number still exists on
+// GitHub before trusting the snapshot. A soft existence check is
+// enough — if the first issue genuinely 404s, treat the whole
+// snapshot as stale (most likely a leftover from a prior
+// project/repo that was purged) and let the caller drop it. One
+// gh call per cache miss, wrapped in the existing
+// BATCH_PROGRESS_TTL_MS cache upstream.
+//
+// Returns one of:
+//   "fresh"   — first issue resolved, snapshot is trustworthy
+//   "gone"    — first issue confirmed 404; snapshot should be dropped
+//   "unknown" — transient error (auth/network/timeout); leave
+//               snapshot alone and let the next cache miss retry
+async function checkBatchSnapshotFreshness(repo, snapshot) {
+  if (!snapshot || !Array.isArray(snapshot.issueNumbers) || snapshot.issueNumbers.length === 0) {
+    return "gone";
+  }
+  const first = snapshot.issueNumbers[0];
+  try {
+    await ghJsonExecAsync([
+      "issue",
+      "view",
+      String(first),
+      "-R",
+      repo,
+      "--json",
+      "number",
+    ]);
+    return "fresh";
+  } catch (err) {
+    // gh surfaces a 404 via stderr text on a non-zero exit. Only
+    // the unambiguous "not found" / "could not resolve" shapes
+    // count as genuinely gone; anything else (network, auth,
+    // timeout) is transient and must NOT delete the snapshot.
+    const msg = String((err && (err.stderr || err.message)) || "").toLowerCase();
+    if (msg.includes("could not resolve") || msg.includes("not found") || msg.includes("no issue")) {
+      return "gone";
+    }
+    return "unknown";
+  }
+}
 
 // Decide which batch to render, combining the live parse of
 // OVERNIGHT-QUEUE.md with the persistent snapshot. The snapshot is
@@ -1204,10 +1255,11 @@ function parseActiveBatch(queueText) {
   const batchNumber = batchMatch ? parseInt(batchMatch[1], 10) : null;
   // Only collect issue numbers from lines that look like list-item
   // entries — i.e. lines whose first content token is either `#N`
-  // or `[#N]` after an optional list marker. This rejects prose
-  // like "Tracking umbrella: #293", "next after #294 merged", and
-  // similar dependency / commentary references that t2a flagged on
-  // realproject7/dropcast's queue.
+  // or `[#N]` after an optional list marker, and optionally after
+  // a GitHub-flavored markdown checkbox token `[ ]` / `[x]` / `[X]`.
+  // This rejects prose like "Tracking umbrella: #293", "next after
+  // #294 merged", and similar dependency / commentary references
+  // that t2a flagged on realproject7/dropcast's queue.
   //
   // Accepted line shapes:
   //   - #295 sub-A heartbeat
@@ -1216,12 +1268,22 @@ function parseActiveBatch(queueText) {
   //   #295 sub-A heartbeat
   //   - [#295] sub-A heartbeat
   //   [#295] sub-A heartbeat
+  //   - [ ] #295 sub-A heartbeat      (#342/quadwork#341: GFM checkbox)
+  //   - [x] #295 sub-A heartbeat      (checked)
+  //   - [X] #295 sub-A heartbeat      (checked, uppercase)
   //
   // Rejected:
   //   Tracking umbrella: #293
   //   Assigned next after #294 merged.
   //   See #295 for context.
-  const ITEM_LINE_RE = /^\s*(?:[-*]\s+|\d+\.\s+)?\[?#(\d{1,6})\]?\b/;
+  //
+  // The previous regex permitted an optional `[` *immediately*
+  // before `#`, which happened to match `[#295]` but not `[ ] #295`
+  // (a space between `[` and `#`), so Head-generated queues that
+  // used GFM checkbox syntax produced zero issue numbers and the
+  // Current Batch panel showed empty. #341 adds an explicit optional
+  // checkbox token after the list marker.
+  const ITEM_LINE_RE = /^\s*(?:[-*]\s+|\d+\.\s+)?(?:\[[ xX]\]\s+)?\[?#(\d{1,6})\]?\b/;
   const seen = new Set();
   const issueNumbers = [];
   for (const line of section.split("\n")) {
@@ -1253,6 +1315,32 @@ async function ghJsonExecAsync(args) {
   return JSON.parse(stdout);
 }
 
+// #350: pure helper for the "no linked PR" branch of
+// progressForItemAsync. Takes the issue JSON (shape: { number,
+// title, state, url, ... }) and returns the batch-progress row
+// for an item that has no closedByPullRequestsReferences. Exported
+// from module.exports below for unit tests — no other callers.
+function buildNoPrRow(issue) {
+  if (issue && issue.state === "CLOSED") {
+    return {
+      issue_number: issue.number,
+      title: issue.title,
+      url: issue.url,
+      status: "closed",
+      progress: 100,
+      label: "Closed (no PR) ✓",
+    };
+  }
+  return {
+    issue_number: issue.number,
+    title: issue.title,
+    url: issue.url,
+    status: "queued",
+    progress: 0,
+    label: "Issue · queued",
+  };
+}
+
 async function progressForItemAsync(repo, issueNumber) {
   // Pull issue state + linked PRs in one call. closedByPullRequestsReferences
   // is gh's serializer for the GraphQL `closedByPullRequestsReferences`
@@ -1279,16 +1367,14 @@ async function progressForItemAsync(repo, issueNumber) {
   const pr = linked.length > 0
     ? linked.slice().sort((a, b) => (b.number || 0) - (a.number || 0))[0]
     : null;
-  // No linked PR yet — queued.
+  // No linked PR. #350: before falling into the "queued" bucket,
+  // honor the issue's own state — a CLOSED issue with no linked
+  // PR is fully done (superseded, not planned, runbook-only, etc.)
+  // and should render at 100% with a ✓ label instead of a
+  // misleading "0% · queued" row. Only truly OPEN issues with no
+  // linked PR are still queued.
   if (!pr) {
-    return {
-      issue_number: issue.number,
-      title: issue.title,
-      url: issue.url,
-      status: "queued",
-      progress: 0,
-      label: "Issue · queued",
-    };
+    return buildNoPrRow(issue);
   }
   // Re-fetch the PR to get reviewDecision + reviews + state, since
   // the issue's closedByPullRequestsReferences edge only carries
@@ -1392,15 +1478,23 @@ async function progressForItemAsync(repo, issueNumber) {
 }
 
 function summarizeItems(items) {
-  let merged = 0, ready = 0, approved1 = 0, inReview = 0, queued = 0;
+  // #350: "closed" (CLOSED issue with no linked PR — superseded,
+  // not planned, runbook-only) counts toward the complete tally
+  // alongside "merged". The panel tally now reads "X/N complete"
+  // when the batch mixes both kinds of completion, otherwise
+  // "X/N merged" for the classic all-via-PR case.
+  let merged = 0, closed = 0, ready = 0, approved1 = 0, inReview = 0, queued = 0;
   for (const it of items) {
     if (it.status === "merged") merged++;
+    else if (it.status === "closed") closed++;
     else if (it.status === "ready") ready++;
     else if (it.status === "approved1") approved1++;
     else if (it.status === "in_review") inReview++;
     else if (it.status === "queued") queued++;
   }
-  const parts = [`${merged}/${items.length} merged`];
+  const done = merged + closed;
+  const doneLabel = closed > 0 ? "complete" : "merged";
+  const parts = [`${done}/${items.length} ${doneLabel}`];
   if (ready > 0) parts.push(`${ready} ready to merge`);
   if (approved1 > 0) parts.push(`${approved1} needs 2nd approval`);
   if (inReview > 0) parts.push(`${inReview} in review`);
@@ -1432,6 +1526,27 @@ router.get("/api/batch-progress", async (req, res) => {
     // per #316's edge case.
   }
 
+  // #334 / quadwork#334: validate the on-disk snapshot against
+  // GitHub before resolveDisplayedBatch can serve it. A snapshot
+  // whose first issue 404s is almost certainly a leftover from a
+  // prior project/repo that was purged; drop the file so the
+  // resolver falls through to the live queue parse (which will
+  // typically also be empty) instead of serving stale data
+  // indefinitely. We only run the check on cache-miss paths (this
+  // route already sits behind BATCH_PROGRESS_TTL_MS) and only
+  // when we'd actually rely on the snapshot — i.e. the live queue
+  // read succeeded, so the existing #316 bypass for unreadable
+  // queue files keeps precedence.
+  if (queueReadOk) {
+    const existing = readBatchSnapshot(projectId);
+    if (existing && Array.isArray(existing.issueNumbers) && existing.issueNumbers.length > 0) {
+      const freshness = await checkBatchSnapshotFreshness(repo, existing);
+      if (freshness === "gone") deleteBatchSnapshot(projectId);
+      // "unknown" → leave the file alone; transient failure will
+      // retry on the next cache miss.
+    }
+  }
+
   // #429 / quadwork#316: resolve the displayed batch through the
   // snapshot-aware helper so merged items stay visible after Head
   // moves them from Active Batch to Done, until a new batch starts.
@@ -1463,7 +1578,10 @@ router.get("/api/batch-progress", async (req, res) => {
     };
   });
   const summary = summarizeItems(items);
-  const complete = items.length > 0 && items.every((it) => it.status === "merged");
+  // #350: treat CLOSED-without-PR items as complete alongside merged
+  // so batches that mix runbook/superseded closes with real PRs
+  // still flip to the COMPLETE state once everything is done.
+  const complete = items.length > 0 && items.every((it) => it.status === "merged" || it.status === "closed");
   const data = { batch_number: batchNumber, items, summary, complete };
   _batchProgressCache.set(projectId, { ts: Date.now(), data });
   res.json(data);
@@ -1956,6 +2074,12 @@ router.post("/api/setup", (req, res) => {
         return res.json({ ok: true, message: "Project already in config" });
       }
       // Match CLI wizard agent structure: { cwd, command, auto_approve, mcp_inject }
+      // #343: default Codex-backed agents to reasoning_effort="medium"
+      // instead of the upstream xhigh/high default. high/xhigh is the
+      // provider-side capacity-failure hot spot; medium is the
+      // safe-default for fresh installs so new projects don't hit
+      // "Selected model is at capacity" out of the box. Operators can
+      // bump individual agents back up via the Agent Models widget.
       const agents = {};
       for (const agentId of ["head", "reviewer1", "reviewer2", "dev"]) {
         const cmd = (backends && backends[agentId]) || "claude";
@@ -1966,6 +2090,7 @@ router.post("/api/setup", (req, res) => {
           command: cmd,
           auto_approve: autoApprove,
           mcp_inject: injectMode,
+          ...(cliBase === "codex" ? { reasoning_effort: "medium" } : {}),
         };
       }
       // Use pre-assigned ports/token from agentchattr-config step if provided,
@@ -2175,6 +2300,66 @@ function telegramConfigToml(projectId) {
   return path.join(CONFIG_DIR, `telegram-${projectId}.toml`);
 }
 
+// #353: per-project log file for the bridge subprocess. The start
+// handler redirects stdout + stderr here so crashes (ImportError,
+// config parse, auth failure) are recoverable instead of
+// /dev/null'd by `stdio: "ignore"`.
+function telegramBridgeLog(projectId) {
+  return path.join(CONFIG_DIR, `telegram-bridge-${projectId}.log`);
+}
+
+// Tail the last N lines of a file without reading the whole thing
+// into memory if it is huge. For the bridge log we care about the
+// final crash frame, not historical output.
+function readLastLines(filePath, n) {
+  try {
+    if (!fs.existsSync(filePath)) return "";
+    const stat = fs.statSync(filePath);
+    const readBytes = Math.min(stat.size, 64 * 1024);
+    if (readBytes === 0) return "";
+    const buf = Buffer.alloc(readBytes);
+    const fd = fs.openSync(filePath, "r");
+    try {
+      fs.readSync(fd, buf, 0, readBytes, Math.max(0, stat.size - readBytes));
+    } finally {
+      fs.closeSync(fd);
+    }
+    const text = buf.toString("utf-8");
+    const lines = text.split(/\r?\n/).filter((l) => l.length > 0);
+    return lines.slice(-n).join("\n");
+  } catch {
+    return "";
+  }
+}
+
+// Verify that the bridge's Python runtime has its required modules
+// available. Cheap pre-flight so a missing `requests` install
+// produces a readable error instead of a silent Start → Stopped
+// flicker. Returns { ok: true } on success, { ok: false, error }
+// otherwise. Keep the import list small and close to what the
+// bridge actually needs; add modules here if the bridge gains new
+// hard deps.
+function checkTelegramBridgePythonDeps() {
+  try {
+    // Only check the third-party module the bridge actually needs
+    // at import time — `requests`. Toml parsing differs between
+    // Python versions (tomllib on 3.11+, tomli on 3.10-), and any
+    // genuine toml import failure will now be captured in the
+    // bridge log file on spawn, so this pre-flight stays narrow
+    // and avoids false negatives on older Python installs.
+    execFileSync("python3", ["-c", "import requests"], {
+      encoding: "utf-8",
+      timeout: 10000,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    return { ok: true };
+  } catch (err) {
+    const stderr = (err && err.stderr && err.stderr.toString && err.stderr.toString()) || "";
+    const msg = stderr.trim() || (err && err.message) || "python3 import check failed";
+    return { ok: false, error: msg };
+  }
+}
+
 function isTelegramRunning(projectId) {
   const pf = telegramPidFile(projectId);
   if (!fs.existsSync(pf)) return false;
@@ -2273,12 +2458,29 @@ router.get("/api/telegram", async (req, res) => {
       }
     } catch { /* non-fatal — widget will just show no username */ }
   }
+  // #353: if the bridge is not running but a log file exists with
+  // content, tail it and expose it as `last_error` so the widget
+  // can surface runtime crashes (bad token mid-session, network
+  // failure, config parse error) that happen after the initial
+  // 500 ms post-spawn liveness check and would otherwise just
+  // revert the pill to Stopped with no explanation.
+  const running = isTelegramRunning(projectId);
+  let lastError = "";
+  if (!running) {
+    const logPath = telegramBridgeLog(projectId);
+    try {
+      if (fs.existsSync(logPath) && fs.statSync(logPath).size > 0) {
+        lastError = readLastLines(logPath, 20);
+      }
+    } catch {}
+  }
   res.json({
-    running: isTelegramRunning(projectId),
+    running,
     configured,
     chat_id: chatId,
     bot_username: botUsername,
     bridge_installed: bridgeInstalled,
+    last_error: lastError,
   });
 });
 
@@ -2301,15 +2503,39 @@ router.post("/api/telegram", async (req, res) => {
       }
     }
     case "install": {
+      // #353: pip3 can exit 0 on some systems (PEP 668 externally-
+      // managed environments, non-writable site-packages) even when
+      // the subsequent import still fails. After the pip step, run
+      // a post-install import check and surface both the pip output
+      // and the import error together if the check fails — that's
+      // the signal the operator needs to know whether to pick a
+      // virtualenv, use --user, or --break-system-packages.
+      let pipOutput = "";
       try {
         if (!fs.existsSync(BRIDGE_DIR)) {
           execFileSync("gh", ["repo", "clone", "realproject7/agentchattr-telegram", BRIDGE_DIR], { encoding: "utf-8", timeout: 30000 });
         }
-        execFileSync("pip3", ["install", "-r", path.join(BRIDGE_DIR, "requirements.txt")], { encoding: "utf-8", timeout: 30000 });
-        return res.json({ ok: true });
+        pipOutput = execFileSync(
+          "pip3",
+          ["install", "-r", path.join(BRIDGE_DIR, "requirements.txt")],
+          { encoding: "utf-8", timeout: 60000 },
+        );
       } catch (err) {
         return res.json({ ok: false, error: err.message || "Install failed" });
       }
+      const depCheck = checkTelegramBridgePythonDeps();
+      if (!depCheck.ok) {
+        return res.json({
+          ok: false,
+          error:
+            "pip3 reported success but the bridge's Python deps still fail to import. " +
+            "This usually means pip installed into a location python3 cannot see " +
+            "(externally-managed environment / PEP 668 / mismatched interpreter).\n\n" +
+            `Import error: ${depCheck.error}\n\n` +
+            `pip output tail:\n${pipOutput.split("\n").slice(-10).join("\n")}`,
+        });
+      }
+      return res.json({ ok: true });
     }
     case "start": {
       const projectId = body.project_id;
@@ -2323,14 +2549,75 @@ router.post("/api/telegram", async (req, res) => {
       const tomlContent = `[telegram]\nbot_token = "${tg.bot_token}"\nchat_id = "${tg.chat_id}"\n\n[agentchattr]\nurl = "${tg.agentchattr_url}"\n`;
       fs.writeFileSync(tomlPath, tomlContent, { mode: 0o600 });
       fs.chmodSync(tomlPath, 0o600);
+      // #353: pre-flight import check so a fresh install with no
+      // `requests` module produces a readable error instead of the
+      // Start → Running → Stopped flicker that the v1 code path
+      // produced with `stdio: "ignore"`.
+      const depCheck = checkTelegramBridgePythonDeps();
+      if (!depCheck.ok) {
+        return res.json({
+          ok: false,
+          error:
+            "Bridge Python dependencies not installed. Click \"Install Bridge\" to install them, " +
+            "or run: pip3 install -r " + path.join(BRIDGE_DIR, "requirements.txt") + "\n\n" +
+            `Import error: ${depCheck.error}`,
+        });
+      }
+      // #353: capture stdout + stderr to a per-project log file so
+      // bridge crashes (bad token, network failure, config parse
+      // error, etc.) are recoverable. The handle must be opened
+      // BEFORE spawn and passed through stdio so the detached
+      // child keeps writing after the parent unrefs it.
+      const logPath = telegramBridgeLog(projectId);
+      // #353 follow-up: truncate the log at the start of every
+      // spawn so the status endpoint's last_error tail only ever
+      // reflects the *current* session. Otherwise a previous
+      // crash's trace would linger forever and the widget would
+      // keep surfacing a stale error even after the operator
+      // fixed the underlying problem and restarted cleanly.
+      try { fs.writeFileSync(logPath, ""); } catch {}
+      let outFd, errFd;
+      try {
+        outFd = fs.openSync(logPath, "a");
+        errFd = fs.openSync(logPath, "a");
+      } catch (err) {
+        return res.json({ ok: false, error: `Could not open bridge log file: ${err.message}` });
+      }
+      let child;
       try {
-        const child = spawn("python3", [bridgeScript, "--config", tomlPath], { detached: true, stdio: "ignore" });
+        child = spawn("python3", [bridgeScript, "--config", tomlPath], {
+          detached: true,
+          stdio: ["ignore", outFd, errFd],
+        });
         child.unref();
         if (child.pid) fs.writeFileSync(telegramPidFile(projectId), String(child.pid));
-        return res.json({ ok: true, running: true, pid: child.pid });
       } catch (err) {
+        try { fs.closeSync(outFd); } catch {}
+        try { fs.closeSync(errFd); } catch {}
         return res.json({ ok: false, error: err.message || "Start failed" });
       }
+      // Close our copies of the fds in the parent now that the
+      // child has inherited them — otherwise the parent holds the
+      // log file open forever.
+      try { fs.closeSync(outFd); } catch {}
+      try { fs.closeSync(errFd); } catch {}
+      // #353: liveness check — wait 500ms, then verify the child
+      // is still running. If it already died, tail the log file
+      // and return those lines as the error.
+      await new Promise((r) => setTimeout(r, 500));
+      let alive = true;
+      try { process.kill(child.pid, 0); } catch { alive = false; }
+      if (!alive) {
+        const tail = readLastLines(logPath, 20);
+        try { fs.unlinkSync(telegramPidFile(projectId)); } catch {}
+        return res.json({
+          ok: false,
+          error:
+            "Bridge crashed on start (exited within 500ms).\n\n" +
+            `Last log lines (${logPath}):\n${tail || "(log empty)"}`,
+        });
+      }
+      return res.json({ ok: true, running: true, pid: child.pid });
     }
     case "stop": {
       const projectId = body.project_id;
@@ -2404,4 +2691,82 @@ router.post("/api/telegram", async (req, res) => {
   }
 });
 
+// #343: per-agent model + reasoning-effort settings endpoint.
+// GET returns the rows the dashboard Agent Models widget needs;
+// PUT persists a single row back to config.json. Kept narrow on
+// purpose — only `model` and `reasoning_effort` are writable
+// here, and codex is the only backend that accepts
+// reasoning_effort today. The launch-time wiring lives in
+// server/index.js buildAgentArgs; this endpoint is purely
+// config storage.
+const ALLOWED_REASONING_EFFORTS = new Set(["minimal", "low", "medium", "high"]);
+
+router.get("/api/project/:projectId/agent-models", (req, res) => {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    const project = cfg.projects?.find((p) => p.id === req.params.projectId);
+    if (!project) return res.status(404).json({ error: "Unknown project" });
+    const rows = ["head", "reviewer1", "reviewer2", "dev"].map((agentId) => {
+      const a = project.agents?.[agentId] || {};
+      const command = a.command || "claude";
+      const cliBase = command.split("/").pop().split(" ")[0];
+      return {
+        agent_id: agentId,
+        backend: cliBase,
+        model: a.model || "",
+        reasoning_effort: a.reasoning_effort || "",
+        reasoning_supported: cliBase === "codex",
+      };
+    });
+    return res.json({ agents: rows });
+  } catch (err) {
+    return res.status(500).json({ error: err.message || "read failed" });
+  }
+});
+
+router.put("/api/project/:projectId/agent-models/:agentId", (req, res) => {
+  const { projectId, agentId } = req.params;
+  if (!["head", "reviewer1", "reviewer2", "dev"].includes(agentId)) {
+    return res.json({ ok: false, error: "Unknown agent" });
+  }
+  const body = req.body || {};
+  // Accept empty string as "clear override → fall back to CLI default".
+  const model = typeof body.model === "string" ? body.model.trim() : undefined;
+  const reasoning = typeof body.reasoning_effort === "string" ? body.reasoning_effort.trim() : undefined;
+  if (reasoning && reasoning !== "" && !ALLOWED_REASONING_EFFORTS.has(reasoning)) {
+    return res.json({ ok: false, error: `Invalid reasoning_effort: ${reasoning}` });
+  }
+  try {
+    const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+    const cfg = JSON.parse(raw);
+    const project = cfg.projects?.find((p) => p.id === projectId);
+    if (!project) return res.status(404).json({ ok: false, error: "Unknown project" });
+    if (!project.agents) project.agents = {};
+    const a = project.agents[agentId] || {};
+    if (model !== undefined) {
+      if (model === "") delete a.model;
+      else a.model = model;
+    }
+    if (reasoning !== undefined) {
+      if (reasoning === "") delete a.reasoning_effort;
+      else a.reasoning_effort = reasoning;
+    }
+    project.agents[agentId] = a;
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+    return res.json({ ok: true, agent: { agent_id: agentId, model: a.model || "", reasoning_effort: a.reasoning_effort || "" } });
+  } catch (err) {
+    return res.json({ ok: false, error: err.message || "write failed" });
+  }
+});
+
 module.exports = router;
+// #341: export parseActiveBatch for unit tests. No production callers
+// outside this file; the export is strictly for the node:assert
+// script at server/routes.parseActiveBatch.test.js.
+module.exports.parseActiveBatch = parseActiveBatch;
+// #350: same pattern — expose the no-linked-PR row builder and
+// summarizeItems for the batch-progress fixture test.
+module.exports.buildNoPrRow = buildNoPrRow;
+module.exports.summarizeItems = summarizeItems;
+// #353: expose readLastLines for the telegram-bridge test.
+module.exports.readLastLines = readLastLines;

package/server/routes.parseActiveBatch.test.js

@@ -0,0 +1,88 @@
+// #341 / quadwork#341: parseActiveBatch regex tests. Plain
+// node:assert script — no test runner is wired up. Run with
+// `node server/routes.parseActiveBatch.test.js`.
+//
+// parseActiveBatch is re-exported from server/routes.js for this
+// test only; it has no production callers outside routes.js.
+
+const assert = require("node:assert/strict");
+const { parseActiveBatch } = require("./routes");
+
+function wrap(body, batchLine = "**Batch:** 33") {
+  return `# Overnight Queue\n\n## Active Batch\n\n${batchLine}\n\n${body}\n\n## Backlog\n\n- #999 something else\n`;
+}
+
+// 1) #341 regression: GFM checkbox items (space between `[` and `#`)
+//    must populate the list.
+{
+  const text = wrap(
+    [
+      "- [ ] #338 — Remove home hero",
+      "- [ ] #337 — Stack SERVER",
+      "- [x] #332 — Commit port drafts",
+      "- [X] #334 — Snapshot stale check",
+    ].join("\n"),
+  );
+  const { batchNumber, issueNumbers } = parseActiveBatch(text);
+  assert.equal(batchNumber, 33, "batch number parsed");
+  assert.deepEqual(issueNumbers, [338, 337, 332, 334], "checkbox items parsed in order");
+}
+
+// 2) Existing shapes keep working.
+{
+  const text = wrap(
+    [
+      "- #295 sub-A heartbeat",
+      "* #296 sub-B",
+      "1. #297 sub-C",
+      "#298 sub-D",
+      "- [#299] sub-E",
+      "[#300] sub-F",
+    ].join("\n"),
+  );
+  const { issueNumbers } = parseActiveBatch(text);
+  assert.deepEqual(issueNumbers, [295, 296, 297, 298, 299, 300], "legacy shapes still parsed");
+}
+
+// 3) Prose references still rejected.
+{
+  const text = wrap(
+    [
+      "- [ ] #400 real item",
+      "Tracking umbrella: #293",
+      "Assigned next after #294 merged.",
+      "See #295 for context.",
+    ].join("\n"),
+  );
+  const { issueNumbers } = parseActiveBatch(text);
+  assert.deepEqual(issueNumbers, [400], "prose references rejected, only real item kept");
+}
+
+// 4) De-dup: same issue number on multiple lines collapses.
+{
+  const text = wrap(
+    [
+      "- [ ] #100 first mention",
+      "- [x] #100 second mention",
+      "- [ ] #101 another",
+    ].join("\n"),
+  );
+  const { issueNumbers } = parseActiveBatch(text);
+  assert.deepEqual(issueNumbers, [100, 101], "de-dup keeps first occurrence");
+}
+
+// 5) Items in Backlog section are NOT picked up.
+{
+  const text = wrap("- [ ] #500 active item");
+  const { issueNumbers } = parseActiveBatch(text);
+  assert.deepEqual(issueNumbers, [500], "Backlog section not scanned");
+}
+
+// 6) Empty / missing Active Batch returns empty.
+{
+  const { batchNumber, issueNumbers } = parseActiveBatch("# no active batch here\n");
+  assert.equal(batchNumber, null);
+  assert.deepEqual(issueNumbers, []);
+}
+
+console.log("routes.parseActiveBatch.test.js: all assertions passed (6 cases)");