kith-coord 0.1.6 → 0.1.7

package/dist/index.js

@@ -1,40 +1,7 @@
-// src/core/claim-wait.ts
-async function waitForClaim(params) {
-  const { waitTimeoutMs, signal } = params;
-  if (!Number.isSafeInteger(waitTimeoutMs) || waitTimeoutMs < 0 || waitTimeoutMs > 6e5) {
-    throw new Error("waitTimeoutMs must be an integer between 0 and 600000");
-  }
-  const started = performance.now();
-  let previous;
-  for (; ; ) {
-    signal?.throwIfAborted();
-    const elapsed = Math.round(performance.now() - started);
-    if (previous && elapsed >= waitTimeoutMs) return { ...previous, waitedMs: elapsed, waitTimedOut: true };
-    params.heartbeat();
-    const result = params.attempt();
-    const waitedMs = Math.round(performance.now() - started);
-    if (result.ok || waitedMs >= waitTimeoutMs) return { ...result, waitedMs, waitTimedOut: !result.ok };
-    previous = result;
-    await new Promise((resolve, reject) => {
-      const abort = () => {
-        clearTimeout(timer);
-        reject(signal.reason);
-      };
-      const timer = setTimeout(() => {
-        signal?.removeEventListener("abort", abort);
-        resolve();
-      }, Math.min(100, waitTimeoutMs - waitedMs));
-      signal?.addEventListener("abort", abort, { once: true });
-    });
-  }
-}
+import { createRequire as __kithRequire } from 'node:module'; const require = __kithRequire(import.meta.url);
 
-// src/version.ts
-var KITH_VERSION = "0.1.6";
-var KITH_PROTOCOL_VERSION = "1.4.0";
-
-// src/core/workspace-observation.ts
-import { execFileSync as execFileSync2, spawnSync } from "child_process";
+// src/core/engine.ts
+import { execFileSync as execFileSync8 } from "child_process";
 
 // src/core/repository.ts
 import { execFileSync } from "child_process";
@@ -86,16 +53,16 @@ function discoverRepository(input) {
     throw new Error("Cannot coordinate a filesystem root; select an explicit project with --repo.");
   }
   if (!fs.statSync(directory).isDirectory()) throw new Error(`Not a directory: ${input}`);
-  const git2 = (...args) => execFileSync("git", ["rev-parse", ...args], {
+  const git3 = (...args) => execFileSync("git", ["rev-parse", ...args], {
     cwd: directory,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   }).replace(/\r?\n$/, "");
   try {
-    const checkoutRoot = fs.realpathSync(git2("--show-toplevel"));
+    const checkoutRoot = fs.realpathSync(git3("--show-toplevel"));
     if (!isWithin(checkoutRoot, directory)) throw new Error("Git routing environment selects a different checkout");
-    const commonGitDir = fs.realpathSync(git2("--path-format=absolute", "--git-common-dir"));
-    const isLinkedWorktree = fs.realpathSync(git2("--absolute-git-dir")) !== commonGitDir;
+    const commonGitDir = fs.realpathSync(git3("--path-format=absolute", "--git-common-dir"));
+    const isLinkedWorktree = fs.realpathSync(git3("--absolute-git-dir")) !== commonGitDir;
     const coordDir = path.basename(commonGitDir) === ".git" ? path.join(path.dirname(commonGitDir), ".coord") : path.join(commonGitDir, "kith");
     return { checkoutRoot, commonGitDir, coordDir, isLinkedWorktree };
   } catch (error) {
@@ -135,7 +102,43 @@ function caseSensitivePaths(root) {
   return false;
 }
 
+// src/core/claim-wait.ts
+async function waitForClaim(params) {
+  const { waitTimeoutMs, signal } = params;
+  if (!Number.isSafeInteger(waitTimeoutMs) || waitTimeoutMs < 0 || waitTimeoutMs > 6e5) {
+    throw new Error("waitTimeoutMs must be an integer between 0 and 600000");
+  }
+  const started = performance.now();
+  let previous;
+  for (; ; ) {
+    signal?.throwIfAborted();
+    const elapsed = Math.round(performance.now() - started);
+    if (previous && elapsed >= waitTimeoutMs) return { ...previous, waitedMs: elapsed, waitTimedOut: true };
+    params.heartbeat();
+    const result = params.attempt();
+    const waitedMs = Math.round(performance.now() - started);
+    if (result.ok || waitedMs >= waitTimeoutMs) return { ...result, waitedMs, waitTimedOut: !result.ok };
+    previous = result;
+    await new Promise((resolve, reject) => {
+      const abort = () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+      };
+      const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", abort);
+        resolve();
+      }, Math.min(100, waitTimeoutMs - waitedMs));
+      signal?.addEventListener("abort", abort, { once: true });
+    });
+  }
+}
+
+// src/version.ts
+var KITH_VERSION = "0.1.7";
+var KITH_PROTOCOL_VERSION = "1.5.0";
+
 // src/core/workspace-observation.ts
+import { execFileSync as execFileSync2, spawnSync } from "child_process";
 function git(cwd, ...args) {
   return execFileSync2("git", ["-c", "core.fsmonitor=false", ...args], {
     cwd,
@@ -264,8 +267,8 @@ function previewIntegration(repoRoot, agent) {
 }
 
 // src/core/engine.ts
-import fs12 from "fs";
-import path11 from "path";
+import fs14 from "fs";
+import path13 from "path";
 
 // src/core/ast-analyzer.ts
 import crypto from "crypto";
@@ -909,6 +912,7 @@ var LockEngine = class _LockEngine {
     const first = segments.findIndex((s) => /[?*]/u.test(s));
     if (first < 0) return false;
     const prefix = segments.slice(0, first).join("/");
+    const recursivePrefix = Boolean(prefix) && segments.length === first + 1 && segments[first] === "**";
     const roots = /* @__PURE__ */ new Set([this.coordDb.repoRoot, ...this.fencing.listAgents(true).map((a) => a.worktree_path).filter((p) => Boolean(p))]);
     const pending = [...roots].map((root) => ({ root, relative: prefix }));
     let budget = 1e4;
@@ -925,7 +929,17 @@ var LockEngine = class _LockEngine {
       for (const entry of entries) {
         if (--budget < 0) return true;
         const file = relative ? relative + "/" + entry.name : entry.name;
-        if (entry.isSymbolicLink()) return true;
+        if (entry.isSymbolicLink()) {
+          if (!recursivePrefix) return true;
+          try {
+            const scopeRoot = physicalPath(path4.join(root, prefix));
+            const linkTarget = fs4.realpathSync(path4.join(dir, entry.name));
+            if (!isWithin(scopeRoot, linkTarget)) return true;
+            continue;
+          } catch {
+            return true;
+          }
+        }
         const fold = (value) => value.normalize("NFC").toLowerCase().replace(/ς/g, "\u03C3");
         if (!_LockEngine.patternsOverlap(fold(pattern), fold(file)) && !_LockEngine.patternsOverlap(fold(pattern), fold(file + "/**"))) continue;
         if (entry.isDirectory()) pending.push({ root, relative: file });
@@ -2718,10 +2732,21 @@ var IntentAndTaskEngine = class {
     return this.coordDb.withTransaction(() => {
       this.fencing.assertSession(agentId);
       const allTasks = this.listTasks();
+      const activeSiblingIntents = allTasks.filter(
+        (t) => t.status === "active" && t.owner_agent_id !== agentId
+      );
       const taskById = new Map(allTasks.map((t) => [t.id, t]));
       const queued = allTasks.filter((t) => t.status === "queued").sort((a, b) => b.priority - a.priority || a.created_at - b.created_at);
       if (queued.length === 0) {
-        return { claimed: false, task: null, fencingToken: null, locks: [], reason: "no_queued_tasks" };
+        return {
+          ok: false,
+          claimed: false,
+          task: null,
+          fencingToken: null,
+          locks: [],
+          activeSiblingIntents,
+          reason: "no_queued_tasks"
+        };
       }
       for (const candidate of queued) {
         const depsSatisfied = candidate.depends_on.every(
@@ -2757,17 +2782,21 @@ var IntentAndTaskEngine = class {
           fencingToken
         });
         return {
+          ok: true,
           claimed: true,
           task: this.getTask(candidate.id),
           fencingToken,
-          locks
+          locks,
+          activeSiblingIntents
         };
       }
       return {
+        ok: false,
         claimed: false,
         task: null,
         fencingToken: null,
         locks: [],
+        activeSiblingIntents,
         reason: "all_queued_tasks_blocked_by_dependencies_or_locks"
       };
     });
@@ -3362,10 +3391,418 @@ var ShadowGitEngine = class {
   }
 };
 
-// src/core/worktree-cow.ts
+// src/core/workspace-contracts.ts
 import { execFileSync as execFileSync6 } from "child_process";
+import fs12 from "fs";
+import path11 from "path";
+
+// src/core/observation.ts
 import fs11 from "fs";
+import os from "os";
 import path10 from "path";
+import { createRequire as createRequire2 } from "module";
+var { DatabaseSync: DatabaseSync2 } = createRequire2(import.meta.url)("node:sqlite");
+function readCoordinationState(directory = process.cwd(), options = {}) {
+  const layout = discoverRepository(directory), observedAt = Date.now();
+  const empty = {
+    protocolVersion: KITH_PROTOCOL_VERSION,
+    observedAt,
+    repository: { root: layout.checkoutRoot, commonGitDir: layout.commonGitDir, coordDir: layout.coordDir },
+    runtime: { node: process.version },
+    state: "missing",
+    error: void 0,
+    sessionEpochs: {},
+    truncated: false,
+    schemaVersion: 0,
+    fencingEpoch: 0,
+    agents: [],
+    tasks: [],
+    locks: [],
+    conflicts: [],
+    contracts: [],
+    resources: [],
+    mergeQueue: [],
+    quarantined: [],
+    mutexWaiters: [],
+    commandGuards: [],
+    events: [],
+    workspaces: []
+  };
+  let scratch, db;
+  try {
+    const file = path10.join(layout.coordDir, "state.db");
+    if (physicalPath(layout.coordDir) !== layout.coordDir || physicalPath(file) !== file) throw new Error("Coordination state must not be a symlink");
+    for (let current = fs11.realpathSync.native(directory); isWithin(layout.checkoutRoot, current); current = path10.dirname(current)) {
+      const local = path10.join(current, ".coord");
+      if (local !== layout.coordDir && fs11.existsSync(path10.join(local, "state.db"))) throw new Error(`Legacy independent state at ${local}; preserve it before consolidation`);
+      if (current === layout.checkoutRoot) break;
+    }
+    if (!fs11.existsSync(file)) {
+      if (["setup.lock", "merge-train.lock"].some((name) => fs11.existsSync(path10.join(layout.coordDir, name))) || ["-wal", "-shm", "-journal"].some((s) => fs11.existsSync(file + s)) || ["worktrees", "quarantine", "snapshots", "shadow-index", "setup"].some((name) => {
+        const p = path10.join(layout.coordDir, name);
+        return fs11.existsSync(p) && (!fs11.lstatSync(p).isDirectory() || fs11.readdirSync(p).length > 0);
+      })) throw new Error("Missing database with retained sidecars; preserve the recovery set");
+      return empty;
+    }
+    const files = ["", "-wal", "-shm", "-journal"].map((s) => file + s);
+    const identity = (f) => {
+      if (!fs11.existsSync(f)) return null;
+      if (physicalPath(f) !== f || !fs11.lstatSync(f).isFile()) throw new Error("Database or sidecar is redirected or not a regular file");
+      const s = fs11.statSync(f, { bigint: true });
+      return [s.dev, s.ino, s.size, s.mtimeNs, s.ctimeNs].join(":");
+    };
+    const before = files.map(identity);
+    scratch = fs11.mkdtempSync(path10.join(os.tmpdir(), "kith-observe-"));
+    for (let i = 0; i < files.length; i++) if (before[i]) {
+      const target = path10.join(scratch, path10.basename(files[i]));
+      fs11.copyFileSync(files[i], target);
+      fs11.chmodSync(target, 384);
+    }
+    if (JSON.stringify(before) !== JSON.stringify(files.map(identity))) throw new Error("Coordination state changed during snapshot; stop writers or retry");
+    db = new DatabaseSync2(path10.join(scratch, "state.db"), { readOnly: true });
+    db.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=1000; BEGIN");
+    const schemaVersion = CoordDatabase.inspectSchema(db);
+    if (schemaVersion < 2) throw new Error("Offline observation requires schema 2 or newer; preserve state and upgrade with clients stopped");
+    const all = (sql) => db.prepare(sql).all();
+    const agents = all("SELECT * FROM agents ORDER BY registered_at DESC" + (options.coordinationOnly ? " LIMIT 201" : ""));
+    if (options.coordinationOnly) {
+      const tasks = all("SELECT * FROM tasks WHERE status IN ('active','blocked','queued') ORDER BY priority DESC, updated_at DESC LIMIT 201").map(({ depends_on_json, scope_globs_json, ...r }) => ({ ...r, depends_on: JSON.parse(String(depends_on_json)), scope_globs: JSON.parse(String(scope_globs_json)) }));
+      const locks = all("SELECT * FROM locks WHERE expires_at > " + observedAt + " ORDER BY acquired_at DESC LIMIT 501");
+      const resources = all("SELECT * FROM resources ORDER BY acquired_at DESC LIMIT 201");
+      const mutexWaiters = all("SELECT ticket,mutex_name,owner_agent_id,session_epoch,expires_at FROM mutex_waiters ORDER BY ticket LIMIT 201");
+      const commandGuards = all("SELECT mutex_name,owner_agent_id,session_epoch,fencing_token FROM mutex_runs LIMIT 201");
+      const mergeQueue = all("SELECT agent_id,branch,worktree_path,status,fencing_token,created_at,updated_at FROM merge_queue WHERE rowid IN (SELECT MAX(rowid) FROM merge_queue GROUP BY agent_id,branch) ORDER BY created_at DESC LIMIT 201");
+      const sessionEpochs = Object.fromEntries(all("SELECT s.agent_id,s.epoch FROM agent_sessions s JOIN agents a ON s.agent_id=a.id ORDER BY a.registered_at DESC LIMIT 201").map((r) => [r.agent_id, r.epoch]));
+      db.exec("COMMIT");
+      return {
+        ...empty,
+        state: "ready",
+        schemaVersion,
+        agents,
+        sessionEpochs,
+        tasks,
+        locks,
+        resources,
+        mutexWaiters,
+        commandGuards,
+        mergeQueue,
+        truncated: [agents, tasks, resources, mutexWaiters, commandGuards, mergeQueue].some((rows) => rows.length > 200) || locks.length > 500
+      };
+    }
+    if (options.ownersOnly) {
+      db.exec("COMMIT");
+      return { ...empty, state: "ready", schemaVersion, agents };
+    }
+    const state = {
+      ...empty,
+      state: "ready",
+      schemaVersion,
+      fencingEpoch: Number(db.prepare("SELECT value FROM meta WHERE key='fencing_epoch'").get().value),
+      agents,
+      tasks: all("SELECT * FROM tasks ORDER BY priority DESC,created_at").map(({ depends_on_json, scope_globs_json, ...r }) => ({ ...r, depends_on: JSON.parse(String(depends_on_json)), scope_globs: JSON.parse(String(scope_globs_json)) })),
+      locks: all("SELECT * FROM locks ORDER BY acquired_at"),
+      conflicts: all("SELECT * FROM conflicts ORDER BY detected_at DESC").map(({ details_json, ...r }) => ({ ...r, details: JSON.parse(String(details_json)) })),
+      contracts: all("SELECT * FROM contracts ORDER BY updated_at DESC").map((r) => ({ ...r, is_breaking: Boolean(r.is_breaking) })),
+      resources: all("SELECT * FROM resources ORDER BY acquired_at"),
+      mergeQueue: all("SELECT * FROM merge_queue ORDER BY created_at DESC"),
+      quarantined: all("SELECT * FROM quarantine ORDER BY created_at DESC"),
+      mutexWaiters: all("SELECT ticket,mutex_name,owner_agent_id,session_epoch,expires_at FROM mutex_waiters ORDER BY ticket"),
+      commandGuards: all("SELECT mutex_name,owner_agent_id,worker_pid,supervisor_pid FROM mutex_runs ORDER BY mutex_name"),
+      events: all("SELECT * FROM events ORDER BY id DESC LIMIT 100").map(({ payload_json, ...r }) => ({ ...r, payload: JSON.parse(String(payload_json)) })),
+      workspaces: options.coordinationOnly ? [] : observeWorkspaces(layout.checkoutRoot, agents, observedAt)
+    };
+    db.exec("COMMIT");
+    return state;
+  } catch (error) {
+    return { ...empty, state: "unavailable", error: error instanceof Error ? error.message : String(error) };
+  } finally {
+    db?.close();
+    if (scratch) fs11.rmSync(scratch, { recursive: true, force: true });
+  }
+}
+function recoveryReport(directory = process.cwd()) {
+  const state = readCoordinationState(directory), retainedRoot = path10.join(state.repository.coordDir, "worktrees");
+  const retained = physicalPath(retainedRoot) === retainedRoot && fs11.existsSync(retainedRoot) && fs11.lstatSync(retainedRoot).isDirectory() && !fs11.lstatSync(retainedRoot).isSymbolicLink() ? fs11.readdirSync(retainedRoot, { withFileTypes: true }).map((entry) => ({
+    path: path10.join(retainedRoot, entry.name),
+    symlink: entry.isSymbolicLink(),
+    agentIds: state.agents.filter((a) => a.worktree_path === path10.join(retainedRoot, entry.name)).map((a) => a.id)
+  })) : [];
+  return {
+    ...state,
+    retainedWorktrees: retained,
+    expiredClaims: state.locks.filter((lock) => Number(lock.expires_at) <= state.observedAt),
+    unfinishedIntegrations: state.mergeQueue.filter((entry) => entry.status !== "merged"),
+    setupLock: { path: path10.join(state.repository.coordDir, "setup.lock"), present: fs11.existsSync(path10.join(state.repository.coordDir, "setup.lock")) },
+    integrationLock: { path: path10.join(state.repository.coordDir, "merge-train.lock"), present: fs11.existsSync(path10.join(state.repository.coordDir, "merge-train.lock")) }
+  };
+}
+
+// src/core/workspace-contracts.ts
+function buildSwarmPrompts(repoRoot) {
+  const layout = discoverRepository(repoRoot);
+  if (!layout.commonGitDir) throw new Error("Select a Git checkout for task prompts, not a parent workspace.");
+  const cleanRoot = layout.checkoutRoot;
+  return {
+    architect: `Use Kith on repository ${cleanRoot} to plan parallel multi-agent work:
+1. Call kith_start_session with a unique agentId (e.g. "architect-1") and repository "${cleanRoot}".
+2. Publish any shared interfaces, routes, or schemas upfront via kith_publish_contract.
+3. Enqueue parallelizable tasks with disjoint file scopes using kith_add_task (passing title, intentSummary, scopeGlobs, priority, and dependsOn for sequential steps).
+4. Summarize the queued task IDs and scopes so worker agents can claim them in parallel.`,
+    worker: `Use Kith on repository ${cleanRoot} to claim and execute the next queued task:
+1. Call kith_claim_next_task with a unique agentId, repository "${cleanRoot}", and isolateWorktree: true.
+2. Edit only inside the returned worktree.worktreePath and within the task's locked scopeGlobs, respecting publishedContracts and linkedContracts.
+3. After each file edit, call kith_record_file_edit to check contract blast radius and live dirty-tree conflicts.
+4. Commit your changes in the worktree and call kith_complete_work with a read-only verificationCmd to verify and merge.`
+  };
+}
+function parseJsoncObject(raw) {
+  let out = "";
+  let inString = false;
+  let stringQuote = '"';
+  let i = 0;
+  while (i < raw.length) {
+    const ch = raw[i];
+    const next = raw[i + 1];
+    if (inString) {
+      out += ch;
+      if (ch === "\\" && i + 1 < raw.length) {
+        out += raw[i + 1];
+        i += 2;
+        continue;
+      }
+      if (ch === stringQuote) {
+        inString = false;
+      }
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = true;
+      stringQuote = ch;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      i += 2;
+      while (i < raw.length && raw[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i + 1 < raw.length && !(raw[i] === "*" && raw[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  const withoutTrailingCommas = out.replace(/,\s*([}\]])/g, "$1");
+  try {
+    const parsed = JSON.parse(withoutTrailingCommas);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var MAX_SOURCE_BYTES = 64 * 1024;
+var MAX_REPLY_BYTES = 16 * 1024;
+var MAX_LINKS = 8;
+var MAX_SYMBOLS = 64;
+function git2(root, ...args) {
+  return execFileSync6("git", ["-c", "core.fsmonitor=false", ...args], {
+    cwd: root,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 2e3,
+    maxBuffer: MAX_SOURCE_BYTES,
+    env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" }
+  }).trim();
+}
+function readBounded(file) {
+  const fd = fs12.openSync(file, "r");
+  try {
+    const stat = fs12.fstatSync(fd);
+    if (!stat.isFile() || stat.size > MAX_SOURCE_BYTES) throw new Error("Contract/config file exceeds inspection limit or is not a regular file");
+    const bytes = Buffer.alloc(MAX_SOURCE_BYTES + 1);
+    const size = fs12.readSync(fd, bytes, 0, bytes.length, 0);
+    if (size > MAX_SOURCE_BYTES) throw new Error("Contract/config file exceeds inspection limit");
+    return bytes.subarray(0, size).toString("utf8");
+  } finally {
+    fs12.closeSync(fd);
+  }
+}
+function resolveFile(base) {
+  for (const name of [base, `${base}.ts`, `${base}.tsx`, `${base}.d.ts`, `${base}.js`, `${base}.jsx`, path11.join(base, "index.ts"), path11.join(base, "index.js")]) {
+    if (fs12.existsSync(name) && fs12.statSync(name).isFile()) return physicalPath(name);
+  }
+}
+function inspectWorkspaceContracts(repoRoot, worktreeDir, imports) {
+  const report = { linkedContracts: [], warnings: [], complete: true };
+  const unavailable = (detail) => {
+    report.complete = false;
+    if (report.warnings.length < 8) report.warnings.push(`[CROSS-REPO UNAVAILABLE] ${detail.slice(0, 300)}`);
+  };
+  try {
+    const layout = discoverRepository(worktreeDir ?? repoRoot);
+    if (!layout.commonGitDir) return report;
+    const activeRoot = layout.checkoutRoot;
+    let config = null;
+    for (const name of ["tsconfig.json", "jsconfig.json"]) {
+      const file = path11.join(activeRoot, name);
+      if (!fs12.existsSync(file)) continue;
+      repositoryFile(activeRoot, file);
+      config = parseJsoncObject(readBounded(file));
+      if (!config) unavailable(`Cannot parse ${name}; aliases were not inspected.`);
+      break;
+    }
+    if (!config) return report;
+    const options = config.compilerOptions;
+    if (config.extends || config.references) {
+      unavailable("Inherited/referenced configuration is not inspected; use your normal compiler checks.");
+      return report;
+    }
+    if (!options?.paths || typeof options.paths !== "object") return report;
+    const caller = discoverRepository(repoRoot);
+    if (caller.commonGitDir !== layout.commonGitDir) {
+      unavailable("Worktree repository identity differs from the caller.");
+      return report;
+    }
+    const bases = [.../* @__PURE__ */ new Set([activeRoot, caller.checkoutRoot])].map((root) => path11.resolve(root, typeof options.baseUrl === "string" ? options.baseUrl : "."));
+    let symbolBudget = MAX_SYMBOLS;
+    const aliases = Object.entries(options.paths).sort(([a], [b]) => b.length - a.length);
+    if (aliases.length > 32) unavailable("Alias limit reached; inspection is partial.");
+    const externalTargets = (targets) => Array.isArray(targets) && targets.slice(0, 8).some((target) => typeof target === "string" && !isWithin(caller.checkoutRoot, physicalPath(path11.resolve(bases[bases.length - 1], target.replace("*", "")))));
+    const selected = imports ? [...new Set(imports)].slice(0, 32) : aliases.slice(0, 32).filter(([a]) => !a.includes("*")).map(([a]) => a);
+    if (imports && imports.length > 32) unavailable("Import limit reached; inspection is partial.");
+    if (!imports && aliases.some(([a, targets]) => a.includes("*") && externalTargets(targets))) unavailable("Wildcard aliases are checked for concrete imports after edits; not enumerated by status.");
+    for (const specifier of selected) {
+      const match = aliases.slice(0, 32).find(([alias2]) => {
+        if (!alias2.includes("*")) return alias2 === specifier;
+        const [prefix, suffix, extra] = alias2.split("*");
+        return extra === void 0 && specifier.startsWith(prefix) && specifier.endsWith(suffix) && specifier.length >= prefix.length + suffix.length;
+      });
+      if (!match || !Array.isArray(match[1])) continue;
+      const [alias, targets] = match;
+      if (!externalTargets(targets)) continue;
+      const star = alias.indexOf("*");
+      const substitution = star < 0 ? "" : specifier.slice(star, specifier.length - (alias.length - star - 1));
+      if (substitution.split(/[\\/]/).some((part) => part === "..")) {
+        unavailable("Alias traversal was not inspected.");
+        continue;
+      }
+      let externalFile;
+      for (const target of targets.slice(0, 8)) {
+        if (typeof target !== "string" || (target.match(/\*/g)?.length ?? 0) > 1) continue;
+        for (const base of bases) {
+          externalFile = resolveFile(path11.resolve(base, target.replace("*", substitution)));
+          if (externalFile) break;
+        }
+        if (externalFile) break;
+      }
+      if (!externalFile) {
+        unavailable(`Cannot resolve '${specifier}'; no compatibility verdict available.`);
+        continue;
+      }
+      if (isWithin(activeRoot, externalFile)) continue;
+      const sibling = discoverRepository(path11.dirname(externalFile));
+      if (!sibling.commonGitDir || sibling.commonGitDir === layout.commonGitDir) {
+        unavailable(`'${specifier}' does not select a separate Git repository; no external source was read.`);
+        continue;
+      }
+      const siblingRoot = sibling.checkoutRoot;
+      const relative = repositoryFile(siblingRoot, externalFile);
+      git2(siblingRoot, "ls-files", "--error-unmatch", "--", relative);
+      if (report.linkedContracts.length >= MAX_LINKS || symbolBudget <= 0) {
+        unavailable("Contract/symbol limit reached; inspection is partial.");
+        break;
+      }
+      const content = readBounded(externalFile);
+      const extracted = AstAnalyzer.extractExports(content);
+      const symbols = extracted.slice(0, symbolBudget).map((s) => ({
+        symbolName: s.symbolName.slice(0, 128),
+        kind: s.kind,
+        signature: `${s.kind} ${s.symbolName}`.slice(0, 160),
+        astHash: s.astHash
+      }));
+      symbolBudget -= symbols.length;
+      const exportsComplete = extracted.length === symbols.length && !/export\s+(?:\*|\{)/.test(content);
+      if (!exportsComplete) unavailable(`'${specifier}' exports are partial or re-exported; missing-export checks are unavailable.`);
+      let dirtyInCheckout = null;
+      try {
+        dirtyInCheckout = Boolean(git2(siblingRoot, "status", "--porcelain=v1", "--", relative));
+      } catch {
+        unavailable(`'${specifier}' Git status is unavailable.`);
+      }
+      const state = readCoordinationState(siblingRoot, { coordinationOnly: true });
+      const ownershipAvailable = state.state === "missing" || state.state === "ready" && state.schemaVersion === 3 && !state.truncated;
+      if (!ownershipAvailable) unavailable(`'${specifier}' sibling ownership is unavailable or partial; inspect its stopped state before recovery.`);
+      const agents = state.state === "ready" ? state.agents.filter((a) => a.status === "active" && a.lease_expires_at > state.observedAt && state.sessionEpochs[a.id] !== void 0) : [];
+      const locked = state.locks.find((l) => agents.some((a) => a.id === l.owner_agent_id) && Number(l.expires_at) > state.observedAt && Number(l.fencing_token) >= state.sessionEpochs[String(l.owner_agent_id)] && LockEngine.patternsOverlap(relative, String(l.pattern)));
+      const drifts = [];
+      for (const agent of agents.slice(0, 8)) {
+        if (!agent.worktree_path || physicalPath(agent.worktree_path) === siblingRoot) continue;
+        try {
+          const wt = discoverRepository(agent.worktree_path);
+          if (wt.checkoutRoot !== physicalPath(agent.worktree_path) || wt.commonGitDir !== sibling.commonGitDir) throw new Error("Worktree identity changed");
+          const file = path11.join(wt.checkoutRoot, relative);
+          repositoryFile(wt.checkoutRoot, file);
+          const current = AstAnalyzer.extractExports(readBounded(file));
+          const original = new Map(extracted.map((s) => [s.symbolName, s.astHash]));
+          const updated = new Map(current.map((s) => [s.symbolName, s.astHash]));
+          const changed = [...updated].filter(([name, hash]) => original.get(name) !== hash).map(([name]) => name);
+          const removed = [...original.keys()].filter((name) => !updated.has(name));
+          if (changed.length || removed.length) drifts.push({ agentId: agent.id, worktreePath: wt.checkoutRoot, changedSymbols: changed.slice(0, 16), removedSymbols: removed.slice(0, 16) });
+          if (changed.length > 16 || removed.length > 16) unavailable(`'${specifier}' drift detail is partial.`);
+        } catch {
+          unavailable(`'${specifier}' recorded worktree is unavailable; drift has not been verified.`);
+        }
+      }
+      if (agents.length > 8) unavailable(`'${specifier}' owner/worktree inspection limit reached.`);
+      const link = { alias: specifier, sourceRepo: siblingRoot, sourceRepoName: path11.basename(siblingRoot), filePath: relative, absolutePath: externalFile, symbols, exportsComplete, ownershipAvailable, dirtyInCheckout, lockedByAgent: locked ? String(locked.owner_agent_id) : null, activeWorktreeDrifts: drifts };
+      report.linkedContracts.push(link);
+      if (Buffer.byteLength(JSON.stringify(report)) > MAX_REPLY_BYTES - 3e3) {
+        report.linkedContracts.pop();
+        unavailable("Reply byte limit reached; inspection is partial.");
+        break;
+      }
+      if (locked) report.warnings.push(`[CROSS-REPO ACTIVE LOCK] '${specifier}' is claimed by '${locked.owner_agent_id}'.`.slice(0, 300));
+      if (dirtyInCheckout) report.warnings.push(`[CROSS-REPO CONTRACT DRIFT] '${specifier}' has uncommitted changes.`.slice(0, 300));
+      for (const drift of drifts) report.warnings.push(`[CROSS-REPO WORKTREE DRIFT] '${specifier}' has unmerged signature changes in '${drift.agentId}'.`.slice(0, 300));
+      if (report.warnings.length > 8) {
+        report.warnings = report.warnings.slice(0, 7);
+        unavailable("Warning limit reached; inspection is partial.");
+      }
+    }
+  } catch {
+    unavailable("Contract inspection could not finish; existing claims/work remain valid. Use normal project verification.");
+  }
+  return report;
+}
+function verifyCrossRepoImportsForFile(params) {
+  if (Buffer.byteLength(params.content) > MAX_SOURCE_BYTES) return ["[CROSS-REPO UNAVAILABLE] Edited file exceeds inspection limit; use normal project verification."];
+  const imports = AstAnalyzer.extractImports(params.worktreeDir ?? params.repoRoot, params.filePath, params.content);
+  const report = inspectWorkspaceContracts(params.repoRoot, params.worktreeDir, imports.map((i) => i.rawSpecifier));
+  const warnings = [...report.warnings];
+  const namedImports = [...params.content.matchAll(/import\s+(?:type\s+)?(?:[\w$]+\s*,\s*)?\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g)];
+  for (const imp of namedImports.slice(0, 32)) {
+    const link = report.linkedContracts.find((l) => l.alias === imp[2]);
+    if (!link?.exportsComplete) continue;
+    const exported = new Set(link.symbols.map((s) => s.symbolName));
+    for (const binding of imp[1].split(",")) {
+      const symbol = binding.trim().replace(/^type\s+/, "").split(/\s+as\s+/)[0];
+      if (!symbol || exported.has(symbol)) continue;
+      if (warnings.length >= 8) break;
+      warnings.push(`[CROSS-REPO CONTRACT MISMATCH] '${params.filePath.slice(0, 120)}' imports '${symbol.slice(0, 120)}' from '${imp[2].slice(0, 120)}', but that module has no such recorded export.`);
+    }
+  }
+  return warnings;
+}
+
+// src/core/worktree-cow.ts
+import { execFileSync as execFileSync7 } from "child_process";
+import fs13 from "fs";
+import path12 from "path";
 var CoWWorktreeManager = class _CoWWorktreeManager {
   constructor(coordDb, fencing) {
     this.coordDb = coordDb;
@@ -3385,32 +3822,32 @@ var CoWWorktreeManager = class _CoWWorktreeManager {
     const safeId = params.agentId.replace(/[^a-zA-Z0-9_-]/g, "-");
     const branch = params.branch ?? `kith/${safeId}`;
     const baseRef = params.baseRef ?? "HEAD";
-    const worktreePath = path10.join(this.coordDb.coordDir, "worktrees", safeId);
+    const worktreePath = path12.join(this.coordDb.coordDir, "worktrees", safeId);
     if (!this.fencing.getAgent(params.agentId)) throw new Error(`Unknown agent: ${params.agentId}`);
     if (!safeId || safeId === "." || safeId === "..") throw new Error("Invalid agent ID");
-    if (fs11.existsSync(worktreePath)) {
+    if (fs13.existsSync(worktreePath)) {
       throw new Error(`Worktree already exists: ${worktreePath}. Commit or preserve its work before removing it.`);
     }
-    fs11.mkdirSync(path10.dirname(worktreePath), { recursive: true });
-    execFileSync6("git", ["worktree", "add", "-b", branch, worktreePath, baseRef], {
+    fs13.mkdirSync(path12.dirname(worktreePath), { recursive: true });
+    execFileSync7("git", ["worktree", "add", "-b", branch, worktreePath, baseRef], {
       cwd: this.coordDb.repoRoot,
       stdio: "ignore"
     });
     const hydratedDirs = [];
     let hydrationMethod = "none";
     for (const dirName of _CoWWorktreeManager.HYDRATABLE_DIRS) {
-      const srcDir = path10.join(this.coordDb.repoRoot, dirName);
-      const destDir = path10.join(worktreePath, dirName);
-      if (!fs11.existsSync(srcDir) || fs11.existsSync(destDir)) continue;
+      const srcDir = path12.join(this.coordDb.repoRoot, dirName);
+      const destDir = path12.join(worktreePath, dirName);
+      if (!fs13.existsSync(srcDir) || fs13.existsSync(destDir)) continue;
       const method = this.cloneDirectoryCoW(srcDir, destDir);
       hydrationMethod = method;
       hydratedDirs.push(dirName);
     }
     for (const envName of _CoWWorktreeManager.ENV_FILES) {
-      const srcEnv = path10.join(this.coordDb.repoRoot, envName);
-      const destEnv = path10.join(worktreePath, envName);
-      if (fs11.existsSync(srcEnv) && !fs11.existsSync(destEnv)) {
-        fs11.copyFileSync(srcEnv, destEnv);
+      const srcEnv = path12.join(this.coordDb.repoRoot, envName);
+      const destEnv = path12.join(worktreePath, envName);
+      if (fs13.existsSync(srcEnv) && !fs13.existsSync(destEnv)) {
+        fs13.copyFileSync(srcEnv, destEnv);
       }
     }
     this.coordDb.withTransaction(() => {
@@ -3435,7 +3872,7 @@ var CoWWorktreeManager = class _CoWWorktreeManager {
   cloneDirectoryCoW(srcDir, destDir) {
     if (process.platform === "darwin") {
       try {
-        execFileSync6("cp", ["-cR", srcDir, destDir], {
+        execFileSync7("cp", ["-cR", srcDir, destDir], {
           stdio: "ignore",
           timeout: 5e3
         });
@@ -3444,7 +3881,7 @@ var CoWWorktreeManager = class _CoWWorktreeManager {
       }
     } else if (process.platform === "linux") {
       try {
-        execFileSync6("cp", ["--reflink=always", "-R", srcDir, destDir], {
+        execFileSync7("cp", ["--reflink=always", "-R", srcDir, destDir], {
           stdio: "ignore",
           timeout: 5e3
         });
@@ -3452,27 +3889,27 @@ var CoWWorktreeManager = class _CoWWorktreeManager {
       } catch {
       }
     }
-    fs11.rmSync(destDir, { recursive: true, force: true });
-    fs11.cpSync(srcDir, destDir, { recursive: true, dereference: false });
+    fs13.rmSync(destDir, { recursive: true, force: true });
+    fs13.cpSync(srcDir, destDir, { recursive: true, dereference: false });
     return "copy";
   }
   removeWorktree(agentId) {
     this.fencing.assertSession(agentId);
     const safeId = agentId.replace(/[^a-zA-Z0-9_-]/g, "-");
-    const worktreePath = path10.join(this.coordDb.coordDir, "worktrees", safeId);
-    if (!fs11.existsSync(worktreePath)) return false;
+    const worktreePath = path12.join(this.coordDb.coordDir, "worktrees", safeId);
+    if (!fs13.existsSync(worktreePath)) return false;
     const registered = this.fencing.getAgent(agentId)?.worktree_path;
     if (!registered || physicalPath(registered) !== physicalPath(worktreePath) || this.fencing.listAgents(true).some((agent) => agent.id !== agentId && agent.worktree_path && physicalPath(agent.worktree_path) === physicalPath(worktreePath))) {
       throw new Error("Refusing to remove a worktree that is not exclusively registered to this agent.");
     }
-    const status = execFileSync6("git", ["status", "--porcelain", "--untracked-files=normal", "--ignored=matching"], {
+    const status = execFileSync7("git", ["status", "--porcelain", "--untracked-files=normal", "--ignored=matching"], {
       cwd: worktreePath,
       encoding: "utf8"
     });
     if (status.trim()) {
       throw new Error(`Refusing to remove dirty worktree: ${worktreePath}. Commit or preserve changed, untracked, and ignored files first.`);
     }
-    execFileSync6("git", ["worktree", "remove", worktreePath], {
+    execFileSync7("git", ["worktree", "remove", worktreePath], {
       cwd: this.coordDb.repoRoot,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -3484,7 +3921,7 @@ var CoWWorktreeManager = class _CoWWorktreeManager {
   }
   listWorktrees() {
     try {
-      const out = execFileSync6("git", ["worktree", "list", "--porcelain"], {
+      const out = execFileSync7("git", ["worktree", "list", "--porcelain"], {
         cwd: this.coordDb.repoRoot,
         encoding: "utf8"
       });
@@ -3551,7 +3988,7 @@ var KithEngine = class {
     const file = LockEngine.normalizeFile(targetRoot, params.filePath);
     const access = this.locks.checkFileWriteAccess({ agentId: params.agentId, filePath: file });
     if (!access.allowed) throw new Error(access.reason);
-    const content = params.content ?? (fs12.existsSync(path11.join(targetRoot, file)) ? fs12.readFileSync(path11.join(targetRoot, file), "utf8") : "");
+    const content = params.content ?? (fs14.existsSync(path13.join(targetRoot, file)) ? fs14.readFileSync(path13.join(targetRoot, file), "utf8") : "");
     const contractReport = this.depGraph.recordFileModification(
       params.agentId,
       file,
@@ -3585,6 +4022,13 @@ var KithEngine = class {
         `[LIVE DIRTY-TREE CONFLICT] Uncommitted changes in '${conf.file_path}' conflict with active agent '${peer}' (${conf.severity}: ${conf.details.reason}).`
       );
     }
+    const crossRepoWarnings = verifyCrossRepoImportsForFile({
+      repoRoot: this.coordDb.repoRoot,
+      worktreeDir: targetRoot,
+      filePath: file,
+      content
+    });
+    warnings.push(...crossRepoWarnings);
     return {
       filePath: file,
       contractReport,
@@ -3636,6 +4080,7 @@ ${lines.join("\n")}` : "";
   }
   getStatus() {
     const agents = this.fencing.listAgents(true);
+    const workspaceContracts = inspectWorkspaceContracts(this.coordDb.repoRoot);
     return {
       protocolVersion: KITH_PROTOCOL_VERSION,
       repository: { root: this.coordDb.repoRoot, commonGitDir: this.coordDb.commonGitDir, coordDir: this.coordDb.coordDir },
@@ -3646,6 +4091,9 @@ ${lines.join("\n")}` : "";
       tasks: this.intents.listTasks(),
       conflicts: this.shadowGit.listConflicts(),
       contracts: this.depGraph.listContracts(),
+      linkedContracts: workspaceContracts.linkedContracts,
+      crossRepoWarnings: workspaceContracts.warnings,
+      crossRepoComplete: workspaceContracts.complete,
       resources: this.broker.listResources(),
       mergeQueue: this.mergeTrain.listQueue(),
       quarantined: this.bashGuard.listQuarantined(),
@@ -3659,9 +4107,70 @@ ${lines.join("\n")}` : "";
     return previewIntegration(this.coordDb.repoRoot, this.fencing.getAgent(agentId));
   }
   beginWork(params) {
-    const intent = this.intents.declareIntent(params);
-    const worktree = intent.ok && params.isolateWorktree ? this.worktrees.spawnWorktree({ agentId: params.agentId }) : null;
-    return { ...intent, worktree };
+    const { intent, worktree } = this.coordDb.withTransaction(() => {
+      const intent2 = this.intents.declareIntent(params);
+      const worktree2 = intent2.ok && params.isolateWorktree ? this.worktrees.spawnWorktree({ agentId: params.agentId }) : null;
+      return { intent: intent2, worktree: worktree2 };
+    });
+    const workspaceContracts = inspectWorkspaceContracts(
+      this.coordDb.repoRoot,
+      worktree?.worktreePath ?? this.fencing.getAgent(params.agentId)?.worktree_path ?? void 0
+    );
+    return {
+      ...intent,
+      worktree,
+      linkedContracts: workspaceContracts.linkedContracts,
+      crossRepoWarnings: workspaceContracts.warnings,
+      crossRepoComplete: workspaceContracts.complete
+    };
+  }
+  claimNextTask(params) {
+    const { claimedRes, worktree } = this.coordDb.withTransaction(() => {
+      const claimedRes2 = this.intents.claimNextTask(params.agentId);
+      const worktree2 = claimedRes2.claimed && params.isolateWorktree ? this.claimWorktree(params.agentId) : null;
+      return { claimedRes: claimedRes2, worktree: worktree2 };
+    });
+    const publishedContracts = this.depGraph.listContracts().slice(0, 30);
+    const workspaceContracts = inspectWorkspaceContracts(
+      this.coordDb.repoRoot,
+      worktree?.worktreePath ?? this.fencing.getAgent(params.agentId)?.worktree_path ?? void 0
+    );
+    return {
+      ...claimedRes,
+      worktree,
+      publishedContracts,
+      linkedContracts: workspaceContracts.linkedContracts,
+      crossRepoWarnings: workspaceContracts.warnings,
+      crossRepoComplete: workspaceContracts.complete
+    };
+  }
+  claimWorktree(agentId) {
+    this.fencing.assertSession(agentId);
+    const agent = this.fencing.getAgent(agentId);
+    if (!agent.worktree_path) return this.worktrees.spawnWorktree({ agentId });
+    const root = physicalPath(agent.worktree_path);
+    const owner = discoverRepository(this.coordDb.repoRoot);
+    const layout = discoverRepository(root);
+    const git3 = (...args) => execFileSync8("git", args, {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 5e3
+    }).trim();
+    if (!isWithin(physicalPath(path13.join(this.coordDb.coordDir, "worktrees")), root) || !layout.isLinkedWorktree || layout.checkoutRoot !== root || layout.commonGitDir !== owner.commonGitDir || !agent.branch || git3("symbolic-ref", "--short", "HEAD") !== agent.branch || !this.worktrees.listWorktrees().some((w) => physicalPath(w.path) === root && w.branch === agent.branch) || this.fencing.listAgents(true).some((a) => a.id !== agentId && a.worktree_path && physicalPath(a.worktree_path) === root)) {
+      throw new Error("Saved worktree identity or ownership changed; inspect and preserve it before claiming another task.");
+    }
+    if (git3("status", "--porcelain", "--untracked-files=normal")) {
+      throw new Error("Saved worktree has unfinished changes; preserve or finish them before claiming another task.");
+    }
+    const head = execFileSync8("git", ["rev-parse", "HEAD"], { cwd: this.coordDb.repoRoot, encoding: "utf8" }).trim();
+    if (git3("rev-parse", "HEAD") !== head) {
+      throw new Error("Saved worktree is ahead or behind the current checkout; integrate or replace it explicitly before claiming another task.");
+    }
+    return { agentId, worktreePath: root, branch: agent.branch, hydrationMethod: "none", hydratedDirs: [], durationMs: 0 };
+  }
+  async claimNextTaskWhenAvailable(params) {
+    return this.waitForOwnedClaim(params, () => this.claimNextTask(params));
   }
   async beginWorkWhenAvailable(params) {
     return this.waitForOwnedClaim(params, () => this.beginWork(params));
@@ -3704,118 +4213,6 @@ ${lines.join("\n")}` : "";
     this.coordDb.close();
   }
 };
-
-// src/core/observation.ts
-import fs13 from "fs";
-import os from "os";
-import path12 from "path";
-import { createRequire as createRequire2 } from "module";
-var { DatabaseSync: DatabaseSync2 } = createRequire2(import.meta.url)("node:sqlite");
-function readCoordinationState(directory = process.cwd(), options = {}) {
-  const layout = discoverRepository(directory), observedAt = Date.now();
-  const empty = {
-    protocolVersion: KITH_PROTOCOL_VERSION,
-    observedAt,
-    repository: { root: layout.checkoutRoot, commonGitDir: layout.commonGitDir, coordDir: layout.coordDir },
-    runtime: { node: process.version },
-    state: "missing",
-    error: void 0,
-    fencingEpoch: 0,
-    agents: [],
-    tasks: [],
-    locks: [],
-    conflicts: [],
-    contracts: [],
-    resources: [],
-    mergeQueue: [],
-    quarantined: [],
-    mutexWaiters: [],
-    commandGuards: [],
-    events: [],
-    workspaces: []
-  };
-  let scratch, db;
-  try {
-    const file = path12.join(layout.coordDir, "state.db");
-    if (physicalPath(layout.coordDir) !== layout.coordDir || physicalPath(file) !== file) throw new Error("Coordination state must not be a symlink");
-    for (let current = fs13.realpathSync.native(directory); isWithin(layout.checkoutRoot, current); current = path12.dirname(current)) {
-      const local = path12.join(current, ".coord");
-      if (local !== layout.coordDir && fs13.existsSync(path12.join(local, "state.db"))) throw new Error(`Legacy independent state at ${local}; preserve it before consolidation`);
-      if (current === layout.checkoutRoot) break;
-    }
-    if (!fs13.existsSync(file)) {
-      if (["setup.lock", "merge-train.lock"].some((name) => fs13.existsSync(path12.join(layout.coordDir, name))) || ["-wal", "-shm", "-journal"].some((s) => fs13.existsSync(file + s)) || ["worktrees", "quarantine", "snapshots", "shadow-index", "setup"].some((name) => {
-        const p = path12.join(layout.coordDir, name);
-        return fs13.existsSync(p) && (!fs13.lstatSync(p).isDirectory() || fs13.readdirSync(p).length > 0);
-      })) throw new Error("Missing database with retained sidecars; preserve the recovery set");
-      return empty;
-    }
-    const files = ["", "-wal", "-shm", "-journal"].map((s) => file + s);
-    const identity = (f) => {
-      if (!fs13.existsSync(f)) return null;
-      if (physicalPath(f) !== f || !fs13.lstatSync(f).isFile()) throw new Error("Database or sidecar is redirected or not a regular file");
-      const s = fs13.statSync(f, { bigint: true });
-      return [s.dev, s.ino, s.size, s.mtimeNs, s.ctimeNs].join(":");
-    };
-    const before = files.map(identity);
-    scratch = fs13.mkdtempSync(path12.join(os.tmpdir(), "kith-observe-"));
-    for (let i = 0; i < files.length; i++) if (before[i]) {
-      const target = path12.join(scratch, path12.basename(files[i]));
-      fs13.copyFileSync(files[i], target);
-      fs13.chmodSync(target, 384);
-    }
-    if (JSON.stringify(before) !== JSON.stringify(files.map(identity))) throw new Error("Coordination state changed during snapshot; stop writers or retry");
-    db = new DatabaseSync2(path12.join(scratch, "state.db"), { readOnly: true });
-    db.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=1000; BEGIN");
-    if (CoordDatabase.inspectSchema(db) < 2) throw new Error("Offline observation requires schema 2 or newer; preserve state and upgrade with clients stopped");
-    const all = (sql) => db.prepare(sql).all();
-    const agents = all("SELECT * FROM agents ORDER BY registered_at DESC");
-    if (options.ownersOnly) {
-      db.exec("COMMIT");
-      return { ...empty, state: "ready", agents };
-    }
-    const state = {
-      ...empty,
-      state: "ready",
-      fencingEpoch: Number(db.prepare("SELECT value FROM meta WHERE key='fencing_epoch'").get().value),
-      agents,
-      tasks: all("SELECT * FROM tasks ORDER BY priority DESC,created_at").map(({ depends_on_json, scope_globs_json, ...r }) => ({ ...r, depends_on: JSON.parse(String(depends_on_json)), scope_globs: JSON.parse(String(scope_globs_json)) })),
-      locks: all("SELECT * FROM locks ORDER BY acquired_at"),
-      conflicts: all("SELECT * FROM conflicts ORDER BY detected_at DESC").map(({ details_json, ...r }) => ({ ...r, details: JSON.parse(String(details_json)) })),
-      contracts: all("SELECT * FROM contracts ORDER BY updated_at DESC").map((r) => ({ ...r, is_breaking: Boolean(r.is_breaking) })),
-      resources: all("SELECT * FROM resources ORDER BY acquired_at"),
-      mergeQueue: all("SELECT * FROM merge_queue ORDER BY created_at DESC"),
-      quarantined: all("SELECT * FROM quarantine ORDER BY created_at DESC"),
-      mutexWaiters: all("SELECT ticket,mutex_name,owner_agent_id,session_epoch,expires_at FROM mutex_waiters ORDER BY ticket"),
-      commandGuards: all("SELECT mutex_name,owner_agent_id,worker_pid,supervisor_pid FROM mutex_runs ORDER BY mutex_name"),
-      events: all("SELECT * FROM events ORDER BY id DESC LIMIT 100").map(({ payload_json, ...r }) => ({ ...r, payload: JSON.parse(String(payload_json)) })),
-      workspaces: observeWorkspaces(layout.checkoutRoot, agents, observedAt)
-    };
-    db.exec("COMMIT");
-    return state;
-  } catch (error) {
-    return { ...empty, state: "unavailable", error: error instanceof Error ? error.message : String(error) };
-  } finally {
-    db?.close();
-    if (scratch) fs13.rmSync(scratch, { recursive: true, force: true });
-  }
-}
-function recoveryReport(directory = process.cwd()) {
-  const state = readCoordinationState(directory), retainedRoot = path12.join(state.repository.coordDir, "worktrees");
-  const retained = physicalPath(retainedRoot) === retainedRoot && fs13.existsSync(retainedRoot) && fs13.lstatSync(retainedRoot).isDirectory() && !fs13.lstatSync(retainedRoot).isSymbolicLink() ? fs13.readdirSync(retainedRoot, { withFileTypes: true }).map((entry) => ({
-    path: path12.join(retainedRoot, entry.name),
-    symlink: entry.isSymbolicLink(),
-    agentIds: state.agents.filter((a) => a.worktree_path === path12.join(retainedRoot, entry.name)).map((a) => a.id)
-  })) : [];
-  return {
-    ...state,
-    retainedWorktrees: retained,
-    expiredClaims: state.locks.filter((lock) => Number(lock.expires_at) <= state.observedAt),
-    unfinishedIntegrations: state.mergeQueue.filter((entry) => entry.status !== "merged"),
-    setupLock: { path: path12.join(state.repository.coordDir, "setup.lock"), present: fs13.existsSync(path12.join(state.repository.coordDir, "setup.lock")) },
-    integrationLock: { path: path12.join(state.repository.coordDir, "merge-train.lock"), present: fs13.existsSync(path12.join(state.repository.coordDir, "merge-train.lock")) }
-  };
-}
 export {
   AstAnalyzer,
   BashMerkleGuard,
@@ -3833,8 +4230,10 @@ export {
   ShadowGitEngine,
   SpeculativeMergeTrain,
   StaleFencingTokenError,
+  buildSwarmPrompts,
   caseSensitivePaths,
   discoverRepository,
+  inspectWorkspaceContracts,
   isWithin,
   observeWorkspaces,
   physicalPath,
@@ -3842,6 +4241,7 @@ export {
   readCoordinationState,
   recoveryReport,
   repositoryFile,
+  verifyCrossRepoImportsForFile,
   worktreeChanges
 };
 //# sourceMappingURL=index.js.map