syntaur 0.11.0 → 0.13.0

package/dist/index.js

@@ -5961,7 +5961,7 @@ __export(parser_exports, {
 });
 import { randomBytes } from "crypto";
 import { readFile as readFile13 } from "fs/promises";
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 function generateShortId() {
   return randomBytes(2).toString("hex");
 }
@@ -6199,10 +6199,10 @@ function serializeLogEntry(entry) {
   return lines.join("\n");
 }
 function checklistPath(todosDir2, workspace) {
-  return resolve18(todosDir2, `${workspace}.md`);
+  return resolve19(todosDir2, `${workspace}.md`);
 }
 function logPath(todosDir2, workspace) {
-  return resolve18(todosDir2, `${workspace}-log.md`);
+  return resolve19(todosDir2, `${workspace}-log.md`);
 }
 function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new Date()) {
   const year = now.getFullYear();
@@ -6226,7 +6226,7 @@ function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new D
     default:
       suffix = `${year}-${month}-${day}`;
   }
-  return resolve18(todosDir2, "archive", `${workspace}-${suffix}.md`);
+  return resolve19(todosDir2, "archive", `${workspace}-${suffix}.md`);
 }
 async function readChecklist(todosDir2, workspace) {
   const path = checklistPath(todosDir2, workspace);
@@ -6855,7 +6855,7 @@ __export(launch_exports, {
 });
 import { spawn as spawn2 } from "child_process";
 import { mkdir as mkdir6, writeFile as writeFile9 } from "fs/promises";
-import { isAbsolute as isAbsolute3, resolve as resolve33 } from "path";
+import { isAbsolute as isAbsolute3, resolve as resolve34 } from "path";
 function formatFallbackCwdWarning(opts) {
   const missing = [];
   if (!opts.worktreePath) missing.push("worktreePath");
@@ -6899,8 +6899,8 @@ async function launchAgent(options) {
     console.error(`Assignment not found: ${projectSlug}/${assignmentSlug}`);
     process.exit(1);
   }
-  const projectDir = resolve33(projectsDir2, projectSlug);
-  const assignmentDir = resolve33(projectDir, "assignments", assignmentSlug);
+  const projectDir = resolve34(projectsDir2, projectSlug);
+  const assignmentDir = resolve34(projectDir, "assignments", assignmentSlug);
   const resolvedFromWorkspace = cwdOverride ?? detail.workspace.worktreePath ?? (detail.workspace.repository?.startsWith("/") ? detail.workspace.repository : null);
   const workspaceDir = resolvedFromWorkspace ?? process.cwd();
   if (!cwdOverride) {
@@ -6912,7 +6912,7 @@ async function launchAgent(options) {
     });
     if (warning) console.warn(warning);
   }
-  const contextDir = resolve33(workspaceDir, ".syntaur");
+  const contextDir = resolve34(workspaceDir, ".syntaur");
   await mkdir6(contextDir, { recursive: true });
   const context = {
     projectSlug,
@@ -6925,7 +6925,7 @@ async function launchAgent(options) {
     grabbedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   await writeFile9(
-    resolve33(contextDir, "context.json"),
+    resolve34(contextDir, "context.json"),
     JSON.stringify(context, null, 2) + "\n"
   );
   const { argv, shellFallbackWarning } = buildAgentArgv(
@@ -7082,7 +7082,7 @@ var init_git_worktree = __esm({
 });
 
 // src/index.ts
-import { Command as Command12 } from "commander";
+import { Command as Command13 } from "commander";
 
 // src/commands/init.ts
 init_paths();
@@ -7240,7 +7240,7 @@ init_create_assignment();
 init_config2();
 import { spawn } from "child_process";
 import { createServer as createNetServer } from "net";
-import { resolve as resolve22, dirname as dirname6 } from "path";
+import { resolve as resolve23, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/dashboard/server.ts
@@ -7249,7 +7249,7 @@ init_api();
 init_assignment_resolver();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve21 } from "path";
+import { resolve as resolve22 } from "path";
 import { writeFile as writeFile5, unlink as unlink4 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
@@ -7464,8 +7464,8 @@ function rowToSession(row) {
   };
 }
 async function appendSession(_projectDir, session) {
-  const db3 = getSessionDb();
-  db3.prepare(`
+  const db4 = getSessionDb();
+  db4.prepare(`
     INSERT INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path, description, transcript_path)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(session_id) DO UPDATE SET
@@ -7490,36 +7490,36 @@ async function appendSession(_projectDir, session) {
   );
 }
 async function updateSessionStatus(_projectDir, sessionId, status) {
-  const db3 = getSessionDb();
+  const db4 = getSessionDb();
   const isTerminal = status === "completed" || status === "stopped";
-  const result = isTerminal ? db3.prepare(
+  const result = isTerminal ? db4.prepare(
     "UPDATE sessions SET status = ?, ended = datetime('now'), updated_at = datetime('now') WHERE session_id = ?"
-  ).run(status, sessionId) : db3.prepare(
+  ).run(status, sessionId) : db4.prepare(
     "UPDATE sessions SET status = ?, updated_at = datetime('now') WHERE session_id = ?"
   ).run(status, sessionId);
   return result.changes > 0;
 }
 async function listAllSessions(_projectsDir) {
-  const db3 = getSessionDb();
-  const rows = db3.prepare("SELECT * FROM sessions ORDER BY started DESC").all();
+  const db4 = getSessionDb();
+  const rows = db4.prepare("SELECT * FROM sessions ORDER BY started DESC").all();
   return rows.map(rowToSession);
 }
 async function listProjectSessions(_projectsDir, projectSlug, assignmentSlug) {
-  const db3 = getSessionDb();
+  const db4 = getSessionDb();
   if (assignmentSlug) {
-    const rows2 = db3.prepare(
+    const rows2 = db4.prepare(
       "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
     ).all(projectSlug, assignmentSlug);
     return rows2.map(rowToSession);
   }
-  const rows = db3.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
+  const rows = db4.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
   return rows.map(rowToSession);
 }
 async function deleteSessions(sessionIds) {
   if (sessionIds.length === 0) return 0;
-  const db3 = getSessionDb();
+  const db4 = getSessionDb();
   const placeholders = sessionIds.map(() => "?").join(", ");
-  const result = db3.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
+  const result = db4.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
   return result.changes;
 }
 var DONE_ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "review"]);
@@ -7535,8 +7535,8 @@ async function readAssignmentStatus(projectDir, assignmentSlug) {
   );
 }
 async function reconcileActiveSessions(projectsDir2, assignmentsDir2) {
-  const db3 = getSessionDb();
-  const activeSessions = db3.prepare("SELECT * FROM sessions WHERE status = 'active' AND assignment_slug IS NOT NULL").all();
+  const db4 = getSessionDb();
+  const activeSessions = db4.prepare("SELECT * FROM sessions WHERE status = 'active' AND assignment_slug IS NOT NULL").all();
   if (activeSessions.length === 0) return 0;
   const assignmentStatuses = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
@@ -7573,10 +7573,10 @@ async function reconcileActiveSessions(projectsDir2, assignmentsDir2) {
   return totalUpdated;
 }
 async function listSessionsByAssignment(projectSlug, assignmentSlug) {
-  const db3 = getSessionDb();
-  const rows = projectSlug === null ? db3.prepare(
+  const db4 = getSessionDb();
+  const rows = projectSlug === null ? db4.prepare(
     "SELECT * FROM sessions WHERE assignment_slug = ? AND project_slug IS NULL ORDER BY started DESC"
-  ).all(assignmentSlug) : db3.prepare(
+  ).all(assignmentSlug) : db4.prepare(
     "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
   ).all(projectSlug, assignmentSlug);
   return rows.map(rowToSession);
@@ -7584,9 +7584,9 @@ async function listSessionsByAssignment(projectSlug, assignmentSlug) {
 
 // src/dashboard/watcher.ts
 import { watch } from "chokidar";
-import { relative, sep } from "path";
+import { basename as basename2, dirname as dirname4, relative, sep } from "path";
 function createWatcher(options) {
-  const { projectsDir: projectsDir2, assignmentsDir: assignmentsDir2, serversDir: serversDir2, playbooksDir: playbooksDir3, todosDir: todosDir2, onMessage, debounceMs = 300 } = options;
+  const { projectsDir: projectsDir2, assignmentsDir: assignmentsDir2, serversDir: serversDir2, playbooksDir: playbooksDir3, todosDir: todosDir2, dbPath, onMessage, debounceMs = 300 } = options;
   const pendingEvents = /* @__PURE__ */ new Map();
   const projectsWatcher = watch(projectsDir2, {
     ignoreInitial: true,
@@ -7754,6 +7754,38 @@ function createWatcher(options) {
     todosWatcher.on("add", handleTodoChange2);
     todosWatcher.on("unlink", handleTodoChange2);
   }
+  let leasesDbWatcher = null;
+  if (dbPath) {
+    let handleDbChange2 = function(filePath) {
+      if (!basename2(filePath).startsWith(dbBase)) return;
+      const debounceKey = "__leases-db__";
+      const existing = pendingEvents.get(debounceKey);
+      if (existing) clearTimeout(existing);
+      pendingEvents.set(
+        debounceKey,
+        setTimeout(() => {
+          pendingEvents.delete(debounceKey);
+          const message = {
+            type: "leases-updated",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          onMessage(message);
+        }, debounceMs)
+      );
+    };
+    var handleDbChange = handleDbChange2;
+    const dbDir = dirname4(dbPath);
+    const dbBase = basename2(dbPath);
+    leasesDbWatcher = watch(dbDir, {
+      ignoreInitial: true,
+      persistent: true,
+      depth: 0,
+      ignored: /(^|[\/\\])\../
+    });
+    leasesDbWatcher.on("change", handleDbChange2);
+    leasesDbWatcher.on("add", handleDbChange2);
+    leasesDbWatcher.on("unlink", handleDbChange2);
+  }
   return {
     close: async () => {
       pendingEvents.forEach((timeout) => {
@@ -7765,6 +7797,7 @@ function createWatcher(options) {
       if (serversWatcher) await serversWatcher.close();
       if (playbooksWatcher) await playbooksWatcher.close();
       if (todosWatcher) await todosWatcher.close();
+      if (leasesDbWatcher) await leasesDbWatcher.close();
     }
   };
 }
@@ -7782,7 +7815,7 @@ init_timestamp();
 init_fs();
 init_parser();
 import { Router } from "express";
-import { resolve as resolve15, basename as basename2 } from "path";
+import { resolve as resolve15, basename as basename3 } from "path";
 import { rm, readFile as readFile11, open as fsOpen } from "fs/promises";
 
 // src/dashboard/acceptance-criteria.ts
@@ -8067,7 +8100,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
       res.status(404).json({ error: `Project "${slug}" not found` });
       return;
     }
-    const document = await getEditableDocument(projectsDir2, "memory", basename2(projectDir), itemSlug);
+    const document = await getEditableDocument(projectsDir2, "memory", basename3(projectDir), itemSlug);
     if (!document) {
       res.status(404).json({ error: "Memory not found" });
       return;
@@ -8086,7 +8119,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
       res.status(404).json({ error: `Project "${slug}" not found` });
       return;
     }
-    const document = await getEditableDocument(projectsDir2, "resource", basename2(projectDir), itemSlug);
+    const document = await getEditableDocument(projectsDir2, "resource", basename3(projectDir), itemSlug);
     if (!document) {
       res.status(404).json({ error: "Resource not found" });
       return;
@@ -8171,7 +8204,7 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
         let content = renderItemStub(kind, {
           slug: requestedSlug,
           name,
-          projectSlug: basename2(projectDir),
+          projectSlug: basename3(projectDir),
           timestamp
         });
         const customBody = typeof body.body === "string" ? body.body : "";
@@ -8188,13 +8221,13 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
         } catch (err2) {
           if (err2.code === "EEXIST") {
             res.status(409).json({
-              error: `${kind === "memory" ? "Memory" : "Resource"} with slug "${requestedSlug}" already exists in project "${basename2(projectDir)}".`
+              error: `${kind === "memory" ? "Memory" : "Resource"} with slug "${requestedSlug}" already exists in project "${basename3(projectDir)}".`
             });
             return;
           }
           throw err2;
         }
-        res.status(201).json({ slug: requestedSlug, projectSlug: basename2(projectDir), content });
+        res.status(201).json({ slug: requestedSlug, projectSlug: basename3(projectDir), content });
       } catch (error) {
         console.error(`Error creating ${kind}:`, error);
         res.status(500).json({ error: `Failed to create ${kind}: ${error.message}` });
@@ -8229,7 +8262,7 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
 ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
         merged = setTopLevelField(merged, "updated", nowTimestamp());
         await writeFileForce(filePath, merged);
-        const detail = await getItemDetail(kind, basename2(projectDir), itemSlug);
+        const detail = await getItemDetail(kind, basename3(projectDir), itemSlug);
         res.json({ [kind]: detail, content: merged });
       } catch (error) {
         console.error(`Error updating ${kind}:`, error);
@@ -9744,6 +9777,575 @@ function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
   return router;
 }
 
+// src/dashboard/api-leases.ts
+import { Router as Router4 } from "express";
+
+// src/db/leases-db.ts
+init_paths();
+import Database2 from "better-sqlite3";
+import { randomUUID as randomUUID2 } from "crypto";
+import { resolve as resolve17 } from "path";
+var db2 = null;
+var LEASE_SCHEMA_VERSION = "1";
+var SCHEMA_SQL2 = `
+CREATE TABLE IF NOT EXISTS meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT
+);
+
+CREATE TABLE IF NOT EXISTS inventories (
+  slug          TEXT PRIMARY KEY,
+  kind          TEXT NOT NULL,
+  display_name  TEXT,
+  default_ttl_s INTEGER NOT NULL CHECK (default_ttl_s > 0),
+  created_at    TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS inventory_members (
+  inventory_slug TEXT NOT NULL,
+  member_id      TEXT NOT NULL,
+  status         TEXT NOT NULL DEFAULT 'idle'
+                   CHECK (status IN ('idle','leased','retired')),
+  generation     INTEGER NOT NULL DEFAULT 0,
+  metadata_json  TEXT,
+  last_used_at   TEXT,
+  retired_at     TEXT,
+  PRIMARY KEY (inventory_slug, member_id),
+  FOREIGN KEY (inventory_slug) REFERENCES inventories(slug)
+);
+
+CREATE INDEX IF NOT EXISTS idx_members_idle
+  ON inventory_members (inventory_slug, status, last_used_at);
+
+CREATE TABLE IF NOT EXISTS leases (
+  lease_id        TEXT PRIMARY KEY,
+  inventory_slug  TEXT NOT NULL,
+  member_id       TEXT NOT NULL,
+  member_gen      INTEGER NOT NULL,
+  state           TEXT NOT NULL
+                    CHECK (state IN ('active','released','expired','revoked')),
+  granted_at      TEXT NOT NULL,
+  expires_at      TEXT NOT NULL,
+  released_at     TEXT,
+  requested_for   TEXT,
+  FOREIGN KEY (inventory_slug, member_id)
+    REFERENCES inventory_members(inventory_slug, member_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_leases_gc
+  ON leases (state, expires_at);
+
+CREATE TABLE IF NOT EXISTS lease_events (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  lease_id     TEXT NOT NULL,
+  event        TEXT NOT NULL,
+  at           TEXT NOT NULL,
+  detail_json  TEXT,
+  FOREIGN KEY (lease_id) REFERENCES leases(lease_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_lease
+  ON lease_events (lease_id, at);
+`;
+var NoIdleMemberError = class extends Error {
+  constructor(inventorySlug) {
+    super(`no idle members in '${inventorySlug}'`);
+    this.inventorySlug = inventorySlug;
+    this.name = "NoIdleMemberError";
+  }
+};
+var StaleLeaseError = class extends Error {
+  constructor(leaseId) {
+    super(`lease ${leaseId} is no longer active (expired or revoked)`);
+    this.leaseId = leaseId;
+    this.name = "StaleLeaseError";
+  }
+};
+var NotFoundError = class extends Error {
+  constructor(id) {
+    super(`lease ${id} not found`);
+    this.id = id;
+    this.name = "NotFoundError";
+  }
+};
+var LeaseContentionError = class extends Error {
+  constructor(inventorySlug) {
+    super(`contention timeout on '${inventorySlug}'; retry`);
+    this.inventorySlug = inventorySlug;
+    this.name = "LeaseContentionError";
+  }
+};
+var MemberInUseError = class extends Error {
+  constructor(inventorySlug, memberId) {
+    super(`member ${inventorySlug}/${memberId} is currently leased; release before retiring`);
+    this.inventorySlug = inventorySlug;
+    this.memberId = memberId;
+    this.name = "MemberInUseError";
+  }
+};
+var DuplicateInventoryError = class extends Error {
+  constructor(slug) {
+    super(`inventory '${slug}' already exists`);
+    this.slug = slug;
+    this.name = "DuplicateInventoryError";
+  }
+};
+var DuplicateMemberError = class extends Error {
+  constructor(inventorySlug, memberId) {
+    super(`member ${inventorySlug}/${memberId} already exists`);
+    this.inventorySlug = inventorySlug;
+    this.memberId = memberId;
+    this.name = "DuplicateMemberError";
+  }
+};
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isBusyError(err2) {
+  if (!err2 || typeof err2 !== "object") return false;
+  const e = err2;
+  return e.code === "SQLITE_BUSY" || e.code === "SQLITE_BUSY_SNAPSHOT";
+}
+function initLeasesDb(dbPath) {
+  if (db2) return db2;
+  const finalPath = dbPath ?? resolve17(syntaurRoot(), "syntaur.db");
+  db2 = new Database2(finalPath);
+  db2.pragma("journal_mode = WAL");
+  db2.pragma("busy_timeout = 5000");
+  db2.pragma("foreign_keys = ON");
+  const database = db2;
+  const runMigrations = database.transaction(() => {
+    database.exec(SCHEMA_SQL2);
+    database.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)").run("lease_schema_version", LEASE_SCHEMA_VERSION);
+  });
+  runMigrations.exclusive();
+  return db2;
+}
+function getLeasesDb() {
+  if (!db2) {
+    throw new Error("Leases database not initialized. Call initLeasesDb() first.");
+  }
+  return db2;
+}
+function closeLeasesDb() {
+  if (db2) {
+    db2.close();
+    db2 = null;
+  }
+}
+function createInventory(input4) {
+  const database = getLeasesDb();
+  const row = {
+    slug: input4.slug,
+    kind: input4.kind,
+    display_name: input4.display_name ?? null,
+    default_ttl_s: input4.default_ttl_s,
+    created_at: nowIso()
+  };
+  try {
+    database.prepare(
+      `INSERT INTO inventories (slug, kind, display_name, default_ttl_s, created_at)
+         VALUES (?, ?, ?, ?, ?)`
+    ).run(row.slug, row.kind, row.display_name, row.default_ttl_s, row.created_at);
+  } catch (err2) {
+    if (err2 instanceof Error && err2.message.includes("UNIQUE")) {
+      throw new DuplicateInventoryError(input4.slug);
+    }
+    throw err2;
+  }
+  return row;
+}
+function listInventories() {
+  const database = getLeasesDb();
+  return database.prepare(
+    `SELECT slug, kind, display_name, default_ttl_s, created_at
+       FROM inventories ORDER BY slug`
+  ).all();
+}
+function getInventoryDetail(slug) {
+  const database = getLeasesDb();
+  const inv = database.prepare(
+    `SELECT slug, kind, display_name, default_ttl_s, created_at
+       FROM inventories WHERE slug = ?`
+  ).get(slug);
+  if (!inv) return null;
+  const members = database.prepare(
+    `SELECT inventory_slug, member_id, status, generation, metadata_json, last_used_at, retired_at
+       FROM inventory_members WHERE inventory_slug = ?
+       ORDER BY member_id`
+  ).all(slug);
+  const active_leases = database.prepare(
+    `SELECT lease_id, inventory_slug, member_id, member_gen, state, granted_at, expires_at, released_at, requested_for
+       FROM leases WHERE inventory_slug = ? AND state = 'active'
+       ORDER BY granted_at`
+  ).all(slug);
+  return { inventory: inv, members, active_leases };
+}
+function addMember(input4) {
+  const database = getLeasesDb();
+  const row = {
+    inventory_slug: input4.inventory_slug,
+    member_id: input4.member_id,
+    status: "idle",
+    generation: 0,
+    metadata_json: input4.metadata ? JSON.stringify(input4.metadata) : null,
+    last_used_at: null,
+    retired_at: null
+  };
+  try {
+    database.prepare(
+      `INSERT INTO inventory_members
+           (inventory_slug, member_id, status, generation, metadata_json)
+         VALUES (?, ?, 'idle', 0, ?)`
+    ).run(row.inventory_slug, row.member_id, row.metadata_json);
+  } catch (err2) {
+    if (err2 instanceof Error && err2.message.includes("UNIQUE")) {
+      throw new DuplicateMemberError(input4.inventory_slug, input4.member_id);
+    }
+    throw err2;
+  }
+  return row;
+}
+function retireMember(inventorySlug, memberId) {
+  const database = getLeasesDb();
+  const retire = database.transaction(() => {
+    const row = database.prepare(
+      `SELECT status FROM inventory_members
+         WHERE inventory_slug = ? AND member_id = ?`
+    ).get(inventorySlug, memberId);
+    if (!row) throw new NotFoundError(`${inventorySlug}/${memberId}`);
+    if (row.status === "leased") {
+      throw new MemberInUseError(inventorySlug, memberId);
+    }
+    database.prepare(
+      `UPDATE inventory_members
+           SET status = 'retired', generation = generation + 1, retired_at = ?
+         WHERE inventory_slug = ? AND member_id = ?`
+    ).run(nowIso(), inventorySlug, memberId);
+  });
+  retire.immediate();
+}
+function claimLease(slug, ttl_s, requested_for) {
+  const database = getLeasesDb();
+  try {
+    const fn = database.transaction(() => {
+      const now = nowIso();
+      database.prepare(
+        `UPDATE leases
+              SET state = 'expired'
+            WHERE state = 'active'
+              AND expires_at <= ?
+              AND inventory_slug = ?`
+      ).run(now, slug);
+      database.prepare(
+        `UPDATE inventory_members
+              SET status = 'idle', generation = generation + 1
+            WHERE inventory_slug = ?
+              AND status = 'leased'
+              AND (inventory_slug, member_id) IN (
+                SELECT inventory_slug, member_id
+                  FROM leases
+                 WHERE inventory_slug = ?
+                   AND state = 'expired'
+                   AND released_at IS NULL
+              )
+              AND generation = (
+                SELECT member_gen FROM leases l
+                 WHERE l.inventory_slug = inventory_members.inventory_slug
+                   AND l.member_id      = inventory_members.member_id
+                   AND l.state          = 'expired'
+                   AND l.released_at IS NULL
+                ORDER BY l.granted_at DESC LIMIT 1
+              )`
+      ).run(slug, slug);
+      database.prepare(
+        `UPDATE leases
+              SET released_at = ?
+            WHERE state = 'expired'
+              AND released_at IS NULL
+              AND inventory_slug = ?`
+      ).run(now, slug);
+      const picked = database.prepare(
+        `UPDATE inventory_members
+              SET status = 'leased',
+                  generation = generation + 1,
+                  last_used_at = ?
+            WHERE (inventory_slug, member_id) = (
+              SELECT inventory_slug, member_id
+                FROM inventory_members
+               WHERE inventory_slug = ? AND status = 'idle'
+               ORDER BY last_used_at ASC NULLS FIRST
+               LIMIT 1
+            )
+           RETURNING member_id, generation, metadata_json`
+      ).get(now, slug);
+      if (!picked) {
+        throw new NoIdleMemberError(slug);
+      }
+      const lease_id = randomUUID2();
+      const expires_at = new Date(Date.now() + ttl_s * 1e3).toISOString();
+      database.prepare(
+        `INSERT INTO leases
+             (lease_id, inventory_slug, member_id, member_gen,
+              state, granted_at, expires_at, requested_for)
+           VALUES (?, ?, ?, ?, 'active', ?, ?, ?)`
+      ).run(
+        lease_id,
+        slug,
+        picked.member_id,
+        picked.generation,
+        now,
+        expires_at,
+        requested_for ?? null
+      );
+      database.prepare(
+        `INSERT INTO lease_events (lease_id, event, at, detail_json)
+           VALUES (?, 'claimed', ?, ?)`
+      ).run(lease_id, now, JSON.stringify({ member_id: picked.member_id }));
+      return {
+        lease_id,
+        inventory_slug: slug,
+        member_id: picked.member_id,
+        member_gen: picked.generation,
+        granted_at: now,
+        expires_at,
+        metadata: picked.metadata_json ? JSON.parse(picked.metadata_json) : null
+      };
+    });
+    return fn.immediate();
+  } catch (err2) {
+    if (isBusyError(err2)) throw new LeaseContentionError(slug);
+    throw err2;
+  }
+}
+function releaseLease(lease_id) {
+  const database = getLeasesDb();
+  try {
+    const fn = database.transaction(() => {
+      const now = nowIso();
+      const memberRes = database.prepare(
+        `UPDATE inventory_members
+              SET status = 'idle', generation = generation + 1
+            WHERE (inventory_slug, member_id) = (
+                SELECT inventory_slug, member_id FROM leases
+                 WHERE lease_id = ? AND state = 'active'
+              )
+              AND generation = (
+                SELECT member_gen FROM leases
+                 WHERE lease_id = ? AND state = 'active'
+              )`
+      ).run(lease_id, lease_id);
+      if (memberRes.changes === 0) {
+        throw new StaleLeaseError(lease_id);
+      }
+      database.prepare(
+        `UPDATE leases
+              SET state = 'released', released_at = ?
+            WHERE lease_id = ? AND state = 'active'`
+      ).run(now, lease_id);
+      database.prepare(
+        `INSERT INTO lease_events (lease_id, event, at)
+           VALUES (?, 'released', ?)`
+      ).run(lease_id, now);
+    });
+    fn.immediate();
+  } catch (err2) {
+    if (isBusyError(err2)) throw new LeaseContentionError(lease_id);
+    throw err2;
+  }
+}
+function extendLease(lease_id, ttl_s) {
+  const database = getLeasesDb();
+  try {
+    const fn = database.transaction(() => {
+      const now = nowIso();
+      const new_expires_at = new Date(Date.now() + ttl_s * 1e3).toISOString();
+      const res = database.prepare(
+        `UPDATE leases
+              SET expires_at = ?
+            WHERE lease_id = ?
+              AND state = 'active'
+              AND expires_at > ?
+              AND member_gen = (
+                SELECT generation FROM inventory_members
+                 WHERE inventory_slug = leases.inventory_slug
+                   AND member_id      = leases.member_id
+              )`
+      ).run(new_expires_at, lease_id, now);
+      if (res.changes === 0) {
+        throw new StaleLeaseError(lease_id);
+      }
+      database.prepare(
+        `INSERT INTO lease_events (lease_id, event, at, detail_json)
+           VALUES (?, 'extended', ?, ?)`
+      ).run(lease_id, now, JSON.stringify({ new_expires_at }));
+      return { new_expires_at };
+    });
+    return fn.immediate();
+  } catch (err2) {
+    if (isBusyError(err2)) throw new LeaseContentionError(lease_id);
+    throw err2;
+  }
+}
+function getLease(lease_id) {
+  const database = getLeasesDb();
+  const row = database.prepare(
+    `SELECT lease_id, inventory_slug, member_id, member_gen, state,
+              granted_at, expires_at, released_at, requested_for
+       FROM leases WHERE lease_id = ?`
+  ).get(lease_id);
+  return row ?? null;
+}
+function listLeases(filter) {
+  const database = getLeasesDb();
+  const where = [];
+  const params2 = [];
+  if (filter?.inventory) {
+    where.push("inventory_slug = ?");
+    params2.push(filter.inventory);
+  }
+  if (filter?.state) {
+    where.push("state = ?");
+    params2.push(filter.state);
+  }
+  const whereSql = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+  return database.prepare(
+    `SELECT lease_id, inventory_slug, member_id, member_gen, state,
+              granted_at, expires_at, released_at, requested_for
+       FROM leases ${whereSql}
+       ORDER BY granted_at DESC`
+  ).all(...params2);
+}
+function gcExpiredLeases() {
+  const database = getLeasesDb();
+  try {
+    const fn = database.transaction(() => {
+      const now = nowIso();
+      const expRes = database.prepare(
+        `UPDATE leases SET state = 'expired'
+            WHERE state = 'active' AND expires_at <= ?`
+      ).run(now);
+      database.prepare(
+        `UPDATE inventory_members
+              SET status = 'idle', generation = generation + 1
+            WHERE status = 'leased'
+              AND (inventory_slug, member_id) IN (
+                SELECT inventory_slug, member_id FROM leases
+                 WHERE state = 'expired' AND released_at IS NULL
+              )
+              AND generation = (
+                SELECT member_gen FROM leases l
+                 WHERE l.inventory_slug = inventory_members.inventory_slug
+                   AND l.member_id      = inventory_members.member_id
+                   AND l.state          = 'expired'
+                   AND l.released_at IS NULL
+                ORDER BY l.granted_at DESC LIMIT 1
+              )`
+      ).run();
+      database.prepare(
+        `UPDATE leases SET released_at = ?
+            WHERE state = 'expired' AND released_at IS NULL AND expires_at <= ?`
+      ).run(now, now);
+      return expRes.changes;
+    });
+    return fn.immediate();
+  } catch (err2) {
+    if (isBusyError(err2)) throw new LeaseContentionError("gc");
+    throw err2;
+  }
+}
+function forceReleaseLease(lease_id) {
+  const database = getLeasesDb();
+  try {
+    const fn = database.transaction(() => {
+      const now = nowIso();
+      const lookup = database.prepare(
+        `SELECT inventory_slug, member_id, member_gen, state
+           FROM leases WHERE lease_id = ?`
+      ).get(lease_id);
+      if (!lookup) throw new NotFoundError(lease_id);
+      if (lookup.state === "revoked") return { member_freed: false };
+      const memberRes = database.prepare(
+        `UPDATE inventory_members
+              SET status = 'idle', generation = generation + 1
+            WHERE inventory_slug = ? AND member_id = ?
+              AND generation = ?`
+      ).run(lookup.inventory_slug, lookup.member_id, lookup.member_gen);
+      database.prepare(
+        `UPDATE leases
+              SET state = 'revoked', released_at = ?
+            WHERE lease_id = ? AND state != 'revoked'`
+      ).run(now, lease_id);
+      const member_freed = memberRes.changes > 0;
+      database.prepare(
+        `INSERT INTO lease_events (lease_id, event, at, detail_json)
+           VALUES (?, 'force_released', ?, ?)`
+      ).run(lease_id, now, JSON.stringify({ member_freed }));
+      return { member_freed };
+    });
+    return fn.immediate();
+  } catch (err2) {
+    if (isBusyError(err2)) throw new LeaseContentionError(lease_id);
+    throw err2;
+  }
+}
+
+// src/dashboard/api-leases.ts
+function createLeasesRouter(broadcast) {
+  const router = Router4();
+  router.get("/", (_req, res) => {
+    try {
+      initLeasesDb();
+      const inventories = listInventories();
+      const details = inventories.map((inv) => getInventoryDetail(inv.slug)).filter((d) => d !== null);
+      res.json({ inventories: details });
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : "List failed"
+      });
+    }
+  });
+  router.get("/:slug", (req, res) => {
+    try {
+      initLeasesDb();
+      const detail = getInventoryDetail(req.params.slug);
+      if (!detail) {
+        res.status(404).json({ error: "Inventory not found" });
+        return;
+      }
+      res.json(detail);
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : "Read failed"
+      });
+    }
+  });
+  router.post("/:slug/force-release/:lease_id", (req, res) => {
+    try {
+      initLeasesDb();
+      const result = forceReleaseLease(req.params.lease_id);
+      broadcast?.({
+        type: "leases-updated",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      res.json({ ...result, lease_id: req.params.lease_id });
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        res.status(404).json({ error: "Lease not found" });
+        return;
+      }
+      if (error instanceof LeaseContentionError) {
+        res.status(503).json({ error: "Contention timeout; retry" });
+        return;
+      }
+      res.status(500).json({
+        error: error instanceof Error ? error.message : "Force release failed"
+      });
+    }
+  });
+  return router;
+}
+
 // src/dashboard/api-playbooks.ts
 init_api();
 init_parser();
@@ -9752,11 +10354,11 @@ init_timestamp();
 init_fs();
 init_playbook();
 init_playbooks();
-import { Router as Router4 } from "express";
-import { resolve as resolve17 } from "path";
+import { Router as Router5 } from "express";
+import { resolve as resolve18 } from "path";
 import { readFile as readFile12, unlink as unlink2 } from "fs/promises";
 function createPlaybooksRouter(playbooksDir3) {
-  const router = Router4();
+  const router = Router5();
   router.get("/", async (_req, res) => {
     try {
       const playbooks = await listPlaybooks(playbooksDir3);
@@ -9823,7 +10425,7 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const filePath = resolve17(playbooksDir3, resolved.filename);
+      const filePath = resolve18(playbooksDir3, resolved.filename);
       const content = await readFile12(filePath, "utf-8");
       res.json({
         documentType: "playbook",
@@ -9849,7 +10451,7 @@ function createPlaybooksRouter(playbooksDir3) {
         return;
       }
       await ensureDir(playbooksDir3);
-      const filePath = resolve17(playbooksDir3, `${slug}.md`);
+      const filePath = resolve18(playbooksDir3, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -9873,7 +10475,7 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const filePath = resolve17(playbooksDir3, resolved.filename);
+      const filePath = resolve18(playbooksDir3, resolved.filename);
       await writeFileForce(filePath, content);
       await rebuildPlaybookManifest(playbooksDir3);
       res.json({ slug: resolved.slug, path: filePath });
@@ -9892,7 +10494,7 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const filePath = resolve17(playbooksDir3, resolved.filename);
+      const filePath = resolve18(playbooksDir3, resolved.filename);
       await unlink2(filePath);
       await removeFromDisabledList(resolved.slug);
       await rebuildPlaybookManifest(playbooksDir3);
@@ -9911,9 +10513,9 @@ init_fs_migration();
 init_parser2();
 init_fs();
 init_paths();
-import { Router as Router5 } from "express";
+import { Router as Router6 } from "express";
 import { readdir as readdir9 } from "fs/promises";
-import { resolve as resolvePath, dirname as dirname4 } from "path";
+import { resolve as resolvePath, dirname as dirname5 } from "path";
 import { rename as rename3, mkdir as mkdir2 } from "fs/promises";
 
 // src/dashboard/todos-locks.ts
@@ -9959,7 +10561,7 @@ function touchItem(item) {
   item.updatedAt = now;
 }
 function createTodosRouter(todosDir2, broadcast, projectsDir2) {
-  const router = Router5();
+  const router = Router6();
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
@@ -10089,7 +10691,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve62 } = await import("path");
+      const { resolve: resolve63 } = await import("path");
       const { readFile: readFile43 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
@@ -10106,7 +10708,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve62(todosDir2, "archive"));
+      await ensureDir(resolve63(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
         archContent = await readFile43(archFile, "utf-8");
@@ -10513,7 +11115,7 @@ workspace: ${workspace}
           if (await fileExists(newPlanDir)) {
             return { status: 409, error: "plan dir already exists in target" };
           }
-          await mkdir2(dirname4(newPlanDir), { recursive: true });
+          await mkdir2(dirname5(newPlanDir), { recursive: true });
           await rename3(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
@@ -10589,9 +11191,9 @@ init_parser2();
 init_fs();
 init_paths();
 init_slug();
-import { Router as Router6 } from "express";
+import { Router as Router7 } from "express";
 import { mkdir as mkdir3, readFile as readFile14, rename as rename4 } from "fs/promises";
-import { resolve as resolve19, dirname as dirname5 } from "path";
+import { resolve as resolve20, dirname as dirname6 } from "path";
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function touchItem2(item) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -10606,7 +11208,7 @@ function params(req) {
   return req.params;
 }
 async function projectExists(projectsDir2, slug) {
-  return fileExists(resolve19(projectsDir2, slug, "project.md"));
+  return fileExists(resolve20(projectsDir2, slug, "project.md"));
 }
 async function ensureProjectTodosDir(projectsDir2, slug) {
   const todosDir2 = projectTodosDir(projectsDir2, slug);
@@ -10623,7 +11225,7 @@ async function ensureProjectTodosDir(projectsDir2, slug) {
     throw err2;
   }
   try {
-    await mkdir3(resolve19(todosDir2, "archive"), { recursive: false });
+    await mkdir3(resolve20(todosDir2, "archive"), { recursive: false });
   } catch (err2) {
     const code = err2.code;
     if (code === "EEXIST") return;
@@ -10639,7 +11241,7 @@ function notFound(res, slug) {
   res.status(404).json({ error: `Project "${slug}" not found` });
 }
 function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
-  const router = Router6({ mergeParams: true });
+  const router = Router7({ mergeParams: true });
   function broadcastUpdate(projectSlug) {
     broadcast({ type: "todos-updated", projectSlug, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
@@ -11247,18 +11849,18 @@ workspace: ${slug}
           if (tg.includes("/")) {
             const parts = tg.split("/");
             if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
-            assignmentDir = resolve19(projectsDir2, parts[0], "assignments", parts[1]);
+            assignmentDir = resolve20(projectsDir2, parts[0], "assignments", parts[1]);
             assignmentRef = `${parts[0]}/${parts[1]}`;
           } else if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(tg)) {
-            assignmentDir = resolve19(assignmentsDirFn(), tg);
+            assignmentDir = resolve20(assignmentsDirFn(), tg);
             assignmentRef = tg;
           } else {
             return { error: `Invalid target.assignment "${tg}"` };
           }
-          const assignmentMdPath3 = resolve19(assignmentDir, "assignment.md");
+          const assignmentMdPath3 = resolve20(assignmentDir, "assignment.md");
           if (!await fileExists(assignmentMdPath3)) return { error: `Target assignment not found: ${assignmentMdPath3}` };
         }
-        const assignmentMdPath2 = resolve19(assignmentDir, "assignment.md");
+        const assignmentMdPath2 = resolve20(assignmentDir, "assignment.md");
         let content = await readFile14(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
@@ -11388,7 +11990,7 @@ workspace: ${slug}
           if (await fileExists(newPlanDir)) {
             return { status: 409, error: "plan dir already exists in target" };
           }
-          await mkdir3(dirname5(newPlanDir), { recursive: true });
+          await mkdir3(dirname6(newPlanDir), { recursive: true });
           await rename4(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
@@ -11451,7 +12053,7 @@ workspace: ${slug}
 
 // src/dashboard/api-backup.ts
 init_config2();
-import { Router as Router7 } from "express";
+import { Router as Router8 } from "express";
 
 // src/utils/github-backup.ts
 init_paths();
@@ -11460,7 +12062,7 @@ init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { cp, mkdtemp, rm as rm2, readFile as readFile15, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename5 } from "fs/promises";
-import { resolve as resolve20, join as join2 } from "path";
+import { resolve as resolve21, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -11500,7 +12102,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve20(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve21(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -11511,7 +12113,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve20(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve21(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open(lockPath, "wx");
@@ -11558,7 +12160,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve20(dest, ".."));
+    await ensureDir(resolve21(dest, ".."));
     await cp(src, dest, { force: true });
   }
 }
@@ -11606,7 +12208,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve20(destPath, ".."));
+        await ensureDir(resolve21(destPath, ".."));
         await writeFile4(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -11660,7 +12262,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve20(localPath, ".."));
+    await ensureDir(resolve21(localPath, ".."));
     await cp(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -11761,7 +12363,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve20(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve21(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -11774,7 +12376,7 @@ async function getBackupStatus() {
 
 // src/dashboard/api-backup.ts
 function createBackupRouter() {
-  const router = Router7();
+  const router = Router8();
   router.get("/", async (_req, res) => {
     try {
       const status = await getBackupStatus();
@@ -12095,10 +12697,11 @@ function createDashboardServer(options) {
   migrateFromMarkdown(projectsDir2).catch((err2) => {
     console.error("Session migration from markdown failed:", err2);
   });
+  initLeasesDb();
   (async () => {
     try {
       const configResult = await migrateLegacyConfig(
-        resolve21(syntaurRoot(), "config.md")
+        resolve22(syntaurRoot(), "config.md")
       );
       const projectResult = await migrateLegacyProjectFiles(projectsDir2);
       const summary = summarizeMigration(projectResult, configResult);
@@ -12428,6 +13031,7 @@ function createDashboardServer(options) {
   });
   app.use(createWriteRouter(projectsDir2, assignmentsDir2));
   app.use("/api/servers", createServersRouter(serversDir2, projectsDir2, assignmentsDir2));
+  app.use("/api/leases", createLeasesRouter(broadcast));
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2));
   app.use("/api/playbooks", createPlaybooksRouter(playbooksDir3));
   app.get("/api/memories", async (_req, res) => {
@@ -12453,14 +13057,14 @@ function createDashboardServer(options) {
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     const sendOpts = { dotfiles: "allow" };
-    app.use("/assets", express.static(resolve21(dashboardDistPath, "assets"), sendOpts));
+    app.use("/assets", express.static(resolve22(dashboardDistPath, "assets"), sendOpts));
     app.use(express.static(dashboardDistPath, { ...sendOpts, index: false, fallthrough: true }));
     app.get("{*path}", async (req, res) => {
       if (req.path.startsWith("/api") || req.path === "/ws" || req.path.startsWith("/assets")) {
         res.status(404).json({ error: "Not Found" });
         return;
       }
-      const indexPath = resolve21(dashboardDistPath, "index.html");
+      const indexPath = resolve22(dashboardDistPath, "index.html");
       if (!await fileExists(indexPath)) {
         res.status(503).send(
           'Dashboard not built. Run "npm run build:dashboard" first.'
@@ -12484,6 +13088,7 @@ function createDashboardServer(options) {
         serversDir: serversDir2,
         playbooksDir: playbooksDir3,
         todosDir: todosDir2,
+        dbPath: resolve22(syntaurRoot(), "syntaur.db"),
         onMessage: broadcast
       });
       startAutodiscovery({ serversDir: serversDir2, projectsDir: projectsDir2, assignmentsDir: assignmentsDir2, excludePids: /* @__PURE__ */ new Set([process.pid]) });
@@ -12498,7 +13103,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve21(syntaurRoot(), "dashboard-port");
+          const portFile = resolve22(syntaurRoot(), "dashboard-port");
           writeFile5(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -12511,11 +13116,12 @@ function createDashboardServer(options) {
         await watcherHandle.close();
       }
       closeSessionDb();
+      closeLeasesDb();
       for (const client of clients) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve21(syntaurRoot(), "dashboard-port");
+      const portFile = resolve22(syntaurRoot(), "dashboard-port");
       await unlink4(portFile).catch(() => {
       });
       server.closeAllConnections?.();
@@ -12595,8 +13201,8 @@ async function dashboardCommand(options) {
     port = availablePort;
   }
   const thisFile = fileURLToPath2(import.meta.url);
-  const packageRoot = resolve22(dirname6(thisFile), "..");
-  const dashboardDist = resolve22(packageRoot, "dashboard", "dist");
+  const packageRoot = resolve23(dirname7(thisFile), "..");
+  const dashboardDist = resolve23(packageRoot, "dashboard", "dist");
   const server = createDashboardServer({
     port,
     projectsDir: projectsDir2,
@@ -12610,8 +13216,8 @@ async function dashboardCommand(options) {
   await server.start();
   let viteProcess = null;
   if (mode === "dev") {
-    const dashboardDir = resolve22(packageRoot, "dashboard");
-    const viteBin = resolve22(dashboardDir, "node_modules", ".bin", "vite");
+    const dashboardDir = resolve23(packageRoot, "dashboard");
+    const viteBin = resolve23(dashboardDir, "node_modules", ".bin", "vite");
     if (!await fileExists(viteBin)) {
       console.error(
         'Vite not found. Run "npm ci --prefix dashboard" first, or use the default bundled dashboard mode.'
@@ -12686,7 +13292,7 @@ init_config2();
 init_slug();
 init_lifecycle();
 init_assignment_resolver();
-import { resolve as resolve23 } from "path";
+import { resolve as resolve24 } from "path";
 async function runTransition(assignment, command, options = {}) {
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
@@ -12697,8 +13303,8 @@ async function runTransition(assignment, command, options = {}) {
     if (!isValidSlug(assignment)) {
       throw new Error(`Invalid assignment slug "${assignment}".`);
     }
-    const projectDir = resolve23(baseDir, options.project);
-    const projectMdPath = resolve23(projectDir, "project.md");
+    const projectDir = resolve24(baseDir, options.project);
+    const projectMdPath = resolve24(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
     }
@@ -12729,8 +13335,8 @@ async function runAssign(assignment, agent, options = {}) {
     if (!isValidSlug(assignment)) {
       throw new Error(`Invalid assignment slug "${assignment}".`);
     }
-    const projectDir = resolve23(baseDir, options.project);
-    const projectMdPath = resolve23(projectDir, "project.md");
+    const projectDir = resolve24(baseDir, options.project);
+    const projectMdPath = resolve24(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
     }
@@ -12825,20 +13431,20 @@ import {
 } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename as basename3, dirname as dirname8, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve25 } from "path";
+import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve26 } from "path";
 
 // src/utils/package-root.ts
 init_fs();
-import { dirname as dirname7, resolve as resolve24 } from "path";
+import { dirname as dirname8, resolve as resolve25 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function findPackageRoot(expectedRelativePath) {
-  let currentDir = dirname7(fileURLToPath3(import.meta.url));
+  let currentDir = dirname8(fileURLToPath3(import.meta.url));
   while (true) {
-    const candidate = resolve24(currentDir, expectedRelativePath);
+    const candidate = resolve25(currentDir, expectedRelativePath);
     if (await fileExists(candidate)) {
       return currentDir;
     }
-    const parentDir = resolve24(currentDir, "..");
+    const parentDir = resolve25(currentDir, "..");
     if (parentDir === currentDir) {
       throw new Error(
         `Could not locate package root containing ${expectedRelativePath}.`
@@ -12859,25 +13465,25 @@ function getPluginManifestRelativePath(pluginKind) {
 }
 function getDefaultPluginTargetDir(pluginKind) {
   const home = homedir2();
-  return pluginKind === "claude" ? resolve25(home, ".claude", "plugins", "syntaur") : resolve25(home, "plugins", "syntaur");
+  return pluginKind === "claude" ? resolve26(home, ".claude", "plugins", "syntaur") : resolve26(home, "plugins", "syntaur");
 }
 function getDefaultMarketplacePath() {
-  return resolve25(homedir2(), ".agents", "plugins", "marketplace.json");
+  return resolve26(homedir2(), ".agents", "plugins", "marketplace.json");
 }
 function getClaudeMarketplacesRoot() {
-  return resolve25(homedir2(), ".claude", "plugins", "marketplaces");
+  return resolve26(homedir2(), ".claude", "plugins", "marketplaces");
 }
 function getClaudeKnownMarketplacesPath() {
-  return resolve25(homedir2(), ".claude", "plugins", "known_marketplaces.json");
+  return resolve26(homedir2(), ".claude", "plugins", "known_marketplaces.json");
 }
 function getClaudeInstalledPluginsPath() {
-  return resolve25(homedir2(), ".claude", "plugins", "installed_plugins.json");
+  return resolve26(homedir2(), ".claude", "plugins", "installed_plugins.json");
 }
 function getInstallMarkerPath(targetDir) {
-  return resolve25(targetDir, INSTALL_MARKER_FILENAME);
+  return resolve26(targetDir, INSTALL_MARKER_FILENAME);
 }
 async function readPackageManifest(packageRoot) {
-  const raw = await readFile16(resolve25(packageRoot, "package.json"), "utf-8");
+  const raw = await readFile16(resolve26(packageRoot, "package.json"), "utf-8");
   return JSON.parse(raw);
 }
 async function readJsonFileIfExists(pathValue) {
@@ -12893,11 +13499,11 @@ async function readJsonFileIfExists(pathValue) {
 }
 async function readClaudePluginManifest(pluginDir) {
   return await readJsonFileIfExists(
-    resolve25(pluginDir, ".claude-plugin", "plugin.json")
+    resolve26(pluginDir, ".claude-plugin", "plugin.json")
   ) ?? {};
 }
 async function readPluginManifestName(targetDir, pluginKind) {
-  const manifestPath = resolve25(targetDir, getPluginManifestRelativePath(pluginKind));
+  const manifestPath = resolve26(targetDir, getPluginManifestRelativePath(pluginKind));
   if (!await fileExists(manifestPath)) {
     return void 0;
   }
@@ -12924,7 +13530,7 @@ async function getInstallStatus(targetDir, pluginKind) {
   const info = await lstat(targetDir);
   if (info.isSymbolicLink()) {
     const symlinkTarget = await readlink(targetDir);
-    const resolvedTarget = resolve25(dirname8(targetDir), symlinkTarget);
+    const resolvedTarget = resolve26(dirname9(targetDir), symlinkTarget);
     const manifestName2 = await readPluginManifestName(resolvedTarget, pluginKind);
     return {
       exists: true,
@@ -12961,16 +13567,16 @@ async function writeInstallMetadata(targetDir, pluginKind, installMode, packageM
   );
 }
 async function installCopy(paths, pluginKind) {
-  await ensureDir(dirname8(paths.targetDir));
+  await ensureDir(dirname9(paths.targetDir));
   await cp2(paths.sourceDir, paths.targetDir, { recursive: true });
   const packageManifest = await readPackageManifest(paths.packageRoot);
   await writeInstallMetadata(paths.targetDir, pluginKind, "copy", packageManifest);
 }
 async function installLink(paths) {
-  await ensureDir(dirname8(paths.targetDir));
+  await ensureDir(dirname9(paths.targetDir));
   await rm3(paths.targetDir, { recursive: true, force: true });
-  await ensureDir(dirname8(paths.targetDir));
-  await symlink(resolve25(paths.sourceDir), paths.targetDir, "dir");
+  await ensureDir(dirname9(paths.targetDir));
+  await symlink(resolve26(paths.sourceDir), paths.targetDir, "dir");
 }
 async function removeInstallMarker(targetDir) {
   const markerPath = getInstallMarkerPath(targetDir);
@@ -12984,13 +13590,13 @@ function normalizeAbsoluteInstallPath(pathValue, label) {
   if (!isAbsolute2(expanded)) {
     throw new Error(`${label} must be an absolute path.`);
   }
-  return resolve25(expanded);
+  return resolve26(expanded);
 }
 async function resolvePluginPaths(pluginKind, targetDir) {
   const packageRoot = await findPackageRoot(getPluginRelativePath(pluginKind));
   return {
     packageRoot,
-    sourceDir: resolve25(packageRoot, getPluginRelativePath(pluginKind)),
+    sourceDir: resolve26(packageRoot, getPluginRelativePath(pluginKind)),
     targetDir: targetDir ?? getDefaultPluginTargetDir(pluginKind)
   };
 }
@@ -13024,7 +13630,7 @@ async function readClaudeMarketplaceFile(manifestPath) {
   };
 }
 async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
-  await ensureDir(dirname8(manifestPath));
+  await ensureDir(dirname9(manifestPath));
   if (Array.isArray(marketplace.plugins)) {
     marketplace.plugins = [...marketplace.plugins].sort((a, b) => {
       const an = a?.name ?? "";
@@ -13115,8 +13721,8 @@ async function listClaudeMarketplaceCandidates() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const candidateRoot = resolve25(rootDir, entry.name);
-    const manifestPath = resolve25(candidateRoot, ".claude-plugin", "marketplace.json");
+    const candidateRoot = resolve26(rootDir, entry.name);
+    const manifestPath = resolve26(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -13143,11 +13749,11 @@ async function listClaudeMarketplaceCandidates() {
     if (!installLocation) {
       continue;
     }
-    const candidateRoot = resolve25(expandHome(installLocation));
+    const candidateRoot = resolve26(expandHome(installLocation));
     if (seen.has(candidateRoot)) {
       continue;
     }
-    const manifestPath = resolve25(candidateRoot, ".claude-plugin", "marketplace.json");
+    const manifestPath = resolve26(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -13175,7 +13781,7 @@ async function getPreferredClaudeMarketplace() {
     name: candidate.name,
     rootDir: candidate.rootDir,
     manifestPath: candidate.manifestPath,
-    targetDir: resolve25(candidate.rootDir, "plugins", "syntaur")
+    targetDir: resolve26(candidate.rootDir, "plugins", "syntaur")
   };
 }
 async function registerKnownClaudeMarketplace(name, rootDir) {
@@ -13207,7 +13813,7 @@ async function registerKnownClaudeMarketplace(name, rootDir) {
   };
   existing[name].lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   existing[name].autoUpdate = true;
-  await ensureDir(dirname8(manifestPath));
+  await ensureDir(dirname9(manifestPath));
   if (await fileExists(manifestPath)) {
     const prev = await readFile16(manifestPath, "utf-8");
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -13223,7 +13829,7 @@ async function ensureKnownClaudeMarketplaceForRoot(options) {
   return registerKnownClaudeMarketplace(options.name, options.rootDir);
 }
 async function setSyntaurPluginEnabled(options) {
-  const settingsPath = resolve25(homedir2(), ".claude", "settings.json");
+  const settingsPath = resolve26(homedir2(), ".claude", "settings.json");
   const key = `syntaur@${options.marketplaceName}`;
   let parsed = {};
   if (await fileExists(settingsPath)) {
@@ -13243,7 +13849,7 @@ async function setSyntaurPluginEnabled(options) {
   }
   enabledPlugins[key] = options.enabled;
   parsed.enabledPlugins = enabledPlugins;
-  await ensureDir(dirname8(settingsPath));
+  await ensureDir(dirname9(settingsPath));
   if (await fileExists(settingsPath)) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const prev = await readFile16(settingsPath, "utf-8");
@@ -13260,9 +13866,9 @@ async function ensureClaudeUserMarketplace() {
   if (existing) {
     return existing;
   }
-  const rootDir = resolve25(getClaudeMarketplacesRoot(), "user-plugins");
-  const manifestPath = resolve25(rootDir, ".claude-plugin", "marketplace.json");
-  await ensureDir(resolve25(rootDir, "plugins"));
+  const rootDir = resolve26(getClaudeMarketplacesRoot(), "user-plugins");
+  const manifestPath = resolve26(rootDir, ".claude-plugin", "marketplace.json");
+  await ensureDir(resolve26(rootDir, "plugins"));
   if (!await fileExists(manifestPath)) {
     const scaffold = {
       plugins: []
@@ -13281,22 +13887,22 @@ async function ensureClaudeUserMarketplace() {
     name: "user-plugins",
     rootDir,
     manifestPath,
-    targetDir: resolve25(rootDir, "plugins", "syntaur")
+    targetDir: resolve26(rootDir, "plugins", "syntaur")
   };
 }
 async function detectClaudeMarketplaceForTarget(targetDir) {
   const normalizedTargetDir = normalizeAbsoluteInstallPath(targetDir, "Claude plugin target");
-  const pluginsDir = dirname8(normalizedTargetDir);
-  if (basename3(pluginsDir) !== "plugins") {
+  const pluginsDir = dirname9(normalizedTargetDir);
+  if (basename4(pluginsDir) !== "plugins") {
     return null;
   }
-  const rootDir = dirname8(pluginsDir);
-  const manifestPath = resolve25(rootDir, ".claude-plugin", "marketplace.json");
+  const rootDir = dirname9(pluginsDir);
+  const manifestPath = resolve26(rootDir, ".claude-plugin", "marketplace.json");
   if (!await fileExists(manifestPath)) {
     return null;
   }
   const marketplace = await readClaudeMarketplaceFile(manifestPath);
-  const name = typeof marketplace.name === "string" && marketplace.name.trim() !== "" ? marketplace.name : basename3(rootDir);
+  const name = typeof marketplace.name === "string" && marketplace.name.trim() !== "" ? marketplace.name : basename4(rootDir);
   return {
     name,
     rootDir,
@@ -13307,7 +13913,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
 async function findManagedClaudeMarketplacePluginDir() {
   const marketplaces = await listClaudeMarketplaceCandidates();
   for (const marketplace of marketplaces) {
-    const targetDir = resolve25(marketplace.rootDir, "plugins", "syntaur");
+    const targetDir = resolve26(marketplace.rootDir, "plugins", "syntaur");
     const status = await getInstallStatus(targetDir, "claude");
     if (status.exists && status.managed) {
       return targetDir;
@@ -13432,7 +14038,7 @@ async function installManagedPlugin(options) {
       `${paths.targetDir} already exists and is not a Syntaur-managed install. Remove it manually before installing Syntaur there.`
     );
   }
-  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve25(paths.sourceDir) && !force) {
+  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve26(paths.sourceDir) && !force) {
     return {
       targetDir: paths.targetDir,
       sourceDir: paths.sourceDir,
@@ -13456,7 +14062,7 @@ async function installManagedPlugin(options) {
   };
 }
 function buildMarketplaceSourcePath(pluginTargetDir, marketplacePath) {
-  const relPath = relative2(dirname8(marketplacePath), pluginTargetDir).replaceAll("\\", "/");
+  const relPath = relative2(dirname9(marketplacePath), pluginTargetDir).replaceAll("\\", "/");
   if (relPath === "") {
     return ".";
   }
@@ -13493,7 +14099,7 @@ async function readMarketplaceFile(marketplacePath) {
   };
 }
 async function writeMarketplaceFile(marketplacePath, marketplace) {
-  await ensureDir(dirname8(marketplacePath));
+  await ensureDir(dirname9(marketplacePath));
   await writeFile6(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
 }
@@ -13645,13 +14251,13 @@ async function recommendMarketplacePath() {
   return configuredOrManaged ?? getDefaultMarketplacePath();
 }
 async function isSyntaurDataInstalled() {
-  return fileExists(resolve25(syntaurRoot(), "config.md"));
+  return fileExists(resolve26(syntaurRoot(), "config.md"));
 }
 async function removeSyntaurData() {
   await rm3(syntaurRoot(), { recursive: true, force: true });
 }
 async function getConfiguredProjectDir() {
-  if (!await fileExists(resolve25(syntaurRoot(), "config.md"))) {
+  if (!await fileExists(resolve26(syntaurRoot(), "config.md"))) {
     return null;
   }
   return (await readConfig()).defaultProjectDir;
@@ -13721,16 +14327,16 @@ async function textPrompt(question, defaultValue) {
 // src/utils/install-skills.ts
 init_fs();
 import { readFile as readFile18, readdir as readdir11, mkdir as mkdir4, copyFile, rm as rm4, lstat as lstat2 } from "fs/promises";
-import { resolve as resolve27, relative as relative3, join as join3 } from "path";
+import { resolve as resolve28, relative as relative3, join as join3 } from "path";
 import { homedir as homedir4 } from "os";
 
 // src/utils/plugin-state.ts
 init_fs();
 import { readFile as readFile17 } from "fs/promises";
-import { resolve as resolve26 } from "path";
+import { resolve as resolve27 } from "path";
 import { homedir as homedir3 } from "os";
 function settingsPathFor(agent) {
-  if (agent === "claude") return resolve26(homedir3(), ".claude", "settings.json");
+  if (agent === "claude") return resolve27(homedir3(), ".claude", "settings.json");
   return null;
 }
 async function readJsonOrNull(path) {
@@ -13781,11 +14387,11 @@ var KNOWN_SKILL_NAMES = [
 var KNOWN_SKILLS = KNOWN_SKILL_NAMES;
 async function getSkillsDir() {
   const packageRoot = await findPackageRoot("skills");
-  return resolve27(packageRoot, "skills");
+  return resolve28(packageRoot, "skills");
 }
 function defaultSkillTargetDir(target) {
-  if (target === "claude") return resolve27(homedir4(), ".claude", "skills");
-  return resolve27(homedir4(), ".codex", "skills");
+  if (target === "claude") return resolve28(homedir4(), ".claude", "skills");
+  return resolve28(homedir4(), ".codex", "skills");
 }
 async function walkFiles(root) {
   const out = [];
@@ -14117,7 +14723,7 @@ async function installPluginCommand(options) {
 init_paths();
 init_fs();
 import { readFile as readFile20, writeFile as writeFile8, copyFile as copyFile2, rm as rm5, stat as stat2, symlink as symlink2, unlink as unlink6, lstat as lstat3 } from "fs/promises";
-import { resolve as resolve29, dirname as dirname10 } from "path";
+import { resolve as resolve30, dirname as dirname11 } from "path";
 import { homedir as homedir5 } from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
@@ -14125,7 +14731,7 @@ import { fileURLToPath as fileURLToPath4 } from "url";
 init_paths();
 init_fs();
 import { readFile as readFile19, writeFile as writeFile7 } from "fs/promises";
-import { resolve as resolve28, dirname as dirname9 } from "path";
+import { resolve as resolve29, dirname as dirname10 } from "path";
 import { spawnSync } from "child_process";
 import { checkbox, input as input2, confirm } from "@inquirer/prompts";
 var AVAILABLE_SEGMENTS = [
@@ -14146,7 +14752,7 @@ var PRESETS = {
   tracker: { segments: ["git", "assignment", "external", "session"], separator: " \xB7 " }
 };
 function getConfigPath(installRoot) {
-  return resolve28(installRoot, "statusline.config.json");
+  return resolve29(installRoot, "statusline.config.json");
 }
 async function readConfig2(path) {
   if (!await fileExists(path)) return null;
@@ -14246,7 +14852,7 @@ function renderPreview(config, statuslineScript, cwd) {
     env: {
       ...process.env,
       // Force the child to pick up the freshly-written config from install root.
-      HOME: dirname9(dirname9(statuslineScript))
+      HOME: dirname10(dirname10(statuslineScript))
     }
   });
   if (res.status !== 0) return null;
@@ -14297,14 +14903,14 @@ async function configureStatuslineCommand(options = {}) {
     console.log("(preview mode \u2014 config NOT written)");
     return;
   }
-  await ensureDir(dirname9(configPath));
+  await ensureDir(dirname10(configPath));
   await writeFile7(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   console.log("Wrote statusline config:");
   console.log(`  path:      ${configPath}`);
   console.log(`  segments:  ${config.segments.join(", ")}`);
   console.log(`  separator: ${JSON.stringify(config.separator)}`);
   if (config.wrap) console.log(`  wrap:      ${config.wrap}`);
-  const script = options.statuslineScript ?? resolve28(installRoot, "statusline.sh");
+  const script = options.statuslineScript ?? resolve29(installRoot, "statusline.sh");
   if (await fileExists(script)) {
     console.log("");
     console.log("Live preview:");
@@ -14324,7 +14930,7 @@ async function configureStatuslineCommand(options = {}) {
 async function writeDefaultConfigIfMissing(installRoot) {
   const path = getConfigPath(installRoot);
   if (await fileExists(path)) return;
-  await ensureDir(dirname9(path));
+  await ensureDir(dirname10(path));
   const defaultConfig = {
     segments: ["git", "assignment", "session"],
     separator: " \xB7 "
@@ -14334,8 +14940,8 @@ async function writeDefaultConfigIfMissing(installRoot) {
 
 // src/commands/install-statusline.ts
 function getPackageStatuslineSource() {
-  const here = dirname10(fileURLToPath4(import.meta.url));
-  return resolve29(here, "..", "statusline", "statusline.sh");
+  const here = dirname11(fileURLToPath4(import.meta.url));
+  return resolve30(here, "..", "statusline", "statusline.sh");
 }
 async function readSettingsJson(settingsPath) {
   if (!await fileExists(settingsPath)) return {};
@@ -14351,7 +14957,7 @@ async function readSettingsJson(settingsPath) {
   }
 }
 async function writeSettingsJson(settingsPath, data) {
-  await ensureDir(dirname10(settingsPath));
+  await ensureDir(dirname11(settingsPath));
   await writeFile8(settingsPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 async function resolveMode(mode, existingCommand, ourCommand) {
@@ -14386,7 +14992,7 @@ function extractExistingCommand(settings) {
   };
 }
 async function backupSettings(settingsSnapshot, backupPath) {
-  await ensureDir(dirname10(backupPath));
+  await ensureDir(dirname11(backupPath));
   await writeFile8(
     backupPath,
     JSON.stringify(
@@ -14403,7 +15009,7 @@ async function backupSettings(settingsSnapshot, backupPath) {
   );
 }
 async function installScript(sourceScript, destScript, link) {
-  await ensureDir(dirname10(destScript));
+  await ensureDir(dirname11(destScript));
   try {
     const s = await lstat3(destScript);
     if (s.isSymbolicLink() || s.isFile()) {
@@ -14419,12 +15025,12 @@ async function installScript(sourceScript, destScript, link) {
 }
 async function installStatuslineCommand(options = {}) {
   const mode = options.mode ?? "ask";
-  const settingsPath = options.settingsPath ?? resolve29(homedir5(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve30(homedir5(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
   const sourceScript = options.sourceScript ?? getPackageStatuslineSource();
-  const destScript = resolve29(installRoot, "statusline.sh");
-  const confPath = resolve29(installRoot, "statusline.conf");
-  const backupPath = resolve29(installRoot, "statusline.backup.json");
+  const destScript = resolve30(installRoot, "statusline.sh");
+  const confPath = resolve30(installRoot, "statusline.conf");
+  const backupPath = resolve30(installRoot, "statusline.backup.json");
   if (!await fileExists(sourceScript)) {
     throw new Error(
       `Statusline source script not found at ${sourceScript}. Try re-installing syntaur (npm install -g syntaur) or pass --source-script explicitly.`
@@ -14460,7 +15066,7 @@ async function installStatuslineCommand(options = {}) {
     if (parsed) {
       wrapTarget = parsed;
     } else {
-      const wrapperPath = resolve29(installRoot, "statusline-wrapped.sh");
+      const wrapperPath = resolve30(installRoot, "statusline-wrapped.sh");
       const wrapperBody = `#!/usr/bin/env bash
 # Auto-generated by syntaur install-statusline.
 # Executes the previously configured statusLine command.
@@ -14471,7 +15077,7 @@ exec ${existingCommand}
       wrapTarget = wrapperPath;
     }
   }
-  await ensureDir(dirname10(confPath));
+  await ensureDir(dirname11(confPath));
   await writeFile8(
     confPath,
     wrapTarget ? `# Wrap target \u2014 the command below is invoked with the same stdin; its
@@ -14515,12 +15121,12 @@ async function chmodExec(path) {
   }
 }
 async function uninstallStatuslineCommand(options = {}) {
-  const settingsPath = options.settingsPath ?? resolve29(homedir5(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve30(homedir5(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
-  const destScript = resolve29(installRoot, "statusline.sh");
-  const confPath = resolve29(installRoot, "statusline.conf");
-  const backupPath = resolve29(installRoot, "statusline.backup.json");
-  const wrapperPath = resolve29(installRoot, "statusline-wrapped.sh");
+  const destScript = resolve30(installRoot, "statusline.sh");
+  const confPath = resolve30(installRoot, "statusline.conf");
+  const backupPath = resolve30(installRoot, "statusline.backup.json");
+  const wrapperPath = resolve30(installRoot, "statusline-wrapped.sh");
   const settings = await readSettingsJson(settingsPath);
   const existing = extractExistingCommand(settings);
   const ourCommand = `bash ${destScript}`;
@@ -14548,7 +15154,7 @@ async function uninstallStatuslineCommand(options = {}) {
     await writeSettingsJson(settingsPath, settings);
   }
   if (!options.keepScript) {
-    const configPath = resolve29(installRoot, "statusline.config.json");
+    const configPath = resolve30(installRoot, "statusline.config.json");
     for (const path of [destScript, confPath, backupPath, wrapperPath, configPath]) {
       try {
         await rm5(path, { force: true });
@@ -14805,7 +15411,7 @@ async function setupCommand(options) {
 }
 
 // src/commands/uninstall.ts
-import { resolve as resolve30 } from "path";
+import { resolve as resolve31 } from "path";
 init_paths();
 function expandTargets(options) {
   if (options.all) {
@@ -14885,7 +15491,7 @@ async function uninstallCommand(options) {
     const configuredProjectDir = await getConfiguredProjectDir();
     await removeSyntaurData();
     console.log(`Removed ${syntaurRoot()}`);
-    if (configuredProjectDir && resolve30(configuredProjectDir) !== resolve30(syntaurRoot(), "projects")) {
+    if (configuredProjectDir && resolve31(configuredProjectDir) !== resolve31(syntaurRoot(), "projects")) {
       console.warn(
         `Warning: config.md pointed to an external project directory (${configuredProjectDir}). That directory was not removed automatically.`
       );
@@ -14904,7 +15510,7 @@ init_slug();
 init_cursor_rules();
 init_codex_agents();
 init_opencode_config();
-import { resolve as resolve31 } from "path";
+import { resolve as resolve32 } from "path";
 var SUPPORTED_FRAMEWORKS = ["cursor", "codex", "opencode"];
 async function setupAdapterCommand(framework, options) {
   if (!SUPPORTED_FRAMEWORKS.includes(framework)) {
@@ -14930,19 +15536,19 @@ async function setupAdapterCommand(framework, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-  const projectDir = resolve31(baseDir, options.project);
-  const assignmentDir = resolve31(
+  const projectDir = resolve32(baseDir, options.project);
+  const assignmentDir = resolve32(
     projectDir,
     "assignments",
     options.assignment
   );
-  const projectMdPath = resolve31(projectDir, "project.md");
+  const projectMdPath = resolve32(projectDir, "project.md");
   if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
     throw new Error(
       `Project "${options.project}" not found at ${projectDir}.`
     );
   }
-  const assignmentMdPath2 = resolve31(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve32(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentDir) || !await fileExists(assignmentMdPath2)) {
     throw new Error(
       `Assignment "${options.assignment}" not found at ${assignmentDir}.`
@@ -14970,15 +15576,15 @@ async function setupAdapterCommand(framework, options) {
     }
   }
   if (framework === "cursor") {
-    const protocolPath = resolve31(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
-    const assignmentPath = resolve31(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
+    const protocolPath = resolve32(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
+    const assignmentPath = resolve32(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
     await writeAdapterFile(protocolPath, renderCursorProtocol());
     await writeAdapterFile(assignmentPath, renderCursorAssignment(rendererParams));
   } else if (framework === "codex" || framework === "opencode") {
-    const agentsPath = resolve31(cwd, "AGENTS.md");
+    const agentsPath = resolve32(cwd, "AGENTS.md");
     await writeAdapterFile(agentsPath, renderCodexAgents(rendererParams));
     if (framework === "opencode") {
-      const configPath = resolve31(cwd, "opencode.json");
+      const configPath = resolve32(cwd, "opencode.json");
       await writeAdapterFile(configPath, renderOpenCodeConfig({ projectDir }));
     }
   }
@@ -15003,7 +15609,7 @@ async function setupAdapterCommand(framework, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve32 } from "path";
+import { resolve as resolve33 } from "path";
 async function trackSessionCommand(options) {
   if (!options.agent) {
     throw new Error("--agent <name> is required.");
@@ -15016,7 +15622,7 @@ async function trackSessionCommand(options) {
   if (options.project) {
     const config = await readConfig();
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-    const projectDir = resolve32(baseDir, options.project);
+    const projectDir = resolve33(baseDir, options.project);
     if (!await fileExists(projectDir)) {
       throw new Error(
         `Project "${options.project}" not found at ${projectDir}.`
@@ -15050,7 +15656,7 @@ init_config2();
 init_paths();
 init_fs();
 import { spawnSync as spawnSync2 } from "child_process";
-import { resolve as resolve34, isAbsolute as isAbsolute4 } from "path";
+import { resolve as resolve35, isAbsolute as isAbsolute4 } from "path";
 import { readFile as readFile22 } from "fs/promises";
 import { select, confirm as confirm2, input as input3 } from "@inquirer/prompts";
 async function browseCommand(options) {
@@ -15120,7 +15726,7 @@ async function pickAgent(agents) {
   return picked;
 }
 async function ensureWorktree(opts) {
-  const assignmentPath = resolve34(
+  const assignmentPath = resolve35(
     opts.projectsDir,
     opts.projectSlug,
     "assignments",
@@ -15201,7 +15807,7 @@ function computeWorktreeDefaults(opts) {
   const repository = opts.existing.repository ?? detectCurrentGitRoot();
   const branch = opts.projectSlug ? `syntaur/${opts.projectSlug}/${opts.assignmentSlug}` : `syntaur/${opts.assignmentSlug}`;
   const parentBranch = opts.existing.parentBranch ?? detectCurrentBranch() ?? "main";
-  const worktreeBase = repository ? resolve34(repository, ".worktrees", branch) : resolve34(
+  const worktreeBase = repository ? resolve35(repository, ".worktrees", branch) : resolve35(
     syntaurRoot(),
     "worktrees",
     opts.projectSlug || "standalone",
@@ -15234,7 +15840,7 @@ function detectCurrentBranch() {
 async function runCreate(opts) {
   const { createWorktreeAndRecord: createWorktreeAndRecord2, GitWorktreeError: GitWorktreeError2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
   const expandedWorktree = expandHome(opts.worktreePath);
-  const absWorktree = isAbsolute4(expandedWorktree) ? expandedWorktree : resolve34(expandedWorktree);
+  const absWorktree = isAbsolute4(expandedWorktree) ? expandedWorktree : resolve35(expandedWorktree);
   try {
     await createWorktreeAndRecord2({
       assignmentPath: opts.assignmentPath,
@@ -15263,7 +15869,7 @@ init_paths();
 init_fs();
 init_playbook();
 init_playbooks();
-import { resolve as resolve35 } from "path";
+import { resolve as resolve36 } from "path";
 async function createPlaybookCommand(name, options) {
   if (!name.trim()) {
     throw new Error("Playbook name cannot be empty.");
@@ -15276,7 +15882,7 @@ async function createPlaybookCommand(name, options) {
   }
   const dir = playbooksDir();
   await ensureDir(dir);
-  const filePath = resolve35(dir, `${slug}.md`);
+  const filePath = resolve36(dir, `${slug}.md`);
   if (await fileExists(filePath)) {
     throw new Error(
       `Playbook "${slug}" already exists at ${filePath}
@@ -15299,7 +15905,7 @@ init_fs();
 init_parser();
 init_config2();
 import { readdir as readdir12, readFile as readFile23 } from "fs/promises";
-import { resolve as resolve36 } from "path";
+import { resolve as resolve37 } from "path";
 async function listPlaybooksCommand(options = {}) {
   const dir = playbooksDir();
   if (!await fileExists(dir)) {
@@ -15314,7 +15920,7 @@ async function listPlaybooksCommand(options = {}) {
   );
   const rows = [];
   for (const entry of mdFiles) {
-    const filePath = resolve36(dir, entry.name);
+    const filePath = resolve37(dir, entry.name);
     const raw = await readFile23(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
@@ -15414,7 +16020,7 @@ init_config2();
 init_slug();
 import { Command } from "commander";
 import { readFile as readFile24 } from "fs/promises";
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 var WORKSPACE_REGEX3 = /^[a-z0-9_][a-z0-9-]*$/;
 async function resolveScope(options) {
   const flagCount = [Boolean(options.project), Boolean(options.workspace), Boolean(options.global)].filter(Boolean).length;
@@ -15426,7 +16032,7 @@ async function resolveScope(options) {
       throw new Error(`Invalid project slug: "${options.project}".`);
     }
     const config = await readConfig();
-    const projectMd = resolve37(config.defaultProjectDir, options.project, "project.md");
+    const projectMd = resolve38(config.defaultProjectDir, options.project, "project.md");
     if (!await fileExists(projectMd)) {
       throw new Error(`Project "${options.project}" not found.`);
     }
@@ -15745,7 +16351,7 @@ todoCommand.command("archive").description("Archive completed todos and their lo
       (e) => e.itemIds.every((id) => completedIds.has(id))
     );
     const archFile = archivePath(todosPath, workspace, checklist.archiveInterval);
-    await ensureDir(resolve37(todosPath, "archive"));
+    await ensureDir(resolve38(todosPath, "archive"));
     let archContent = "";
     if (await fileExists(archFile)) {
       archContent = await readFile24(archFile, "utf-8");
@@ -15977,7 +16583,7 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
     );
     let target;
     if (existingFiles.length === 0) {
-      target = resolve37(planDir, "plan.md");
+      target = resolve38(planDir, "plan.md");
     } else {
       const versions = /* @__PURE__ */ new Set();
       for (const f of existingFiles) {
@@ -15987,7 +16593,7 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
       }
       let n = 2;
       while (versions.has(n)) n++;
-      target = resolve37(planDir, `plan-v${n}.md`);
+      target = resolve38(planDir, `plan-v${n}.md`);
     }
     if (!await fileExists(target)) {
       const stub = `---
@@ -16058,8 +16664,8 @@ async function moveTodo(id, options) {
       throw new Error(`Plan directory already exists at target: ${newPlanDir}; refusing to move.`);
     }
     const { rename: rename8, mkdir: mkdir8 } = await import("fs/promises");
-    const { dirname: dirname16 } = await import("path");
-    await mkdir8(dirname16(newPlanDir), { recursive: true });
+    const { dirname: dirname17 } = await import("path");
+    await mkdir8(dirname17(newPlanDir), { recursive: true });
     await rename8(item.planDir, newPlanDir);
     item.planDir = newPlanDir;
   }
@@ -16177,31 +16783,31 @@ backupCommand.command("config").description("Show or update backup configuration
 // src/commands/doctor.ts
 import { Command as Command3 } from "commander";
 import { readFile as readFile31 } from "fs/promises";
-import { isAbsolute as isAbsolute7, resolve as resolve47 } from "path";
+import { isAbsolute as isAbsolute7, resolve as resolve48 } from "path";
 
 // src/utils/doctor/index.ts
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { readFile as readFile30 } from "fs/promises";
-import { dirname as dirname13, join as join6 } from "path";
+import { dirname as dirname14, join as join6 } from "path";
 
 // src/utils/doctor/context.ts
 init_config2();
 init_paths();
 init_fs();
-import Database2 from "better-sqlite3";
-import { resolve as resolve38 } from "path";
+import Database3 from "better-sqlite3";
+import { resolve as resolve39 } from "path";
 async function buildCheckContext(cwd = process.cwd()) {
   const config = await readConfig();
   const root = syntaurRoot();
-  const dbPath = resolve38(root, "syntaur.db");
-  let db3 = null;
+  const dbPath = resolve39(root, "syntaur.db");
+  let db4 = null;
   let dbError = null;
   if (await fileExists(dbPath)) {
     try {
-      db3 = new Database2(dbPath, { readonly: true, fileMustExist: true });
+      db4 = new Database3(dbPath, { readonly: true, fileMustExist: true });
     } catch (err2) {
       dbError = err2 instanceof Error ? err2.message : String(err2);
-      db3 = null;
+      db4 = null;
     }
   } else {
     dbError = `database file not found at ${dbPath}`;
@@ -16209,7 +16815,7 @@ async function buildCheckContext(cwd = process.cwd()) {
   return {
     config,
     syntaurRoot: root,
-    db: db3,
+    db: db4,
     dbError,
     cwd,
     now: /* @__PURE__ */ new Date()
@@ -16227,10 +16833,10 @@ function closeCheckContext(ctx) {
 // src/utils/doctor/checks/env.ts
 init_fs();
 init_paths();
-import { resolve as resolve39, isAbsolute as isAbsolute5 } from "path";
+import { resolve as resolve40, isAbsolute as isAbsolute5 } from "path";
 import { readFile as readFile25, stat as stat3 } from "fs/promises";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname11, join as join4 } from "path";
+import { dirname as dirname12, join as join4 } from "path";
 var CATEGORY = "env";
 var syntaurRootExists = {
   id: "env.syntaur-root-exists",
@@ -16268,7 +16874,7 @@ var configValid = {
   category: CATEGORY,
   title: "~/.syntaur/config.md is valid",
   async run(ctx) {
-    const configPath = resolve39(ctx.syntaurRoot, "config.md");
+    const configPath = resolve40(ctx.syntaurRoot, "config.md");
     if (!await fileExists(configPath)) {
       return {
         id: this.id,
@@ -16561,14 +17167,14 @@ async function readLocalVersion() {
 async function readLocalPkg() {
   try {
     const here = fileURLToPath5(import.meta.url);
-    let dir = dirname11(here);
+    let dir = dirname12(here);
     for (let i = 0; i < 6; i++) {
       const candidate = join4(dir, "package.json");
       try {
         const text = await readFile25(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
-        dir = dirname11(dir);
+        dir = dirname12(dir);
       }
     }
     return null;
@@ -16617,7 +17223,7 @@ function versionGte(a, b) {
 
 // src/utils/doctor/checks/structure.ts
 init_fs();
-import { resolve as resolve40 } from "path";
+import { resolve as resolve41 } from "path";
 import { readdir as readdir13, stat as stat4 } from "fs/promises";
 var CATEGORY2 = "structure";
 var KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
@@ -16637,7 +17243,7 @@ var projectsDir = {
   category: CATEGORY2,
   title: "projects/ directory exists",
   async run(ctx) {
-    const p = resolve40(ctx.syntaurRoot, "projects");
+    const p = resolve41(ctx.syntaurRoot, "projects");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -16662,7 +17268,7 @@ var playbooksDir2 = {
   category: CATEGORY2,
   title: "playbooks/ directory exists",
   async run(ctx) {
-    const p = resolve40(ctx.syntaurRoot, "playbooks");
+    const p = resolve41(ctx.syntaurRoot, "playbooks");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -16687,7 +17293,7 @@ var todosDirValid = {
   category: CATEGORY2,
   title: "todos/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve40(ctx.syntaurRoot, "todos");
+    const p = resolve41(ctx.syntaurRoot, "todos");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -16718,7 +17324,7 @@ var serversDirValid = {
   category: CATEGORY2,
   title: "servers/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve40(ctx.syntaurRoot, "servers");
+    const p = resolve41(ctx.syntaurRoot, "servers");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -16763,7 +17369,7 @@ var knownFilesRecognized = {
       title: this.title,
       status: "warn",
       detail: `unexpected top-level entries: ${unexpected.join(", ")}`,
-      affected: unexpected.map((n) => resolve40(ctx.syntaurRoot, n)),
+      affected: unexpected.map((n) => resolve41(ctx.syntaurRoot, n)),
       remediation: {
         kind: "manual",
         suggestion: "Review these entries \u2014 they may be leftover state from older versions",
@@ -16792,7 +17398,7 @@ function pass2(check) {
 
 // src/utils/doctor/checks/project.ts
 init_fs();
-import { resolve as resolve41 } from "path";
+import { resolve as resolve42 } from "path";
 import { readdir as readdir14, stat as stat5 } from "fs/promises";
 var CATEGORY3 = "project";
 var REQUIRED_PROJECT_FILES = [
@@ -16822,10 +17428,10 @@ async function listProjects2(ctx) {
   for (const e of entries) {
     if (!e.isDirectory()) continue;
     if (e.name.startsWith(".") || e.name.startsWith("_")) continue;
-    const projectDir = resolve41(dir, e.name);
+    const projectDir = resolve42(dir, e.name);
     let looksLikeProject = false;
     for (const marker of PROJECT_MARKERS) {
-      if (await fileExists(resolve41(projectDir, marker))) {
+      if (await fileExists(resolve42(projectDir, marker))) {
         looksLikeProject = true;
         break;
       }
@@ -16844,7 +17450,7 @@ var requiredFiles = {
     for (const projectDir of projects) {
       const missing = [];
       for (const rel of REQUIRED_PROJECT_FILES) {
-        const p = resolve41(projectDir, rel);
+        const p = resolve42(projectDir, rel);
         if (!await fileExists(p)) missing.push(rel);
       }
       if (missing.length === 0) continue;
@@ -16854,7 +17460,7 @@ var requiredFiles = {
         title: this.title,
         status: "error",
         detail: `project at ${projectDir} is missing: ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve41(projectDir, m)),
+        affected: missing.map((m) => resolve42(projectDir, m)),
         remediation: {
           kind: "manual",
           suggestion: "Recreate the missing scaffold files from templates",
@@ -16877,7 +17483,7 @@ var manifestStale = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const manifestPath = resolve41(projectDir, "manifest.md");
+      const manifestPath = resolve42(projectDir, "manifest.md");
       if (!await fileExists(manifestPath)) continue;
       const manifestMtime = (await stat5(manifestPath)).mtimeMs;
       const newestAssignment = await newestAssignmentMtime(projectDir);
@@ -16926,7 +17532,7 @@ var orphanFiles = {
         title: this.title,
         status: "warn",
         detail: `project at ${projectDir} has unexpected entries: ${orphans.join(", ")}`,
-        affected: orphans.map((o) => resolve41(projectDir, o)),
+        affected: orphans.map((o) => resolve42(projectDir, o)),
         autoFixable: false
       });
     }
@@ -16936,7 +17542,7 @@ var orphanFiles = {
 };
 var projectChecks = [requiredFiles, manifestStale, orphanFiles];
 async function newestAssignmentMtime(projectDir) {
-  const assignmentsRoot = resolve41(projectDir, "assignments");
+  const assignmentsRoot = resolve42(projectDir, "assignments");
   if (!await fileExists(assignmentsRoot)) return 0;
   let newest = 0;
   let entries;
@@ -16947,7 +17553,7 @@ async function newestAssignmentMtime(projectDir) {
   }
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const assignmentMd = resolve41(assignmentsRoot, e.name, "assignment.md");
+    const assignmentMd = resolve42(assignmentsRoot, e.name, "assignment.md");
     try {
       const s = await stat5(assignmentMd);
       if (s.mtimeMs > newest) newest = s.mtimeMs;
@@ -16971,7 +17577,7 @@ init_fs();
 init_parser();
 init_types();
 init_paths();
-import { resolve as resolve42 } from "path";
+import { resolve as resolve43 } from "path";
 import { readdir as readdir15, readFile as readFile26 } from "fs/promises";
 var CATEGORY4 = "assignment";
 var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]);
@@ -16983,16 +17589,16 @@ async function listAssignments(ctx) {
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
-      const assignmentsDir2 = resolve42(projectsDir2, m.name, "assignments");
+      const assignmentsDir2 = resolve43(projectsDir2, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
       const entries = await readdir15(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-        const assignmentDir = resolve42(assignmentsDir2, a.name);
-        const assignmentMd = resolve42(assignmentDir, "assignment.md");
+        const assignmentDir = resolve43(assignmentsDir2, a.name);
+        const assignmentMd = resolve43(assignmentDir, "assignment.md");
         const entry = {
-          projectDir: resolve42(projectsDir2, m.name),
+          projectDir: resolve43(projectsDir2, m.name),
           projectSlug: m.name,
           assignmentDir,
           assignmentSlug: a.name,
@@ -17012,8 +17618,8 @@ async function listAssignments(ctx) {
     for (const a of entries) {
       if (!a.isDirectory()) continue;
       if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-      const assignmentDir = resolve42(standaloneRoot, a.name);
-      const assignmentMd = resolve42(assignmentDir, "assignment.md");
+      const assignmentDir = resolve43(standaloneRoot, a.name);
+      const assignmentMd = resolve43(assignmentDir, "assignment.md");
       const entry = {
         projectDir: standaloneRoot,
         projectSlug: null,
@@ -17091,7 +17697,7 @@ var invalidStatus = {
     const allowed = configuredStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve42(a.assignmentDir, "assignment.md");
+      const path = resolve43(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (!allowed.has(parsed.status)) {
@@ -17124,7 +17730,7 @@ var workspaceMissing = {
     const terminal = terminalStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve42(a.assignmentDir, "assignment.md");
+      const path = resolve43(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (terminal.has(parsed.status)) continue;
@@ -17171,12 +17777,12 @@ var requiredFilesByStatus = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const assignmentPath = resolve42(a.assignmentDir, "assignment.md");
+      const assignmentPath = resolve43(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(assignmentPath);
       if (!parsed) continue;
       const missing = [];
       if (STATUSES_REQUIRING_HANDOFF.has(parsed.status)) {
-        const handoffPath = resolve42(a.assignmentDir, "handoff.md");
+        const handoffPath = resolve43(a.assignmentDir, "handoff.md");
         if (!await fileExists(handoffPath)) missing.push("handoff.md");
       }
       if (missing.length === 0) continue;
@@ -17186,7 +17792,7 @@ var requiredFilesByStatus = {
         title: this.title,
         status: "warn",
         detail: `${a.projectSlug}/${a.assignmentSlug} (status: ${parsed.status}) is missing ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve42(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve43(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create the missing ${missing.join(" and ")} files for this assignment`,
@@ -17209,7 +17815,7 @@ var companionFilesScaffolded = {
     for (const a of withAssignmentMd) {
       const missing = [];
       for (const filename of ["progress.md", "comments.md"]) {
-        if (!await fileExists(resolve42(a.assignmentDir, filename))) {
+        if (!await fileExists(resolve43(a.assignmentDir, filename))) {
           missing.push(filename);
         }
       }
@@ -17221,7 +17827,7 @@ var companionFilesScaffolded = {
         title: this.title,
         status: "warn",
         detail: `${label} is missing ${missing.join(" and ")} (pre-v2.0 assignment \u2014 not required, but scaffolding them keeps the dashboard and CLIs consistent)`,
-        affected: missing.map((m) => resolve42(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve43(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create ${missing.join(" and ")} with the renderProgress/renderComments templates, or re-scaffold via the CLI`,
@@ -17254,7 +17860,7 @@ var typeDefinition = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve42(a.assignmentDir, "assignment.md");
+      const path = resolve43(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (!parsed.type) continue;
@@ -17288,7 +17894,7 @@ var projectFrontmatterMatchesContainer = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve42(a.assignmentDir, "assignment.md");
+      const path = resolve43(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (a.standalone) {
@@ -17362,7 +17968,7 @@ function pass4(check, detail) {
 
 // src/utils/doctor/checks/dashboard.ts
 init_fs();
-import { resolve as resolve43 } from "path";
+import { resolve as resolve44 } from "path";
 var CATEGORY5 = "dashboard";
 var dbReachable = {
   id: "dashboard.db-reachable",
@@ -17376,7 +17982,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `could not open syntaur.db: ${ctx.dbError ?? "unknown error"}`,
-        affected: [resolve43(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve44(ctx.syntaurRoot, "syntaur.db")],
         remediation: {
           kind: "manual",
           suggestion: "Start the dashboard once (`syntaur dashboard`) to initialize the DB, or restore it from backup",
@@ -17394,7 +18000,7 @@ var dbReachable = {
           title: this.title,
           status: "error",
           detail: 'syntaur.db is missing the expected "sessions" table',
-          affected: [resolve43(ctx.syntaurRoot, "syntaur.db")],
+          affected: [resolve44(ctx.syntaurRoot, "syntaur.db")],
           autoFixable: false
         };
       }
@@ -17406,7 +18012,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `syntaur.db query failed: ${err2 instanceof Error ? err2.message : String(err2)}`,
-        affected: [resolve43(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve44(ctx.syntaurRoot, "syntaur.db")],
         autoFixable: false
       };
     }
@@ -17432,7 +18038,7 @@ var ghostSessions = {
     const results = [];
     for (const row of rows) {
       if (!row.project_slug) continue;
-      const projectPath = resolve43(projectsDir2, row.project_slug, "project.md");
+      const projectPath = resolve44(projectsDir2, row.project_slug, "project.md");
       if (!await fileExists(projectPath)) {
         results.push({
           id: this.id,
@@ -17451,7 +18057,7 @@ var ghostSessions = {
         continue;
       }
       if (row.assignment_slug) {
-        const assignmentPath = resolve43(
+        const assignmentPath = resolve44(
           projectsDir2,
           row.project_slug,
           "assignments",
@@ -17503,7 +18109,7 @@ function skipped(check, reason) {
 
 // src/utils/doctor/checks/integrations.ts
 init_fs();
-import { resolve as resolve44, dirname as dirname12, basename as basename4 } from "path";
+import { resolve as resolve45, dirname as dirname13, basename as basename5 } from "path";
 import { readdir as readdir16, readFile as readFile27 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 var CATEGORY6 = "integrations";
@@ -17586,7 +18192,7 @@ var backupConfigured = {
   }
 };
 async function readKnownMarketplaces() {
-  const path = resolve44(homedir6(), ".claude", "plugins", "known_marketplaces.json");
+  const path = resolve45(homedir6(), ".claude", "plugins", "known_marketplaces.json");
   if (!await fileExists(path)) return {};
   try {
     const raw = await readFile27(path, "utf-8");
@@ -17605,8 +18211,8 @@ var claudeMarketplaceRegistered = {
     if (!await fileExists(dir)) {
       return skipped2(this, "claudePluginDir does not exist (run install-plugin)");
     }
-    const pluginsParent = dirname12(dir);
-    if (basename4(pluginsParent) !== "plugins") {
+    const pluginsParent = dirname13(dir);
+    if (basename5(pluginsParent) !== "plugins") {
       return {
         id: this.id,
         category: this.category,
@@ -17622,8 +18228,8 @@ var claudeMarketplaceRegistered = {
         autoFixable: false
       };
     }
-    const marketplaceRoot = dirname12(pluginsParent);
-    const marketplaceManifest = resolve44(marketplaceRoot, ".claude-plugin", "marketplace.json");
+    const marketplaceRoot = dirname13(pluginsParent);
+    const marketplaceManifest = resolve45(marketplaceRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(marketplaceManifest)) {
       return {
         id: this.id,
@@ -17654,7 +18260,7 @@ var claudeMarketplaceRegistered = {
         autoFixable: false
       };
     }
-    const marketplaceName = parsed.name ?? basename4(marketplaceRoot);
+    const marketplaceName = parsed.name ?? basename5(marketplaceRoot);
     const hasSyntaurEntry = (parsed.plugins ?? []).some((p) => p?.name === "syntaur");
     const known = await readKnownMarketplaces();
     const registered = known[marketplaceName]?.installLocation === marketplaceRoot || Object.values(known).some((v) => v.installLocation === marketplaceRoot);
@@ -17674,7 +18280,7 @@ var claudeMarketplaceRegistered = {
       title: this.title,
       status: "error",
       detail: issues.join("; "),
-      affected: [marketplaceManifest, resolve44(homedir6(), ".claude", "plugins", "known_marketplaces.json")],
+      affected: [marketplaceManifest, resolve45(homedir6(), ".claude", "plugins", "known_marketplaces.json")],
       remediation: {
         kind: "manual",
         suggestion: "Re-run install-plugin to ensure both files are in sync.",
@@ -17714,7 +18320,7 @@ function skipped2(check, reason) {
 init_fs();
 init_parser();
 init_types();
-import { resolve as resolve45 } from "path";
+import { resolve as resolve46 } from "path";
 import { readFile as readFile28 } from "fs/promises";
 var CATEGORY7 = "workspace";
 var ASSIGNMENT_FIELDS = ["projectSlug", "assignmentSlug", "projectDir", "assignmentDir"];
@@ -17727,7 +18333,7 @@ function isStandaloneSession(ctx) {
   return !hasAnyAssignmentField(ctx) && typeof ctx.sessionId === "string" && ctx.sessionId.length > 0;
 }
 async function loadContext(ctx) {
-  const path = resolve45(ctx.cwd, ".syntaur", "context.json");
+  const path = resolve46(ctx.cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) {
     return { data: null, path, exists: false, parseError: null };
   }
@@ -17807,7 +18413,7 @@ var contextAssignmentResolves = {
     if (!exists) return skipped3(this, "no context to resolve");
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to resolve");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve45(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve46(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       return {
         id: this.id,
@@ -17836,7 +18442,7 @@ var contextTerminal = {
     if (!exists) return skipped3(this, "no context to check");
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to check");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve45(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve46(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) return skipped3(this, "assignment file missing");
     try {
       const content = await readFile28(assignmentMd, "utf-8");
@@ -17984,13 +18590,13 @@ var agentChecks = [agentsResolvable];
 
 // src/utils/doctor/checks/skills.ts
 init_fs();
-import { resolve as resolve46, join as join5 } from "path";
+import { resolve as resolve47, join as join5 } from "path";
 import { readdir as readdir17, readFile as readFile29, lstat as lstat4 } from "fs/promises";
 import { homedir as homedir7 } from "os";
 var CATEGORY9 = "skills";
 var skillTargets = [
-  { agent: "claude", dir: resolve46(homedir7(), ".claude", "skills"), label: "~/.claude/skills" },
-  { agent: "codex", dir: resolve46(homedir7(), ".codex", "skills"), label: "~/.codex/skills" }
+  { agent: "claude", dir: resolve47(homedir7(), ".claude", "skills"), label: "~/.claude/skills" },
+  { agent: "codex", dir: resolve47(homedir7(), ".codex", "skills"), label: "~/.codex/skills" }
 ];
 var skillsDedupCheck = {
   id: "skills.dedup",
@@ -18156,14 +18762,14 @@ async function finalize(checks) {
 async function readVersion() {
   try {
     const here = fileURLToPath6(import.meta.url);
-    let dir = dirname13(here);
+    let dir = dirname14(here);
     for (let i = 0; i < 6; i++) {
       try {
         const raw = await readFile30(join6(dir, "package.json"), "utf-8");
         const parsed = JSON.parse(raw);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
-        dir = dirname13(dir);
+        dir = dirname14(dir);
       }
     }
     return null;
@@ -18256,7 +18862,7 @@ var REQUIRED_WORKSPACE_FIELDS = [
 ];
 var ISO_DATE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
 async function validateAssignmentFile(inputPath, cwd = process.cwd()) {
-  const absolute = isAbsolute7(inputPath) ? inputPath : resolve47(cwd, inputPath);
+  const absolute = isAbsolute7(inputPath) ? inputPath : resolve48(cwd, inputPath);
   const errors = [];
   const warnings = [];
   if (!await fileExists(absolute)) {
@@ -18593,7 +19199,7 @@ init_uuid();
 init_timestamp();
 init_assignment_resolver();
 init_templates();
-import { resolve as resolve48 } from "path";
+import { resolve as resolve49 } from "path";
 import { readFile as readFile32 } from "fs/promises";
 function shortId() {
   return generateId().split("-")[0];
@@ -18624,7 +19230,7 @@ async function commentCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve48(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve49(baseDir, options.project, "assignments", target);
     assignmentRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -18634,7 +19240,7 @@ async function commentCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     assignmentRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const commentsPath = resolve48(assignmentDir, "comments.md");
+  const commentsPath = resolve49(assignmentDir, "comments.md");
   const timestamp = nowTimestamp();
   const author = options.author ?? process.env.USER ?? "unknown";
   let currentContent;
@@ -18674,7 +19280,7 @@ ${entry}`;
 }
 
 // src/commands/capture.ts
-import { resolve as resolve51, relative as relative4 } from "path";
+import { resolve as resolve52, relative as relative4 } from "path";
 import { copyFile as copyFile3, mkdir as mkdir7, realpath as realpath2, stat as stat6 } from "fs/promises";
 
 // src/utils/assignment-target.ts
@@ -18684,12 +19290,12 @@ init_config2();
 init_slug();
 init_assignment_resolver();
 init_parser();
-import { resolve as resolve49 } from "path";
+import { resolve as resolve50 } from "path";
 import { readFile as readFile33 } from "fs/promises";
 var AssignmentTargetError = class extends Error {
 };
 async function readAssignmentFrontmatterId(assignmentDir) {
-  const path = resolve49(assignmentDir, "assignment.md");
+  const path = resolve50(assignmentDir, "assignment.md");
   if (!await fileExists(path)) return null;
   try {
     const content = await readFile33(path, "utf-8");
@@ -18700,7 +19306,7 @@ async function readAssignmentFrontmatterId(assignmentDir) {
   }
 }
 async function readContextJson(cwd) {
-  const path = resolve49(cwd, ".syntaur", "context.json");
+  const path = resolve50(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
     const raw = await readFile33(path, "utf-8");
@@ -18724,15 +19330,15 @@ async function resolveAssignmentTarget(input4, opts = {}) {
     if (!isValidSlug(input4)) {
       throw new AssignmentTargetError(`Invalid assignment slug "${input4}".`);
     }
-    const projectDir = resolve49(baseDir, opts.project);
-    const projectMdPath = resolve49(projectDir, "project.md");
+    const projectDir = resolve50(baseDir, opts.project);
+    const projectMdPath = resolve50(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new AssignmentTargetError(
         `Project "${opts.project}" not found at ${projectDir}.`
       );
     }
-    const assignmentDir = resolve49(projectDir, "assignments", input4);
-    const assignmentMdPath2 = resolve49(assignmentDir, "assignment.md");
+    const assignmentDir = resolve50(projectDir, "assignments", input4);
+    const assignmentMdPath2 = resolve50(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `Assignment "${input4}" not found in project "${opts.project}".`
@@ -18766,7 +19372,7 @@ async function resolveAssignmentTarget(input4, opts = {}) {
   }
   if (ctx.assignmentDir) {
     const dir = expandHome(ctx.assignmentDir);
-    const assignmentMdPath2 = resolve49(dir, "assignment.md");
+    const assignmentMdPath2 = resolve50(dir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `.syntaur/context.json points to a missing assignment dir: ${dir}.`
@@ -18795,8 +19401,8 @@ async function resolveAssignmentTarget(input4, opts = {}) {
         `.syntaur/context.json contains invalid slugs: project="${ctx.projectSlug}" assignment="${ctx.assignmentSlug}".`
       );
     }
-    const assignmentDir = resolve49(baseDir, ctx.projectSlug, "assignments", ctx.assignmentSlug);
-    const assignmentMdPath2 = resolve49(assignmentDir, "assignment.md");
+    const assignmentDir = resolve50(baseDir, ctx.projectSlug, "assignments", ctx.assignmentSlug);
+    const assignmentMdPath2 = resolve50(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `.syntaur/context.json points to a missing assignment: ${assignmentDir}.`
@@ -18857,11 +19463,11 @@ init_fs();
 
 // src/db/proof-db.ts
 init_paths();
-import Database3 from "better-sqlite3";
-import { resolve as resolve50 } from "path";
-var db2 = null;
+import Database4 from "better-sqlite3";
+import { resolve as resolve51 } from "path";
+var db3 = null;
 var PROOF_SCHEMA_VERSION = "1";
-var SCHEMA_SQL2 = `
+var SCHEMA_SQL3 = `
 CREATE TABLE IF NOT EXISTS artifacts (
   id TEXT PRIMARY KEY,
   assignment_id TEXT NOT NULL,
@@ -18877,26 +19483,26 @@ CREATE INDEX IF NOT EXISTS idx_artifacts_assignment_criterion ON artifacts(assig
 CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
 `;
 function initProofDb(dbPath) {
-  if (db2) return db2;
-  const finalPath = dbPath ?? resolve50(syntaurRoot(), "syntaur.db");
-  db2 = new Database3(finalPath);
-  db2.pragma("journal_mode = WAL");
-  db2.exec(SCHEMA_SQL2);
-  db2.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)").run(
+  if (db3) return db3;
+  const finalPath = dbPath ?? resolve51(syntaurRoot(), "syntaur.db");
+  db3 = new Database4(finalPath);
+  db3.pragma("journal_mode = WAL");
+  db3.exec(SCHEMA_SQL3);
+  db3.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)").run(
     "proof_schema_version",
     PROOF_SCHEMA_VERSION
   );
-  const database = db2;
+  const database = db3;
   const runMigrations = database.transaction(() => {
   });
   runMigrations.exclusive();
-  return db2;
+  return db3;
 }
 function getProofDb() {
-  if (!db2) {
+  if (!db3) {
     throw new Error("Proof database not initialized. Call initProofDb() first.");
   }
-  return db2;
+  return db3;
 }
 function insertArtifact(input4) {
   const database = getProofDb();
@@ -18982,7 +19588,7 @@ async function captureCommand(target, options = {}) {
   });
   let resolvedSource = null;
   if (options.file) {
-    const expanded = options.file.startsWith("~/") ? resolve51(process.env.HOME ?? "", options.file.slice(2)) : resolve51(options.file);
+    const expanded = options.file.startsWith("~/") ? resolve52(process.env.HOME ?? "", options.file.slice(2)) : resolve52(options.file);
     if (!await fileExists(expanded)) {
       throw new Error(`--file does not exist: ${options.file}`);
     }
@@ -19007,7 +19613,7 @@ async function captureCommand(target, options = {}) {
   }
   initProofDb();
   const subdir = criterionIndex === null ? "untagged" : String(criterionIndex);
-  const destDir = resolve51(proofDir(resolved.assignmentDir), subdir);
+  const destDir = resolve52(proofDir(resolved.assignmentDir), subdir);
   if (resolvedSource) await mkdir7(destDir, { recursive: true });
   const ext = resolvedSource ? extensionForKind(kind) : null;
   let id = null;
@@ -19016,7 +19622,7 @@ async function captureCommand(target, options = {}) {
   let lastErr = null;
   for (let attempt = 0; attempt < MAX_ID_RETRIES; attempt += 1) {
     const candidate = generateArtifactId();
-    const candidateAbsPath = resolvedSource && ext ? resolve51(destDir, `${candidate}.${ext}`) : null;
+    const candidateAbsPath = resolvedSource && ext ? resolve52(destDir, `${candidate}.${ext}`) : null;
     const candidateRel = candidateAbsPath ? relative4(resolved.assignmentDir, candidateAbsPath) : null;
     try {
       insertArtifact({
@@ -19052,14 +19658,14 @@ async function captureCommand(target, options = {}) {
   const tagSuffix = criterionIndex === null ? "untagged" : `criterion ${criterionIndex}`;
   console.log(`Captured artifact ${id} (${kind}) for ${ref} \u2014 ${tagSuffix}.`);
   if (relativeFilePath) {
-    console.log(`  file: ${resolve51(resolved.assignmentDir, relativeFilePath)}`);
+    console.log(`  file: ${resolve52(resolved.assignmentDir, relativeFilePath)}`);
   }
 }
 
 // src/commands/proof.ts
 import { Command as Command5 } from "commander";
 import { readFile as readFile34, writeFile as writeFile10, rename as rename7, stat as stat7 } from "fs/promises";
-import { resolve as resolve52, relative as relative5, isAbsolute as isAbsolute8 } from "path";
+import { resolve as resolve53, relative as relative5, isAbsolute as isAbsolute8 } from "path";
 import { randomBytes as randomBytes3 } from "crypto";
 
 // src/utils/acceptance-criteria-parse.ts
@@ -19262,7 +19868,7 @@ function renderProofHtml(params2, inlineFiles = /* @__PURE__ */ new Map()) {
 
 // src/commands/proof.ts
 async function readAssignmentMeta(assignmentDir) {
-  const path = resolve52(assignmentDir, "assignment.md");
+  const path = resolve53(assignmentDir, "assignment.md");
   if (!await fileExists(path)) {
     return { title: "", body: "" };
   }
@@ -19313,7 +19919,7 @@ async function loadInlineFiles(rows, assignmentDir) {
   for (const r of rows) {
     if (!r.file_path) continue;
     if (r.kind !== "http" && r.kind !== "text") continue;
-    const abs = resolve52(assignmentDir, r.file_path);
+    const abs = resolve53(assignmentDir, r.file_path);
     if (!isWithin(proofRoot, abs)) {
       out.set(r.file_path, null);
       continue;
@@ -19361,8 +19967,8 @@ async function proofBuildCommand(target, options = {}) {
   };
   const md = renderProofMarkdown(renderParams);
   const html = renderProofHtml(renderParams, inlineFiles);
-  const mdPath = resolve52(resolved.assignmentDir, "proof.md");
-  const htmlPath = resolve52(resolved.assignmentDir, "proof.html");
+  const mdPath = resolve53(resolved.assignmentDir, "proof.md");
+  const htmlPath = resolve53(resolved.assignmentDir, "proof.html");
   await atomicWrite(mdPath, md);
   await atomicWrite(htmlPath, html);
   console.log(`Wrote ${htmlPath}`);
@@ -19379,6 +19985,261 @@ proofCommand.command("build").description("Render proof.html and proof.md for an
   }
 });
 
+// src/commands/lease.ts
+import { Command as Command6 } from "commander";
+var DURATION_REGEX = /^(\d+)\s*(s|m|h|d)?$/i;
+function parseDuration(input4, fallbackSeconds) {
+  if (!input4) return fallbackSeconds;
+  const match = DURATION_REGEX.exec(input4.trim());
+  if (!match) {
+    throw new Error(
+      `invalid duration "${input4}" \u2014 use e.g. 30s, 5m, 2h, 1d`
+    );
+  }
+  const n = Number.parseInt(match[1], 10);
+  const unit = (match[2] ?? "s").toLowerCase();
+  const mult = { s: 1, m: 60, h: 3600, d: 86400 };
+  return n * mult[unit];
+}
+function parseMetadataFlags(values) {
+  if (!values || values.length === 0) return void 0;
+  const out = {};
+  for (const raw of values) {
+    const eq = raw.indexOf("=");
+    if (eq < 0) {
+      throw new Error(`invalid -m flag "${raw}" \u2014 use key=value`);
+    }
+    out[raw.slice(0, eq)] = raw.slice(eq + 1);
+  }
+  return out;
+}
+var leaseCommand = new Command6("lease").description(
+  "Resource leases \u2014 claim and release coordinated shared resources"
+);
+leaseCommand.command("create-inventory").description("Create a new inventory of leaseable resources").argument("<slug>", "Inventory slug (e.g. dev-envs, prod-migration-lock)").requiredOption("--kind <kind>", "Inventory kind (free-form label, e.g. dev-env, db-instance, lock)").option("--display-name <text>", "Human-readable display name").option("--default-ttl <duration>", "Default lease TTL (e.g. 30m, 2h). Default: 30m", "30m").action(async (slug, opts) => {
+  try {
+    initLeasesDb();
+    const ttl_s = parseDuration(opts.defaultTtl, 30 * 60);
+    const row = createInventory({
+      slug,
+      kind: opts.kind,
+      display_name: opts.displayName,
+      default_ttl_s: ttl_s
+    });
+    console.log(`Created inventory '${row.slug}' (kind=${row.kind}, default_ttl=${row.default_ttl_s}s).`);
+  } catch (error) {
+    if (error instanceof DuplicateInventoryError) {
+      console.error(`Error: inventory '${error.slug}' already exists`);
+      process.exit(1);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+});
+var memberCommand = leaseCommand.command("member").description("Manage members of an inventory");
+memberCommand.command("add").description("Add a member to an inventory").argument("<inventory>", "Inventory slug").argument("<member-id>", "Member id (unique within the inventory)").option("-m, --metadata <key=value...>", "Metadata key=value pairs (repeatable)").action(async (inventory, memberId, opts) => {
+  try {
+    initLeasesDb();
+    const metadata = parseMetadataFlags(opts.metadata);
+    addMember({ inventory_slug: inventory, member_id: memberId, metadata });
+    console.log(`Added member '${memberId}' to '${inventory}'.`);
+  } catch (error) {
+    if (error instanceof DuplicateMemberError) {
+      console.error(`Error: member ${error.inventorySlug}/${error.memberId} already exists`);
+      process.exit(1);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+});
+memberCommand.command("retire").description("Retire a member (no longer claimable). Refuses if member is currently leased.").argument("<inventory>", "Inventory slug").argument("<member-id>", "Member id").action(async (inventory, memberId) => {
+  try {
+    initLeasesDb();
+    retireMember(inventory, memberId);
+    console.log(`Retired member '${inventory}/${memberId}'.`);
+  } catch (error) {
+    if (error instanceof MemberInUseError) {
+      console.error(
+        `Error: member ${error.inventorySlug}/${error.memberId} is currently leased; release before retiring`
+      );
+      process.exit(1);
+    }
+    if (error instanceof NotFoundError) {
+      console.error(`Error: member not found`);
+      process.exit(1);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+});
+leaseCommand.command("claim").description("Claim an idle member of an inventory. Fail-fast if none idle.").argument("<inventory>", "Inventory slug").option("--ttl <duration>", "Lease TTL (overrides inventory default)").option("--for <tag>", "Free-form requester tag (session id, assignment slug, etc.)").option("--json", "Output JSON instead of a one-line summary").action(async (inventory, opts) => {
+  try {
+    initLeasesDb();
+    const detail = getInventoryDetail(inventory);
+    if (!detail) {
+      console.error(`Error: inventory '${inventory}' not found`);
+      process.exit(1);
+      return;
+    }
+    const ttl_s = parseDuration(opts.ttl, detail.inventory.default_ttl_s);
+    const result = claimLease(inventory, ttl_s, opts.for);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(
+        `Claimed ${result.member_id} as ${result.lease_id} (expires ${result.expires_at})`
+      );
+    }
+  } catch (error) {
+    if (error instanceof NoIdleMemberError) {
+      console.error(`Error: no idle members in '${error.inventorySlug}'`);
+      process.exit(1);
+    }
+    if (error instanceof LeaseContentionError) {
+      console.error(`Error: contention timeout on '${error.inventorySlug}'; retry`);
+      process.exit(1);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+});
+leaseCommand.command("release").description("Release a lease by its lease_id").argument("<lease-id>", "Opaque lease id returned by `claim`").action(async (leaseId) => {
+  try {
+    initLeasesDb();
+    releaseLease(leaseId);
+    console.log(`Released lease ${leaseId}.`);
+  } catch (error) {
+    if (error instanceof StaleLeaseError) {
+      console.error(
+        `Error: lease ${error.leaseId} is no longer active (expired or revoked)`
+      );
+      process.exit(1);
+    }
+    if (error instanceof LeaseContentionError) {
+      console.error(`Error: contention timeout; retry`);
+      process.exit(1);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+});
+leaseCommand.command("extend").description("Extend a lease \u2014 sets new expires_at = now + ttl. Refuses if expired or stale.").argument("<lease-id>", "Opaque lease id").requiredOption("--ttl <duration>", "New TTL from now (e.g. 15m)").action(async (leaseId, opts) => {
+  try {
+    initLeasesDb();
+    const ttl_s = parseDuration(opts.ttl, 0);
+    if (ttl_s <= 0) {
+      throw new Error("--ttl must be positive");
+    }
+    const res = extendLease(leaseId, ttl_s);
+    console.log(`Extended lease ${leaseId} (new expires_at=${res.new_expires_at}).`);
+  } catch (error) {
+    if (error instanceof StaleLeaseError) {
+      console.error(
+        `Error: lease ${error.leaseId} cannot be extended (expired, revoked, or member generation advanced)`
+      );
+      process.exit(1);
+    }
+    if (error instanceof LeaseContentionError) {
+      console.error(`Error: contention timeout; retry`);
+      process.exit(1);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+});
+leaseCommand.command("show").description("Show a single lease as JSON").argument("<lease-id>", "Lease id").action(async (leaseId) => {
+  try {
+    initLeasesDb();
+    const row = getLease(leaseId);
+    if (!row) {
+      console.error(`Error: lease ${leaseId} not found`);
+      process.exit(1);
+      return;
+    }
+    console.log(JSON.stringify(row, null, 2));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+});
+var VALID_STATES = /* @__PURE__ */ new Set([
+  "active",
+  "expired",
+  "released",
+  "revoked"
+]);
+leaseCommand.command("list").description("List leases (optionally filtered by inventory and/or state)").option("--inventory <slug>", "Filter by inventory").option("--state <state>", "Filter by state: active|expired|released|revoked").option("--json", "Output JSON instead of a table").action(async (opts) => {
+  try {
+    initLeasesDb();
+    let state;
+    if (opts.state) {
+      if (!VALID_STATES.has(opts.state)) {
+        throw new Error(
+          `--state must be one of: ${[...VALID_STATES].join("|")}`
+        );
+      }
+      state = opts.state;
+    }
+    if (!opts.inventory && !state && !opts.json) {
+      const inventories = listInventories();
+      if (inventories.length === 0) {
+        console.log("(no inventories \u2014 create one with `syntaur lease create-inventory <slug> --kind <kind>`)");
+        return;
+      }
+      for (const inv of inventories) {
+        const detail = getInventoryDetail(inv.slug);
+        if (!detail) continue;
+        const idleCount = detail.members.filter((m) => m.status === "idle").length;
+        const leasedCount = detail.members.filter((m) => m.status === "leased").length;
+        console.log(
+          `${inv.slug.padEnd(24)} kind=${inv.kind}  idle=${idleCount}  leased=${leasedCount}  active_leases=${detail.active_leases.length}`
+        );
+      }
+      return;
+    }
+    const rows = listLeases({ inventory: opts.inventory, state });
+    if (opts.json) {
+      console.log(JSON.stringify(rows, null, 2));
+      return;
+    }
+    if (rows.length === 0) {
+      console.log("(no leases match)");
+      return;
+    }
+    for (const r of rows) {
+      console.log(
+        `${r.lease_id}  ${r.inventory_slug}/${r.member_id}  ${r.state}  expires=${r.expires_at}`
+      );
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+});
+leaseCommand.command("gc").description("Sweep expired leases across all inventories (idempotent, concurrency-safe)").action(async () => {
+  try {
+    initLeasesDb();
+    const n = gcExpiredLeases();
+    console.log(`Expired ${n} lease(s).`);
+  } catch (error) {
+    if (error instanceof LeaseContentionError) {
+      console.error(`Error: contention timeout; retry`);
+      process.exit(1);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+});
+
 // src/commands/request.ts
 init_paths();
 init_fs();
@@ -19387,7 +20248,7 @@ init_slug();
 init_timestamp();
 init_assignment_resolver();
 init_assignment_todos();
-import { resolve as resolve53 } from "path";
+import { resolve as resolve54 } from "path";
 import { readFile as readFile35 } from "fs/promises";
 async function requestCommand(target, text, options = {}) {
   if (!text || !text.trim()) {
@@ -19404,7 +20265,7 @@ async function requestCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve53(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve54(baseDir, options.project, "assignments", target);
     targetRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -19414,7 +20275,7 @@ async function requestCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     targetRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const assignmentMdPath2 = resolve53(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve54(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) {
     throw new Error(`assignment.md not found at ${assignmentMdPath2}`);
   }
@@ -19431,11 +20292,11 @@ async function requestCommand(target, text, options = {}) {
 // src/commands/plan.ts
 init_fs();
 init_paths();
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 import { readFile as readFile36, readdir as readdir18 } from "fs/promises";
-import { resolve as resolve54 } from "path";
+import { resolve as resolve55 } from "path";
 async function readContextAssignmentDir(cwd) {
-  const path = resolve54(cwd, ".syntaur", "context.json");
+  const path = resolve55(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
     const raw = await readFile36(path, "utf-8");
@@ -19452,9 +20313,9 @@ async function resolveAssignmentDir(opts) {
   const cwd = opts.cwd ?? process.cwd();
   if (opts.assignment) {
     if (opts.project) {
-      return resolve54(defaultProjectDir(), opts.project, "assignments", opts.assignment);
+      return resolve55(defaultProjectDir(), opts.project, "assignments", opts.assignment);
     }
-    return resolve54(assignmentsDir(), opts.assignment);
+    return resolve55(assignmentsDir(), opts.assignment);
   }
   const fromCtx = await readContextAssignmentDir(cwd);
   if (fromCtx) return fromCtx;
@@ -19597,7 +20458,7 @@ async function runPlanVersion(options) {
   if (!await fileExists(assignmentDir)) {
     throw new Error(`Assignment directory does not exist: ${assignmentDir}`);
   }
-  const assignmentMdPath2 = resolve54(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve55(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) {
     throw new Error(`Missing assignment.md at: ${assignmentMdPath2}`);
   }
@@ -19609,14 +20470,14 @@ async function runPlanVersion(options) {
   }
   const current = planFiles[planFiles.length - 1];
   const next = nextPlanFileName(current.version);
-  const newPath = resolve54(assignmentDir, next.fileName);
+  const newPath = resolve55(assignmentDir, next.fileName);
   if (await fileExists(newPath) && !options.force) {
     throw new Error(`${next.fileName} already exists. Use --force to overwrite.`);
   }
   const assignmentMd = await readFile36(assignmentMdPath2, "utf-8");
   const slugMatch = assignmentMd.match(/^slug:\s*(.+?)\s*$/m);
   const slug = slugMatch ? slugMatch[1].trim() : assignmentDir.split("/").pop() ?? "";
-  const oldPlanPath = resolve54(assignmentDir, current.fileName);
+  const oldPlanPath = resolve55(assignmentDir, current.fileName);
   const oldPlanContent = await readFile36(oldPlanPath, "utf-8");
   const oldBody = oldPlanContent.replace(/^---[\s\S]*?\n---\n?/, "");
   const carriedTodos = extractUncheckedTodos(oldBody);
@@ -19639,7 +20500,7 @@ async function runPlanVersion(options) {
   console.log(`Path: ${newPath}`);
   console.log(`Carried forward: ${carriedTodos.length} unchecked task(s).`);
 }
-var planCommand = new Command6("plan").description("Manage plan files for the active assignment");
+var planCommand = new Command7("plan").description("Manage plan files for the active assignment");
 planCommand.command("version").description(
   "Create the next plan-v<N>.md, supersede the prior plan in assignment.md ## Todos, and carry forward unchecked tasks"
 ).option("--assignment <slug>", "Assignment slug (UUID for standalone). Defaults to .syntaur/context.json").option("--project <slug>", "Project slug. Required when --assignment is given for a project-nested assignment").option("--force", "Overwrite if the next plan-v<N>.md already exists").action(async (options) => {
@@ -19653,11 +20514,11 @@ planCommand.command("version").description(
 
 // src/commands/session.ts
 init_fs();
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 import { readFile as readFile37, readdir as readdir19, stat as stat8 } from "fs/promises";
-import { resolve as resolve55 } from "path";
+import { resolve as resolve56 } from "path";
 async function readContext(cwd) {
-  const path = resolve55(cwd, ".syntaur", "context.json");
+  const path = resolve56(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
     const raw = await readFile37(path, "utf-8");
@@ -19667,13 +20528,13 @@ async function readContext(cwd) {
   }
 }
 async function findLatestSessionSummary(assignmentDir) {
-  const sessionsRoot = resolve55(assignmentDir, "sessions");
+  const sessionsRoot = resolve56(assignmentDir, "sessions");
   if (!await fileExists(sessionsRoot)) return null;
   const entries = await readdir19(sessionsRoot, { withFileTypes: true });
   let best = null;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const summaryPath = resolve55(sessionsRoot, entry.name, "summary.md");
+    const summaryPath = resolve56(sessionsRoot, entry.name, "summary.md");
     if (!await fileExists(summaryPath)) continue;
     const st = await stat8(summaryPath);
     if (best === null || st.mtime.getTime() > best.mtime.getTime()) {
@@ -19683,7 +20544,7 @@ async function findLatestSessionSummary(assignmentDir) {
   return best;
 }
 async function findOpenHandoff(assignmentDir) {
-  const handoffPath = resolve55(assignmentDir, "handoff.md");
+  const handoffPath = resolve56(assignmentDir, "handoff.md");
   if (!await fileExists(handoffPath)) return null;
   const content = await readFile37(handoffPath, "utf-8");
   const body = content.replace(/^---[\s\S]*?\n---\n?/, "").trim();
@@ -19775,7 +20636,7 @@ async function runSessionResume(options, cwd = process.cwd()) {
   }
   return out;
 }
-var sessionCommand = new Command7("session").description("Manage agent sessions for the active assignment");
+var sessionCommand = new Command8("session").description("Manage agent sessions for the active assignment");
 sessionCommand.command("resume").description(
   "Re-orient a fresh session: print active assignment context, latest saved session summary, and any open handoff. Idempotent \u2014 does not mutate state."
 ).option("--json", "Emit machine-readable JSON instead of human-readable text").action(async (options) => {
@@ -19792,11 +20653,11 @@ sessionCommand.command("resume").description(
 init_git_worktree();
 init_fs();
 init_paths();
-import { Command as Command8 } from "commander";
+import { Command as Command9 } from "commander";
 import { readFile as readFile38 } from "fs/promises";
-import { resolve as resolve56 } from "path";
+import { resolve as resolve57 } from "path";
 async function readContext2(cwd) {
-  const path = resolve56(cwd, ".syntaur", "context.json");
+  const path = resolve57(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
     return JSON.parse(await readFile38(path, "utf-8"));
@@ -19807,7 +20668,7 @@ async function readContext2(cwd) {
 async function resolveAssignmentPath2(opts) {
   if (opts.assignment) {
     if (opts.project) {
-      return resolve56(
+      return resolve57(
         defaultProjectDir(),
         opts.project,
         "assignments",
@@ -19815,10 +20676,10 @@ async function resolveAssignmentPath2(opts) {
         "assignment.md"
       );
     }
-    return resolve56(assignmentsDir(), opts.assignment, "assignment.md");
+    return resolve57(assignmentsDir(), opts.assignment, "assignment.md");
   }
   const ctx = await readContext2(opts.cwd);
-  if (ctx?.assignmentDir) return resolve56(ctx.assignmentDir, "assignment.md");
+  if (ctx?.assignmentDir) return resolve57(ctx.assignmentDir, "assignment.md");
   throw new Error(
     "No active assignment. Pass --assignment <slug> [--project <slug>] or run from a workspace with .syntaur/context.json."
   );
@@ -19829,7 +20690,7 @@ async function runWorktreeCreate(options, cwd = process.cwd()) {
   }
   const repository = options.repository ?? cwd;
   const parentBranch = options.parentBranch ?? "main";
-  const worktreePath = options.worktreePath ?? resolve56(repository, ".worktrees", options.branch);
+  const worktreePath = options.worktreePath ?? resolve57(repository, ".worktrees", options.branch);
   const assignmentPath = await resolveAssignmentPath2({
     assignment: options.assignment,
     project: options.project,
@@ -19847,7 +20708,7 @@ async function runWorktreeCreate(options, cwd = process.cwd()) {
   });
   return { worktreePath, assignmentPath };
 }
-var worktreeCommand = new Command8("worktree").description("Manage git worktrees bound to Syntaur assignments");
+var worktreeCommand = new Command9("worktree").description("Manage git worktrees bound to Syntaur assignments");
 worktreeCommand.command("create").description(
   "Create a worktree at <repository>/.worktrees/<branch> and record it in the assignment workspace block. Atomic \u2014 rolls back the worktree if writing assignment.md fails."
 ).requiredOption("--branch <name>", "Branch name to create (also used as worktree dir name)").option("--repository <path>", "Repository root (defaults to current working directory)").option("--parent-branch <name>", "Parent branch to fork from", "main").option("--assignment <slug>", "Assignment slug (UUID for standalone). Defaults to .syntaur/context.json").option("--project <slug>", "Project slug. Required when --assignment is given for a project-nested assignment").option("--worktree-path <path>", "Override the computed <repository>/.worktrees/<branch> path").action(async (options) => {
@@ -19865,15 +20726,15 @@ worktreeCommand.command("create").description(
 init_paths();
 init_fs();
 init_slug();
-import { Command as Command9 } from "commander";
-import { resolve as resolve58 } from "path";
+import { Command as Command10 } from "commander";
+import { resolve as resolve59 } from "path";
 
 // src/utils/project-indexes.ts
 init_parser();
 init_fs();
 import { readdir as readdir20, readFile as readFile39 } from "fs/promises";
-import { resolve as resolve57 } from "path";
-function nowIso() {
+import { resolve as resolve58 } from "path";
+function nowIso2() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
 function readProjectSlug(projectDir) {
@@ -19891,14 +20752,14 @@ function joinList(items) {
   return items.length === 0 ? "\u2014" : items.map(escapeCell).join(", ");
 }
 async function rebuildResourcesIndex(projectDir) {
-  const dir = resolve57(projectDir, "resources");
+  const dir = resolve58(projectDir, "resources");
   await ensureDir(dir);
   const files = await listSlugFiles(dir);
   const slug = readProjectSlug(projectDir);
   const lines = [];
   lines.push("---");
   lines.push(`project: ${slug}`);
-  lines.push(`generated: "${nowIso()}"`);
+  lines.push(`generated: "${nowIso2()}"`);
   lines.push(`total: ${files.length}`);
   lines.push("---");
   lines.push("");
@@ -19907,7 +20768,7 @@ async function rebuildResourcesIndex(projectDir) {
   lines.push("| Name | Category | Source | Related Assignments | Updated |");
   lines.push("|------|----------|--------|---------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile39(resolve57(dir, fileName), "utf-8");
+    const content = await readFile39(resolve58(dir, fileName), "utf-8");
     const parsed = parseResource(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -19917,19 +20778,19 @@ async function rebuildResourcesIndex(projectDir) {
     );
   }
   lines.push("");
-  const indexPath = resolve57(dir, "_index.md");
+  const indexPath = resolve58(dir, "_index.md");
   await writeFileForce(indexPath, lines.join("\n"));
   return { total: files.length, path: indexPath };
 }
 async function rebuildMemoriesIndex(projectDir) {
-  const dir = resolve57(projectDir, "memories");
+  const dir = resolve58(projectDir, "memories");
   await ensureDir(dir);
   const files = await listSlugFiles(dir);
   const slug = readProjectSlug(projectDir);
   const lines = [];
   lines.push("---");
   lines.push(`project: ${slug}`);
-  lines.push(`generated: "${nowIso()}"`);
+  lines.push(`generated: "${nowIso2()}"`);
   lines.push(`total: ${files.length}`);
   lines.push("---");
   lines.push("");
@@ -19938,7 +20799,7 @@ async function rebuildMemoriesIndex(projectDir) {
   lines.push("| Name | Source | Scope | Source Assignment | Updated |");
   lines.push("|------|--------|-------|-------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile39(resolve57(dir, fileName), "utf-8");
+    const content = await readFile39(resolve58(dir, fileName), "utf-8");
     const parsed = parseMemory(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -19948,13 +20809,13 @@ async function rebuildMemoriesIndex(projectDir) {
     );
   }
   lines.push("");
-  const indexPath = resolve57(dir, "_index.md");
+  const indexPath = resolve58(dir, "_index.md");
   await writeFileForce(indexPath, lines.join("\n"));
   return { total: files.length, path: indexPath };
 }
 
 // src/commands/resource.ts
-function nowIso2() {
+function nowIso3() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
 function parseList(value) {
@@ -19965,7 +20826,7 @@ function yamlQuote(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
 function renderResourceFile(opts) {
-  const created = nowIso2();
+  const created = nowIso3();
   const related = opts.relatedAssignments.length === 0 ? "[]" : `
 ${opts.relatedAssignments.map((a) => `  - ${a}`).join("\n")}`;
   return `---
@@ -19986,8 +20847,8 @@ async function runResourceAdd(options) {
   if (!isValidSlug(options.project)) {
     throw new Error(`Invalid project slug: "${options.project}".`);
   }
-  const projectDir = resolve58(defaultProjectDir(), options.project);
-  if (!await fileExists(resolve58(projectDir, "project.md"))) {
+  const projectDir = resolve59(defaultProjectDir(), options.project);
+  if (!await fileExists(resolve59(projectDir, "project.md"))) {
     throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
   }
   if (!options.name) throw new Error("--name is required.");
@@ -19996,7 +20857,7 @@ async function runResourceAdd(options) {
   if (!isValidSlug(slug)) {
     throw new Error(`Invalid resource slug: "${slug}".`);
   }
-  const filePath = resolve58(projectDir, "resources", `${slug}.md`);
+  const filePath = resolve59(projectDir, "resources", `${slug}.md`);
   if (await fileExists(filePath) && !options.force) {
     throw new Error(
       `Resource "${slug}" already exists at ${filePath}. Use --force to overwrite.`
@@ -20012,7 +20873,7 @@ async function runResourceAdd(options) {
   const { path: indexPath, total } = await rebuildResourcesIndex(projectDir);
   return { filePath, indexPath, total };
 }
-var resourceCommand = new Command9("resource").description("Manage project-level resource entries");
+var resourceCommand = new Command10("resource").description("Manage project-level resource entries");
 resourceCommand.command("add").description(
   "Add a project resource at <projectDir>/resources/<slug>.md and regenerate _index.md"
 ).requiredOption("--project <slug>", "Project slug").requiredOption("--name <name>", "Human-readable resource name").requiredOption("--source <url-or-path>", "Resource source (URL or path)").option("--category <name>", "Optional category (e.g. dashboard, doc, ticket)").option("--slug <slug>", "Override the slug (default: slugify(--name))").option("--related-assignments <slugs>", "Comma-separated related assignment slugs").option("--force", "Overwrite if the resource file already exists").action(async (options) => {
@@ -20030,9 +20891,9 @@ resourceCommand.command("add").description(
 init_paths();
 init_fs();
 init_slug();
-import { Command as Command10 } from "commander";
-import { resolve as resolve59 } from "path";
-function nowIso3() {
+import { Command as Command11 } from "commander";
+import { resolve as resolve60 } from "path";
+function nowIso4() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
 function parseList2(value) {
@@ -20043,7 +20904,7 @@ function yamlQuote2(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
 function renderMemoryFile(opts) {
-  const created = nowIso3();
+  const created = nowIso4();
   const related = opts.relatedAssignments.length === 0 ? "[]" : `
 ${opts.relatedAssignments.map((a) => `  - ${a}`).join("\n")}`;
   const sourceAssignment = opts.sourceAssignment === null ? "null" : yamlQuote2(opts.sourceAssignment);
@@ -20066,8 +20927,8 @@ async function runMemoryAdd(options) {
   if (!isValidSlug(options.project)) {
     throw new Error(`Invalid project slug: "${options.project}".`);
   }
-  const projectDir = resolve59(defaultProjectDir(), options.project);
-  if (!await fileExists(resolve59(projectDir, "project.md"))) {
+  const projectDir = resolve60(defaultProjectDir(), options.project);
+  if (!await fileExists(resolve60(projectDir, "project.md"))) {
     throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
   }
   if (!options.name) throw new Error("--name is required.");
@@ -20076,7 +20937,7 @@ async function runMemoryAdd(options) {
   if (!isValidSlug(slug)) {
     throw new Error(`Invalid memory slug: "${slug}".`);
   }
-  const filePath = resolve59(projectDir, "memories", `${slug}.md`);
+  const filePath = resolve60(projectDir, "memories", `${slug}.md`);
   if (await fileExists(filePath) && !options.force) {
     throw new Error(
       `Memory "${slug}" already exists at ${filePath}. Use --force to overwrite.`
@@ -20093,7 +20954,7 @@ async function runMemoryAdd(options) {
   const { path: indexPath, total } = await rebuildMemoriesIndex(projectDir);
   return { filePath, indexPath, total };
 }
-var memoryCommand = new Command10("memory").description("Manage project-level memory entries");
+var memoryCommand = new Command11("memory").description("Manage project-level memory entries");
 memoryCommand.command("add").description(
   "Add a project memory at <projectDir>/memories/<slug>.md and regenerate _index.md"
 ).requiredOption("--project <slug>", "Project slug").requiredOption("--name <name>", "Human-readable memory name").requiredOption("--source <text>", "Where this memory came from (conversation, decision, doc URL, etc.)").option("--scope <scope>", "Memory scope (default: project)", "project").option("--source-assignment <slug>", "Assignment slug this memory was captured during").option("--slug <slug>", "Override the slug (default: slugify(--name))").option("--related-assignments <slugs>", "Comma-separated related assignment slugs").option("--force", "Overwrite if the memory file already exists").action(async (options) => {
@@ -20112,9 +20973,9 @@ init_api();
 init_paths();
 init_fs();
 init_frontmatter();
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 import { readFile as readFile40 } from "fs/promises";
-import { resolve as resolve60 } from "path";
+import { resolve as resolve61 } from "path";
 var AGE_PATTERN = /^(\d+)([dhwm])$/i;
 function parseAgeToCutoff(age) {
   const match = age.match(AGE_PATTERN);
@@ -20133,7 +20994,7 @@ function parseAgeToCutoff(age) {
 }
 function assignmentMdPath(item) {
   if (item.projectSlug) {
-    return resolve60(
+    return resolve61(
       defaultProjectDir(),
       item.projectSlug,
       "assignments",
@@ -20141,7 +21002,7 @@ function assignmentMdPath(item) {
       "assignment.md"
     );
   }
-  return resolve60(assignmentsDir(), item.id, "assignment.md");
+  return resolve61(assignmentsDir(), item.id, "assignment.md");
 }
 async function loadTags(item) {
   const path = assignmentMdPath(item);
@@ -20207,7 +21068,7 @@ function renderTable(items) {
   );
   return all.map((row) => row.map((cell, c2) => pad(cell ?? "", widths[c2])).join("  ")).join("\n");
 }
-var lsCommand = new Command11("ls").description(
+var lsCommand = new Command12("ls").description(
   "List assignments across all projects with optional filters by status, project, tag, or age."
 ).option("--status <list>", "Comma-separated status filter (e.g. pending,in_progress)").option("--project <slug>", "Filter to one project").option("--tag <list>", "Comma-separated tag filter (assignment must have ALL tags)").option("--age <duration>", "Only include assignments updated within duration (e.g. 7d, 24h, 2w, 1m)").option("--json", "Emit JSON instead of a table").action(async (options) => {
   try {
@@ -20266,18 +21127,18 @@ init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath8 } from "url";
 import { readFile as readFile42 } from "fs/promises";
-import { dirname as dirname15, join as join8, resolve as resolve61 } from "path";
+import { dirname as dirname16, join as join8, resolve as resolve62 } from "path";
 import { spawn as spawn4 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/utils/version.ts
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { readFile as readFile41 } from "fs/promises";
-import { dirname as dirname14, join as join7 } from "path";
+import { dirname as dirname15, join as join7 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
     const scriptPath = fileURLToPath7(scriptUrl);
-    const pkgRoot = dirname14(dirname14(scriptPath));
+    const pkgRoot = dirname15(dirname15(scriptPath));
     const raw = await readFile41(join7(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
@@ -20287,7 +21148,7 @@ async function readPackageVersion(scriptUrl) {
 }
 
 // src/utils/npx-prompt.ts
-var STATE_FILE = resolve61(syntaurRoot(), "npx-install.json");
+var STATE_FILE = resolve62(syntaurRoot(), "npx-install.json");
 var META_ARGS = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version", "help"]);
 var GLOBAL_VERSION_TIMEOUT_MS = 2e3;
 function isRunningViaNpx(scriptUrl) {
@@ -20319,7 +21180,7 @@ async function writeState(state) {
 `);
 }
 async function resolveNpmBin() {
-  const nodeDir = dirname15(process.execPath);
+  const nodeDir = dirname16(process.execPath);
   const isWin = process.platform === "win32";
   const npmName = isWin ? "npm.cmd" : "npm";
   const nearNode = join8(nodeDir, npmName);
@@ -20486,7 +21347,7 @@ async function maybePromptInstall(scriptUrl) {
 
 // src/index.ts
 await maybePromptInstall(import.meta.url);
-var program = new Command12();
+var program = new Command13();
 var version = await readPackageVersion(import.meta.url) ?? "0.0.0";
 program.name("syntaur").description("CLI scaffolding tool for the Syntaur protocol").version(version);
 program.command("init").description("Initialize ~/.syntaur/ directory structure and config").option("--force", "Overwrite existing config file").action(async (options) => {
@@ -20865,6 +21726,7 @@ program.addCommand(worktreeCommand);
 program.addCommand(resourceCommand);
 program.addCommand(memoryCommand);
 program.addCommand(lsCommand);
+program.addCommand(leaseCommand);
 if (process.argv.length <= 2) {
   process.argv.push(await getDefaultCommandName());
 }