chapterhouse 0.5.1 → 0.6.0

package/dist/sprint-merge.test.js

@@ -0,0 +1,131 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { runSprintMerge, parseSprintMergeArgs } from "./sprint-merge.js";
+test("runSprintMerge merges PRs serially and refreshes remaining branches after each merge", async () => {
+    const commands = [];
+    const runner = (command, args) => {
+        commands.push([command, ...args].join(" "));
+        if (command === "gh" && args[0] === "pr" && args[1] === "view") {
+            return JSON.stringify({ state: "OPEN", mergeable: "MERGEABLE", reviewDecision: "APPROVED" });
+        }
+        return "";
+    };
+    const lines = await runSprintMerge([264, 265, 266], { dryRun: false, runner });
+    assert.deepEqual(commands, [
+        "gh pr view 264 --json state,mergeable,reviewDecision",
+        "gh pr merge 264 --squash",
+        "git fetch origin main",
+        "gh pr update-branch 265",
+        "gh pr update-branch 266",
+        "gh pr view 265 --json state,mergeable,reviewDecision",
+        "gh pr merge 265 --squash",
+        "git fetch origin main",
+        "gh pr update-branch 266",
+        "gh pr view 266 --json state,mergeable,reviewDecision",
+        "gh pr merge 266 --squash",
+        "git fetch origin main",
+    ]);
+    assert.match(lines.join("\n"), /Processing #264/);
+    assert.match(lines.join("\n"), /Merged #265/);
+    assert.match(lines.join("\n"), /Refreshed #266/);
+});
+test("runSprintMerge continues after merge failures and skips non-mergeable PRs", async () => {
+    const commands = [];
+    const runner = (command, args) => {
+        commands.push([command, ...args].join(" "));
+        if (command === "gh" && args[0] === "pr" && args[1] === "view") {
+            const prNumber = args[2];
+            if (prNumber === "264") {
+                return JSON.stringify({ state: "OPEN", mergeable: "MERGEABLE", reviewDecision: "APPROVED" });
+            }
+            if (prNumber === "265") {
+                return JSON.stringify({ state: "OPEN", mergeable: "CONFLICTING", reviewDecision: "APPROVED" });
+            }
+            return JSON.stringify({ state: "OPEN", mergeable: "MERGEABLE", reviewDecision: "REVIEW_REQUIRED" });
+        }
+        if (command === "gh" && args[0] === "pr" && args[1] === "merge" && args[2] === "264") {
+            throw new Error("merge failed");
+        }
+        return "";
+    };
+    const lines = await runSprintMerge([264, 265, 266], { dryRun: false, runner });
+    assert.deepEqual(commands, [
+        "gh pr view 264 --json state,mergeable,reviewDecision",
+        "gh pr merge 264 --squash",
+        "gh pr view 265 --json state,mergeable,reviewDecision",
+        "gh pr view 266 --json state,mergeable,reviewDecision",
+        "gh pr merge 266 --squash",
+        "git fetch origin main",
+    ]);
+    assert.match(lines.join("\n"), /Failed #264: merge failed/);
+    assert.match(lines.join("\n"), /Skipped #265: mergeable=CONFLICTING/);
+    assert.match(lines.join("\n"), /Merged #266/);
+});
+test("runSprintMerge dry-run validates PR state via gh pr view and prints plan without mutating commands", async () => {
+    const mutatingCalls = [];
+    const runner = (command, args) => {
+        if (command === "gh" && args[0] === "pr" && args[1] === "view") {
+            return JSON.stringify({ state: "OPEN", mergeable: "MERGEABLE", reviewDecision: "APPROVED" });
+        }
+        mutatingCalls.push([command, ...args].join(" "));
+        return "";
+    };
+    const lines = await runSprintMerge([264, 265, 266], { dryRun: true, runner });
+    assert.deepEqual(mutatingCalls, [], "dry-run must not invoke any mutating commands");
+    assert.deepEqual(lines, [
+        "[DRY RUN] Merge order: #264 -> #265 -> #266",
+        "[DRY RUN] PR #264: OPEN, mergeable: MERGEABLE, reviewDecision: APPROVED ✅",
+        "[DRY RUN] Would merge #264 with: gh pr merge 264 --squash",
+        "[DRY RUN] Would fetch origin/main with: git fetch origin main",
+        "[DRY RUN] Would refresh #265 with: gh pr update-branch 265",
+        "[DRY RUN] Would refresh #266 with: gh pr update-branch 266",
+        "[DRY RUN] PR #265: OPEN, mergeable: MERGEABLE, reviewDecision: APPROVED ✅",
+        "[DRY RUN] Would merge #265 with: gh pr merge 265 --squash",
+        "[DRY RUN] Would fetch origin/main with: git fetch origin main",
+        "[DRY RUN] Would refresh #266 with: gh pr update-branch 266",
+        "[DRY RUN] PR #266: OPEN, mergeable: MERGEABLE, reviewDecision: APPROVED ✅",
+        "[DRY RUN] Would merge #266 with: gh pr merge 266 --squash",
+        "[DRY RUN] Would fetch origin/main with: git fetch origin main",
+    ]);
+});
+test("runSprintMerge dry-run flags closed and conflicting PRs but reports full plan", async () => {
+    const mutatingCalls = [];
+    const runner = (command, args) => {
+        if (command === "gh" && args[0] === "pr" && args[1] === "view") {
+            const prNumber = args[2];
+            if (prNumber === "264") {
+                return JSON.stringify({ state: "CLOSED", mergeable: "UNKNOWN", reviewDecision: null });
+            }
+            if (prNumber === "265") {
+                return JSON.stringify({ state: "OPEN", mergeable: "CONFLICTING", reviewDecision: null });
+            }
+            return JSON.stringify({ state: "OPEN", mergeable: "MERGEABLE", reviewDecision: "APPROVED" });
+        }
+        mutatingCalls.push([command, ...args].join(" "));
+        return "";
+    };
+    const lines = await runSprintMerge([264, 265, 266], { dryRun: true, runner });
+    assert.deepEqual(mutatingCalls, [], "dry-run must not invoke any mutating commands");
+    assert.deepEqual(lines, [
+        "[DRY RUN] Merge order: #264 -> #265 -> #266",
+        "[DRY RUN] PR #264: CLOSED ❌ — would be skipped",
+        "[DRY RUN] PR #265: OPEN, mergeable: CONFLICTING ❌ — would be skipped",
+        "[DRY RUN] PR #266: OPEN, mergeable: MERGEABLE, reviewDecision: APPROVED ✅",
+        "[DRY RUN] Would merge #266 with: gh pr merge 266 --squash",
+        "[DRY RUN] Would fetch origin/main with: git fetch origin main",
+    ]);
+});
+test("parseSprintMergeArgs accepts --dry-run, -n, and PR numbers", () => {
+    assert.deepEqual(parseSprintMergeArgs(["--dry-run", "264", "265"]), {
+        dryRun: true,
+        prs: [264, 265],
+    });
+    assert.deepEqual(parseSprintMergeArgs(["-n", "266"]), {
+        dryRun: true,
+        prs: [266],
+    });
+});
+test("parseSprintMergeArgs rejects missing PR numbers with dry-run usage example", () => {
+    assert.throws(() => parseSprintMergeArgs([]), /Usage:[\s\S]*--dry-run[\s\S]*Examples:[\s\S]*--dry-run 264 265 266/);
+});
+//# sourceMappingURL=sprint-merge.test.js.map

package/dist/store/db.js

@@ -1094,6 +1094,69 @@ export function getTaskSessionKey(taskId) {
         return "default";
     }
 }
+/**
+ * Return whether a batch of agent tasks has fully reached terminal completion.
+ *
+ * `completed` and `error` are terminal. Missing rows are treated as not-ready
+ * so callers do not open downstream barriers (for example, a Scribe merge pass)
+ * until every expected task has recorded a terminal state.
+ */
+export function getTaskBarrierStatus(taskIds) {
+    const orderedTaskIds = Array.from(new Set(taskIds.filter((taskId) => taskId.trim().length > 0)));
+    if (orderedTaskIds.length === 0) {
+        return {
+            ready: true,
+            pendingTaskIds: [],
+            missingTaskIds: [],
+            statuses: [],
+        };
+    }
+    const db = getDb();
+    const placeholders = orderedTaskIds.map(() => "?").join(", ");
+    const rows = db.prepare(`SELECT task_id, status FROM agent_tasks WHERE task_id IN (${placeholders})`).all(...orderedTaskIds);
+    const statusByTaskId = new Map(rows.map((row) => [row.task_id, row.status ?? "missing"]));
+    const statuses = orderedTaskIds.map((taskId) => ({
+        taskId,
+        status: statusByTaskId.get(taskId) ?? "missing",
+    }));
+    const missingTaskIds = statuses.filter((entry) => entry.status === "missing").map((entry) => entry.taskId);
+    const pendingTaskIds = statuses
+        .filter((entry) => entry.status !== "completed" && entry.status !== "error")
+        .map((entry) => entry.taskId);
+    return {
+        ready: pendingTaskIds.length === 0,
+        pendingTaskIds,
+        missingTaskIds,
+        statuses,
+    };
+}
+/**
+ * Poll `getTaskBarrierStatus` until all tasks are terminal or the timeout
+ * is reached.
+ *
+ * On VS Code, all subagents in a single coordinator turn run concurrently,
+ * so Scribe cannot rely on siblings being complete at the instant it starts.
+ * This function lets Scribe (or any downstream pass) wait until every
+ * sibling has written its `.squad/decisions/inbox/` file and reached a
+ * terminal state before proceeding with the merge.
+ *
+ * Returns the last observed `TaskBarrierStatus`. Callers must check
+ * `.ready` — a `false` result means the timeout was reached with at least
+ * one task still pending.
+ */
+export async function pollTaskBarrierStatus(taskIds, options) {
+    const intervalMs = options?.intervalMs ?? 500;
+    const timeoutMs = options?.timeoutMs ?? 30_000;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        const status = getTaskBarrierStatus(taskIds);
+        if (status.ready)
+            return status;
+        if (Date.now() >= deadline)
+            return status;
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}
 /**
  * Get recent conversation history formatted for injection into system message.
  *

package/dist/store/db.test.js

@@ -851,6 +851,285 @@ test("#158: updateTaskResult updates agent_tasks status and result", async () =>
         dbModule.closeDb();
     }
 });
+test("#275: getTaskBarrierStatus returns complete when every expected task is terminal", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-gate-001", "coder", "completed work", "completed");
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-gate-002", "oracle", "failed but terminal", "error");
+        assert.deepEqual(dbModule.getTaskBarrierStatus(["task-gate-001", "task-gate-002"]), {
+            ready: true,
+            pendingTaskIds: [],
+            missingTaskIds: [],
+            statuses: [
+                { taskId: "task-gate-001", status: "completed" },
+                { taskId: "task-gate-002", status: "error" },
+            ],
+        });
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#275: getTaskBarrierStatus returns pending when expected tasks are missing", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-gate-003", "coder", "still running", "running");
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-gate-004", "oracle", "already done", "completed");
+        assert.deepEqual(dbModule.getTaskBarrierStatus(["task-gate-003", "task-gate-004", "task-gate-005", "task-gate-006"]), {
+            ready: false,
+            pendingTaskIds: ["task-gate-003", "task-gate-005", "task-gate-006"],
+            missingTaskIds: ["task-gate-005", "task-gate-006"],
+            statuses: [
+                { taskId: "task-gate-003", status: "running" },
+                { taskId: "task-gate-004", status: "completed" },
+                { taskId: "task-gate-005", status: "missing" },
+                { taskId: "task-gate-006", status: "missing" },
+            ],
+        });
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#275: getTaskBarrierStatus keeps gate closed when one task is still running", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-gate-007", "coder", "finished work", "completed");
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-gate-008", "oracle", "still in progress", "running");
+        const result = dbModule.getTaskBarrierStatus(["task-gate-007", "task-gate-008"]);
+        assert.strictEqual(result.ready, false, "barrier must not be ready while a task is still running");
+        assert.deepEqual(result.pendingTaskIds, ["task-gate-008"]);
+        assert.deepEqual(result.missingTaskIds, []);
+        assert.deepEqual(result.statuses, [
+            { taskId: "task-gate-007", status: "completed" },
+            { taskId: "task-gate-008", status: "running" },
+        ]);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#275: getTaskBarrierStatus returns complete immediately when no tasks are expected", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        assert.deepEqual(dbModule.getTaskBarrierStatus([]), {
+            ready: true,
+            pendingTaskIds: [],
+            missingTaskIds: [],
+            statuses: [],
+        });
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+// ---------------------------------------------------------------------------
+// pollTaskBarrierStatus — VS Code concurrent-spawn race regression tests (#275)
+// ---------------------------------------------------------------------------
+test("#275 vscode: pollTaskBarrierStatus resolves immediately when all tasks are already terminal", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-poll-001", "coder", "already done", "completed");
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-poll-002", "oracle", "terminal error", "error");
+        const start = Date.now();
+        const result = await dbModule.pollTaskBarrierStatus(["task-poll-001", "task-poll-002"], { intervalMs: 50, timeoutMs: 2000 });
+        const elapsed = Date.now() - start;
+        assert.deepEqual(result, {
+            ready: true,
+            pendingTaskIds: [],
+            missingTaskIds: [],
+            statuses: [
+                { taskId: "task-poll-001", status: "completed" },
+                { taskId: "task-poll-002", status: "error" },
+            ],
+        });
+        assert.ok(elapsed < 500, `should resolve quickly, took ${elapsed}ms`);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#275 vscode: pollTaskBarrierStatus retries until a missing sibling record arrives", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-poll-003", "coder", "finished early", "completed");
+        // Insert 3× the poll interval after start to give comfortable CI margin
+        setTimeout(() => {
+            db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-poll-004", "neo", "late arrival", "completed");
+        }, 150);
+        const start = Date.now();
+        const result = await dbModule.pollTaskBarrierStatus(["task-poll-003", "task-poll-004"], { intervalMs: 50, timeoutMs: 3000 });
+        const elapsed = Date.now() - start;
+        assert.deepEqual(result, {
+            ready: true,
+            pendingTaskIds: [],
+            missingTaskIds: [],
+            statuses: [
+                { taskId: "task-poll-003", status: "completed" },
+                { taskId: "task-poll-004", status: "completed" },
+            ],
+        });
+        assert.ok(elapsed >= 150, `should wait for late-arriving task, took ${elapsed}ms`);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#275 vscode: pollTaskBarrierStatus returns timeout when a sibling never reaches a terminal state", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-poll-005", "coder", "finished", "completed");
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-poll-006", "neo", "never finishes", "running");
+        const start = Date.now();
+        const result = await dbModule.pollTaskBarrierStatus(["task-poll-005", "task-poll-006"], { intervalMs: 50, timeoutMs: 300 });
+        const elapsed = Date.now() - start;
+        assert.deepEqual(result, {
+            ready: false,
+            pendingTaskIds: ["task-poll-006"],
+            missingTaskIds: [],
+            statuses: [
+                { taskId: "task-poll-005", status: "completed" },
+                { taskId: "task-poll-006", status: "running" },
+            ],
+        });
+        assert.ok(elapsed >= 280, `should have waited for ~300ms timeout, took ${elapsed}ms`);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#275 vscode: pollTaskBarrierStatus resolves immediately when no tasks are expected", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const start = Date.now();
+        const result = await dbModule.pollTaskBarrierStatus([], { intervalMs: 50, timeoutMs: 300 });
+        const elapsed = Date.now() - start;
+        assert.deepEqual(result, {
+            ready: true,
+            pendingTaskIds: [],
+            missingTaskIds: [],
+            statuses: [],
+        });
+        assert.ok(elapsed < 100, `empty barrier should resolve immediately, took ${elapsed}ms`);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#275 vscode: pollTaskBarrierStatus returns partial completion details when timeout leaves one task missing", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-poll-007", "coder", "already finished", "completed");
+        // Insert 3× the poll interval after start to give comfortable CI margin
+        setTimeout(() => {
+            db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-poll-008", "oracle", "finished during polling", "completed");
+        }, 150);
+        const start = Date.now();
+        const result = await dbModule.pollTaskBarrierStatus(["task-poll-007", "task-poll-008", "task-poll-009"], {
+            intervalMs: 50,
+            timeoutMs: 400,
+        });
+        const elapsed = Date.now() - start;
+        assert.deepEqual(result, {
+            ready: false,
+            pendingTaskIds: ["task-poll-009"],
+            missingTaskIds: ["task-poll-009"],
+            statuses: [
+                { taskId: "task-poll-007", status: "completed" },
+                { taskId: "task-poll-008", status: "completed" },
+                { taskId: "task-poll-009", status: "missing" },
+            ],
+        });
+        assert.ok(elapsed >= 350, `partial timeout should wait until deadline, took ${elapsed}ms`);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+// ---------------------------------------------------------------------------
+// Scribe sequencing contract — VS Code coordinator (#275 / #289)
+//
+// Regression guard: the Coordinator MUST spawn Scribe in a *separate subsequent
+// turn*, not batched alongside sibling agents.  If Scribe were batched in the
+// same parallel group, it could start its merge pass before siblings have
+// written their .squad/decisions/inbox/ files, reproducing the original #283
+// race condition.
+//
+// The invariant enforced here:
+//   pollTaskBarrierStatus(siblingIds) resolves ready=true
+//     BEFORE any code that schedules Scribe can execute.
+//
+// These tests use the real running→completed UPDATE lifecycle (not final-state
+// INSERTs) to exercise the same code path the orchestrator follows.
+// ---------------------------------------------------------------------------
+test("#275 vscode: Scribe sequencing contract — barrier resolves before Scribe is schedulable", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        // Coordinator spawns sibling agents — both start as "running" (real lifecycle)
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-seq-001", "coder", "sibling work", "running");
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-seq-002", "oracle", "sibling review", "running");
+        const sequenceLog = [];
+        // Sibling agents complete asynchronously (3× poll interval for CI safety)
+        setTimeout(() => {
+            db.prepare("UPDATE agent_tasks SET status = 'completed' WHERE task_id = ?").run("task-seq-001");
+            db.prepare("UPDATE agent_tasks SET status = 'completed' WHERE task_id = ?").run("task-seq-002");
+            sequenceLog.push("siblings-terminal");
+        }, 150);
+        // Coordinator must await the barrier — nothing after this line runs until siblings are terminal
+        const barrierResult = await dbModule.pollTaskBarrierStatus(["task-seq-001", "task-seq-002"], { intervalMs: 50, timeoutMs: 3000 });
+        sequenceLog.push("barrier-resolved");
+        // Only schedule Scribe when barrier confirms all siblings are terminal
+        if (barrierResult.ready) {
+            sequenceLog.push("scribe-spawned");
+        }
+        // Core sequencing invariant: siblings-terminal → barrier-resolved → scribe-spawned
+        assert.ok(sequenceLog.indexOf("siblings-terminal") < sequenceLog.indexOf("barrier-resolved"), "barrier must not resolve before siblings reach a terminal state");
+        assert.ok(sequenceLog.indexOf("barrier-resolved") < sequenceLog.indexOf("scribe-spawned"), "Scribe must not be spawned before the barrier resolves");
+        assert.strictEqual(barrierResult.ready, true, "barrier must be ready when all siblings are terminal");
+        assert.deepEqual(barrierResult.pendingTaskIds, []);
+        assert.deepEqual(barrierResult.statuses, [
+            { taskId: "task-seq-001", status: "completed" },
+            { taskId: "task-seq-002", status: "completed" },
+        ]);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#275 vscode: premature Scribe dispatch is blocked when a sibling is still running", async () => {
+    // This test encodes the negative case: a coordinator that checks the barrier
+    // synchronously (or skips the await) and tries to schedule Scribe immediately
+    // must be blocked.  If this test were removed and the "batched" pattern were
+    // reintroduced, getTaskBarrierStatus would still return ready=false here,
+    // causing this test to fail and alerting that the gate was removed.
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        // One sibling finished, one still running — exact pre-race state from #283
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-preempt-001", "coder", "finished first", "completed");
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-preempt-002", "oracle", "still running", "running");
+        // Synchronous barrier check — as if coordinator did NOT await
+        const immediateStatus = dbModule.getTaskBarrierStatus(["task-preempt-001", "task-preempt-002"]);
+        // Gate is closed: Scribe must not be scheduled
+        assert.strictEqual(immediateStatus.ready, false, "barrier must block Scribe while any sibling is still running");
+        assert.deepEqual(immediateStatus.pendingTaskIds, ["task-preempt-002"]);
+        assert.deepEqual(immediateStatus.missingTaskIds, []);
+        // Coordinator guard: Scribe is only schedulable when the gate opens
+        const scribeSchedulable = immediateStatus.ready;
+        assert.strictEqual(scribeSchedulable, false, "Scribe scheduling must be gated on barrier readiness");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
 // ---------------------------------------------------------------------------
 // normalizeSqliteTsToIso — unit tests
 // ---------------------------------------------------------------------------

package/dist/wiki/team-sync.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { config } from "../config.js";
+import { ModeContext } from "../mode-context.js";
 import { WIKI_DIR } from "../paths.js";
 import { assertPagePath, readPage, writePage, writeFileAtomic } from "./fs.js";
 import { addToIndex, buildIndexEntryForPage } from "./index-manager.js";
@@ -18,6 +19,7 @@ export class TeamWikiSync {
     fetchImpl;
     warn;
     now;
+    modeContext;
     constructor(options = {}) {
         this.teamChapterhouseUrl = (options.teamChapterhouseUrl ?? config.teamChapterhouseUrl).trim().replace(/\/+$/, "");
         this.teamChapterhouseToken = (options.teamChapterhouseToken ?? config.teamChapterhouseToken).trim();
@@ -32,9 +34,14 @@ export class TeamWikiSync {
         this.fetchImpl = options.fetchImpl ?? fetch;
         this.warn = options.warn ?? ((message) => log.warn(message));
         this.now = options.now ?? (() => new Date());
+        this.modeContext = new ModeContext({
+            ...config,
+            teamChapterhouseUrl: this.teamChapterhouseUrl,
+            standaloneMode: this.standaloneMode,
+        });
     }
     isEnabled() {
-        return !this.standaloneMode && this.teamChapterhouseUrl.length > 0;
+        return this.modeContext.canSyncTeamWiki();
     }
     isTeamPath(path) {
         return this.teamWikiPaths.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "chapterhouse",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"
   },
   "files": [
     "dist/**/*.js",
+    ".pr-types.json",
     "agents/",
     "skills/",
     "web/dist/",
@@ -22,7 +23,10 @@
     "dev:server": "tsx --watch src/daemon.ts",
     "dev:web": "npm --prefix web run dev",
     "dev": "tsx --watch src/daemon.ts",
+    "sprint:merge": "tsx src/sprint-merge.ts",
     "lint:md": "markdownlint-cli2 'README.md' 'CHANGELOG.md' 'docs/**/*.md' '.github/**/*.md'",
+    "pr:title:check": "tsx scripts/validate-pr-title.ts",
+    "threat-model:check": "tsx scripts/check-threat-model.ts",
     "release:check": "if [ -n \"$(git status --porcelain)\" ]; then echo '❌ Working tree is not clean. Stage or stash changes before running npm version.'; git status --short; exit 1; fi",
     "preversion": "npm run release:check",
     "prepare": "husky",
@@ -73,6 +77,7 @@
     "@types/node": "^25.6.0",
     "husky": "^9.1.7",
     "markdownlint-cli2": "^0.22.1",
+    "ts-node": "^10.9.2",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }