syntaur 0.12.0 → 0.14.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);
@@ -9639,6 +9672,65 @@ function createServersRouter(serversDir2, projectsDir2, assignmentsDir2) {
 import { Router as Router3 } from "express";
 import { resolve as resolve16 } from "path";
 init_fs();
+
+// src/utils/transcript.ts
+import { open } from "fs/promises";
+var MAX_LINES_SCANNED = 50;
+async function derivePathFromTranscript(transcriptPath) {
+  if (!transcriptPath) return null;
+  let handle;
+  try {
+    handle = await open(transcriptPath, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const stream = handle.createReadStream({ encoding: "utf-8" });
+    let buffer = "";
+    let scanned = 0;
+    for await (const chunk of stream) {
+      buffer += chunk;
+      let nl = buffer.indexOf("\n");
+      while (nl !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        const cwd = extractCwd(line);
+        if (cwd) {
+          stream.destroy();
+          return cwd;
+        }
+        scanned++;
+        if (scanned >= MAX_LINES_SCANNED) {
+          stream.destroy();
+          return null;
+        }
+        nl = buffer.indexOf("\n");
+      }
+    }
+    if (buffer.length > 0) {
+      const cwd = extractCwd(buffer);
+      if (cwd) return cwd;
+    }
+    return null;
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+}
+function extractCwd(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0 || trimmed[0] !== "{") return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
+      return parsed.cwd;
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/dashboard/api-agent-sessions.ts
 function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
   const router = Router3();
   router.get("/", async (_req, res) => {
@@ -9686,6 +9778,8 @@ function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
           return;
         }
       }
+      const derivedPath = await derivePathFromTranscript(transcriptPath);
+      const recordedPath = derivedPath ?? path ?? "";
       const session = {
         projectSlug: projectSlug || null,
         assignmentSlug: assignmentSlug || null,
@@ -9693,7 +9787,7 @@ function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
         sessionId,
         started: (/* @__PURE__ */ new Date()).toISOString(),
         status: "active",
-        path: path || "",
+        path: recordedPath,
         description: description || null,
         transcriptPath: transcriptPath || null
       };
@@ -9744,6 +9838,692 @@ 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 listMembers(inventory_slug) {
+  const database = getLeasesDb();
+  const inv = database.prepare("SELECT slug FROM inventories WHERE slug = ?").get(inventory_slug);
+  if (!inv) throw new NotFoundError(inventory_slug);
+  return 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(inventory_slug);
+}
+function getLeaseEvents(lease_id, limit = 50) {
+  const database = getLeasesDb();
+  if (lease_id) {
+    return database.prepare(
+      `SELECT id, lease_id, event, at, detail_json
+         FROM lease_events WHERE lease_id = ?
+         ORDER BY at ASC, id ASC
+         LIMIT ?`
+    ).all(lease_id, limit);
+  }
+  return database.prepare(
+    `SELECT id, lease_id, event, at, detail_json
+       FROM lease_events
+       ORDER BY at DESC, id DESC
+       LIMIT ?`
+  ).all(limit);
+}
+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;
+  }
+}
+function updateInventory(slug, input4) {
+  if ("kind" in input4) {
+    throw new Error("inventory kind is immutable");
+  }
+  if (input4.default_ttl_s === void 0 && input4.display_name === void 0) {
+    throw new Error("nothing to update");
+  }
+  if (input4.default_ttl_s !== void 0 && input4.default_ttl_s <= 0) {
+    throw new Error("default_ttl_s must be positive");
+  }
+  const database = getLeasesDb();
+  const fn = database.transaction(() => {
+    const existing = database.prepare("SELECT slug FROM inventories WHERE slug = ?").get(slug);
+    if (!existing) throw new NotFoundError(slug);
+    const sets = [];
+    const params2 = [];
+    if (input4.default_ttl_s !== void 0) {
+      sets.push("default_ttl_s = ?");
+      params2.push(input4.default_ttl_s);
+    }
+    if (input4.display_name !== void 0) {
+      sets.push("display_name = ?");
+      params2.push(input4.display_name);
+    }
+    params2.push(slug);
+    database.prepare(`UPDATE inventories SET ${sets.join(", ")} WHERE slug = ?`).run(...params2);
+    return database.prepare(
+      `SELECT slug, kind, display_name, default_ttl_s, created_at
+         FROM inventories WHERE slug = ?`
+    ).get(slug);
+  });
+  try {
+    return fn.immediate();
+  } catch (err2) {
+    if (isBusyError(err2)) throw new LeaseContentionError(slug);
+    throw err2;
+  }
+}
+function deleteInventory(slug, opts = {}) {
+  const database = getLeasesDb();
+  let revoked = 0;
+  const fn = database.transaction(() => {
+    const existing = database.prepare("SELECT slug FROM inventories WHERE slug = ?").get(slug);
+    if (!existing) throw new NotFoundError(slug);
+    const activeLeases = database.prepare(
+      `SELECT lease_id FROM leases
+          WHERE inventory_slug = ? AND state = 'active'`
+    ).all(slug);
+    if (activeLeases.length > 0 && !opts.force) {
+      throw new MemberInUseError(slug, "*");
+    }
+    revoked = activeLeases.length;
+    database.prepare(
+      `DELETE FROM lease_events
+          WHERE lease_id IN (SELECT lease_id FROM leases WHERE inventory_slug = ?)`
+    ).run(slug);
+    database.prepare("DELETE FROM leases WHERE inventory_slug = ?").run(slug);
+    database.prepare("DELETE FROM inventory_members WHERE inventory_slug = ?").run(slug);
+    database.prepare("DELETE FROM inventories WHERE slug = ?").run(slug);
+  });
+  try {
+    fn.immediate();
+  } catch (err2) {
+    if (isBusyError(err2)) throw new LeaseContentionError(slug);
+    throw err2;
+  }
+  return { deleted: true, revoked };
+}
+function releaseLeasesByRequestedFor(tag) {
+  const database = getLeasesDb();
+  const rows = database.prepare(
+    `SELECT lease_id FROM leases
+        WHERE state = 'active' AND requested_for = ?`
+  ).all(tag);
+  const released = [];
+  const stale = [];
+  for (const { lease_id } of rows) {
+    try {
+      releaseLease(lease_id);
+      released.push(lease_id);
+    } catch (err2) {
+      if (err2 instanceof StaleLeaseError) {
+        stale.push(lease_id);
+        continue;
+      }
+      throw err2;
+    }
+  }
+  return { released, stale };
+}
+
+// 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 +10532,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 +10603,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 +10629,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 +10653,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 +10672,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 +10691,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 +10739,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 +10869,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 +10886,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 +11293,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 +11369,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 +11386,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 +11403,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 +11419,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 +12027,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 +12168,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 +12231,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();
@@ -11459,8 +12239,8 @@ init_fs();
 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 { cp, mkdtemp, rm as rm2, readFile as readFile15, writeFile as writeFile4, unlink as unlink3, stat, open as open2, rename as rename5 } from "fs/promises";
+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 +12280,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,10 +12291,10 @@ 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");
+    const handle = await open2(lockPath, "wx");
     await handle.write(String(process.pid));
     await handle.close();
     return lockPath;
@@ -11558,7 +12338,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 +12386,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 +12440,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 +12541,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 +12554,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 +12875,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 +13209,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 +13235,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 +13266,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 +13281,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 +13294,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 +13379,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 +13394,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 +13470,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 +13481,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 +13513,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 +13609,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 +13643,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 +13677,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 +13708,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 +13745,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 +13768,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 +13808,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 +13899,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 +13927,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 +13959,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 +13991,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 +14007,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 +14027,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 +14044,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 +14065,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 +14091,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 +14216,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 +14240,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 +14277,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 +14429,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 +14505,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) {
@@ -13776,16 +14560,20 @@ var KNOWN_SKILL_NAMES = [
   "add-memory",
   "list-assignments",
   "log-progress",
-  "set-workspace"
+  "set-workspace",
+  "claim-resource",
+  "release-resource",
+  "extend-resource",
+  "list-resources"
 ];
 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 = [];
@@ -13839,8 +14627,8 @@ async function skillMatches(srcDir, destDir) {
 }
 async function isSymlink(path) {
   try {
-    const stat9 = await lstat2(path);
-    return stat9.isSymbolicLink();
+    const stat10 = await lstat2(path);
+    return stat10.isSymbolicLink();
   } catch {
     return false;
   }
@@ -14117,7 +14905,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 +14913,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 +14934,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 +15034,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 +15085,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 +15112,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 +15122,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 +15139,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 +15174,7 @@ function extractExistingCommand(settings) {
   };
 }
 async function backupSettings(settingsSnapshot, backupPath) {
-  await ensureDir(dirname10(backupPath));
+  await ensureDir(dirname11(backupPath));
   await writeFile8(
     backupPath,
     JSON.stringify(
@@ -14403,7 +15191,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 +15207,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 +15248,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 +15259,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 +15303,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 +15336,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 +15593,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 +15673,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 +15692,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 +15718,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 +15758,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 +15791,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 +15804,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}.`
@@ -15025,6 +15813,8 @@ async function trackSessionCommand(options) {
   }
   initSessionDb();
   const { sessionId } = options;
+  const derivedPath = await derivePathFromTranscript(options.transcriptPath);
+  const recordedPath = derivedPath ?? options.path ?? process.cwd();
   await appendSession("", {
     projectSlug: options.project || null,
     assignmentSlug: options.assignment || null,
@@ -15032,7 +15822,7 @@ async function trackSessionCommand(options) {
     sessionId,
     started: (/* @__PURE__ */ new Date()).toISOString(),
     status: "active",
-    path: options.path || process.cwd(),
+    path: recordedPath,
     description: options.description || null,
     transcriptPath: options.transcriptPath ?? null
   });
@@ -15050,7 +15840,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 +15910,7 @@ async function pickAgent(agents) {
   return picked;
 }
 async function ensureWorktree(opts) {
-  const assignmentPath = resolve34(
+  const assignmentPath = resolve35(
     opts.projectsDir,
     opts.projectSlug,
     "assignments",
@@ -15201,7 +15991,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 +16024,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 +16053,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 +16066,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 +16089,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 +16104,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 +16204,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 +16216,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 +16535,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 +16767,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 +16777,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 +16848,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 +16967,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 +16999,7 @@ async function buildCheckContext(cwd = process.cwd()) {
   return {
     config,
     syntaurRoot: root,
-    db: db3,
+    db: db4,
     dbError,
     cwd,
     now: /* @__PURE__ */ new Date()
@@ -16227,10 +17017,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 +17058,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 +17351,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 +17407,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 +17427,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 +17452,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 +17477,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 +17508,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 +17553,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 +17582,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 +17612,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 +17634,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 +17644,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 +17667,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 +17716,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 +17726,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 +17737,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 +17761,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 +17773,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 +17802,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 +17881,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 +17914,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 +17961,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 +17976,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 +17999,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 +18011,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 +18044,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 +18078,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 +18152,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 +18166,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 +18184,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 +18196,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 +18222,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 +18241,7 @@ var ghostSessions = {
         continue;
       }
       if (row.assignment_slug) {
-        const assignmentPath = resolve43(
+        const assignmentPath = resolve44(
           projectsDir2,
           row.project_slug,
           "assignments",
@@ -17503,7 +18293,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 +18376,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 +18395,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 +18412,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 +18444,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 +18464,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 +18504,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 +18517,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 +18597,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 +18626,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 +18774,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 +18946,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 +19046,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 +19383,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 +19414,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 +19424,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,8 +19464,8 @@ ${entry}`;
 }
 
 // src/commands/capture.ts
-import { resolve as resolve51, relative as relative4 } from "path";
-import { copyFile as copyFile3, mkdir as mkdir7, realpath as realpath2, stat as stat6 } from "fs/promises";
+import { resolve as resolve52, relative as relative4 } from "path";
+import { copyFile as copyFile3, mkdir as mkdir7, realpath as realpath2, stat as stat7 } from "fs/promises";
 
 // src/utils/assignment-target.ts
 init_paths();
@@ -18684,12 +19474,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 +19490,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 +19514,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 +19556,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 +19585,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}.`
@@ -18855,48 +19645,122 @@ function isArtifactKind(value) {
 // src/commands/capture.ts
 init_fs();
 
-// src/db/proof-db.ts
-init_paths();
-import Database3 from "better-sqlite3";
-import { resolve as resolve50 } from "path";
-var db2 = null;
-var PROOF_SCHEMA_VERSION = "1";
-var SCHEMA_SQL2 = `
-CREATE TABLE IF NOT EXISTS artifacts (
-  id TEXT PRIMARY KEY,
-  assignment_id TEXT NOT NULL,
-  assignment_dir TEXT NOT NULL,
-  criterion_index INTEGER,
-  kind TEXT NOT NULL,
-  file_path TEXT,
-  note TEXT,
-  created_at TEXT NOT NULL DEFAULT (datetime('now'))
-);
-CREATE INDEX IF NOT EXISTS idx_artifacts_assignment ON artifacts(assignment_id);
-CREATE INDEX IF NOT EXISTS idx_artifacts_assignment_criterion ON artifacts(assignment_id, criterion_index);
-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(
-    "proof_schema_version",
+// src/utils/screencapture.ts
+import { spawn as spawn4 } from "child_process";
+import { mkdtemp as mkdtemp2, rm as rm6, stat as stat6 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join7 } from "path";
+function argsFor(mode, pngPath) {
+  switch (mode) {
+    case "interactive":
+      return ["-i", pngPath];
+    case "window":
+      return ["-iWo", pngPath];
+    case "fullscreen":
+      return ["-x", pngPath];
+  }
+}
+function runScreencapture(args) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn4("screencapture", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let settled = false;
+    child.once("error", (err2) => {
+      if (settled) return;
+      settled = true;
+      reject(err2);
+    });
+    child.once("close", (code) => {
+      if (settled) return;
+      settled = true;
+      resolvePromise(code ?? -1);
+    });
+  });
+}
+async function captureScreenshot(mode) {
+  if (process.platform !== "darwin") {
+    throw new Error(
+      "screencapture is only available on macOS. Use --file <path> to attach an existing image."
+    );
+  }
+  const tmpDir = await mkdtemp2(join7(tmpdir2(), "syntaur-screenshot-"));
+  const pngPath = join7(tmpDir, "shot.png");
+  const cleanup = async () => {
+    await rm6(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+  };
+  try {
+    let code;
+    try {
+      code = await runScreencapture(argsFor(mode, pngPath));
+    } catch (err2) {
+      if (err2 && typeof err2 === "object" && err2.code === "ENOENT") {
+        throw new Error(
+          "screencapture binary not found. Is this macOS with the system utility on PATH?"
+        );
+      }
+      throw err2;
+    }
+    if (code !== 0) {
+      throw new Error(`Screenshot canceled or failed (exit ${code}).`);
+    }
+    let size = 0;
+    try {
+      size = (await stat6(pngPath)).size;
+    } catch {
+      throw new Error("screencapture exited 0 but produced no image.");
+    }
+    if (size === 0) {
+      throw new Error("screencapture exited 0 but produced no image.");
+    }
+    return { pngPath, cleanup };
+  } catch (err2) {
+    await cleanup();
+    throw err2;
+  }
+}
+
+// src/db/proof-db.ts
+init_paths();
+import Database4 from "better-sqlite3";
+import { resolve as resolve51 } from "path";
+var db3 = null;
+var PROOF_SCHEMA_VERSION = "1";
+var SCHEMA_SQL3 = `
+CREATE TABLE IF NOT EXISTS artifacts (
+  id TEXT PRIMARY KEY,
+  assignment_id TEXT NOT NULL,
+  assignment_dir TEXT NOT NULL,
+  criterion_index INTEGER,
+  kind TEXT NOT NULL,
+  file_path TEXT,
+  note TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_artifacts_assignment ON artifacts(assignment_id);
+CREATE INDEX IF NOT EXISTS idx_artifacts_assignment_criterion ON artifacts(assignment_id, criterion_index);
+CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
+`;
+function initProofDb(dbPath) {
+  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();
@@ -18959,6 +19823,27 @@ async function captureCommand(target, options = {}) {
     );
   }
   const kind = options.kind;
+  const shelloutFlagCount = [
+    options.interactive,
+    options.window,
+    options.fullscreen
+  ].filter(Boolean).length;
+  if (shelloutFlagCount > 1) {
+    throw new Error("--interactive, --window, --fullscreen are mutually exclusive.");
+  }
+  const shelloutMode = options.interactive ? "interactive" : options.window ? "window" : options.fullscreen ? "fullscreen" : null;
+  if (shelloutMode) {
+    if (kind !== "screenshot") {
+      throw new Error(
+        "--interactive, --window, and --fullscreen require --kind=screenshot."
+      );
+    }
+    if (options.file) {
+      throw new Error(
+        "--file cannot be combined with --interactive, --window, or --fullscreen."
+      );
+    }
+  }
   if (kind === "text") {
     if (options.file) {
       throw new Error("--kind=text forbids --file. Use --note for text payloads.");
@@ -18967,7 +19852,7 @@ async function captureCommand(target, options = {}) {
       throw new Error("--kind=text requires --note.");
     }
   } else {
-    if (kind !== "http" && !options.file) {
+    if (kind !== "http" && !options.file && !shelloutMode) {
       throw new Error(`--kind=${kind} requires --file.`);
     }
     if (kind === "http" && !options.file && (!options.note || options.note.trim() === "")) {
@@ -18981,8 +19866,9 @@ async function captureCommand(target, options = {}) {
     cwd: options.cwd
   });
   let resolvedSource = null;
+  let shelloutCleanup = 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}`);
     }
@@ -18994,72 +19880,93 @@ async function captureCommand(target, options = {}) {
         `--file is unreadable: ${options.file} (${e instanceof Error ? e.message : String(e)})`
       );
     }
-    const st = await stat6(real);
+    const st = await stat7(real);
     if (!st.isFile()) {
       throw new Error(`--file is not a regular file: ${options.file}`);
     }
     resolvedSource = real;
+  } else if (shelloutMode) {
+    const { pngPath, cleanup } = await captureScreenshot(shelloutMode);
+    resolvedSource = pngPath;
+    shelloutCleanup = cleanup;
   }
-  if (!resolved.id || resolved.id.trim() === "") {
-    throw new Error(
-      `Resolved assignment is missing a frontmatter \`id\`: ${resolved.assignmentDir}. Cannot record artifact.`
-    );
-  }
-  initProofDb();
-  const subdir = criterionIndex === null ? "untagged" : String(criterionIndex);
-  const destDir = resolve51(proofDir(resolved.assignmentDir), subdir);
-  if (resolvedSource) await mkdir7(destDir, { recursive: true });
-  const ext = resolvedSource ? extensionForKind(kind) : null;
-  let id = null;
-  let relativeFilePath = null;
-  let absPath = null;
-  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 candidateRel = candidateAbsPath ? relative4(resolved.assignmentDir, candidateAbsPath) : null;
-    try {
-      insertArtifact({
-        id: candidate,
-        assignmentId: resolved.id,
-        assignmentDir: resolved.assignmentDir,
-        criterionIndex,
-        kind,
-        filePath: candidateRel,
-        note: options.note ?? null
-      });
-      id = candidate;
-      absPath = candidateAbsPath;
-      relativeFilePath = candidateRel;
-      break;
-    } catch (e) {
-      if (isUniqueConstraintError(e)) {
-        lastErr = e;
-        continue;
+  try {
+    if (!resolved.id || resolved.id.trim() === "") {
+      throw new Error(
+        `Resolved assignment is missing a frontmatter \`id\`: ${resolved.assignmentDir}. Cannot record artifact.`
+      );
+    }
+    initProofDb();
+    const subdir = criterionIndex === null ? "untagged" : String(criterionIndex);
+    const destDir = resolve52(proofDir(resolved.assignmentDir), subdir);
+    if (resolvedSource) await mkdir7(destDir, { recursive: true });
+    const ext = resolvedSource ? extensionForKind(kind) : null;
+    let id = null;
+    let relativeFilePath = null;
+    let absPath = null;
+    let lastErr = null;
+    for (let attempt = 0; attempt < MAX_ID_RETRIES; attempt += 1) {
+      const candidate = generateArtifactId();
+      const candidateAbsPath = resolvedSource && ext ? resolve52(destDir, `${candidate}.${ext}`) : null;
+      const candidateRel = candidateAbsPath ? relative4(resolved.assignmentDir, candidateAbsPath) : null;
+      try {
+        insertArtifact({
+          id: candidate,
+          assignmentId: resolved.id,
+          assignmentDir: resolved.assignmentDir,
+          criterionIndex,
+          kind,
+          filePath: candidateRel,
+          note: options.note ?? null
+        });
+        id = candidate;
+        absPath = candidateAbsPath;
+        relativeFilePath = candidateRel;
+        break;
+      } catch (e) {
+        if (isUniqueConstraintError(e)) {
+          lastErr = e;
+          continue;
+        }
+        throw e;
       }
-      throw e;
     }
-  }
-  if (!id) {
-    throw new Error(
-      `Failed to generate a unique artifact id after ${MAX_ID_RETRIES} attempts: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
-    );
-  }
-  if (resolvedSource && absPath) {
-    await copyFile3(resolvedSource, absPath);
-  }
-  const ref = resolved.standalone ? resolved.id : `${resolved.projectSlug}/${resolved.assignmentSlug}`;
-  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)}`);
+    if (!id) {
+      throw new Error(
+        `Failed to generate a unique artifact id after ${MAX_ID_RETRIES} attempts: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
+      );
+    }
+    if (resolvedSource && absPath) {
+      try {
+        await copyFile3(resolvedSource, absPath);
+      } catch (err2) {
+        if (shelloutCleanup) {
+          console.error(
+            `Screenshot saved at ${resolvedSource} \u2014 DB row inserted but copy to proof dir failed. Recover with: mv ${resolvedSource} ${absPath}`
+          );
+          shelloutCleanup = null;
+        }
+        throw err2;
+      }
+    }
+    const ref = resolved.standalone ? resolved.id : `${resolved.projectSlug}/${resolved.assignmentSlug}`;
+    const tagSuffix = criterionIndex === null ? "untagged" : `criterion ${criterionIndex}`;
+    console.log(`Captured artifact ${id} (${kind}) for ${ref} \u2014 ${tagSuffix}.`);
+    if (relativeFilePath) {
+      console.log(`  file: ${resolve52(resolved.assignmentDir, relativeFilePath)}`);
+    }
+  } finally {
+    if (shelloutCleanup) {
+      await shelloutCleanup();
+      shelloutCleanup = null;
+    }
   }
 }
 
 // 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 { readFile as readFile34, writeFile as writeFile10, rename as rename7, stat as stat8 } from "fs/promises";
+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 +20169,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 +20220,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;
@@ -19322,7 +20229,7 @@ async function loadInlineFiles(rows, assignmentDir) {
       out.set(r.file_path, null);
       continue;
     }
-    const st = await stat7(abs);
+    const st = await stat8(abs);
     if (st.size > INLINE_TEXT_LIMIT_BYTES) {
       out.set(r.file_path, null);
       continue;
@@ -19361,8 +20268,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 +20286,478 @@ 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 unless --wait is set.").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(
+  "--wait <duration>",
+  "Block up to <duration> waiting for an idle member. Backoff: 100ms \u2192 200ms \u2192 400ms \u2192 800ms \u2192 1s cap."
+).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 waitBudgetMs = opts.wait !== void 0 ? parseDuration(opts.wait, 0) * 1e3 : 0;
+      const tryClaim = () => claimLease(inventory, ttl_s, opts.for);
+      let result;
+      if (waitBudgetMs <= 0) {
+        result = tryClaim();
+      } else {
+        const deadline = Date.now() + waitBudgetMs;
+        const backoffSchedule = [100, 200, 400, 800];
+        let attempt = 0;
+        while (true) {
+          try {
+            result = tryClaim();
+            break;
+          } catch (err2) {
+            if (!(err2 instanceof NoIdleMemberError)) throw err2;
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+              console.error(
+                `Error: timed out waiting ${opts.wait} for an idle member of '${inventory}'`
+              );
+              process.exit(1);
+              return;
+            }
+            const delay = Math.min(
+              backoffSchedule[Math.min(attempt, backoffSchedule.length - 1)] ?? 1e3,
+              1e3,
+              remaining
+            );
+            attempt += 1;
+            await new Promise((r) => setTimeout(r, delay));
+          }
+        }
+      }
+      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);
+  }
+});
+leaseCommand.command("revoke").description(
+  "Force-release a lease (administrative). Idempotent \u2014 already-revoked exits 0."
+).argument("<lease-id>", "Lease id to revoke").action(async (leaseId) => {
+  try {
+    initLeasesDb();
+    const existing = getLease(leaseId);
+    if (!existing) {
+      console.error(`Error: lease ${leaseId} not found`);
+      process.exit(1);
+      return;
+    }
+    if (existing.state === "revoked") {
+      console.log(`already revoked ${leaseId}`);
+      return;
+    }
+    const res = forceReleaseLease(leaseId);
+    console.log(`revoked ${leaseId} (member_freed=${res.member_freed})`);
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      console.error(`Error: lease ${error.id} not found`);
+      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("release-all").description("Release every active lease matching --for <tag>.").requiredOption("--for <tag>", "Requester tag to match against `requested_for`").option("--json", "Output JSON {released, stale} as id arrays").action(async (opts) => {
+  try {
+    initLeasesDb();
+    const res = releaseLeasesByRequestedFor(opts.for);
+    if (opts.json) {
+      console.log(JSON.stringify(res, null, 2));
+      return;
+    }
+    for (const lid of res.released) {
+      console.log(`released ${lid}`);
+    }
+    for (const lid of res.stale) {
+      console.log(`skipped ${lid} (stale)`);
+    }
+    console.log(
+      `released ${res.released.length} lease(s) for tag "${opts.for}" (${res.stale.length} stale skipped)`
+    );
+  } 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);
+  }
+});
+leaseCommand.command("history").description(
+  "Show lease_events. With a lease-id, print that lease's timeline; without, print the last N events across all leases."
+).argument("[lease-id]", "Optional lease id to filter on").option("--limit <n>", "Max events to return (default 50)", "50").option("--json", "Output JSON rows").action(
+  async (leaseId, opts) => {
+    try {
+      initLeasesDb();
+      const limit = Number.parseInt(opts.limit, 10);
+      if (!Number.isFinite(limit) || limit <= 0) {
+        throw new Error("--limit must be a positive integer");
+      }
+      const rows = getLeaseEvents(leaseId, limit);
+      if (opts.json) {
+        console.log(JSON.stringify(rows, null, 2));
+        return;
+      }
+      if (rows.length === 0) {
+        console.log("(no events)");
+        return;
+      }
+      for (const r of rows) {
+        const detail = r.detail_json ? ` ${r.detail_json}` : "";
+        console.log(`${r.at}  ${r.event.padEnd(16)} ${r.lease_id}${detail}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exit(1);
+    }
+  }
+);
+var inventoryCommand = leaseCommand.command("inventory").description("Manage existing inventories (update, delete)");
+inventoryCommand.command("update").description(
+  "Update mutable inventory fields. `kind` is immutable in v1."
+).argument("<slug>", "Inventory slug").option("--default-ttl <duration>", "New default TTL (e.g. 30m, 2h)").option("--display-name <text>", "New display name").action(
+  async (slug, opts) => {
+    try {
+      initLeasesDb();
+      if (opts.defaultTtl === void 0 && opts.displayName === void 0) {
+        throw new Error(
+          "nothing to update \u2014 pass --default-ttl or --display-name"
+        );
+      }
+      const patch = {};
+      if (opts.defaultTtl !== void 0) {
+        patch.default_ttl_s = parseDuration(opts.defaultTtl, 0);
+      }
+      if (opts.displayName !== void 0) {
+        patch.display_name = opts.displayName;
+      }
+      const row = updateInventory(slug, patch);
+      console.log(
+        `Updated inventory '${row.slug}' (kind=${row.kind}, default_ttl=${row.default_ttl_s}s, display_name=${row.display_name ?? "(none)"}).`
+      );
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        console.error(`Error: inventory '${slug}' not found`);
+        process.exit(1);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Error: ${message}`);
+      process.exit(1);
+    }
+  }
+);
+inventoryCommand.command("delete").description(
+  "Delete an inventory. Refuses if any lease is active unless --force is set."
+).argument("<slug>", "Inventory slug").option("--force", "Revoke all active leases first, then cascade delete").action(async (slug, opts) => {
+  try {
+    initLeasesDb();
+    const res = deleteInventory(slug, { force: opts.force });
+    console.log(
+      `deleted "${slug}" (revoked ${res.revoked} active lease(s))`
+    );
+  } catch (error) {
+    if (error instanceof MemberInUseError) {
+      console.error(
+        `Error: inventory "${slug}" has active leases \u2014 use --force to revoke and delete`
+      );
+      process.exit(1);
+    }
+    if (error instanceof NotFoundError) {
+      console.error(`Error: inventory '${slug}' not found`);
+      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);
+  }
+});
+memberCommand.command("list").description("List all members of an inventory (pure roster \u2014 no lease state).").argument("<inventory>", "Inventory slug").option("--json", "Output JSON rows").action(async (inventory, opts) => {
+  try {
+    initLeasesDb();
+    const rows = listMembers(inventory);
+    if (opts.json) {
+      console.log(JSON.stringify(rows, null, 2));
+      return;
+    }
+    if (rows.length === 0) {
+      console.log("(no members)");
+      return;
+    }
+    for (const r of rows) {
+      const meta = r.metadata_json ? ` ${r.metadata_json}` : "";
+      const last = r.last_used_at ? ` last_used=${r.last_used_at}` : "";
+      console.log(
+        `${r.member_id.padEnd(24)} ${r.status.padEnd(8)} gen=${r.generation}${last}${meta}`
+      );
+    }
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      console.error(`Error: inventory '${inventory}' not found`);
+      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 +20766,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 +20783,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 +20793,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 +20810,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 +20831,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 +20976,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 +20988,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 +21018,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 +21032,11 @@ planCommand.command("version").description(
 
 // src/commands/session.ts
 init_fs();
-import { Command as Command7 } from "commander";
-import { readFile as readFile37, readdir as readdir19, stat as stat8 } from "fs/promises";
-import { resolve as resolve55 } from "path";
+import { Command as Command8 } from "commander";
+import { readFile as readFile37, readdir as readdir19, stat as stat9 } from "fs/promises";
+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,15 +21046,15 @@ 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);
+    const st = await stat9(summaryPath);
     if (best === null || st.mtime.getTime() > best.mtime.getTime()) {
       best = { sessionId: entry.name, path: summaryPath, mtime: st.mtime };
     }
@@ -19683,7 +21062,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 +21154,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 +21171,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 +21186,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 +21194,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 +21208,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 +21226,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 +21244,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 +21270,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 +21286,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 +21296,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 +21317,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 +21327,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 +21344,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 +21365,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 +21375,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 +21391,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 +21409,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 +21422,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 +21445,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 +21455,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 +21472,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 +21491,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 +21512,7 @@ function parseAgeToCutoff(age) {
 }
 function assignmentMdPath(item) {
   if (item.projectSlug) {
-    return resolve60(
+    return resolve61(
       defaultProjectDir(),
       item.projectSlug,
       "assignments",
@@ -20141,7 +21520,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 +21586,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,19 +21645,19 @@ 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 { spawn as spawn4 } from "child_process";
+import { dirname as dirname16, join as join9, resolve as resolve62 } from "path";
+import { spawn as spawn5 } 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 join8 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
     const scriptPath = fileURLToPath7(scriptUrl);
-    const pkgRoot = dirname14(dirname14(scriptPath));
-    const raw = await readFile41(join7(pkgRoot, "package.json"), "utf-8");
+    const pkgRoot = dirname15(dirname15(scriptPath));
+    const raw = await readFile41(join8(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -20287,7 +21666,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,10 +21698,10 @@ 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);
+  const nearNode = join9(nodeDir, npmName);
   if (await fileExists(nearNode)) {
     return { cmd: nearNode, shell: false };
   }
@@ -20331,7 +21710,7 @@ async function resolveNpmBin() {
 async function installGlobally() {
   const { cmd, shell } = await resolveNpmBin();
   return new Promise((resolvePromise) => {
-    const child = spawn4(cmd, ["install", "-g", "syntaur"], {
+    const child = spawn5(cmd, ["install", "-g", "syntaur"], {
       stdio: "inherit",
       shell
     });
@@ -20342,7 +21721,7 @@ async function installGlobally() {
 async function readGlobalVersion() {
   const { cmd, shell } = await resolveNpmBin();
   const rootPath = await new Promise((resolvePromise) => {
-    const child = spawn4(cmd, ["root", "-g"], {
+    const child = spawn5(cmd, ["root", "-g"], {
       shell,
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -20365,7 +21744,7 @@ async function readGlobalVersion() {
   });
   if (!rootPath) return null;
   try {
-    const manifestPath = join8(rootPath, "syntaur", "package.json");
+    const manifestPath = join9(rootPath, "syntaur", "package.json");
     if (!await fileExists(manifestPath)) return null;
     const raw = await readFile42(manifestPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -20486,7 +21865,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) => {
@@ -20537,7 +21916,7 @@ program.command("comment").description("Add a comment to an assignment (CLI-medi
     process.exit(1);
   }
 });
-program.command("capture").description("Capture a typed proof artifact for an assignment").argument("[target]", "Assignment slug (with --project) or UUID; falls back to .syntaur/context.json").option("--kind <type>", "Artifact kind: screenshot | video | asciinema | http | text").option("--file <path>", "Source file to ingest (forbidden for --kind=text)").option("--criterion <index>", "Optional 0-based criterion index to tag").option("--note <text>", "Optional note (required for --kind=text)").option("--project <slug>", "Project slug if the target is project-nested").option("--dir <path>", "Override default project directory").action(async (target, options) => {
+program.command("capture").description("Capture a typed proof artifact for an assignment").argument("[target]", "Assignment slug (with --project) or UUID; falls back to .syntaur/context.json").option("--kind <type>", "Artifact kind: screenshot | video | asciinema | http | text").option("--file <path>", "Source file to ingest (forbidden for --kind=text)").option("--criterion <index>", "Optional 0-based criterion index to tag").option("--note <text>", "Optional note (required for --kind=text)").option("--project <slug>", "Project slug if the target is project-nested").option("--dir <path>", "Override default project directory").option("--interactive", "Screenshot mode: drag a region (macOS only)").option("--window", "Screenshot mode: window picker (macOS only)").option("--fullscreen", "Screenshot mode: silent full-screen capture (macOS only)").action(async (target, options) => {
   try {
     await captureCommand(target, options);
   } catch (error) {
@@ -20865,6 +22244,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());
 }