mcp-coordinator 0.3.0 → 0.5.0

package/README.md

@@ -666,6 +666,20 @@ Resolution priority (highest to lowest): CLI flag → env var → config.json
 | `COORDINATOR_ADMIN_SECRET` | — | Separate secret for admin token creation |
 | `MAX_QUOTA_PCT` | `95` | Pre-flight abort threshold for Anthropic quota |
 
+### Environment variables (v0.6)
+
+| Variable | Default | Effect |
+|---|---|---|
+| `COORDINATOR_REPO_ROOT` | (unset → team-mode) | Repo root for path-guard, FS fallback, Layer 4 |
+| `COORDINATOR_MAX_BODY_BYTES` | `1048576` | parseBody hard cap |
+| `COORDINATOR_LAYER4_DENYLIST` | (uses defaults) | Comma-separated globs appended to denylist |
+| `COORDINATOR_LAYER4_SINCE_DAYS` | `7` | git log --since window |
+| `COORDINATOR_LAYER4_MAX_COMMITS` | `2000` | git log --max-count |
+| `COORDINATOR_LAYER4_REFRESH_INTERVAL_MS` | `1800000` | Refresh on success |
+| `COORDINATOR_LAYER4_RETRY_MS` | `300000` | Retry on timeout |
+| `COORDINATOR_WORKING_FILES_TTL_MIN` | `30` | working_files claim TTL |
+| `COORDINATOR_WORKING_FILES_SWEEP_INTERVAL_MS` | `60000` | TTL sweeper tick |
+
 ---
 
 ## Structured Logging

package/dashboard/public/index.html

@@ -217,6 +217,16 @@
       <div id="token-total"></div>
       <div id="token-agents"></div>
 
+      <div class="panel-title" style="margin-top:16px;">Conflict signals (24h)</div>
+      <div id="conflict-signals">
+        <div class="metric"><span class="metric-label">L0 announced</span><span class="metric-value" data-layer="L0">—</span></div>
+        <div class="metric"><span class="metric-label">L1 same file</span><span class="metric-value" data-layer="L1">—</span></div>
+        <div class="metric"><span class="metric-label">L0.5 disjoint</span><span class="metric-value" data-layer="L0.5">—</span></div>
+        <div class="metric"><span class="metric-label">L2 depends_on</span><span class="metric-value" data-layer="L2">—</span></div>
+        <div class="metric"><span class="metric-label">L3 module</span><span class="metric-value" data-layer="L3">—</span></div>
+        <div class="metric"><span class="metric-label">L4 co-change</span><span class="metric-value" data-layer="L4">—</span></div>
+      </div>
+
       <div class="panel-title" style="margin-top:16px;">Configuration</div>
       <div id="run-config">
         <div style="color:#64748b;font-size:12px;">Aucun run actif</div>
@@ -1171,6 +1181,19 @@
     // Fetch config on load
     fetch(`${COORDINATOR_URL}/api/run-config`).then(r => r.json()).then(renderRunConfig).catch(() => {});
 
+    async function refreshConflictSignals() {
+      try {
+        const r = await fetch(`${COORDINATOR_URL}/api/scoring-stats?since=24h`);
+        const j = await r.json();
+        for (const layer of j.layers) {
+          const el = document.querySelector(`[data-layer="${layer.layer}"]`);
+          if (el) el.textContent = layer.fire_count;
+        }
+      } catch {}
+    }
+    refreshConflictSignals();
+    setInterval(refreshConflictSignals, 30000);
+
     connectSSE();
     updateAgents();
   </script>

package/dist/cli/server/backup.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+/**
+ * Check whether the coordinator daemon appears to be running.
+ * Returns the pid if alive, or null otherwise.
+ */
+export declare function getRunningCoordinatorPid(configDir: string): number | null;
+export declare function createServerBackupCommand(): Command;

package/dist/cli/server/backup.js

@@ -0,0 +1,162 @@
+import { Command } from "commander";
+import { existsSync, readFileSync, statSync } from "fs";
+import { join, resolve, basename } from "path";
+import { create as tarCreate } from "tar";
+import { getConfigDir, loadConfig } from "../config.js";
+/**
+ * Format a timestamp suitable for filenames: YYYY-MM-DD-HHMMSS (UTC).
+ */
+function timestampSlug(date = new Date()) {
+    const pad = (n) => String(n).padStart(2, "0");
+    return (`${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}` +
+        `-${pad(date.getUTCHours())}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}`);
+}
+/**
+ * Returns true if a process with the given pid is currently alive.
+ * On both POSIX and Windows, sending signal 0 acts as a liveness probe
+ * (it raises ESRCH if the process is dead, EPERM if alive but not ours).
+ */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM means the process exists but we lack permission — still "alive".
+        if (err.code === "EPERM")
+            return true;
+        return false;
+    }
+}
+/**
+ * Check whether the coordinator daemon appears to be running.
+ * Returns the pid if alive, or null otherwise.
+ */
+export function getRunningCoordinatorPid(configDir) {
+    const pidPath = join(configDir, "server.pid");
+    if (!existsSync(pidPath))
+        return null;
+    const raw = readFileSync(pidPath, "utf-8").trim();
+    const pid = parseInt(raw, 10);
+    if (Number.isNaN(pid))
+        return null;
+    return isProcessAlive(pid) ? pid : null;
+}
+/**
+ * Recursively walk a directory and yield relative file paths.
+ * Used purely for reporting (file count) — tar handles the actual packing.
+ */
+async function countFiles(root) {
+    const { readdir, stat } = await import("fs/promises");
+    let count = 0;
+    const walk = async (dir) => {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full);
+            }
+            else if (entry.isFile()) {
+                count += 1;
+            }
+        }
+    };
+    if (existsSync(root))
+        await walk(root);
+    return count;
+}
+/**
+ * Build the list of entries (relative to configDir) we want to include in the
+ * tarball. We deliberately keep the layout flat — the same paths used at
+ * runtime — so a `tar -xzf` into `~/.mcp-coordinator/` is a valid restore.
+ *
+ * NOTE on live backups: this command refuses to run while the coordinator is
+ * up because better-sqlite3's WAL journal may have uncommitted writes that
+ * file-copy will miss. For online backups, switch to SQLite's Online Backup
+ * API (`db.backup(path)` from better-sqlite3) and snapshot config.json
+ * separately — see docs/superpowers/working/v04/backup-integration.md.
+ */
+function buildEntries(configDir, dataDirAbsolute) {
+    const entries = [];
+    if (existsSync(join(configDir, "config.json")))
+        entries.push("config.json");
+    // The data dir might live outside ~/.mcp-coordinator (custom --data-dir).
+    // tar's `cwd` option can only point at one directory, so when the data dir
+    // is non-default we pack it under its absolute path inside the archive
+    // (preserving structure for round-trip restore via --data-dir).
+    const defaultDataDir = join(configDir, "data");
+    if (resolve(dataDirAbsolute) === resolve(defaultDataDir) && existsSync(defaultDataDir)) {
+        entries.push("data");
+    }
+    return entries;
+}
+export function createServerBackupCommand() {
+    return new Command("backup")
+        .description("Snapshot the coordinator config + SQLite database to a tar.gz archive")
+        .option("--output <path>", "Output tarball path (default ./mcp-coordinator-backup-<ts>.tar.gz)")
+        .option("--data-dir <path>", "Data directory to back up (overrides config.server.data_dir)")
+        .option("--force", "Skip the running-coordinator safety check")
+        .action(async (opts) => {
+        const configDir = getConfigDir();
+        const config = loadConfig(configDir);
+        const dataDir = resolve(opts.dataDir ?? process.env.COORDINATOR_DATA_DIR ?? config.server.data_dir);
+        // Safety: refuse when the daemon is up. WAL writes might be in flight.
+        const runningPid = getRunningCoordinatorPid(configDir);
+        if (runningPid !== null && !opts.force) {
+            console.error(`Coordinator is running (PID ${runningPid}).`);
+            console.error("Refusing to back up: live SQLite WAL writes may be in flight.");
+            console.error("Either stop it first ('mcp-coordinator server stop') or pass --force.");
+            process.exit(1);
+        }
+        if (!existsSync(configDir)) {
+            console.error(`No coordinator config directory at ${configDir} — nothing to back up.`);
+            process.exit(1);
+        }
+        const ts = timestampSlug();
+        const outputPath = resolve(opts.output ?? join(process.cwd(), `mcp-coordinator-backup-${ts}.tar.gz`));
+        const defaultDataDir = join(configDir, "data");
+        const dataIsCustom = resolve(dataDir) !== resolve(defaultDataDir);
+        // Pack ~/.mcp-coordinator entries from configDir as cwd.
+        const entries = buildEntries(configDir, dataDir);
+        // For custom data dirs, pack them under their absolute path so restore
+        // can reproduce the original location (or be redirected with --data-dir).
+        const customDataEntries = [];
+        if (dataIsCustom && existsSync(dataDir)) {
+            customDataEntries.push({ cwd: resolve(dataDir, ".."), entry: basename(dataDir) });
+        }
+        if (entries.length === 0 && customDataEntries.length === 0) {
+            console.error("Nothing to back up: no config.json and no data directory found.");
+            process.exit(1);
+        }
+        // First archive pass: config + default data (if any).
+        if (entries.length > 0) {
+            await tarCreate({ gzip: true, file: outputPath, cwd: configDir, portable: true }, entries);
+        }
+        // Second pass for a custom data dir — append into the same archive.
+        // tar's gzip mode doesn't support append, so we re-create instead by
+        // extracting the previous entries and re-packing. Simpler path: emit
+        // a sibling .data.tar.gz when custom dir is in use, and document it.
+        if (customDataEntries.length > 0) {
+            const dataArchive = outputPath.replace(/\.tar\.gz$/, ".data.tar.gz");
+            for (const { cwd, entry } of customDataEntries) {
+                await tarCreate({ gzip: true, file: dataArchive, cwd, portable: true }, [entry]);
+            }
+            console.log(`Custom data dir packed separately: ${dataArchive}`);
+        }
+        // outputPath only exists if entries.length > 0; report on whichever
+        // archive(s) we actually produced.
+        const reportPath = entries.length > 0
+            ? outputPath
+            : outputPath.replace(/\.tar\.gz$/, ".data.tar.gz");
+        const sizeBytes = existsSync(reportPath) ? statSync(reportPath).size : 0;
+        const sizeMB = (sizeBytes / (1024 * 1024)).toFixed(2);
+        const fileCount = (existsSync(join(configDir, "config.json")) ? 1 : 0) +
+            (await countFiles(dataIsCustom ? dataDir : defaultDataDir));
+        console.log("Backup complete.");
+        console.log(`  Archive:   ${reportPath}`);
+        console.log(`  Size:      ${sizeMB} MB (${sizeBytes} bytes)`);
+        console.log(`  Files:     ${fileCount}`);
+        console.log(`  ConfigDir: ${configDir}`);
+        console.log(`  DataDir:   ${dataDir}${dataIsCustom ? " (custom)" : ""}`);
+    });
+}

package/dist/cli/server/index.js

@@ -3,11 +3,16 @@ import { createServerStartCommand } from "./start.js";
 import { createServerStopCommand } from "./stop.js";
 import { createServerStatusCommand } from "./status.js";
 import { createServerLogsCommand } from "./logs.js";
+import { createServerBackupCommand } from "./backup.js";
+import { createServerRestoreCommand } from "./restore.js";
 export function createServerProgram() {
     const server = new Command("server").description("Manage the coordination server");
     server.addCommand(createServerStartCommand());
     server.addCommand(createServerStopCommand());
     server.addCommand(createServerStatusCommand());
     server.addCommand(createServerLogsCommand());
+    // v0.4 Operability
+    server.addCommand(createServerBackupCommand());
+    server.addCommand(createServerRestoreCommand());
     return server;
 }

package/dist/cli/server/restore.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createServerRestoreCommand(): Command;

package/dist/cli/server/restore.js

@@ -0,0 +1,117 @@
+import { Command } from "commander";
+import { existsSync, mkdirSync, renameSync, statSync } from "fs";
+import { resolve } from "path";
+import { extract as tarExtract, list as tarList } from "tar";
+import { getConfigDir } from "../config.js";
+import { getRunningCoordinatorPid } from "./backup.js";
+function timestampSlug(date = new Date()) {
+    const pad = (n) => String(n).padStart(2, "0");
+    return (`${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}` +
+        `-${pad(date.getUTCHours())}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}`);
+}
+/**
+ * Inspect the tarball without extracting and return the list of top-level
+ * entries (file or dir names). Used to validate structure before touching
+ * the user's existing config dir.
+ */
+async function listTarballEntries(tarPath) {
+    const entries = [];
+    await tarList({
+        file: tarPath,
+        onReadEntry: (entry) => {
+            // Trailing slash on dirs — strip it, take the first path segment only.
+            const head = entry.path.replace(/\\/g, "/").split("/")[0];
+            if (head && !entries.includes(head))
+                entries.push(head);
+        },
+    });
+    return entries;
+}
+export function createServerRestoreCommand() {
+    return new Command("restore")
+        .description("Restore a coordinator config + database snapshot from a tar.gz archive")
+        .argument("<tarball>", "Path to the backup .tar.gz produced by 'mcp-coordinator server backup'")
+        .option("--force", "Skip the running-coordinator safety check")
+        .option("--no-backup", "Do not snapshot the existing config dir before overwriting")
+        .option("--data-dir <path>", "Override data directory (rarely needed)")
+        .action(async (tarballArg, opts) => {
+        const tarPath = resolve(tarballArg);
+        if (!existsSync(tarPath)) {
+            console.error(`Tarball not found: ${tarPath}`);
+            process.exit(1);
+        }
+        const tarStat = statSync(tarPath);
+        if (!tarStat.isFile()) {
+            console.error(`Not a regular file: ${tarPath}`);
+            process.exit(1);
+        }
+        const configDir = getConfigDir();
+        // Safety: refuse when the daemon is running so we don't clobber an
+        // open SQLite handle (would corrupt the WAL on the daemon side).
+        const runningPid = getRunningCoordinatorPid(configDir);
+        if (runningPid !== null && !opts.force) {
+            console.error(`Coordinator is running (PID ${runningPid}).`);
+            console.error("Refusing to restore: stop the coordinator first or pass --force.");
+            process.exit(1);
+        }
+        // Validate tarball contents BEFORE moving anything aside.
+        let entries;
+        try {
+            entries = await listTarballEntries(tarPath);
+        }
+        catch (err) {
+            console.error(`Failed to read tarball: ${err.message}`);
+            process.exit(1);
+        }
+        const hasConfig = entries.includes("config.json");
+        const hasData = entries.includes("data");
+        if (!hasConfig && !hasData) {
+            console.error("Tarball does not contain expected entries (config.json or data/).");
+            console.error(`Top-level entries found: ${entries.join(", ") || "(none)"}`);
+            process.exit(1);
+        }
+        // Snapshot the existing config dir before overwriting.
+        // commander auto-flips `--no-backup` -> opts.backup = false. The default
+        // value is `true` (the option is registered with .option("--no-backup")
+        // below, which makes commander seed `opts.backup = true`).
+        const shouldSnapshot = opts.backup !== false;
+        let snapshotPath = null;
+        if (shouldSnapshot && existsSync(configDir)) {
+            snapshotPath = `${configDir}.bak-${timestampSlug()}`;
+            renameSync(configDir, snapshotPath);
+            console.log(`Existing config moved aside: ${snapshotPath}`);
+        }
+        // Recreate the target dir and extract.
+        mkdirSync(configDir, { recursive: true });
+        try {
+            await tarExtract({ file: tarPath, cwd: configDir });
+        }
+        catch (err) {
+            console.error(`Extraction failed: ${err.message}`);
+            // Try to roll back the snapshot if we made one.
+            if (snapshotPath !== null && existsSync(snapshotPath)) {
+                // Best-effort: only roll back if extraction created an empty dir.
+                try {
+                    renameSync(configDir, `${configDir}.failed-${timestampSlug()}`);
+                    renameSync(snapshotPath, configDir);
+                    console.error("Rolled back to previous config dir.");
+                }
+                catch {
+                    console.error(`Manual recovery required — snapshot at: ${snapshotPath}`);
+                }
+            }
+            process.exit(1);
+        }
+        console.log("Restore complete.");
+        console.log(`  Source:    ${tarPath}`);
+        console.log(`  ConfigDir: ${configDir}`);
+        console.log(`  Restored:  ${entries.filter((e) => e === "config.json" || e === "data").join(", ")}`);
+        if (snapshotPath !== null) {
+            console.log(`  Previous:  ${snapshotPath}  (delete once verified)`);
+        }
+        if (opts.dataDir !== undefined) {
+            console.log(`  Note:      --data-dir was provided but restore extracts to default location.\n` +
+                `             Update config.json or COORDINATOR_DATA_DIR if you need a non-default path.`);
+        }
+    });
+}

package/dist/cli/server/start.js

@@ -8,7 +8,32 @@ export function createServerStartCommand() {
         .option("--port <port>", "Server port")
         .option("--data-dir <path>", "Data directory")
         .option("--daemon", "Run as background daemon")
+        .option("--repo-root <path>", "Project repo root (enables Layer 4 + FS fallback). Default env COORDINATOR_REPO_ROOT.")
+        .option("--max-body-bytes <bytes>", "Max HTTP request body in bytes. Default 1048576.")
+        .option("--working-files-ttl-min <minutes>", "TTL for working_files claims. Default 30.")
+        .option("--working-files-sweep-ms <ms>", "TTL sweeper tick interval. Default 60000.")
+        .option("--layer4-since-days <days>", "git log --since window. Default 7.")
+        .option("--layer4-max-commits <count>", "git log --max-count. Default 2000.")
+        .option("--layer4-refresh-ms <ms>", "Layer 4 successful-build refresh interval. Default 1800000.")
+        .option("--layer4-retry-ms <ms>", "Layer 4 retry interval on timeout. Default 300000.")
         .action(async (opts) => {
+        // Wire CLI flags to env vars (CLI takes precedence; rest of codebase reads from env)
+        if (opts.repoRoot)
+            process.env.COORDINATOR_REPO_ROOT = opts.repoRoot;
+        if (opts.maxBodyBytes)
+            process.env.COORDINATOR_MAX_BODY_BYTES = opts.maxBodyBytes;
+        if (opts.workingFilesTtlMin)
+            process.env.COORDINATOR_WORKING_FILES_TTL_MIN = opts.workingFilesTtlMin;
+        if (opts.workingFilesSweepMs)
+            process.env.COORDINATOR_WORKING_FILES_SWEEP_INTERVAL_MS = opts.workingFilesSweepMs;
+        if (opts.layer4SinceDays)
+            process.env.COORDINATOR_LAYER4_SINCE_DAYS = opts.layer4SinceDays;
+        if (opts.layer4MaxCommits)
+            process.env.COORDINATOR_LAYER4_MAX_COMMITS = opts.layer4MaxCommits;
+        if (opts.layer4RefreshMs)
+            process.env.COORDINATOR_LAYER4_REFRESH_INTERVAL_MS = opts.layer4RefreshMs;
+        if (opts.layer4RetryMs)
+            process.env.COORDINATOR_LAYER4_RETRY_MS = opts.layer4RetryMs;
         const config = loadConfig();
         const port = parseInt(opts.port ?? process.env.PORT ?? String(config.server.port), 10);
         const dataDir = opts.dataDir ?? process.env.COORDINATOR_DATA_DIR ?? config.server.data_dir;
@@ -47,6 +72,14 @@ export function createServerStartCommand() {
             fwd("COORDINATOR_ADMIN_SECRET", process.env.COORDINATOR_ADMIN_SECRET);
             fwd("COORDINATOR_MQTT_TCP_PORT", process.env.COORDINATOR_MQTT_TCP_PORT);
             fwd("COORDINATOR_MQTT_WS_PATH", process.env.COORDINATOR_MQTT_WS_PATH);
+            fwd("COORDINATOR_REPO_ROOT", process.env.COORDINATOR_REPO_ROOT);
+            fwd("COORDINATOR_MAX_BODY_BYTES", process.env.COORDINATOR_MAX_BODY_BYTES);
+            fwd("COORDINATOR_WORKING_FILES_TTL_MIN", process.env.COORDINATOR_WORKING_FILES_TTL_MIN);
+            fwd("COORDINATOR_WORKING_FILES_SWEEP_INTERVAL_MS", process.env.COORDINATOR_WORKING_FILES_SWEEP_INTERVAL_MS);
+            fwd("COORDINATOR_LAYER4_SINCE_DAYS", process.env.COORDINATOR_LAYER4_SINCE_DAYS);
+            fwd("COORDINATOR_LAYER4_MAX_COMMITS", process.env.COORDINATOR_LAYER4_MAX_COMMITS);
+            fwd("COORDINATOR_LAYER4_REFRESH_INTERVAL_MS", process.env.COORDINATOR_LAYER4_REFRESH_INTERVAL_MS);
+            fwd("COORDINATOR_LAYER4_RETRY_MS", process.env.COORDINATOR_LAYER4_RETRY_MS);
             const child = spawn(cmd, args, {
                 detached: true,
                 stdio: ["ignore", logFd, logFd],

package/dist/src/announce-workflow.d.ts

@@ -42,6 +42,7 @@ export interface CommonFlowParams {
     depends_on_files?: string[];
     exports_affected?: string[];
     keep_open?: boolean;
+    target_symbols?: string[];
 }
 /**
  * Run the common post-`announceWork` orchestration. Mutates the thread row

package/dist/src/announce-workflow.js

@@ -15,7 +15,16 @@ export function runCommonAnnounceFlow(services, threadId, params) {
         target_files: params.target_files,
         depends_on_files: params.depends_on_files,
         exports_affected: params.exports_affected,
+        target_symbols: params.target_symbols,
     });
+    // Layer firing log: one row per concerned/gray-zone scored agent.
+    // Used by /api/scoring-stats and the dashboard "Conflict signals" panel.
+    const dbForFirings = getDb();
+    const insertFiring = dbForFirings.prepare("INSERT INTO layer_firings (thread_id, layer, score, agent_id) VALUES (?, ?, ?, ?)");
+    for (const s of [...categorized.concerned, ...categorized.gray_zone]) {
+        const layer = inferLayerFromReasons(s.reasons);
+        insertFiring.run(threadId, layer, s.score, s.agent_id);
+    }
     // 2. Override expected_respondents on the thread with the scored set.
     // Auto-resolve only when truly alone — if peers are online but not concerned
     // (e.g., they haven't announced yet), keep the thread open so a subsequent
@@ -72,6 +81,25 @@ export function runCommonAnnounceFlow(services, threadId, params) {
     const respondents = JSON.parse(updated.expected_respondents || "[]");
     return { updated, categorized, respondents, planQuality };
 }
+function inferLayerFromReasons(reasons) {
+    for (const r of reasons) {
+        if (r.includes("disjoint symbols"))
+            return "L0.5";
+        if (r.includes("announced same file") || r.includes("modifies my dependency") || r.includes("they depend on my target"))
+            return "L0";
+        if (r.includes("same file (in flight)"))
+            return "L1";
+        if (r.includes("same file"))
+            return "L1";
+        if (r.includes("co-change"))
+            return "L4";
+        if (r.includes("depends on"))
+            return "L2";
+        if (r.includes("module overlap"))
+            return "L3";
+    }
+    return "L1";
+}
 function scoredCategory(s) {
     if (s.score >= 90)
         return "concerned";

package/dist/src/consultation.d.ts

@@ -74,6 +74,14 @@ export declare class Consultation {
          * parsing the thread list themselves.
          */
         assigned_to_me?: string;
+        /**
+         * P2 perf: bound resolved-thread queries to a recency window. Without
+         * this, the impact scorer would scan all-time resolved threads on every
+         * announce_work call (O(historical-threads) per scoring pass). The window
+         * applies to resolved_at when status='resolved', otherwise to created_at,
+         * so the filter is meaningful for both states.
+         */
+        since_minutes?: number;
     }): Thread[];
     getThreadUpdates(agentId: string, since?: string): ThreadMessage[];
     logActionSummary(params: {

package/dist/src/consultation.js

@@ -320,6 +320,14 @@ export class Consultation {
             sql += " AND (assigned_to IS NULL OR assigned_to = ?)";
             params.push(filters.assigned_to_me);
         }
+        if (typeof filters.since_minutes === "number") {
+            // For resolved threads, gate on resolved_at (the moment that matters
+            // for "recent enough to still influence scoring"). For open/resolving
+            // threads, gate on created_at since they have no resolved_at yet.
+            // COALESCE picks the right column per row.
+            sql += " AND COALESCE(resolved_at, created_at) > datetime('now', '-' || ? || ' minutes')";
+            params.push(filters.since_minutes);
+        }
         sql += " ORDER BY created_at DESC";
         return db.prepare(sql).all(...params);
     }

package/dist/src/database.js

@@ -3,6 +3,7 @@ import { mkdirSync } from "fs";
 import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 let db;
+const CURRENT_USER_VERSION = 6;
 const SCHEMA = `
     CREATE TABLE IF NOT EXISTS agents (
       id TEXT PRIMARY KEY,
@@ -129,6 +130,45 @@ const SCHEMA = `
       revoked_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
       revoked_by TEXT NOT NULL
     );
+
+    CREATE TABLE IF NOT EXISTS working_files (
+      agent_id          TEXT NOT NULL,
+      file_path         TEXT NOT NULL,
+      started_at        TEXT NOT NULL,
+      last_activity_at  TEXT NOT NULL,
+      claim_until       TEXT NOT NULL,
+      PRIMARY KEY (agent_id, file_path)
+    );
+    CREATE INDEX IF NOT EXISTS idx_working_files_path  ON working_files(file_path);
+    CREATE INDEX IF NOT EXISTS idx_working_files_until ON working_files(claim_until);
+
+    CREATE TABLE IF NOT EXISTS git_cochange (
+      file_a        TEXT NOT NULL,
+      file_b        TEXT NOT NULL,
+      count         INTEGER NOT NULL,
+      total_commits INTEGER NOT NULL,
+      computed_at   TEXT NOT NULL,
+      PRIMARY KEY (file_a, file_b),
+      CHECK (file_a < file_b)
+    );
+    CREATE INDEX IF NOT EXISTS idx_cochange_a ON git_cochange(file_a);
+    CREATE INDEX IF NOT EXISTS idx_cochange_b ON git_cochange(file_b);
+
+    CREATE TABLE IF NOT EXISTS git_cochange_meta (
+      k TEXT PRIMARY KEY,
+      v TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS layer_firings (
+      id        INTEGER PRIMARY KEY AUTOINCREMENT,
+      thread_id TEXT,
+      layer     TEXT NOT NULL,
+      score     INTEGER NOT NULL,
+      agent_id  TEXT,
+      fired_at  TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE INDEX IF NOT EXISTS idx_firings_layer  ON layer_firings(layer, fired_at);
+    CREATE INDEX IF NOT EXISTS idx_firings_thread ON layer_firings(thread_id);
 `;
 function createBetterSqlite3(dataDir) {
     mkdirSync(dataDir, { recursive: true });
@@ -157,6 +197,20 @@ export function initDatabase(dataDir) {
     else {
         db = createBetterSqlite3(dataDir);
     }
+    // Check for downgrade: refuse if DB was written by a newer binary
+    let foundVersion = 0;
+    try {
+        const v = db
+            .prepare("PRAGMA user_version")
+            .get();
+        foundVersion = v?.user_version ?? 0;
+    }
+    catch {
+        foundVersion = 0;
+    }
+    if (foundVersion > CURRENT_USER_VERSION) {
+        throw new Error(`Database schema is from a newer version (${foundVersion}) than this binary supports (${CURRENT_USER_VERSION}). Downgrade not supported.`);
+    }
     db.exec(SCHEMA);
     // Migrations for existing databases — columns may already exist
     try {
@@ -182,6 +236,17 @@ export function initDatabase(dataDir) {
         db.exec("ALTER TABLE threads ADD COLUMN assigned_to TEXT");
     }
     catch { /* already exists */ }
+    // v0.6: per-edit symbol metadata on file_activity
+    try {
+        db.exec("ALTER TABLE file_activity ADD COLUMN symbols_touched TEXT");
+    }
+    catch { /* already exists */ }
+    try {
+        db.exec("ALTER TABLE file_activity ADD COLUMN content_hash TEXT");
+    }
+    catch { /* already exists */ }
+    // v0.6: schema version marker. Used by cli/server/restore.ts to refuse downgrades.
+    db.exec("PRAGMA user_version = 6");
 }
 export function getDb() {
     if (!db)

package/dist/src/db-adapter.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Database adapter surface.
+ *
+ * Design intent: this file is the *contract* both `createBetterSqlite3` and
+ * `createBunSqlite` (in `database.ts`) implement. The interfaces are a strict
+ * subset of better-sqlite3's API that Bun:sqlite also satisfies, so callers
+ * stay portable across both runtimes.
+ *
+ * Helpers (e.g. `withTransaction`) live here so portable code paths can use
+ * one canonical entry point without each call site re-deriving the
+ * `db.transaction(fn)()` two-step pattern.
+ */
 export interface RunResult {
     changes: number;
     lastInsertRowid: number;
@@ -13,3 +25,21 @@ export interface DatabaseAdapter {
     close(): void;
     transaction<T>(fn: () => T): () => T;
 }
+/**
+ * Run `fn` inside a single SQLite transaction and return its result.
+ *
+ * Replaces the verbose two-step pattern:
+ *
+ *     const tx = db.transaction(() => { ...; return value; });
+ *     const value = tx();
+ *
+ * with:
+ *
+ *     const value = withTransaction(db, () => { ...; return value; });
+ *
+ * Errors thrown inside `fn` propagate to the caller and the transaction is
+ * rolled back by the underlying driver (better-sqlite3 / bun:sqlite both do
+ * this). Use this for any read-modify-write block where multiple statements
+ * must be atomic.
+ */
+export declare function withTransaction<T>(db: DatabaseAdapter, fn: () => T): T;

package/dist/src/db-adapter.js

@@ -1 +1,32 @@
-export {};
+/**
+ * Database adapter surface.
+ *
+ * Design intent: this file is the *contract* both `createBetterSqlite3` and
+ * `createBunSqlite` (in `database.ts`) implement. The interfaces are a strict
+ * subset of better-sqlite3's API that Bun:sqlite also satisfies, so callers
+ * stay portable across both runtimes.
+ *
+ * Helpers (e.g. `withTransaction`) live here so portable code paths can use
+ * one canonical entry point without each call site re-deriving the
+ * `db.transaction(fn)()` two-step pattern.
+ */
+/**
+ * Run `fn` inside a single SQLite transaction and return its result.
+ *
+ * Replaces the verbose two-step pattern:
+ *
+ *     const tx = db.transaction(() => { ...; return value; });
+ *     const value = tx();
+ *
+ * with:
+ *
+ *     const value = withTransaction(db, () => { ...; return value; });
+ *
+ * Errors thrown inside `fn` propagate to the caller and the transaction is
+ * rolled back by the underlying driver (better-sqlite3 / bun:sqlite both do
+ * this). Use this for any read-modify-write block where multiple statements
+ * must be atomic.
+ */
+export function withTransaction(db, fn) {
+    return db.transaction(fn)();
+}