kith-coord 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,3708 @@
+// src/version.ts
+var KITH_VERSION = "0.1.0";
+var KITH_PROTOCOL_VERSION = "1.0.0";
+
+// src/core/workspace-observation.ts
+import { execFileSync as execFileSync2, spawnSync } from "child_process";
+
+// src/core/repository.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+function physicalPath(input) {
+  const absolute = path.isAbsolute(input) ? input : process.cwd() + path.sep + input;
+  let current = path.parse(absolute).root;
+  for (const component of absolute.slice(current.length).split(path.sep)) {
+    if (!component || component === ".") continue;
+    if (component === "..") {
+      current = path.dirname(current);
+      continue;
+    }
+    const candidate = path.join(current, component);
+    try {
+      fs.lstatSync(candidate);
+      current = fs.realpathSync.native(candidate);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      try {
+        fs.lstatSync(candidate);
+        throw new Error(`Unresolved symlink: ${candidate}`);
+      } catch (statError) {
+        if (statError.code !== "ENOENT") throw statError;
+      }
+      current = candidate;
+    }
+  }
+  return current;
+}
+function isWithin(root, target) {
+  const relative = path.relative(root, target);
+  return relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative);
+}
+function repositoryFile(root, file) {
+  if (!file || /[\\\x00-\x1f\x7f]/u.test(file)) throw new Error(`Invalid file path: ${file}`);
+  const canonicalRoot = physicalPath(root);
+  const target = physicalPath(path.isAbsolute(file) ? file : canonicalRoot + path.sep + file);
+  if (!isWithin(canonicalRoot, target) || target === canonicalRoot) {
+    throw new Error(`File is outside repository: ${file}`);
+  }
+  return path.relative(canonicalRoot, target).split(path.sep).join("/");
+}
+function discoverRepository(input) {
+  const directory = fs.realpathSync.native(input);
+  if (!fs.statSync(directory).isDirectory()) throw new Error(`Not a directory: ${input}`);
+  const git2 = (...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"));
+    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 coordDir = path.basename(commonGitDir) === ".git" ? path.join(path.dirname(commonGitDir), ".coord") : path.join(commonGitDir, "kith");
+    return { checkoutRoot, commonGitDir, coordDir, isLinkedWorktree };
+  } catch (error) {
+    const markerExists = (file) => {
+      try {
+        fs.lstatSync(file);
+        return true;
+      } catch (failure) {
+        if (failure.code === "ENOENT") return false;
+        throw failure;
+      }
+    };
+    for (let current = directory; ; current = path.dirname(current)) {
+      if (markerExists(path.join(current, ".git")) || fs.existsSync(path.join(current, "HEAD")) && fs.existsSync(path.join(current, "objects"))) {
+        throw new Error(`Cannot discover Git repository at ${directory}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      if (path.dirname(current) === current) break;
+    }
+    if (process.env.GIT_DIR || process.env.GIT_WORK_TREE || process.env.GIT_COMMON_DIR) throw error;
+    return { checkoutRoot: directory, commonGitDir: null, coordDir: path.join(directory, ".coord"), isLinkedWorktree: false };
+  }
+}
+function caseSensitivePaths(root) {
+  for (let current = physicalPath(root); path.dirname(current) !== current; current = path.dirname(current)) {
+    const name = path.basename(current);
+    const variant = name.replace(/[a-zA-Z]/, (c) => c === c.toLowerCase() ? c.toUpperCase() : c.toLowerCase());
+    if (variant === name) continue;
+    try {
+      const original = fs.statSync(current);
+      const alias = fs.statSync(path.join(path.dirname(current), variant));
+      return original.dev !== alias.dev || original.ino !== alias.ino;
+    } catch (error) {
+      if (error.code === "ENOENT") return true;
+      return false;
+    }
+  }
+  return false;
+}
+
+// src/core/workspace-observation.ts
+function git(cwd, ...args) {
+  return execFileSync2("git", ["-c", "core.fsmonitor=false", ...args], {
+    cwd,
+    encoding: "utf8",
+    env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 5e3,
+    maxBuffer: 4 * 1024 * 1024
+  });
+}
+function worktreeChanges(cwd) {
+  const records = git(cwd, "status", "--porcelain=v1", "-z", "--untracked-files=all").split("\0");
+  const changes = [];
+  for (let i = 0; i < records.length; i++) {
+    const record = records[i];
+    if (!record) continue;
+    const change = { status: record.slice(0, 2), path: record.slice(3) };
+    if (/[RC]/.test(change.status)) change.originalPath = records[++i];
+    changes.push(change);
+  }
+  return changes;
+}
+function observeWorkspaces(repoRoot, agents, now = Date.now()) {
+  let base = null;
+  try {
+    base = git(repoRoot, "rev-parse", "--verify", "HEAD").trim();
+  } catch {
+  }
+  const workspaces = agents.filter((a) => a.worktree_path || a.status === "active").map((a) => {
+    const result = {
+      agentId: a.id,
+      path: a.worktree_path ?? repoRoot,
+      recordedBranch: a.branch,
+      status: a.status,
+      leaseExpired: a.lease_expires_at <= now,
+      lastHeartbeatAt: a.last_heartbeat_at,
+      available: false,
+      branch: null,
+      head: null,
+      comparisonBase: base,
+      dirtyFiles: [],
+      lastCommitAt: null,
+      hoursSinceLastCommit: null,
+      ahead: null,
+      behind: null,
+      overlaps: []
+    };
+    try {
+      if (discoverRepository(result.path).commonGitDir !== discoverRepository(repoRoot).commonGitDir) throw new Error("Workspace belongs to another repository");
+      result.dirtyFiles = worktreeChanges(result.path);
+      result.head = git(result.path, "rev-parse", "--verify", "HEAD").trim();
+      result.branch = git(result.path, "branch", "--show-current").trim() || null;
+      result.lastCommitAt = Number(git(result.path, "show", "-s", "--format=%ct", "HEAD").trim()) * 1e3;
+      result.hoursSinceLastCommit = Math.max(0, now - result.lastCommitAt) / 36e5;
+      if (base) {
+        const [behind, ahead] = git(result.path, "rev-list", "--left-right", "--count", `${base}...${result.head}`).trim().split(/\s+/).map(Number);
+        result.ahead = ahead;
+        result.behind = behind;
+      }
+      result.available = true;
+    } catch (error) {
+      result.error = error instanceof Error ? error.message : String(error);
+    }
+    return result;
+  });
+  for (const workspace of workspaces) {
+    if (!workspace.available) continue;
+    const files = new Set(workspace.dirtyFiles.flatMap((c) => [c.path, ...c.originalPath ? [c.originalPath] : []]));
+    for (const file of files) {
+      const peers = workspaces.filter((peer) => peer.agentId !== workspace.agentId && peer.status === "active" && peer.available && peer.dirtyFiles.some((c) => c.path === file || c.originalPath === file)).map((peer) => peer.agentId);
+      if (peers.length) workspace.overlaps.push({ path: file, agentIds: peers });
+    }
+  }
+  return workspaces;
+}
+function previewIntegration(repoRoot, agent) {
+  if (!agent.worktree_path || !agent.branch) throw new Error("Integration preview requires a registered worktree and branch");
+  const source = discoverRepository(agent.worktree_path), target = discoverRepository(repoRoot);
+  if (source.checkoutRoot !== physicalPath(agent.worktree_path) || source.commonGitDir !== target.commonGitDir || git(agent.worktree_path, "branch", "--show-current").trim() !== agent.branch.replace(/^refs\/heads\//, "")) {
+    throw new Error("Registered source checkout repository or branch does not match");
+  }
+  const sourceHead = git(agent.worktree_path, "rev-parse", "--verify", "HEAD").trim();
+  const targetHead = git(repoRoot, "rev-parse", "--verify", "HEAD").trim();
+  const dirtyFiles = worktreeChanges(agent.worktree_path);
+  const targetDirtyFiles = worktreeChanges(repoRoot).filter((change) => !(change.status === "??" && target.coordDir === target.checkoutRoot + "/.coord" && change.path.startsWith(".coord/")));
+  const sourceBranch = git(agent.worktree_path, "branch", "--show-current").trim(), targetBranch = git(repoRoot, "branch", "--show-current").trim();
+  if (!targetBranch) throw new Error("Integration target must be on a branch");
+  if (targetDirtyFiles.length) return { ok: false, clean: null, sourceHead, targetHead, sourceBranch, targetBranch, conflicts: [], dirtyFiles, targetDirtyFiles, reason: "Integration target has local changes. Preserve or commit them before preview." };
+  if (dirtyFiles.length) return {
+    ok: false,
+    clean: null,
+    sourceHead,
+    targetHead,
+    sourceBranch,
+    targetBranch,
+    conflicts: [],
+    dirtyFiles,
+    targetDirtyFiles,
+    reason: "Commit or preserve source changes before preview. Uncommitted edits are not included in a committed-tree preview."
+  };
+  const drivers = spawnSync("git", ["config", "--get-regexp", "^merge\\..*\\.driver$"], {
+    cwd: repoRoot,
+    encoding: "utf8",
+    timeout: 5e3,
+    maxBuffer: 4 * 1024 * 1024
+  });
+  if (drivers.error || drivers.status !== 0 && drivers.status !== 1) throw new Error("Cannot inspect merge-driver configuration safely");
+  if (drivers.status === 0) throw new Error("Integration preview is unavailable with configured custom merge drivers; they can execute commands");
+  const probe = spawnSync("git", ["merge-tree", "--write-tree", "-z", targetHead, sourceHead], {
+    cwd: repoRoot,
+    encoding: "utf8",
+    env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
+    timeout: 1e4,
+    maxBuffer: 4 * 1024 * 1024
+  });
+  if (probe.error || probe.status !== 0 && probe.status !== 1) throw new Error(`Git integration preview failed: ${probe.error?.message ?? probe.stderr}`);
+  const stages = probe.stdout.split("\0").slice(1);
+  const boundary = stages.indexOf("");
+  const conflicts = [...new Set(stages.slice(0, boundary < 0 ? stages.length : boundary).flatMap((record) => {
+    const match = /^\d{6} [0-9a-f]+ [123]\t([\s\S]+)$/.exec(record);
+    return match ? [match[1]] : [];
+  }))];
+  if (probe.status === 1 && !conflicts.length) throw new Error("Git returned a conflict without identifiable paths; preview is unavailable");
+  if (git(repoRoot, "rev-parse", "HEAD").trim() !== targetHead || git(agent.worktree_path, "rev-parse", "HEAD").trim() !== sourceHead || git(repoRoot, "branch", "--show-current").trim() !== targetBranch || git(agent.worktree_path, "branch", "--show-current").trim() !== sourceBranch || worktreeChanges(repoRoot).some((change) => !(change.status === "??" && target.coordDir === target.checkoutRoot + "/.coord" && change.path.startsWith(".coord/"))) || worktreeChanges(agent.worktree_path).length) throw new Error("Source or target changed during preview; retry");
+  return { ok: true, clean: probe.status === 0, sourceHead, targetHead, sourceBranch, targetBranch, conflicts, dirtyFiles, targetDirtyFiles, verified: false };
+}
+
+// src/core/engine.ts
+import fs12 from "fs";
+import path10 from "path";
+
+// src/core/ast-analyzer.ts
+import crypto from "crypto";
+import fs2 from "fs";
+import path2 from "path";
+var AstAnalyzer = class _AstAnalyzer {
+  /**
+   * Analyzes a source file's content to extract exported contracts (functions, types,
+   * interfaces, schemas, routes) and imported module dependencies.
+   */
+  static analyzeSource(repoRoot, filePath, sourceContent) {
+    const relPath = repositoryFile(repoRoot, filePath);
+    const absPath = path2.join(repoRoot, relPath);
+    const content = sourceContent ?? (fs2.existsSync(absPath) ? fs2.readFileSync(absPath, "utf8") : "");
+    const fileHash = crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+    const exports = _AstAnalyzer.extractExports(content);
+    const imports = _AstAnalyzer.extractImports(repoRoot, relPath, content);
+    return {
+      filePath: relPath,
+      fileHash,
+      exports,
+      imports
+    };
+  }
+  static extractExports(content) {
+    const results = /* @__PURE__ */ new Map();
+    const lines = content.split(/\r?\n/);
+    const getPrecedingDoc = (lineIndex) => {
+      const comments = [];
+      let i = lineIndex - 1;
+      while (i >= 0) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*") || trimmed.startsWith("*/") || trimmed.startsWith("#")) {
+          comments.unshift(
+            trimmed.replace(/^(\/\/+|\/\*+|\*+\/|#|\*)\s?/, "").trim()
+          );
+          i--;
+        } else if (trimmed === "") {
+          break;
+        } else {
+          break;
+        }
+      }
+      return comments.filter(Boolean).join(" ").slice(0, 240);
+    };
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*")) continue;
+      const fnMatch = trimmed.match(
+        /^export\s+(?:default\s+)?(?:async\s+)?function\s+([A-Za-z0-9_$]+)\s*(?:<[^>]*>)?\s*\(([^)]*)\)\s*(?::\s*([^{;]+))?/
+      );
+      if (fnMatch) {
+        const [, name, rawParams, rawReturn] = fnMatch;
+        const cleanReturn = (rawReturn ?? "unknown").trim();
+        const sig = `function ${name}(${_AstAnalyzer.normalizeWhitespace(rawParams)}): ${cleanReturn}`;
+        const kind = /^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)$/.test(name) ? "route" : "function";
+        results.set(name, {
+          symbolName: name,
+          kind,
+          signature: sig,
+          astHash: _AstAnalyzer.hashSignature(sig),
+          paramsFingerprint: _AstAnalyzer.computeParamsFingerprint(rawParams, cleanReturn),
+          docComment: getPrecedingDoc(i)
+        });
+        continue;
+      }
+      const arrowMatch = trimmed.match(
+        /^export\s+const\s+([A-Za-z0-9_$]+)\s*(?::\s*[^=]+)?=\s*(?:async\s+)?(?:\(([^)]*)\)|([A-Za-z0-9_$]+))\s*(?::\s*([^=]+?))?\s*=>/
+      );
+      if (arrowMatch) {
+        const [, name, tupleParams, singleParam, rawReturn] = arrowMatch;
+        const rawParams = tupleParams ?? singleParam ?? "";
+        const cleanReturn = (rawReturn ?? "unknown").trim();
+        const sig = `function ${name}(${_AstAnalyzer.normalizeWhitespace(rawParams)}): ${cleanReturn}`;
+        results.set(name, {
+          symbolName: name,
+          kind: "function",
+          signature: sig,
+          astHash: _AstAnalyzer.hashSignature(sig),
+          paramsFingerprint: _AstAnalyzer.computeParamsFingerprint(rawParams, cleanReturn),
+          docComment: getPrecedingDoc(i)
+        });
+        continue;
+      }
+      const ifaceMatch = trimmed.match(
+        /^export\s+interface\s+([A-Za-z0-9_$]+)(?:\s*<[^>]*>)?(?:\s+extends\s+[^{]+)?\s*\{/
+      );
+      if (ifaceMatch) {
+        const name = ifaceMatch[1];
+        const bodyFields = _AstAnalyzer.extractBracedBlockSummary(lines, i);
+        const sig = `interface ${name} { ${bodyFields} }`;
+        results.set(name, {
+          symbolName: name,
+          kind: "interface",
+          signature: sig,
+          astHash: _AstAnalyzer.hashSignature(sig),
+          paramsFingerprint: `interface:${_AstAnalyzer.extractFieldTypesFingerprint(bodyFields)}`,
+          docComment: getPrecedingDoc(i)
+        });
+        continue;
+      }
+      const typeMatch = trimmed.match(/^export\s+type\s+([A-Za-z0-9_$]+)(?:\s*<[^>]*>)?\s*=\s*(.+)$/);
+      if (typeMatch) {
+        const [, name, rhs] = typeMatch;
+        const fullRhs = rhs.includes("{") && !rhs.includes("}") ? `{ ${_AstAnalyzer.extractBracedBlockSummary(lines, i)} }` : rhs.replace(/;$/, "").trim();
+        const sig = `type ${name} = ${_AstAnalyzer.normalizeWhitespace(fullRhs)}`;
+        results.set(name, {
+          symbolName: name,
+          kind: "type",
+          signature: sig,
+          astHash: _AstAnalyzer.hashSignature(sig),
+          paramsFingerprint: `type:${_AstAnalyzer.normalizeWhitespace(fullRhs)}`,
+          docComment: getPrecedingDoc(i)
+        });
+        continue;
+      }
+      const classMatch = trimmed.match(
+        /^export\s+(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z0-9_$]+)/
+      );
+      if (classMatch) {
+        const name = classMatch[1];
+        const sig = `class ${name}`;
+        results.set(name, {
+          symbolName: name,
+          kind: "class",
+          signature: sig,
+          astHash: _AstAnalyzer.hashSignature(sig),
+          paramsFingerprint: `class:${name}`,
+          docComment: getPrecedingDoc(i)
+        });
+        continue;
+      }
+      const constMatch = trimmed.match(
+        /^export\s+const\s+([A-Za-z0-9_$]+)\s*(?::\s*([^=]+))?\s*=\s*(.+)$/
+      );
+      if (constMatch) {
+        const [, name, explicitType, rhs] = constMatch;
+        const isSchema = /Schema$|z\.|pgTable|sqliteTable|mysqlTable/.test(name + rhs);
+        const kind = isSchema ? "schema" : "const";
+        const sig = `const ${name}: ${(explicitType ?? rhs.slice(0, 60)).replace(/;$/, "").trim()}`;
+        results.set(name, {
+          symbolName: name,
+          kind,
+          signature: sig,
+          astHash: _AstAnalyzer.hashSignature(sig),
+          paramsFingerprint: `${kind}:${name}`,
+          docComment: getPrecedingDoc(i)
+        });
+        continue;
+      }
+      const pyFnMatch = line.match(
+        /^(?:async\s+)?def\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s*(?:->\s*([^:]+))?:/
+      );
+      if (pyFnMatch && !pyFnMatch[1].startsWith("_")) {
+        const [, name, rawParams, rawRet] = pyFnMatch;
+        const ret = (rawRet ?? "Any").trim();
+        const sig = `def ${name}(${_AstAnalyzer.normalizeWhitespace(rawParams)}) -> ${ret}`;
+        results.set(name, {
+          symbolName: name,
+          kind: "function",
+          signature: sig,
+          astHash: _AstAnalyzer.hashSignature(sig),
+          paramsFingerprint: _AstAnalyzer.computeParamsFingerprint(rawParams, ret),
+          docComment: getPrecedingDoc(i)
+        });
+      }
+    }
+    return Array.from(results.values());
+  }
+  static extractImports(repoRoot, sourceRelPath, content) {
+    const imports = [];
+    const importRegex = /(?:import\s+(?:type\s+)?(?:(\{[^}]*\})|([A-Za-z0-9_$*]+))?\s*(?:,\s*(\{[^}]*\}))?\s*from\s+['"]([^'"]+)['"]|export\s+(?:\*|\{[^}]*\})\s+from\s+['"]([^'"]+)['"]|require\(\s*['"]([^'"]+)['"]\s*\))/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const namedBlock = match[1] ?? match[3] ?? "";
+      const defaultIdent = match[2] ?? "";
+      const specifier = match[4] ?? match[5] ?? match[6] ?? "";
+      if (!specifier) continue;
+      const symbols = [];
+      if (defaultIdent) symbols.push(defaultIdent.trim());
+      if (namedBlock) {
+        const inner = namedBlock.replace(/[{}]/g, "");
+        for (const part of inner.split(",")) {
+          const clean = part.trim().split(/\s+as\s+/)[0].replace(/^type\s+/, "").trim();
+          if (clean) symbols.push(clean);
+        }
+      }
+      const resolvedPath = _AstAnalyzer.resolveRelativeImport(
+        repoRoot,
+        sourceRelPath,
+        specifier
+      );
+      imports.push({
+        rawSpecifier: specifier,
+        resolvedPath,
+        importedSymbols: symbols
+      });
+    }
+    return imports;
+  }
+  static resolveRelativeImport(repoRoot, sourceRelPath, specifier) {
+    if (!specifier.startsWith(".")) {
+      return null;
+    }
+    const sourceDir = path2.dirname(path2.join(repoRoot, sourceRelPath));
+    const baseTarget = path2.resolve(sourceDir, specifier.replace(/\.(js|jsx|mjs|cjs)$/, ""));
+    const candidates = [
+      path2.resolve(sourceDir, specifier),
+      `${baseTarget}.ts`,
+      `${baseTarget}.tsx`,
+      `${baseTarget}.js`,
+      `${baseTarget}.mjs`,
+      path2.join(baseTarget, "index.ts"),
+      path2.join(baseTarget, "index.tsx"),
+      path2.join(baseTarget, "index.js")
+    ];
+    for (const candidate of candidates) {
+      if (fs2.existsSync(candidate) && fs2.statSync(candidate).isFile()) {
+        try {
+          return repositoryFile(repoRoot, candidate);
+        } catch {
+          return null;
+        }
+      }
+    }
+    const inferred = `${baseTarget}.ts`;
+    try {
+      return repositoryFile(repoRoot, inferred);
+    } catch {
+      return null;
+    }
+  }
+  static extractBracedBlockSummary(lines, startIndex) {
+    const fields = [];
+    let depth = 0;
+    for (let i = startIndex; i < Math.min(lines.length, startIndex + 35); i++) {
+      const line = lines[i];
+      for (const ch of line) {
+        if (ch === "{") depth++;
+        else if (ch === "}") depth--;
+      }
+      if (i > startIndex && depth >= 1) {
+        const clean = line.trim().replace(/;$/, "").replace(/,$/, "");
+        if (clean && !clean.startsWith("//") && clean !== "}") {
+          fields.push(clean);
+        }
+      }
+      if (depth <= 0 && i >= startIndex && line.includes("}")) {
+        break;
+      }
+    }
+    return fields.join("; ");
+  }
+  static extractFieldTypesFingerprint(bodyFields) {
+    return bodyFields.split(";").map((f) => {
+      const parts = f.split(":");
+      return parts.length > 1 ? parts[1].trim().toLowerCase() : f.trim().toLowerCase();
+    }).filter(Boolean).sort().join(",");
+  }
+  static computeParamsFingerprint(rawParams, rawReturn) {
+    const paramTypes = rawParams.split(",").map((p) => p.trim()).filter(Boolean).map((p) => {
+      const colonIdx = p.indexOf(":");
+      if (colonIdx === -1) return "any";
+      return p.slice(colonIdx + 1).replace(/=.*$/, "").trim().toLowerCase();
+    });
+    const retNorm = rawReturn.replace(/^Promise<(.+)>$/, "$1").trim().toLowerCase();
+    return `(${paramTypes.join(",")})->${retNorm}`;
+  }
+  static normalizeWhitespace(s) {
+    return s.replace(/\s+/g, " ").trim();
+  }
+  static hashSignature(sig) {
+    return crypto.createHash("sha256").update(sig).digest("hex").slice(0, 16);
+  }
+};
+
+// src/core/bash-guard.ts
+import crypto4 from "crypto";
+import fs5 from "fs";
+import path4 from "path";
+
+// src/core/locks.ts
+import crypto3 from "crypto";
+import fs4 from "fs";
+import path3 from "path";
+
+// src/core/glob.ts
+function scopeSegments(pattern, literal = false) {
+  if (!pattern || pattern.length > 512 || (literal ? /[\x00-\x1f\x7f\\]/u : /[\x00-\x1f\x7f\\[\]{}()!]/u).test(pattern)) {
+    throw new Error(`Unsupported scope syntax: ${pattern}`);
+  }
+  const segments = pattern.split("/");
+  if (segments.length > 64 || segments.some((s) => !s || s === "." || s === ".." || !literal && s.includes("**") && s !== "**")) {
+    throw new Error(`Invalid scope segments: ${pattern}`);
+  }
+  return segments;
+}
+function segmentsOverlap(a, b, literalA, literalB) {
+  const STAR = /* @__PURE__ */ Symbol("star"), ANY = /* @__PURE__ */ Symbol("any");
+  const tokens = (text, literal) => Array.from(text).map((c) => !literal && c === "*" ? STAR : !literal && c === "?" ? ANY : c);
+  const left = tokens(a, literalA), right = tokens(b, literalB);
+  const queue = [[0, 0, 0]];
+  const seen = /* @__PURE__ */ new Set();
+  for (let q = 0; q < queue.length; q++) {
+    const [i, j, kind] = queue[q];
+    const key = `${i},${j},${kind}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (i === left.length && j === right.length && kind === 3) return true;
+    const x = left[i], y = right[j];
+    if (x === STAR) queue.push([i + 1, j, kind]);
+    if (y === STAR) queue.push([i, j + 1, kind]);
+    if (x === void 0 || y === void 0) continue;
+    const anyX = x === STAR || x === ANY, anyY = y === STAR || y === ANY;
+    if (!anyX && !anyY && x !== y) continue;
+    const literal = !anyX ? x : !anyY ? y : void 0;
+    const nextI = x === STAR ? i : i + 1, nextJ = y === STAR ? j : j + 1;
+    if (literal === void 0 || literal === ".") {
+      queue.push([nextI, nextJ, kind === 0 ? 1 : kind === 1 ? 2 : 3]);
+    }
+    if (literal === void 0 || literal !== ".") queue.push([nextI, nextJ, 3]);
+  }
+  return false;
+}
+function scopesOverlap(a, b, literalA = false, literalB = false) {
+  const left = scopeSegments(a, literalA), right = scopeSegments(b, literalB);
+  const queue = [[0, 0, false]];
+  const seen = /* @__PURE__ */ new Set();
+  const memo = /* @__PURE__ */ new Map();
+  for (let q = 0; q < queue.length; q++) {
+    const [i, j, consumed] = queue[q];
+    const key = `${i},${j},${consumed}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (i === left.length && j === right.length && consumed) return true;
+    const x = left[i], y = right[j];
+    const starA = !literalA && x === "**", starB = !literalB && y === "**";
+    if (starA) queue.push([i + 1, j, consumed]);
+    if (starB) queue.push([i, j + 1, consumed]);
+    if (x === void 0 || y === void 0) continue;
+    const pair = JSON.stringify([x, y]);
+    let overlap = memo.get(pair);
+    if (overlap === void 0) {
+      overlap = segmentsOverlap(starA ? "*" : x, starB ? "*" : y, starA ? false : literalA, starB ? false : literalB);
+      memo.set(pair, overlap);
+    }
+    if (overlap) queue.push([starA ? i : i + 1, starB ? j : j + 1, true]);
+  }
+  return false;
+}
+
+// src/core/fencing.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import crypto2 from "crypto";
+import fs3 from "fs";
+var SessionOwnershipError = class extends Error {
+  constructor(agentId) {
+    super(`No valid active session capability for '${agentId}'. Start a session, or resume it with its session token.`);
+    this.name = "SessionOwnershipError";
+  }
+};
+var StaleFencingTokenError = class extends Error {
+  constructor(resourceId, providedToken, expectedToken) {
+    super(`Fencing token mismatch for '${resourceId}': provided ${providedToken}, expected ${expectedToken}.`);
+    this.resourceId = resourceId;
+    this.providedToken = providedToken;
+    this.expectedToken = expectedToken;
+    this.name = "StaleFencingTokenError";
+  }
+  resourceId;
+  providedToken;
+  expectedToken;
+};
+var FencingAndAgentManager = class _FencingAndAgentManager {
+  constructor(coordDb) {
+    this.coordDb = coordDb;
+  }
+  coordDb;
+  static DEFAULT_LEASE_MS = 5 * 60 * 1e3;
+  capabilities = /* @__PURE__ */ new Map();
+  static validateLease(duration) {
+    if (!Number.isSafeInteger(duration) || duration < 100 || duration > 864e5) {
+      throw new Error("Lease duration must be an integer between 100 and 86400000 milliseconds");
+    }
+    return duration;
+  }
+  /** A real kernel process identity; tests must not supply liveness sentinels. */
+  static getProcessStartTime(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0) return null;
+    try {
+      if (process.platform === "linux") {
+        const stat = fs3.readFileSync(`/proc/${pid}/stat`, "utf8");
+        return `linux:${stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]}`;
+      }
+      const out = execFileSync3("ps", ["-o", "lstart=", "-p", String(pid)], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1500,
+        env: { ...process.env, LC_ALL: "C" }
+      }).trim();
+      return out || null;
+    } catch {
+      return null;
+    }
+  }
+  static isProcessAlive(pid, expectedStartTime) {
+    if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+    try {
+      process.kill(pid, 0);
+    } catch (err) {
+      if (err.code === "ESRCH") return false;
+    }
+    const current = this.getProcessStartTime(pid);
+    return current === null || current === expectedStartTime;
+  }
+  registerAgent(params) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/.test(params.id)) throw new Error("Invalid agent ID");
+    const leaseMs = _FencingAndAgentManager.validateLease(params.leaseDurationMs ?? _FencingAndAgentManager.DEFAULT_LEASE_MS);
+    this.reapDeadAgents();
+    return this.coordDb.withTransaction(() => {
+      const existing = this.getAgent(params.id);
+      const supplied = params.sessionToken ?? this.capabilities.get(params.id);
+      if (existing?.status === "active") {
+        const epoch2 = this.assertSession(params.id, supplied);
+        this.capabilities.set(params.id, supplied);
+        this.heartbeat(params.id, leaseMs);
+        return { agent: this.getAgent(params.id), fencingToken: epoch2, sessionToken: supplied, sessionEpoch: epoch2 };
+      }
+      if (params.sessionToken !== void 0) throw new SessionOwnershipError(params.id);
+      const pid = params.pid ?? process.pid;
+      const start = _FencingAndAgentManager.getProcessStartTime(pid);
+      if (!start) throw new Error(`Cannot determine start time of live session owner PID ${pid}`);
+      const now = Date.now();
+      const epoch = this.coordDb.nextFencingToken();
+      const token = crypto2.randomBytes(32).toString("base64url");
+      const latest = this.coordDb.db.prepare("SELECT COALESCE(MAX(id), 0) AS id FROM events").get().id;
+      this.coordDb.db.prepare(`
+        INSERT INTO agents (id, name, client, pid, pid_start_time, pgid, worktree_path, branch,
+          shadow_tree_sha, status, last_seen_event_id, registered_at, last_heartbeat_at, lease_expires_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, 'active', ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET name=excluded.name, client=excluded.client, pid=excluded.pid,
+          pid_start_time=excluded.pid_start_time, pgid=excluded.pgid, status='active',
+          worktree_path=COALESCE(agents.worktree_path, excluded.worktree_path),
+          shadow_tree_sha=NULL, last_seen_event_id=excluded.last_seen_event_id,
+          registered_at=excluded.registered_at, last_heartbeat_at=excluded.last_heartbeat_at,
+          lease_expires_at=excluded.lease_expires_at
+      `).run(
+        params.id,
+        params.name ?? existing?.name ?? params.id,
+        params.client ?? "unknown",
+        pid,
+        start,
+        params.pgid ?? pid,
+        params.worktreePath ?? (this.coordDb.isLinkedWorktree ? this.coordDb.repoRoot : null),
+        params.branch ?? null,
+        latest,
+        now,
+        now,
+        now + leaseMs
+      );
+      this.coordDb.db.prepare("INSERT OR REPLACE INTO agent_sessions(agent_id, token_hash, epoch) VALUES (?, ?, ?)").run(params.id, this.hash(token), epoch);
+      this.capabilities.set(params.id, token);
+      this.coordDb.logEvent(params.id, "agent_registered", { client: params.client ?? "unknown", pid, sessionEpoch: epoch });
+      return { agent: this.getAgent(params.id), fencingToken: epoch, sessionToken: token, sessionEpoch: epoch };
+    });
+  }
+  resumeSession(agentId, sessionToken) {
+    const epoch = this.assertSession(agentId, sessionToken);
+    this.capabilities.set(agentId, sessionToken);
+    return epoch;
+  }
+  assertSession(agentId, sessionToken = this.capabilities.get(agentId)) {
+    const agent = this.getAgent(agentId);
+    const session = this.coordDb.db.prepare("SELECT token_hash, epoch FROM agent_sessions WHERE agent_id = ?").get(agentId);
+    if (!agent || agent.status !== "active" || agent.lease_expires_at <= Date.now() || !session || !sessionToken || this.hash(sessionToken) !== session.token_hash || !_FencingAndAgentManager.isProcessAlive(agent.pid, agent.pid_start_time)) {
+      throw new SessionOwnershipError(agentId);
+    }
+    return session.epoch;
+  }
+  sessionEnvironment(agentId) {
+    this.assertSession(agentId);
+    return { ...process.env, KITH_AGENT_ID: agentId, KITH_SESSION_TOKEN: this.capabilities.get(agentId) };
+  }
+  heartbeat(agentId, leaseDurationMs = _FencingAndAgentManager.DEFAULT_LEASE_MS) {
+    const lease = _FencingAndAgentManager.validateLease(leaseDurationMs);
+    return this.coordDb.withTransaction(() => {
+      this.assertSession(agentId);
+      const now = Date.now();
+      const expires = now + lease;
+      this.coordDb.db.prepare("UPDATE agents SET last_heartbeat_at=?, lease_expires_at=? WHERE id=?").run(now, expires, agentId);
+      this.coordDb.db.prepare("UPDATE locks SET expires_at=MAX(expires_at, ?) WHERE owner_agent_id=? AND expires_at>?").run(expires, agentId, now);
+      this.coordDb.db.prepare("UPDATE resources SET expires_at=MAX(expires_at, ?) WHERE type='port' AND owner_agent_id=? AND expires_at>?").run(expires, agentId, now);
+      return this.getAgent(agentId);
+    });
+  }
+  getAgent(agentId) {
+    return this.coordDb.db.prepare("SELECT * FROM agents WHERE id=?").get(agentId) ?? null;
+  }
+  listAgents(onlyActive = false) {
+    this.reapDeadAgents();
+    return this.coordDb.db.prepare(onlyActive ? "SELECT * FROM agents WHERE status='active' ORDER BY registered_at" : "SELECT * FROM agents ORDER BY registered_at DESC").all();
+  }
+  reapDeadAgents() {
+    const agents = this.coordDb.db.prepare("SELECT * FROM agents WHERE status='active'").all();
+    const liveness = /* @__PURE__ */ new Map();
+    const candidates = agents.filter((a) => {
+      const key = `${a.pid}:${a.pid_start_time}`;
+      if (!liveness.has(key)) liveness.set(key, _FencingAndAgentManager.isProcessAlive(a.pid, a.pid_start_time));
+      return a.lease_expires_at <= Date.now() || !liveness.get(key);
+    });
+    if (!candidates.length) return [];
+    return this.coordDb.withTransaction(() => {
+      const reaped = [];
+      for (const previous of candidates) {
+        const current = this.getAgent(previous.id);
+        if (!current || current.status !== "active" || current.registered_at !== previous.registered_at || current.pid !== previous.pid || current.pid_start_time !== previous.pid_start_time) continue;
+        if (current.lease_expires_at > Date.now() && _FencingAndAgentManager.isProcessAlive(current.pid, current.pid_start_time)) continue;
+        this.reclaim(current.id, "dead", "process_died_or_lease_expired");
+        reaped.push(current.id);
+      }
+      return reaped;
+    });
+  }
+  completeAgentSession(agentId) {
+    this.coordDb.withTransaction(() => {
+      this.assertSession(agentId);
+      this.reclaim(agentId, "completed", "session_completed");
+    });
+    this.capabilities.delete(agentId);
+  }
+  abandonAgentSession(agentId) {
+    this.coordDb.withTransaction(() => {
+      this.assertSession(agentId);
+      this.reclaim(agentId, "dead", "client_disconnected");
+    });
+    this.capabilities.delete(agentId);
+  }
+  reclaim(agentId, status, reason) {
+    const epoch = this.coordDb.nextFencingToken();
+    const now = Date.now();
+    this.coordDb.db.prepare("UPDATE agents SET status=?, last_heartbeat_at=? WHERE id=?").run(status, now, agentId);
+    this.coordDb.db.prepare("DELETE FROM locks WHERE owner_agent_id=?").run(agentId);
+    this.coordDb.db.prepare("DELETE FROM resources WHERE owner_agent_id=?").run(agentId);
+    this.coordDb.db.prepare("DELETE FROM mutex_waiters WHERE owner_agent_id=?").run(agentId);
+    this.coordDb.db.prepare("DELETE FROM conflicts WHERE agent_a=? OR agent_b=?").run(agentId, agentId);
+    if (status === "dead") {
+      this.coordDb.db.prepare("UPDATE tasks SET status='queued', owner_agent_id=NULL, fencing_token=NULL, updated_at=? WHERE owner_agent_id=? AND status='active'").run(now, agentId);
+    } else {
+      this.coordDb.db.prepare("UPDATE tasks SET status='done', updated_at=? WHERE owner_agent_id=? AND status='active'").run(now, agentId);
+    }
+    this.coordDb.logEvent(agentId, `agent_${status}`, { reason, newFencingEpoch: epoch });
+  }
+  verifyFencingToken(resourceId, provided, expected) {
+    if (provided !== expected) throw new StaleFencingTokenError(resourceId, provided, expected);
+  }
+  hash(token) {
+    return crypto2.createHash("sha256").update(token).digest("hex");
+  }
+};
+
+// src/core/locks.ts
+var LockEngine = class _LockEngine {
+  constructor(coordDb, fencing) {
+    this.coordDb = coordDb;
+    this.fencing = fencing;
+  }
+  coordDb;
+  fencing;
+  pathCase = /* @__PURE__ */ new Map();
+  static normalizePattern(repoRoot, rawPattern) {
+    if (rawPattern.startsWith("file:")) return _LockEngine.literalScope(_LockEngine.normalizeFile(repoRoot, rawPattern.slice(5)));
+    if (rawPattern.startsWith("symbol:")) {
+      const hash = rawPattern.indexOf("#");
+      const name = rawPattern.slice(hash + 1);
+      if (hash < 0 || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) throw new Error("Symbol scope must include #symbolName");
+      const file = _LockEngine.normalizeFile(repoRoot, rawPattern.slice(7, hash));
+      return `symbol:${file}#${name}`;
+    }
+    if (!rawPattern || /[\\\x00-\x1f\x7f]/u.test(rawPattern)) throw new Error(`Invalid repository scope: ${rawPattern}`);
+    const root = physicalPath(repoRoot);
+    const parts = rawPattern.split("/");
+    const magic = parts.findIndex((p) => /[?*]/u.test(p));
+    const prefix = magic < 0 ? rawPattern : parts.slice(0, magic).join("/") || ".";
+    const absolute = physicalPath(path3.isAbsolute(prefix) ? prefix : root + "/" + prefix);
+    if (!isWithin(root, absolute)) throw new Error(`Scope is outside repository: ${rawPattern}`);
+    const relative = path3.relative(root, absolute).split(path3.sep).join("/");
+    const suffix = magic < 0 ? "" : parts.slice(magic).join("/");
+    const normalized = [relative, suffix].filter(Boolean).join("/");
+    scopeSegments(normalized);
+    return normalized;
+  }
+  static normalizeFile(repoRoot, file) {
+    const normalized = repositoryFile(repoRoot, file);
+    scopeSegments(normalized, true);
+    return normalized;
+  }
+  static literalScope(file) {
+    try {
+      scopeSegments(file);
+      if (!/[?*]/u.test(file) && !file.startsWith("symbol:") && !file.startsWith("file:")) return file;
+    } catch {
+    }
+    return "file:" + file;
+  }
+  rootForAgent(agentId) {
+    return this.fencing.getAgent(agentId)?.worktree_path ?? this.coordDb.repoRoot;
+  }
+  // A wildcard can traverse an alias that maps to a different scope. If exact
+  // lexical comparison was disjoint, retain exclusion when such aliases exist.
+  wildcardHasAliases(pattern) {
+    if (pattern.startsWith("symbol:") || pattern.startsWith("file:")) return false;
+    const segments = scopeSegments(pattern);
+    const first = segments.findIndex((s) => /[?*]/u.test(s));
+    if (first < 0) return false;
+    const prefix = segments.slice(0, first).join("/");
+    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;
+    while (pending.length) {
+      const { root, relative } = pending.pop();
+      const dir = path3.join(root, relative);
+      let entries;
+      try {
+        entries = fs4.readdirSync(dir, { withFileTypes: true });
+      } catch (error) {
+        if (error.code === "ENOENT") continue;
+        return true;
+      }
+      for (const entry of entries) {
+        if (--budget < 0) return true;
+        const file = relative ? relative + "/" + entry.name : entry.name;
+        if (entry.isSymbolicLink()) 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 });
+      }
+    }
+    return false;
+  }
+  /** Exact overlap for the documented scope grammar; legacy unsupported locks block conservatively. */
+  static patternsOverlap(rawA, rawB) {
+    const decode = (value) => {
+      if (value.startsWith("symbol:")) {
+        const match = /^symbol:(.+)#([A-Za-z_$][A-Za-z0-9_$]*)$/.exec(value);
+        if (!match) throw new Error("Invalid symbol scope");
+        scopeSegments(match[1], true);
+        return { file: match[1], symbol: match[2], literal: true };
+      }
+      const literal = value.startsWith("file:");
+      const file = literal ? value.slice(5) : value;
+      scopeSegments(file, literal);
+      return { file, symbol: null, literal };
+    };
+    try {
+      const a = decode(rawA), b = decode(rawB);
+      if (a.symbol && b.symbol) return a.file === b.file && a.symbol === b.symbol;
+      return scopesOverlap(a.file, b.file, a.literal, b.literal);
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * Atomically acquires locks on one or more file/glob/symbol patterns.
+   * All-or-nothing: if any pattern conflicts with another live agent, no locks are created.
+   */
+  acquireLocks(params) {
+    this.fencing.reapDeadAgents();
+    const mode = params.mode ?? "exclusive";
+    const lockType = params.lockType ?? "glob";
+    const now = Date.now();
+    const expiresAt = now + (params.leaseDurationMs ?? FencingAndAgentManager.DEFAULT_LEASE_MS);
+    const normalizedPatterns = Array.from(
+      new Set(params.patterns.map((p) => _LockEngine.normalizePattern(this.rootForAgent(params.agentId), lockType === "file" && !p.startsWith("file:") ? "file:" + p : p)))
+    );
+    return this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(params.agentId);
+      const existingLocks = this.coordDb.db.prepare(`SELECT * FROM locks WHERE expires_at > ?`).all(now);
+      const conflicts = [];
+      for (const reqPattern of normalizedPatterns) {
+        for (const existing of existingLocks) {
+          if (existing.owner_agent_id === params.agentId) {
+            continue;
+          }
+          const bothShared = mode === "shared" && existing.mode === "shared";
+          if (bothShared) {
+            continue;
+          }
+          if (this.overlapsExisting(reqPattern, existing.pattern)) {
+            const owner = this.fencing.getAgent(existing.owner_agent_id);
+            const activeTask = this.coordDb.db.prepare(
+              `SELECT intent_summary FROM tasks WHERE owner_agent_id = ? AND status = 'active' LIMIT 1`
+            ).get(existing.owner_agent_id);
+            conflicts.push({
+              existingLock: existing,
+              requestedPattern: reqPattern,
+              ownerAgentName: owner?.name ?? existing.owner_agent_id,
+              ownerIntent: activeTask?.intent_summary ?? existing.reason ?? null
+            });
+          }
+        }
+      }
+      if (conflicts.length > 0) {
+        this.coordDb.logEvent(params.agentId, "lock_conflict", {
+          requestedPatterns: normalizedPatterns,
+          conflicts: conflicts.map((c) => ({
+            pattern: c.existingLock.pattern,
+            owner: c.existingLock.owner_agent_id
+          }))
+        });
+        return {
+          ok: false,
+          fencingToken: this.coordDb.currentFencingEpoch(),
+          locks: [],
+          conflicts
+        };
+      }
+      const token = this.coordDb.nextFencingToken();
+      const acquired = [];
+      for (const pattern of normalizedPatterns) {
+        this.coordDb.db.prepare(`DELETE FROM locks WHERE owner_agent_id = ? AND pattern = ?`).run(params.agentId, pattern);
+        const id = `lock_${crypto3.randomBytes(6).toString("hex")}`;
+        const inferredType = pattern.startsWith("file:") ? "file" : pattern.startsWith("symbol:") ? "symbol" : pattern.includes("*") || pattern.includes("?") || pattern.includes("{") ? "glob" : lockType === "glob" ? "file" : lockType;
+        this.coordDb.db.prepare(`
+            INSERT INTO locks (
+              id, pattern, lock_type, mode, owner_agent_id,
+              task_id, fencing_token, reason, acquired_at, expires_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `).run(
+          id,
+          pattern,
+          inferredType,
+          mode,
+          params.agentId,
+          params.taskId ?? null,
+          token,
+          params.reason ?? "",
+          now,
+          expiresAt
+        );
+        acquired.push({
+          id,
+          pattern,
+          lock_type: inferredType,
+          mode,
+          owner_agent_id: params.agentId,
+          task_id: params.taskId ?? null,
+          fencing_token: token,
+          reason: params.reason ?? "",
+          acquired_at: now,
+          expires_at: expiresAt
+        });
+      }
+      this.coordDb.logEvent(params.agentId, "locks_acquired", {
+        patterns: normalizedPatterns,
+        fencingToken: token
+      });
+      return {
+        ok: true,
+        fencingToken: token,
+        locks: acquired,
+        conflicts: []
+      };
+    });
+  }
+  /**
+   * Checks whether `agentId` is allowed to edit `filePath`.
+   * Also verifies the fencing token if provided.
+   */
+  checkFileWriteAccess(params) {
+    this.fencing.reapDeadAgents();
+    this.fencing.assertSession(params.agentId);
+    const normPath = _LockEngine.normalizeFile(this.rootForAgent(params.agentId), params.filePath);
+    const requested = _LockEngine.literalScope(normPath);
+    const now = Date.now();
+    const activeLocks = this.coordDb.db.prepare(`SELECT * FROM locks WHERE expires_at > ?`).all(now);
+    for (const lock of activeLocks) {
+      if (this.overlapsExisting(requested, lock.pattern)) {
+        if (lock.owner_agent_id !== params.agentId) {
+          const activeTask = this.coordDb.db.prepare(
+            `SELECT intent_summary FROM tasks WHERE owner_agent_id = ? AND status = 'active' LIMIT 1`
+          ).get(lock.owner_agent_id);
+          return {
+            allowed: false,
+            reason: `File '${normPath}' is locked by agent '${lock.owner_agent_id}' (pattern: '${lock.pattern}', token: ${lock.fencing_token}). Intent: ${activeTask?.intent_summary ?? (lock.reason || "active work")}`,
+            conflictingLock: lock,
+            ownerIntent: activeTask?.intent_summary ?? lock.reason ?? null
+          };
+        } else if (params.fencingToken !== void 0) {
+          this.fencing.verifyFencingToken(normPath, params.fencingToken, lock.fencing_token);
+        }
+      }
+    }
+    return { allowed: true };
+  }
+  releaseLocks(params) {
+    return this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(params.agentId);
+      const myLocks = this.coordDb.db.prepare(`SELECT * FROM locks WHERE owner_agent_id = ?`).all(params.agentId);
+      if (params.fencingToken !== void 0) {
+        for (const lock of myLocks) {
+          if (!params.patterns || params.patterns.some(
+            (p) => _LockEngine.normalizePattern(this.rootForAgent(params.agentId), p) === lock.pattern
+          )) {
+            this.fencing.verifyFencingToken(lock.pattern, params.fencingToken, lock.fencing_token);
+          }
+        }
+      }
+      if (!params.patterns || params.patterns.length === 0) {
+        const res = this.coordDb.db.prepare(`DELETE FROM locks WHERE owner_agent_id = ?`).run(params.agentId);
+        return Number(res.changes);
+      }
+      let count = 0;
+      for (const rawPattern of params.patterns) {
+        const norm = _LockEngine.normalizePattern(this.rootForAgent(params.agentId), rawPattern);
+        const res = this.coordDb.db.prepare(`DELETE FROM locks WHERE owner_agent_id = ? AND pattern = ?`).run(params.agentId, norm);
+        count += Number(res.changes);
+      }
+      return count;
+    });
+  }
+  overlapsExisting(requested, existing) {
+    try {
+      const normalized = _LockEngine.normalizePattern(this.coordDb.repoRoot, existing);
+      const roots = [this.coordDb.repoRoot, ...this.fencing.listAgents(true).map((a) => a.worktree_path).filter((p) => Boolean(p))];
+      const insensitive = roots.some((root) => {
+        if (!this.pathCase.has(root)) this.pathCase.set(root, caseSensitivePaths(root));
+        return !this.pathCase.get(root);
+      });
+      const fold = (scope) => {
+        const hash = scope.startsWith("symbol:") ? scope.lastIndexOf("#") : -1;
+        const file = hash < 0 ? scope : scope.slice(0, hash);
+        return file.normalize("NFC").toLowerCase().replace(/ς/g, "\u03C3") + (hash < 0 ? "" : scope.slice(hash));
+      };
+      const overlap = (a, b) => _LockEngine.patternsOverlap(a, b) || insensitive && _LockEngine.patternsOverlap(fold(a), fold(b));
+      return overlap(requested, existing) || overlap(requested, normalized) || this.wildcardHasAliases(requested) || this.wildcardHasAliases(normalized);
+    } catch {
+      return true;
+    }
+  }
+  listLocks() {
+    this.fencing.reapDeadAgents();
+    return this.coordDb.db.prepare(`SELECT * FROM locks WHERE expires_at > ? ORDER BY acquired_at ASC`).all(Date.now());
+  }
+};
+
+// src/core/bash-guard.ts
+var GIT_PREFIX = String.raw`\bgit(?:\s+(?:-C|-c|--git-dir|--work-tree)(?:=|\s+)(?:"[^"]*"|'[^']*'|[^\s;&|]+)|\s+--(?:no-pager|literal-pathspecs|no-optional-locks))*\s+`;
+var DESTRUCTIVE_SHARED_TREE = new RegExp(GIT_PREFIX + String.raw`(?:reset|clean|checkout|restore|switch|stash|merge|rebase|pull|cherry-pick|revert|am)\b`);
+var DESTRUCTIVE_SHARED_REFS = new RegExp(GIT_PREFIX + String.raw`(?:update-ref|symbolic-ref|worktree\s+(?:remove|prune)|branch\s+(?:-[dDmMfF]|--(?:delete|move|force)))\b`);
+var BashMerkleGuard = class {
+  constructor(coordDb, fencing, lockEngine, depGraph, shadowGit) {
+    this.coordDb = coordDb;
+    this.fencing = fencing;
+    this.lockEngine = lockEngine;
+    this.depGraph = depGraph;
+    this.shadowGit = shadowGit;
+  }
+  coordDb;
+  fencing;
+  lockEngine;
+  depGraph;
+  shadowGit;
+  /**
+   * Checks whether a shell command is safe to execute in the workspace.
+   */
+  checkCommandSafety(params) {
+    this.fencing.assertSession(params.agentId);
+    const root = physicalPath(this.fencing.getAgent(params.agentId)?.worktree_path ?? this.coordDb.repoRoot);
+    const peers = this.fencing.listAgents(true).filter((a) => a.id !== params.agentId);
+    const sharesCheckout = peers.some((a) => physicalPath(a.worktree_path ?? this.coordDb.repoRoot) === root);
+    if (peers.length && DESTRUCTIVE_SHARED_REFS.test(params.command) || sharesCheckout && DESTRUCTIVE_SHARED_TREE.test(params.command)) {
+      return { safe: false, reason: "Git operation can replace shared work or refs while peer agents are active. Coordinate the operation before retrying." };
+    }
+    return { safe: true };
+  }
+  getSnapshotFilePath(agentId) {
+    const epoch = this.fencing.assertSession(agentId);
+    const safeId = crypto4.createHash("sha256").update(`${agentId}:${epoch}`).digest("hex");
+    return path4.join(this.coordDb.coordDir, "snapshots", `${safeId}.json`);
+  }
+  /**
+   * Captures a Merkle snapshot of workspace files before a Bash tool execution.
+   * For any file locked by another active agent, stores a full lossless backup so
+   * unauthorized mutations by bash scripts (`sed`, `python`, etc.) can be reverted atomically.
+   */
+  capturePreBashSnapshot(agentId, rootDir = this.coordDb.repoRoot) {
+    const activeLocks = this.lockEngine.listLocks().filter((l) => l.owner_agent_id !== agentId);
+    const entries = {};
+    const files = this.walkWorkspaceFiles(rootDir);
+    for (const absPath of files) {
+      const relPath = path4.relative(rootDir, absPath).replace(/\\/g, "/");
+      const stat = fs5.statSync(absPath);
+      if (stat.size > 5 * 1024 * 1024) continue;
+      const buf = fs5.readFileSync(absPath);
+      const sha256 = crypto4.createHash("sha256").update(buf).digest("hex");
+      const lockedByOther = activeLocks.some(
+        (l) => LockEngine.patternsOverlap(relPath, l.pattern)
+      );
+      entries[relPath] = {
+        relPath,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+        sha256,
+        lockedByOther,
+        backupContentBase64: lockedByOther ? buf.toString("base64") : void 0
+      };
+    }
+    const snapPath = this.getSnapshotFilePath(agentId);
+    fs5.writeFileSync(
+      snapPath,
+      JSON.stringify({ timestamp: Date.now(), rootDir, entries }),
+      { encoding: "utf8", mode: 384 }
+    );
+    return snapPath;
+  }
+  /**
+   * Compares workspace state after a Bash command completes against the pre-Bash Merkle snapshot.
+   * Saves recovery copies of edits to files locked by sibling agents. Restoration is opt-in,
+   * and indexes authorized modifications into the AST Contract Blackboard & Dirty-Tree Conflict Radar.
+   */
+  verifyPostBashAndQuarantine(params) {
+    const snapPath = this.getSnapshotFilePath(params.agentId);
+    if (!fs5.existsSync(snapPath)) {
+      return { allowed: true, authorizedModifiedFiles: [], quarantinedViolations: [] };
+    }
+    const rawSnap = JSON.parse(fs5.readFileSync(snapPath, "utf8"));
+    const rootDir = params.rootDir ?? rawSnap.rootDir ?? this.coordDb.repoRoot;
+    const beforeEntries = rawSnap.entries;
+    const currentFiles = this.walkWorkspaceFiles(rootDir);
+    const seenCurrentRelPaths = /* @__PURE__ */ new Set();
+    const authorizedModifiedFiles = [];
+    const quarantinedViolations = [];
+    for (const absPath of currentFiles) {
+      const relPath = path4.relative(rootDir, absPath).replace(/\\/g, "/");
+      seenCurrentRelPaths.add(relPath);
+      const stat = fs5.statSync(absPath);
+      if (stat.size > 5 * 1024 * 1024) continue;
+      const prev = beforeEntries[relPath];
+      if (prev && prev.mtimeMs === stat.mtimeMs && prev.size === stat.size) {
+        continue;
+      }
+      const buf = fs5.readFileSync(absPath);
+      const sha256 = crypto4.createHash("sha256").update(buf).digest("hex");
+      if (prev && prev.sha256 === sha256) {
+        continue;
+      }
+      const access = this.lockEngine.checkFileWriteAccess({
+        agentId: params.agentId,
+        filePath: relPath
+      });
+      if (!access.allowed) {
+        const violation = this.quarantineAndRevertFile({
+          agentId: params.agentId,
+          command: params.command,
+          rootDir,
+          relPath,
+          unauthorizedBuf: buf,
+          restoreLockedFiles: params.restoreLockedFiles ?? false,
+          prevEntry: prev ?? null,
+          reason: access.reason ?? "Locked by another agent"
+        });
+        quarantinedViolations.push(violation);
+      } else {
+        authorizedModifiedFiles.push(relPath);
+      }
+    }
+    for (const [relPath, prev] of Object.entries(beforeEntries)) {
+      if (!seenCurrentRelPaths.has(relPath)) {
+        const access = this.lockEngine.checkFileWriteAccess({
+          agentId: params.agentId,
+          filePath: relPath
+        });
+        if (!access.allowed) {
+          const violation = this.quarantineAndRevertFile({
+            agentId: params.agentId,
+            command: params.command,
+            rootDir,
+            relPath,
+            unauthorizedBuf: null,
+            restoreLockedFiles: params.restoreLockedFiles ?? false,
+            prevEntry: prev,
+            reason: access.reason ?? "Deleted file locked by another agent"
+          });
+          quarantinedViolations.push(violation);
+        } else {
+          authorizedModifiedFiles.push(relPath);
+        }
+      }
+    }
+    try {
+      fs5.unlinkSync(snapPath);
+    } catch {
+    }
+    if (authorizedModifiedFiles.length > 0) {
+      for (const relFile of authorizedModifiedFiles) {
+        const absFile = path4.join(rootDir, relFile);
+        if (fs5.existsSync(absFile) && /\.(ts|tsx|js|jsx|mjs|py)$/.test(relFile)) {
+          this.depGraph.recordFileModification(params.agentId, relFile, fs5.readFileSync(absFile, "utf8"));
+        }
+      }
+      this.shadowGit.probeAllActiveConflicts(
+        params.agentId,
+        authorizedModifiedFiles.map((f) => ({ filePath: f })),
+        rootDir
+      );
+    }
+    return {
+      allowed: quarantinedViolations.length === 0,
+      authorizedModifiedFiles,
+      quarantinedViolations
+    };
+  }
+  quarantineAndRevertFile(params) {
+    const id = `quar_${crypto4.randomBytes(6).toString("hex")}`;
+    const now = Date.now();
+    const safeName = params.relPath.replace(/[^a-zA-Z0-9._-]/g, "_");
+    const patchPath = path4.join(
+      this.coordDb.coordDir,
+      "quarantine",
+      `${id}_${safeName}.quarantine`
+    );
+    if (params.unauthorizedBuf) {
+      fs5.writeFileSync(patchPath, params.unauthorizedBuf, { mode: 384 });
+    } else {
+      fs5.writeFileSync(patchPath, `[DELETED BY COMMAND: ${params.command}]
+`, { encoding: "utf8", mode: 384 });
+    }
+    if (params.prevEntry?.backupContentBase64 !== void 0) {
+      fs5.writeFileSync(patchPath + ".before", Buffer.from(params.prevEntry.backupContentBase64, "base64"), { mode: 384 });
+    }
+    const absTarget = path4.join(params.rootDir, params.relPath);
+    if (params.restoreLockedFiles && params.prevEntry === null) {
+      if (fs5.existsSync(absTarget)) {
+        fs5.unlinkSync(absTarget);
+      }
+    } else if (params.restoreLockedFiles && params.prevEntry?.backupContentBase64 !== void 0) {
+      fs5.mkdirSync(path4.dirname(absTarget), { recursive: true });
+      fs5.writeFileSync(
+        absTarget,
+        Buffer.from(params.prevEntry.backupContentBase64, "base64")
+      );
+    }
+    const record = {
+      id,
+      agent_id: params.agentId,
+      command: params.command,
+      file_path: params.relPath,
+      patch_path: patchPath,
+      reason: params.reason,
+      created_at: now
+    };
+    this.coordDb.withTransaction(() => {
+      this.coordDb.db.prepare(`
+          INSERT INTO quarantine (id, agent_id, command, file_path, patch_path, reason, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run(
+        record.id,
+        record.agent_id,
+        record.command,
+        record.file_path,
+        record.patch_path,
+        record.reason,
+        record.created_at
+      );
+      this.coordDb.logEvent(params.agentId, "bash_mutation_quarantined", {
+        filePath: params.relPath,
+        command: params.command,
+        patchPath,
+        reason: params.reason
+      });
+    });
+    return record;
+  }
+  walkWorkspaceFiles(dir, acc = []) {
+    if (!fs5.existsSync(dir)) return acc;
+    const entries = fs5.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === ".git" || entry.name === ".coord" || entry.name === "node_modules" || entry.name === "dist" || entry.name === "coverage" || entry.name === ".next" || entry.name === "target") {
+        continue;
+      }
+      const fullPath = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        this.walkWorkspaceFiles(fullPath, acc);
+      } else if (entry.isFile()) {
+        acc.push(fullPath);
+      }
+    }
+    return acc;
+  }
+  listQuarantined() {
+    return this.coordDb.db.prepare(`SELECT * FROM quarantine ORDER BY created_at DESC`).all();
+  }
+};
+
+// src/core/broker.ts
+import { fork } from "child_process";
+import fs6 from "fs";
+import { fileURLToPath } from "url";
+import crypto5 from "crypto";
+import net from "net";
+var ResourceBroker = class _ResourceBroker {
+  constructor(coordDb, fencing) {
+    this.coordDb = coordDb;
+    this.fencing = fencing;
+  }
+  coordDb;
+  fencing;
+  activeExecutions = 0;
+  hasActiveCommands() {
+    return this.activeExecutions > 0;
+  }
+  /**
+   * Acquires a collision-free port lease for `(agentId, serviceName)`.
+   * Verifies both SQLite resource table and OS TCP socket availability.
+   */
+  async acquirePort(params) {
+    this.fencing.reapDeadAgents();
+    this.fencing.assertSession(params.agentId);
+    const basePort = params.basePort ?? 3100;
+    const leaseMs = FencingAndAgentManager.validateLease(params.leaseDurationMs ?? FencingAndAgentManager.DEFAULT_LEASE_MS);
+    const now = Date.now();
+    const expiresAt = now + leaseMs;
+    const resourceKey = `${params.agentId}:${params.serviceName}`;
+    const existing = this.getResource("port", resourceKey);
+    if (existing && existing.expires_at > now) {
+      return this.coordDb.withTransaction(() => {
+        this.fencing.assertSession(params.agentId);
+        this.coordDb.db.prepare(`UPDATE resources SET expires_at = ? WHERE id = ?`).run(expiresAt, existing.id);
+        return {
+          port: Number(existing.value),
+          fencingToken: existing.fencing_token,
+          resource: this.getResource("port", resourceKey)
+        };
+      });
+    }
+    if (!Number.isInteger(basePort) || basePort < 1 || basePort > 65535) {
+      throw new Error("basePort must be an integer between 1 and 65535");
+    }
+    const limit = Math.min(basePort + 500, 65536);
+    for (let candidatePort = basePort; candidatePort < limit; candidatePort++) {
+      if (!await _ResourceBroker.isTcpPortFree(candidatePort)) continue;
+      const reservation = this.coordDb.withTransaction(() => {
+        this.fencing.assertSession(params.agentId);
+        const now2 = Date.now();
+        const sameService = this.getResource("port", resourceKey);
+        if (sameService && sameService.expires_at > now2) {
+          return { port: Number(sameService.value), fencingToken: sameService.fencing_token, resource: sameService };
+        }
+        const taken = this.coordDb.db.prepare(
+          `SELECT id FROM resources WHERE type = 'port' AND value = ? AND expires_at > ?`
+        ).get(String(candidatePort), now2);
+        if (taken) return null;
+        const token = this.coordDb.nextFencingToken();
+        this.coordDb.db.prepare(`
+          INSERT OR REPLACE INTO resources (
+            id, type, name, value, owner_agent_id, fencing_token, queue_json, acquired_at, expires_at
+          ) VALUES (?, 'port', ?, ?, ?, ?, '[]', ?, ?)
+        `).run(
+          `res_${crypto5.randomBytes(6).toString("hex")}`,
+          resourceKey,
+          String(candidatePort),
+          params.agentId,
+          token,
+          now2,
+          now2 + leaseMs
+        );
+        this.coordDb.logEvent(params.agentId, "port_leased", {
+          serviceName: params.serviceName,
+          port: candidatePort,
+          fencingToken: token
+        });
+        return { port: candidatePort, fencingToken: token, resource: this.getResource("port", resourceKey) };
+      });
+      if (reservation) return reservation;
+    }
+    throw new Error(`No free port available in range ${basePort}-${limit - 1}`);
+  }
+  static isTcpPortFree(port) {
+    return new Promise((resolve) => {
+      const server = net.createServer();
+      server.unref();
+      server.on("error", () => resolve(false));
+      server.listen(port, "127.0.0.1", () => {
+        server.close(() => resolve(true));
+      });
+    });
+  }
+  /** FIFO order survives releases; queued requests belong to a specific session epoch. */
+  tryAcquireMutex(params) {
+    this.fencing.reapDeadAgents();
+    const leaseMs = FencingAndAgentManager.validateLease(params.leaseDurationMs ?? FencingAndAgentManager.DEFAULT_LEASE_MS);
+    return this.coordDb.withTransaction(() => {
+      const epoch = this.fencing.assertSession(params.agentId);
+      const now = Date.now();
+      const requestId = params.requestId ?? `session:${epoch}`;
+      this.pruneWaiters(params.mutexName);
+      const run = this.getRun(params.mutexName);
+      const guarded = run && this.runIsAlive(run);
+      if (run && !guarded) this.clearRun(run);
+      const existing = this.getResource("mutex", params.mutexName);
+      if (!guarded && existing && existing.expires_at > now && existing.owner_agent_id === params.agentId) {
+        this.coordDb.db.prepare("UPDATE resources SET expires_at=? WHERE id=?").run(now + leaseMs, existing.id);
+        return { acquired: true, fencingToken: existing.fencing_token, holderAgentId: params.agentId, queuePosition: 0 };
+      }
+      const start = FencingAndAgentManager.getProcessStartTime(process.pid);
+      if (!start) throw new Error("Cannot inspect mutex waiter process. Sandboxed MCP clients can use kith_run_with_mutex instead.");
+      this.coordDb.db.prepare(`INSERT INTO mutex_waiters
+        (mutex_name, request_id, owner_agent_id, session_epoch, waiter_pid, waiter_start, expires_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(mutex_name, request_id) DO UPDATE SET expires_at=excluded.expires_at
+      `).run(params.mutexName, requestId, params.agentId, epoch, process.pid, start, now + leaseMs);
+      const waiters = this.waiters(params.mutexName);
+      const position = waiters.findIndex((w) => w.request_id === requestId) + 1;
+      if (guarded || existing && existing.expires_at > now || position !== 1) {
+        return {
+          acquired: false,
+          fencingToken: run?.fencing_token ?? existing?.fencing_token ?? 0,
+          holderAgentId: guarded ? run.owner_agent_id : existing?.owner_agent_id ?? waiters[0].owner_agent_id,
+          queuePosition: position
+        };
+      }
+      const token = this.coordDb.nextFencingToken();
+      this.coordDb.db.prepare(`INSERT OR REPLACE INTO resources
+        (id, type, name, value, owner_agent_id, fencing_token, queue_json, acquired_at, expires_at)
+        VALUES (?, 'mutex', ?, 'locked', ?, ?, '[]', ?, ?)
+      `).run(existing?.id ?? `res_${crypto5.randomBytes(6).toString("hex")}`, params.mutexName, params.agentId, token, now, now + leaseMs);
+      this.coordDb.db.prepare("DELETE FROM mutex_waiters WHERE mutex_name=? AND request_id=?").run(params.mutexName, requestId);
+      this.coordDb.logEvent(params.agentId, "mutex_acquired", { mutexName: params.mutexName, fencingToken: token });
+      return { acquired: true, fencingToken: token, holderAgentId: params.agentId, queuePosition: 0 };
+    });
+  }
+  renewMutex(params) {
+    const lease = FencingAndAgentManager.validateLease(params.leaseDurationMs ?? FencingAndAgentManager.DEFAULT_LEASE_MS);
+    this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(params.agentId);
+      const resource = this.getResource("mutex", params.mutexName);
+      if (!resource || resource.owner_agent_id !== params.agentId || resource.expires_at <= Date.now()) {
+        throw new Error(`Mutex lease lost: ${params.mutexName}`);
+      }
+      this.fencing.verifyFencingToken(params.mutexName, params.fencingToken, resource.fencing_token);
+      this.coordDb.db.prepare("UPDATE resources SET expires_at=? WHERE id=?").run(Date.now() + lease, resource.id);
+    });
+  }
+  releaseMutex(params) {
+    return this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(params.agentId);
+      const resource = this.getResource("mutex", params.mutexName);
+      if (!resource || resource.owner_agent_id !== params.agentId) return false;
+      this.fencing.verifyFencingToken(params.mutexName, params.fencingToken, resource.fencing_token);
+      const run = this.getRun(params.mutexName);
+      if (run && this.runIsAlive(run)) throw new Error("Cannot release a mutex while its supervised process group is alive");
+      this.coordDb.db.prepare("DELETE FROM resources WHERE id=?").run(resource.id);
+      this.coordDb.logEvent(params.agentId, "mutex_released", { mutexName: params.mutexName });
+      return true;
+    });
+  }
+  /** Renew leases while a detached, recorded process group runs; stop it before releasing. */
+  async executeWithMutex(params) {
+    if (process.platform === "win32") throw new Error("Supervised mutex commands currently require macOS or Linux process groups");
+    if (!params.command.length) throw new Error("A command is required");
+    const leaseMs = FencingAndAgentManager.validateLease(params.leaseDurationMs ?? FencingAndAgentManager.DEFAULT_LEASE_MS);
+    const waitTimeout = params.timeoutMs ?? 6e4;
+    const grace = params.killGraceMs ?? 1e3;
+    if (!Number.isFinite(waitTimeout) || waitTimeout < 0 || !Number.isFinite(grace) || grace < 0 || params.commandTimeoutMs !== void 0 && (!Number.isFinite(params.commandTimeoutMs) || params.commandTimeoutMs <= 0)) {
+      throw new Error("Timeouts must be finite nonnegative milliseconds (command timeout must be positive)");
+    }
+    if (params.maxOutputBytes !== void 0 && (!Number.isSafeInteger(params.maxOutputBytes) || params.maxOutputBytes <= 0)) throw new Error("maxOutputBytes must be a positive integer");
+    const epoch = this.fencing.assertSession(params.agentId);
+    const requestId = crypto5.randomUUID();
+    const started = Date.now();
+    let run = null;
+    const abortError = () => new DOMException("Mutex command cancelled", "AbortError");
+    this.activeExecutions++;
+    try {
+      while (!run) {
+        if (params.signal?.aborted) throw abortError();
+        run = this.coordDb.withTransaction(() => {
+          const attempt = this.tryAcquireMutex({ ...params, requestId });
+          if (!attempt.acquired) return null;
+          const record = {
+            mutex_name: params.mutexName,
+            run_id: requestId,
+            owner_agent_id: params.agentId,
+            session_epoch: epoch,
+            fencing_token: attempt.fencingToken,
+            supervisor_pid: process.pid,
+            supervisor_start: FencingAndAgentManager.getProcessStartTime(process.pid),
+            worker_pid: null,
+            worker_start: null
+          };
+          this.coordDb.db.prepare(`INSERT INTO mutex_runs
+            (mutex_name, run_id, owner_agent_id, session_epoch, fencing_token, supervisor_pid, supervisor_start)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+          `).run(record.mutex_name, record.run_id, record.owner_agent_id, epoch, record.fencing_token, process.pid, record.supervisor_start);
+          return record;
+        });
+        if (run) break;
+        if (Date.now() - started >= waitTimeout) throw new Error(`Timed out waiting for mutex '${params.mutexName}'`);
+        this.fencing.heartbeat(params.agentId);
+        await delay(Math.min(50, Math.max(10, leaseMs / 4)));
+      }
+      const waitedMs = Date.now() - started;
+      const candidates = ["./command-worker.js", "../command-worker.js", "../../dist/command-worker.js"].map((name) => fileURLToPath(new URL(name, import.meta.url)));
+      const script = candidates.find((name) => fs6.existsSync(name));
+      if (!script) throw new Error("Missing command worker. Build Kith before running supervised commands.");
+      const worker = fork(script, [], { detached: true, stdio: ["ignore", "pipe", "pipe", "ipc"], execArgv: [] });
+      const workerPid = worker.pid;
+      if (!workerPid) {
+        worker.on("error", () => {
+        });
+        throw new Error("Could not start command supervisor");
+      }
+      let workerIdentity = FencingAndAgentManager.getProcessStartTime(workerPid);
+      let failure;
+      let outcome;
+      const stdout = [];
+      const stderr = [];
+      let outputBytes = 0;
+      let killTimer;
+      let stopTimer;
+      let stopDeadline;
+      let disposed = false;
+      let finishStopped;
+      const stopped = new Promise((resolve) => {
+        finishStopped = resolve;
+      });
+      const stop = (err) => {
+        if (disposed) return;
+        failure ??= err;
+        const termError = signalGroup(workerPid, "SIGTERM", workerIdentity);
+        failure ??= termError;
+        killTimer ??= setTimeout(() => {
+          const killError = signalGroup(workerPid, "SIGKILL", workerIdentity);
+          failure ??= killError;
+        }, grace);
+        stopDeadline ??= Date.now() + grace + 5e3;
+        stopTimer ??= setTimeout(finishStopped, Math.max(0, stopDeadline - Date.now()));
+      };
+      const onAbort = () => stop(abortError());
+      params.signal?.addEventListener("abort", onAbort, { once: true });
+      const interval = setInterval(() => {
+        try {
+          this.fencing.heartbeat(params.agentId);
+          this.renewMutex({ ...params, fencingToken: run.fencing_token });
+        } catch (err) {
+          stop(err instanceof Error ? err : new Error(String(err)));
+        }
+      }, Math.max(10, Math.floor(leaseMs / 3)));
+      const commandTimer = params.commandTimeoutMs === void 0 ? void 0 : setTimeout(() => stop(new Error("Mutex command execution timed out")), params.commandTimeoutMs);
+      const capture = (destination, stream) => (chunk) => {
+        stream?.(chunk);
+        outputBytes += chunk.length;
+        if (outputBytes > (params.maxOutputBytes ?? 16 * 1024 * 1024)) stop(new Error("Mutex command output limit exceeded"));
+        else destination.push(chunk);
+      };
+      worker.stdout.on("data", capture(stdout, params.onStdout));
+      worker.stderr.on("data", capture(stderr, params.onStderr));
+      worker.on("message", (message) => {
+        if (disposed) return;
+        if (message.ready) {
+          try {
+            if (params.signal?.aborted) throw abortError();
+            this.coordDb.withTransaction(() => {
+              this.fencing.assertSession(params.agentId);
+              const identity = FencingAndAgentManager.getProcessStartTime(workerPid);
+              if (!identity) throw new Error("Cannot inspect command worker");
+              this.coordDb.db.prepare("UPDATE mutex_runs SET worker_pid=?, worker_start=? WHERE run_id=?").run(workerPid, identity, requestId);
+              run.worker_pid = workerPid;
+              run.worker_start = identity;
+              workerIdentity = identity;
+              this.renewMutex({ ...params, fencingToken: run.fencing_token });
+            });
+            worker.send({ command: params.command, cwd: params.cwd ?? this.coordDb.repoRoot, mutexName: params.mutexName });
+          } catch (err) {
+            stop(err instanceof Error ? err : new Error(String(err)));
+          }
+        } else {
+          outcome = { exitCode: message.exitCode ?? 1, error: message.error };
+        }
+      });
+      worker.once("exit", () => {
+        if (!disposed && groupIsAlive(workerPid, workerIdentity)) stop();
+      });
+      try {
+        await Promise.race([new Promise((resolve, reject) => {
+          worker.once("close", () => resolve());
+          worker.once("error", reject);
+        }), stopped]);
+        if (params.signal?.aborted) failure ??= abortError();
+        if (failure) throw failure;
+        if (!outcome) throw new Error("Command worker exited without a result");
+        if (outcome.error) throw new Error(outcome.error);
+        return { stdout: Buffer.concat(stdout).toString(), stderr: Buffer.concat(stderr).toString(), exitCode: outcome.exitCode, waitedMs };
+      } finally {
+        clearInterval(interval);
+        if (commandTimer) clearTimeout(commandTimer);
+        params.signal?.removeEventListener("abort", onAbort);
+        if (groupIsAlive(workerPid, workerIdentity)) {
+          const killError = signalGroup(workerPid, "SIGKILL", workerIdentity);
+          failure ??= killError;
+          const deadline = stopDeadline ?? Date.now() + 5e3;
+          while (groupIsAlive(workerPid, workerIdentity) && Date.now() < deadline) await delay(20);
+        }
+        disposed = true;
+        if (killTimer) clearTimeout(killTimer);
+        if (stopTimer) clearTimeout(stopTimer);
+        if (groupIsAlive(workerPid, workerIdentity)) {
+          worker.stdout?.destroy();
+          worker.stderr?.destroy();
+          if (worker.connected) worker.disconnect();
+          worker.unref();
+          throw new Error("Command group has not stopped; mutex guard retained for safety");
+        }
+      }
+    } finally {
+      try {
+        this.coordDb.withTransaction(() => {
+          this.coordDb.db.prepare("DELETE FROM mutex_waiters WHERE mutex_name=? AND request_id=? AND session_epoch=?").run(params.mutexName, requestId, epoch);
+          if (run && !this.runIsAlive(run)) this.clearRun(run);
+          if (run && run.worker_pid === null) this.clearRun(run);
+        });
+      } finally {
+        this.activeExecutions--;
+      }
+    }
+  }
+  getRun(name) {
+    return this.coordDb.db.prepare("SELECT * FROM mutex_runs WHERE mutex_name=?").get(name) ?? null;
+  }
+  runIsAlive(run) {
+    return run.worker_pid !== null ? groupIsAlive(run.worker_pid, run.worker_start) : FencingAndAgentManager.isProcessAlive(run.supervisor_pid, run.supervisor_start);
+  }
+  clearRun(run) {
+    this.coordDb.db.prepare("DELETE FROM mutex_runs WHERE mutex_name=? AND run_id=?").run(run.mutex_name, run.run_id);
+    this.coordDb.db.prepare("DELETE FROM resources WHERE type='mutex' AND name=? AND fencing_token=?").run(run.mutex_name, run.fencing_token);
+  }
+  waiters(name) {
+    return this.coordDb.db.prepare("SELECT * FROM mutex_waiters WHERE mutex_name=? ORDER BY ticket").all(name);
+  }
+  pruneWaiters(name) {
+    for (const waiter of this.waiters(name)) {
+      const agent = this.fencing.getAgent(waiter.owner_agent_id);
+      const session = this.coordDb.db.prepare("SELECT epoch FROM agent_sessions WHERE agent_id=?").get(waiter.owner_agent_id);
+      if (!agent || agent.status !== "active" || agent.lease_expires_at <= Date.now() || session?.epoch !== waiter.session_epoch || waiter.expires_at <= Date.now() || !FencingAndAgentManager.isProcessAlive(waiter.waiter_pid, waiter.waiter_start)) {
+        this.coordDb.db.prepare("DELETE FROM mutex_waiters WHERE ticket=?").run(waiter.ticket);
+      }
+    }
+  }
+  getResource(type, name) {
+    const row = this.coordDb.db.prepare(`SELECT * FROM resources WHERE type = ? AND name = ?`).get(type, name);
+    if (!row) return null;
+    return this.mapRow(row);
+  }
+  listResources() {
+    this.fencing.reapDeadAgents();
+    const rows = this.coordDb.db.prepare(`SELECT * FROM resources WHERE expires_at > ? ORDER BY acquired_at ASC`).all(Date.now());
+    return rows.map((r) => this.mapRow(r));
+  }
+  mapRow(row) {
+    return {
+      id: String(row.id),
+      type: row.type,
+      name: String(row.name),
+      value: String(row.value),
+      owner_agent_id: String(row.owner_agent_id),
+      fencing_token: Number(row.fencing_token),
+      queue: row.type === "mutex" ? this.waiters(String(row.name)).map((w) => w.owner_agent_id) : [],
+      acquired_at: Number(row.acquired_at),
+      expires_at: Number(row.expires_at)
+    };
+  }
+};
+function groupIsAlive(pgid, expectedStart) {
+  if (expectedStart) {
+    const currentStart = FencingAndAgentManager.getProcessStartTime(pgid);
+    if (currentStart && currentStart !== expectedStart) return false;
+  }
+  try {
+    process.kill(-pgid, 0);
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+  if (process.platform === "linux") {
+    try {
+      for (const pid of fs6.readdirSync("/proc").filter((name) => /^\d+$/.test(name))) {
+        let stat;
+        try {
+          stat = fs6.readFileSync(`/proc/${pid}/stat`, "utf8");
+        } catch (err) {
+          if (err.code === "ENOENT" || err.code === "ESRCH") continue;
+          return true;
+        }
+        const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+        if (Number(fields[2]) === pgid && fields[0] !== "Z" && fields[0] !== "X") return true;
+      }
+      return false;
+    } catch {
+      return true;
+    }
+  }
+  return true;
+}
+function signalGroup(pgid, signal, expectedStart) {
+  if (!groupIsAlive(pgid, expectedStart)) return;
+  try {
+    process.kill(-pgid, signal);
+  } catch (err) {
+    if (err.code !== "ESRCH") return err instanceof Error ? err : new Error(String(err));
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/db.ts
+import { createRequire } from "module";
+import fs7 from "fs";
+import path5 from "path";
+var require2 = createRequire(import.meta.url);
+var { DatabaseSync } = require2("node:sqlite");
+var CoordDatabase = class _CoordDatabase {
+  db;
+  repoRoot;
+  commonGitDir;
+  isLinkedWorktree;
+  coordDir;
+  dbPath;
+  inTransaction = false;
+  constructor(repoRoot, customDbPath) {
+    const layout = discoverRepository(repoRoot);
+    this.repoRoot = layout.checkoutRoot;
+    this.commonGitDir = layout.commonGitDir;
+    this.isLinkedWorktree = layout.isLinkedWorktree;
+    for (let current = fs7.realpathSync.native(repoRoot); isWithin(this.repoRoot, current); current = path5.dirname(current)) {
+      const local = path5.join(current, ".coord");
+      if (local !== layout.coordDir && fs7.existsSync(path5.join(local, "state.db"))) {
+        throw new Error(`Legacy checkout-local coordination state found at ${local}. Stop clients and preserve that directory before consolidating shared state.`);
+      }
+      if (current === this.repoRoot) break;
+    }
+    this.coordDir = layout.coordDir;
+    if (physicalPath(this.coordDir) !== this.coordDir) throw new Error("Coordination directory must not be a symlink");
+    this.dbPath = customDbPath ?? path5.join(this.coordDir, "state.db");
+    if (!customDbPath && physicalPath(this.dbPath) !== this.dbPath) throw new Error("Coordination database must not be a symlink");
+    const recoveryFiles = !customDbPath && (fs7.existsSync(path5.join(this.coordDir, "merge-train.lock")) || fs7.existsSync(path5.join(this.coordDir, "setup.lock")) || ["shadow-index", "quarantine", "snapshots", "worktrees", "setup"].some((name) => {
+      const dir = path5.join(this.coordDir, name);
+      return fs7.existsSync(dir) && (!fs7.lstatSync(dir).isDirectory() || fs7.readdirSync(dir).length > 0);
+    }));
+    const sidecars = ["-wal", "-shm", "-journal"].some((suffix) => fs7.existsSync(this.dbPath + suffix));
+    if (!fs7.existsSync(this.dbPath) && (recoveryFiles || sidecars)) {
+      throw new Error("Missing coordination database with existing recovery state. Stop clients and preserve the database, sidecars and worktrees before repair.");
+    }
+    if (fs7.existsSync(this.dbPath)) {
+      const probe = new DatabaseSync(this.dbPath, { readOnly: true });
+      try {
+        probe.exec("PRAGMA busy_timeout=10000; BEGIN");
+        _CoordDatabase.schemaVersion(probe, !recoveryFiles);
+        const check = probe.prepare("PRAGMA quick_check(1)").get();
+        if (check.quick_check !== "ok") throw new Error("Damaged coordination database. Preserve all state before repair.");
+      } finally {
+        probe.close();
+      }
+    }
+    fs7.mkdirSync(this.coordDir, { recursive: true, mode: 448 });
+    for (const name of ["shadow-index", "quarantine", "snapshots", "worktrees"]) {
+      const target = path5.join(this.coordDir, name);
+      if (!isWithin(this.coordDir, physicalPath(target)) || physicalPath(target) !== target) {
+        throw new Error(`Coordination subdirectory must not be a symlink: ${name}`);
+      }
+      fs7.mkdirSync(target, { recursive: true });
+    }
+    this.db = new DatabaseSync(this.dbPath);
+    try {
+      this.configurePragmas();
+      this.migrate(!recoveryFiles);
+    } catch (err) {
+      this.db.close();
+      throw err;
+    }
+  }
+  /** Validate an existing snapshot without migration or ownership changes. */
+  static inspectSchema(db) {
+    const version = this.schemaVersion(db, false);
+    const check = db.prepare("PRAGMA quick_check(1)").get();
+    if (check.quick_check !== "ok") throw new Error("Damaged coordination database. Preserve all state before repair.");
+    return version;
+  }
+  configurePragmas() {
+    this.db.exec(`
+      PRAGMA busy_timeout = 10000;
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+      PRAGMA foreign_keys = ON;
+      PRAGMA temp_store = MEMORY;
+    `);
+  }
+  static schemaVersion(db, allowEmpty) {
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT GLOB 'sqlite_*'").all();
+    if (!tables.length) {
+      if (!allowEmpty) throw new Error("Empty coordination database with existing recovery files. Preserve all state before repair.");
+      return 1;
+    }
+    if (!tables.some((table) => table.name === "meta")) throw new Error("Missing coordination schema metadata. Preserve the database before repair.");
+    const row = db.prepare("SELECT value FROM meta WHERE key='schema_version'").get();
+    if (row?.value !== "1" && row?.value !== "2") {
+      throw new Error(`Unsupported coordination schema version: ${String(row?.value)}. Preserve the database before upgrading or repairing it.`);
+    }
+    const version = Number(row.value);
+    const required = [
+      "agents",
+      "tasks",
+      "locks",
+      "file_deps",
+      "contracts",
+      "conflicts",
+      "merge_queue",
+      "resources",
+      "quarantine",
+      "events",
+      ...version === 2 ? ["agent_sessions", "mutex_waiters", "mutex_runs"] : []
+    ];
+    if (required.some((name) => !tables.some((table) => table.name === name))) {
+      throw new Error("Incomplete coordination schema. Preserve the database before repair.");
+    }
+    const columns = {
+      agents: "id,pid,pid_start_time,status,registered_at,lease_expires_at,worktree_path,branch",
+      tasks: "status,owner_agent_id,fencing_token,scope_globs_json,depends_on_json",
+      locks: "owner_agent_id,pattern,mode,fencing_token,expires_at",
+      resources: "type,name,owner_agent_id,fencing_token,expires_at",
+      ...version === 2 ? {
+        agent_sessions: "agent_id,token_hash,epoch",
+        mutex_waiters: "ticket,mutex_name,request_id,owner_agent_id,session_epoch,waiter_pid,waiter_start,expires_at",
+        mutex_runs: "mutex_name,run_id,owner_agent_id,session_epoch,fencing_token,supervisor_pid,supervisor_start,worker_pid,worker_start"
+      } : {}
+    };
+    for (const [table, fields] of Object.entries(columns)) {
+      try {
+        db.prepare(`SELECT ${fields} FROM ${table} LIMIT 0`);
+      } catch {
+        throw new Error(`Incomplete coordination schema (${table}). Preserve the database before repair.`);
+      }
+    }
+    const epoch = _CoordDatabase.fencingEpoch(db);
+    const tokens = [
+      "SELECT fencing_token AS token FROM locks",
+      "SELECT fencing_token FROM tasks",
+      "SELECT fencing_token FROM resources",
+      "SELECT fencing_token FROM merge_queue",
+      ...version === 2 ? ["SELECT epoch FROM agent_sessions", "SELECT session_epoch FROM mutex_waiters", "SELECT fencing_token FROM mutex_runs"] : []
+    ];
+    if (db.prepare(`SELECT 1 FROM (${tokens.join(" UNION ALL ")}) WHERE token IS NOT NULL AND (typeof(token)!='integer' OR token<0 OR token>?) LIMIT 1`).get(epoch)) {
+      throw new Error("Invalid or regressed fencing counter. Preserve the database before repair.");
+    }
+    return version;
+  }
+  static fencingEpoch(db) {
+    const row = db.prepare("SELECT value FROM meta WHERE key='fencing_epoch'").get();
+    const epoch = Number(row?.value);
+    if (!row || typeof row.value !== "string" || !/^(0|[1-9][0-9]*)$/.test(row.value) || !Number.isSafeInteger(epoch)) {
+      throw new Error("Missing or invalid fencing counter. Preserve the database before repair.");
+    }
+    return epoch;
+  }
+  migrate(allowEmpty) {
+    this.withTransaction(() => {
+      const version = _CoordDatabase.schemaVersion(this.db, allowEmpty);
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS meta (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        );
+
+        INSERT OR IGNORE INTO meta (key, value) VALUES ('fencing_epoch', '1000');
+        INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', '1');
+
+        CREATE TABLE IF NOT EXISTS agents (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          client TEXT NOT NULL,
+          pid INTEGER NOT NULL,
+          pid_start_time TEXT NOT NULL,
+          pgid INTEGER NOT NULL,
+          worktree_path TEXT,
+          branch TEXT,
+          shadow_tree_sha TEXT,
+          status TEXT NOT NULL DEFAULT 'active',
+          last_seen_event_id INTEGER NOT NULL DEFAULT 0,
+          registered_at INTEGER NOT NULL,
+          last_heartbeat_at INTEGER NOT NULL,
+          lease_expires_at INTEGER NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status);
+
+        CREATE TABLE IF NOT EXISTS tasks (
+          id TEXT PRIMARY KEY,
+          title TEXT NOT NULL,
+          intent_summary TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'queued',
+          priority INTEGER NOT NULL DEFAULT 0,
+          owner_agent_id TEXT,
+          fencing_token INTEGER,
+          depends_on_json TEXT NOT NULL DEFAULT '[]',
+          scope_globs_json TEXT NOT NULL DEFAULT '[]',
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status, priority DESC);
+        CREATE INDEX IF NOT EXISTS idx_tasks_owner ON tasks(owner_agent_id);
+
+        CREATE TABLE IF NOT EXISTS locks (
+          id TEXT PRIMARY KEY,
+          pattern TEXT NOT NULL,
+          lock_type TEXT NOT NULL DEFAULT 'glob',
+          mode TEXT NOT NULL DEFAULT 'exclusive',
+          owner_agent_id TEXT NOT NULL,
+          task_id TEXT,
+          fencing_token INTEGER NOT NULL,
+          reason TEXT NOT NULL DEFAULT '',
+          acquired_at INTEGER NOT NULL,
+          expires_at INTEGER NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_locks_owner ON locks(owner_agent_id);
+        CREATE INDEX IF NOT EXISTS idx_locks_pattern ON locks(pattern);
+
+        CREATE TABLE IF NOT EXISTS file_deps (
+          source_file TEXT NOT NULL,
+          target_file TEXT NOT NULL,
+          imported_symbols_json TEXT NOT NULL DEFAULT '[]',
+          file_hash TEXT NOT NULL,
+          updated_at INTEGER NOT NULL,
+          PRIMARY KEY (source_file, target_file)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_file_deps_target ON file_deps(target_file);
+
+        CREATE TABLE IF NOT EXISTS contracts (
+          id TEXT PRIMARY KEY,
+          file_path TEXT NOT NULL,
+          symbol_name TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          signature TEXT NOT NULL,
+          ast_hash TEXT NOT NULL,
+          params_fingerprint TEXT NOT NULL,
+          doc_comment TEXT NOT NULL DEFAULT '',
+          owner_agent_id TEXT,
+          version INTEGER NOT NULL DEFAULT 1,
+          is_breaking INTEGER NOT NULL DEFAULT 0,
+          updated_at INTEGER NOT NULL,
+          UNIQUE(file_path, symbol_name)
+        );
+
+        CREATE TABLE IF NOT EXISTS conflicts (
+          id TEXT PRIMARY KEY,
+          agent_a TEXT NOT NULL,
+          agent_b TEXT NOT NULL,
+          file_path TEXT NOT NULL,
+          severity TEXT NOT NULL,
+          details_json TEXT NOT NULL,
+          detected_at INTEGER NOT NULL,
+          UNIQUE(agent_a, agent_b, file_path)
+        );
+
+        CREATE TABLE IF NOT EXISTS merge_queue (
+          id TEXT PRIMARY KEY,
+          agent_id TEXT NOT NULL,
+          branch TEXT NOT NULL,
+          worktree_path TEXT,
+          status TEXT NOT NULL DEFAULT 'queued',
+          fencing_token INTEGER NOT NULL,
+          verification_cmd TEXT,
+          diagnostics_output TEXT,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS resources (
+          id TEXT PRIMARY KEY,
+          type TEXT NOT NULL,
+          name TEXT NOT NULL,
+          value TEXT NOT NULL,
+          owner_agent_id TEXT NOT NULL,
+          fencing_token INTEGER NOT NULL,
+          queue_json TEXT NOT NULL DEFAULT '[]',
+          acquired_at INTEGER NOT NULL,
+          expires_at INTEGER NOT NULL,
+          UNIQUE(type, name)
+        );
+
+        CREATE TABLE IF NOT EXISTS quarantine (
+          id TEXT PRIMARY KEY,
+          agent_id TEXT NOT NULL,
+          command TEXT NOT NULL,
+          file_path TEXT NOT NULL,
+          patch_path TEXT NOT NULL,
+          reason TEXT NOT NULL,
+          created_at INTEGER NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS events (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          timestamp INTEGER NOT NULL,
+          agent_id TEXT,
+          event_type TEXT NOT NULL,
+          payload_json TEXT NOT NULL
+        );
+      `);
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS agent_sessions (
+          agent_id TEXT PRIMARY KEY, token_hash TEXT NOT NULL, epoch INTEGER NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS mutex_waiters (
+          ticket INTEGER PRIMARY KEY AUTOINCREMENT, mutex_name TEXT NOT NULL,
+          request_id TEXT NOT NULL, owner_agent_id TEXT NOT NULL, session_epoch INTEGER NOT NULL,
+          waiter_pid INTEGER NOT NULL, waiter_start TEXT NOT NULL, expires_at INTEGER NOT NULL,
+          UNIQUE(mutex_name, request_id)
+        );
+        CREATE TABLE IF NOT EXISTS mutex_runs (
+          mutex_name TEXT PRIMARY KEY, run_id TEXT NOT NULL UNIQUE, owner_agent_id TEXT NOT NULL,
+          session_epoch INTEGER NOT NULL, fencing_token INTEGER NOT NULL,
+          supervisor_pid INTEGER NOT NULL, supervisor_start TEXT NOT NULL,
+          worker_pid INTEGER, worker_start TEXT
+        );
+      `);
+      if (version < 2) {
+        this.db.exec(`
+          UPDATE tasks SET status='queued', owner_agent_id=NULL, fencing_token=NULL
+            WHERE status='active' AND owner_agent_id IN (SELECT id FROM agents);
+          DELETE FROM locks;
+          DELETE FROM resources;
+          DELETE FROM conflicts;
+          UPDATE agents SET status='dead' WHERE status='active';
+          UPDATE meta SET value='2' WHERE key='schema_version';
+        `);
+      }
+    });
+  }
+  /**
+   * Executes a synchronous callback inside a `BEGIN IMMEDIATE` transaction
+   * with automatic jittered backoff retries if another process temporarily holds the WAL write lock.
+   */
+  withTransaction(fn, maxRetries = 12) {
+    if (this.inTransaction) {
+      return fn();
+    }
+    let attempt = 0;
+    while (true) {
+      try {
+        this.db.exec("BEGIN IMMEDIATE");
+        this.inTransaction = true;
+        try {
+          const result = fn();
+          this.db.exec("COMMIT");
+          this.inTransaction = false;
+          return result;
+        } catch (innerErr) {
+          try {
+            this.db.exec("ROLLBACK");
+          } catch {
+          }
+          this.inTransaction = false;
+          throw innerErr;
+        }
+      } catch (err) {
+        this.inTransaction = false;
+        const msg = err instanceof Error ? err.message : String(err);
+        if (attempt < maxRetries && (msg.includes("SQLITE_BUSY") || msg.includes("database is locked"))) {
+          attempt++;
+          const sleepMs = Math.min(250, 5 * Math.pow(1.5, attempt) + Math.random() * 10);
+          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.round(sleepMs));
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+  /**
+   * Atomically increments and returns the next monotonic fencing token.
+   */
+  nextFencingToken() {
+    return this.withTransaction(() => {
+      const next = this.currentFencingEpoch() + 1;
+      if (!Number.isSafeInteger(next)) throw new Error("Fencing counter exhausted; preserve state before recovery.");
+      this.db.prepare("UPDATE meta SET value=? WHERE key='fencing_epoch'").run(String(next));
+      return next;
+    });
+  }
+  currentFencingEpoch() {
+    return _CoordDatabase.fencingEpoch(this.db);
+  }
+  logEvent(agentId, eventType, payload = {}) {
+    const res = this.db.prepare(`
+        INSERT INTO events (timestamp, agent_id, event_type, payload_json)
+        VALUES (?, ?, ?, ?)
+      `).run(Date.now(), agentId, eventType, JSON.stringify(payload));
+    return Number(res.lastInsertRowid);
+  }
+  getEventsSince(sinceId, limit = 100) {
+    const rows = this.db.prepare(`
+        SELECT id, timestamp, agent_id, event_type, payload_json
+        FROM events
+        WHERE id > ?
+        ORDER BY id ASC
+        LIMIT ?
+      `).all(sinceId, limit);
+    return rows.map((r) => ({
+      id: r.id,
+      timestamp: r.timestamp,
+      agent_id: r.agent_id,
+      event_type: r.event_type,
+      payload: JSON.parse(r.payload_json)
+    }));
+  }
+  close() {
+    try {
+      this.db.close();
+    } catch {
+    }
+  }
+};
+
+// src/core/dep-graph.ts
+import crypto6 from "crypto";
+import fs8 from "fs";
+import path6 from "path";
+var DependencyAndContractEngine = class {
+  constructor(coordDb, lockEngine, fencing) {
+    this.coordDb = coordDb;
+    this.lockEngine = lockEngine;
+    this.fencing = fencing;
+  }
+  coordDb;
+  lockEngine;
+  fencing;
+  /**
+   * Scans a repository directory to index initial file dependencies and exported contracts.
+   */
+  indexRepositoryFiles(dirPath = this.coordDb.repoRoot) {
+    const files = this.walkSourceFiles(dirPath);
+    let indexedCount = 0;
+    for (const file of files) {
+      this.recordFileModification(null, file);
+      indexedCount++;
+    }
+    return indexedCount;
+  }
+  walkSourceFiles(dir, acc = []) {
+    if (!fs8.existsSync(dir) || dir !== this.coordDb.repoRoot && fs8.existsSync(path6.join(dir, ".git"))) return acc;
+    const entries = fs8.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target" || entry.name === "coverage") {
+        continue;
+      }
+      const fullPath = path6.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        this.walkSourceFiles(fullPath, acc);
+      } else if (entry.isFile() && /\.(ts|tsx|js|jsx|mjs|py)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+        acc.push(fullPath);
+      }
+    }
+    return acc;
+  }
+  /**
+   * Automatically parses a modified file's imports and exports, updates the dependency graph
+   * and Contract Blackboard, and calculates the transitive blast radius
+   * if any exported signature changed or was removed.
+   */
+  recordFileModification(agentId, rawFilePath, sourceContent) {
+    const analysis = AstAnalyzer.analyzeSource(
+      this.coordDb.repoRoot,
+      rawFilePath,
+      sourceContent
+    );
+    const relPath = analysis.filePath;
+    const now = Date.now();
+    return this.coordDb.withTransaction(() => {
+      if (agentId) this.fencing.assertSession(agentId);
+      this.coordDb.db.prepare(`DELETE FROM file_deps WHERE source_file = ?`).run(relPath);
+      for (const imp of analysis.imports) {
+        if (!imp.resolvedPath) continue;
+        this.coordDb.db.prepare(`
+            INSERT OR REPLACE INTO file_deps (
+              source_file, target_file, imported_symbols_json, file_hash, updated_at
+            )
+            VALUES (?, ?, ?, ?, ?)
+          `).run(
+          relPath,
+          imp.resolvedPath,
+          JSON.stringify(imp.importedSymbols),
+          analysis.fileHash,
+          now
+        );
+      }
+      const existingRows = this.coordDb.db.prepare(`SELECT * FROM contracts WHERE file_path = ?`).all(relPath);
+      const existingBySymbol = new Map(
+        existingRows.map((r) => [String(r.symbol_name), this.mapRowToContract(r)])
+      );
+      const newSymbolNames = new Set(analysis.exports.map((e) => e.symbolName));
+      const upsertedContracts = [];
+      const removedSymbols = [];
+      const changedSymbols = [];
+      for (const [oldName, oldContract] of existingBySymbol.entries()) {
+        if (!newSymbolNames.has(oldName)) {
+          removedSymbols.push(oldName);
+          changedSymbols.push({
+            symbolName: oldName,
+            previousSignature: oldContract.signature,
+            newSignature: null
+          });
+          this.coordDb.db.prepare(`DELETE FROM contracts WHERE id = ?`).run(oldContract.id);
+        }
+      }
+      for (const exp of analysis.exports) {
+        const prev = existingBySymbol.get(exp.symbolName);
+        const isBreaking = prev !== void 0 && prev.ast_hash !== exp.astHash;
+        if (isBreaking && prev) {
+          changedSymbols.push({
+            symbolName: exp.symbolName,
+            previousSignature: prev.signature,
+            newSignature: exp.signature
+          });
+        }
+        const contract = this.upsertContractInternal({
+          filePath: relPath,
+          symbol: exp,
+          agentId,
+          prev,
+          isBreaking,
+          now
+        });
+        upsertedContracts.push(contract);
+      }
+      const transitiveDependents = this.getTransitiveDependents(relPath, 4);
+      const breakingChanges = [];
+      if (changedSymbols.length > 0 && transitiveDependents.length > 0) {
+        const activeLocks = this.lockEngine.listLocks();
+        for (const change of changedSymbols) {
+          for (const dep of transitiveDependents) {
+            if (dep.hopDistance === 1 && dep.importedSymbols.length > 0) {
+              if (!dep.importedSymbols.includes("*") && !dep.importedSymbols.includes(change.symbolName)) {
+                continue;
+              }
+            }
+            const affectedLock = activeLocks.find(
+              (l) => l.owner_agent_id !== agentId && LockEngine.patternsOverlap(dep.filePath, l.pattern)
+            );
+            const alert = {
+              modifiedFile: relPath,
+              symbolName: change.symbolName,
+              previousSignature: change.previousSignature,
+              newSignature: change.newSignature,
+              affectedDownstreamFile: dep.filePath,
+              hopDistance: dep.hopDistance,
+              affectedAgentId: affectedLock?.owner_agent_id ?? null
+            };
+            breakingChanges.push(alert);
+            if (agentId && affectedLock) {
+              const conflictId = `conf_${crypto6.randomBytes(6).toString("hex")}`;
+              this.coordDb.db.prepare(`
+                  INSERT OR REPLACE INTO conflicts (
+                    id, agent_a, agent_b, file_path, severity, details_json, detected_at
+                  )
+                  VALUES (?, ?, ?, ?, 'transitive_contract_break', ?, ?)
+                `).run(
+                conflictId,
+                agentId,
+                affectedLock.owner_agent_id,
+                dep.filePath,
+                JSON.stringify(alert),
+                now
+              );
+            }
+          }
+        }
+        this.coordDb.logEvent(agentId, "contract_breaking_change", {
+          filePath: relPath,
+          breakingChanges
+        });
+      } else if (upsertedContracts.length > 0 && agentId) {
+        this.coordDb.logEvent(agentId, "contracts_updated", {
+          filePath: relPath,
+          symbols: upsertedContracts.map((c) => ({
+            name: c.symbol_name,
+            signature: c.signature,
+            version: c.version
+          }))
+        });
+      }
+      return {
+        filePath: relPath,
+        upsertedContracts,
+        removedSymbols,
+        breakingChanges,
+        transitiveDependents: transitiveDependents.map((d) => ({
+          filePath: d.filePath,
+          hopDistance: d.hopDistance
+        }))
+      };
+    });
+  }
+  /**
+   * Explicitly publishes a contract to the shared blackboard (e.g. REST route, env var, or type).
+   */
+  publishExplicitContract(params) {
+    const relPath = LockEngine.normalizeFile(this.coordDb.repoRoot, params.filePath);
+    const now = Date.now();
+    const astHash = crypto6.createHash("sha256").update(params.signature).digest("hex").slice(0, 16);
+    return this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(params.agentId);
+      const prevRow = this.coordDb.db.prepare(`SELECT * FROM contracts WHERE file_path = ? AND symbol_name = ?`).get(relPath, params.symbolName);
+      const prev = prevRow ? this.mapRowToContract(prevRow) : void 0;
+      const isBreaking = prev !== void 0 && prev.ast_hash !== astHash;
+      const contract = this.upsertContractInternal({
+        filePath: relPath,
+        symbol: {
+          symbolName: params.symbolName,
+          kind: params.kind,
+          signature: params.signature,
+          astHash,
+          paramsFingerprint: `${params.kind}:${params.symbolName}`,
+          docComment: params.docComment ?? ""
+        },
+        agentId: params.agentId,
+        prev,
+        isBreaking,
+        now
+      });
+      this.coordDb.logEvent(params.agentId, "contract_published", {
+        filePath: relPath,
+        symbolName: params.symbolName,
+        signature: params.signature,
+        isBreaking
+      });
+      return contract;
+    });
+  }
+  upsertContractInternal(params) {
+    const id = params.prev?.id ?? `ctr_${crypto6.randomBytes(6).toString("hex")}`;
+    const version = params.prev ? params.prev.ast_hash !== params.symbol.astHash ? params.prev.version + 1 : params.prev.version : 1;
+    this.coordDb.db.prepare(`
+        INSERT OR REPLACE INTO contracts (
+          id, file_path, symbol_name, kind, signature,
+          ast_hash, params_fingerprint, doc_comment,
+          owner_agent_id, version, is_breaking, updated_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+      id,
+      params.filePath,
+      params.symbol.symbolName,
+      params.symbol.kind,
+      params.symbol.signature,
+      params.symbol.astHash,
+      params.symbol.paramsFingerprint,
+      params.symbol.docComment,
+      params.agentId ?? params.prev?.owner_agent_id ?? null,
+      version,
+      params.isBreaking ? 1 : 0,
+      params.now
+    );
+    return {
+      id,
+      file_path: params.filePath,
+      symbol_name: params.symbol.symbolName,
+      kind: params.symbol.kind,
+      signature: params.symbol.signature,
+      ast_hash: params.symbol.astHash,
+      params_fingerprint: params.symbol.paramsFingerprint,
+      doc_comment: params.symbol.docComment,
+      owner_agent_id: params.agentId ?? params.prev?.owner_agent_id ?? null,
+      version,
+      is_breaking: params.isBreaking,
+      updated_at: params.now
+    };
+  }
+  /**
+   * Computes all files that directly or transitively import `targetFile` up to `maxHops` away.
+   */
+  getTransitiveDependents(targetFile, maxHops = 4) {
+    const normTarget = LockEngine.normalizeFile(this.coordDb.repoRoot, targetFile);
+    const visited = /* @__PURE__ */ new Map();
+    let frontier = [normTarget];
+    for (let hop = 1; hop <= maxHops; hop++) {
+      const nextFrontier = [];
+      for (const curr of frontier) {
+        const rows = this.coordDb.db.prepare(`SELECT source_file, imported_symbols_json FROM file_deps WHERE target_file = ?`).all(curr);
+        for (const r of rows) {
+          if (r.source_file === normTarget || visited.has(r.source_file)) continue;
+          visited.set(r.source_file, {
+            hopDistance: hop,
+            importedSymbols: JSON.parse(r.imported_symbols_json)
+          });
+          nextFrontier.push(r.source_file);
+        }
+      }
+      if (nextFrontier.length === 0) break;
+      frontier = nextFrontier;
+    }
+    return Array.from(visited.entries()).map(([filePath, meta]) => ({
+      filePath,
+      hopDistance: meta.hopDistance,
+      importedSymbols: meta.importedSymbols
+    }));
+  }
+  listContracts(filePathFilter) {
+    const rows = filePathFilter ? this.coordDb.db.prepare(`SELECT * FROM contracts WHERE file_path = ? ORDER BY updated_at DESC`).all(LockEngine.normalizeFile(this.coordDb.repoRoot, filePathFilter)) : this.coordDb.db.prepare(`SELECT * FROM contracts ORDER BY updated_at DESC`).all();
+    return rows.map((r) => this.mapRowToContract(r));
+  }
+  mapRowToContract(row) {
+    return {
+      id: String(row.id),
+      file_path: String(row.file_path),
+      symbol_name: String(row.symbol_name),
+      kind: row.kind,
+      signature: String(row.signature),
+      ast_hash: String(row.ast_hash),
+      params_fingerprint: String(row.params_fingerprint),
+      doc_comment: String(row.doc_comment ?? ""),
+      owner_agent_id: row.owner_agent_id ?? null,
+      version: Number(row.version),
+      is_breaking: Boolean(row.is_breaking),
+      updated_at: Number(row.updated_at)
+    };
+  }
+};
+
+// src/core/intents.ts
+import crypto7 from "crypto";
+var IntentAndTaskEngine = class {
+  constructor(coordDb, fencing, lockEngine) {
+    this.coordDb = coordDb;
+    this.fencing = fencing;
+    this.lockEngine = lockEngine;
+  }
+  coordDb;
+  fencing;
+  lockEngine;
+  /**
+   * Peer-to-Peer Mode: Declares an agent's intent, checks scope-lock collisions
+   * and reserves the scope if available.
+   */
+  declareIntent(params) {
+    this.fencing.reapDeadAgents();
+    const summary = params.intentSummary ?? params.title;
+    return this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(params.agentId);
+      const activeTasks = this.listTasks({ status: "active" }).filter(
+        (t) => t.owner_agent_id !== params.agentId
+      );
+      const taskId = `task_${crypto7.randomBytes(6).toString("hex")}`;
+      const lockRes = this.lockEngine.acquireLocks({
+        agentId: params.agentId,
+        patterns: params.scopeGlobs,
+        taskId,
+        reason: params.title
+      });
+      if (!lockRes.ok) {
+        return {
+          ok: false,
+          task: null,
+          fencingToken: lockRes.fencingToken,
+          locks: [],
+          lockConflicts: lockRes.conflicts,
+          activeSiblingIntents: activeTasks
+        };
+      }
+      const now = Date.now();
+      const normGlobs = params.scopeGlobs.map(
+        (g) => LockEngine.normalizePattern(this.fencing.getAgent(params.agentId)?.worktree_path ?? this.coordDb.repoRoot, g)
+      );
+      this.coordDb.db.prepare(`
+          INSERT INTO tasks (
+            id, title, intent_summary, status, priority,
+            owner_agent_id, fencing_token, depends_on_json, scope_globs_json,
+            created_at, updated_at
+          )
+          VALUES (?, ?, ?, 'active', 50, ?, ?, '[]', ?, ?, ?)
+        `).run(
+        taskId,
+        params.title,
+        summary,
+        params.agentId,
+        lockRes.fencingToken,
+        JSON.stringify(normGlobs),
+        now,
+        now
+      );
+      this.coordDb.logEvent(params.agentId, "intent_declared", {
+        taskId,
+        title: params.title,
+        scopeGlobs: normGlobs,
+        fencingToken: lockRes.fencingToken
+      });
+      return {
+        ok: true,
+        task: this.getTask(taskId),
+        fencingToken: lockRes.fencingToken,
+        locks: lockRes.locks,
+        lockConflicts: [],
+        activeSiblingIntents: activeTasks
+      };
+    });
+  }
+  /**
+   * Orchestrator Mode: Adds a task to the DAG queue with optional dependencies and priority.
+   */
+  addTask(params) {
+    const id = params.id ?? `task_${crypto7.randomBytes(6).toString("hex")}`;
+    const dependsOn = params.dependsOn ?? [];
+    const scopeGlobs = (params.scopeGlobs ?? []).map(
+      (g) => LockEngine.normalizePattern(this.coordDb.repoRoot, g)
+    );
+    return this.coordDb.withTransaction(() => {
+      for (const depId of dependsOn) {
+        if (depId === id) {
+          throw new Error(`Task '${id}' cannot depend on itself.`);
+        }
+        const dep = this.getTask(depId);
+        if (!dep) {
+          throw new Error(`Dependency task '${depId}' does not exist.`);
+        }
+        if (this.hasPathInDag(depId, id)) {
+          throw new Error(`Circular dependency detected between '${id}' and '${depId}'.`);
+        }
+      }
+      const now = Date.now();
+      this.coordDb.db.prepare(`
+          INSERT INTO tasks (
+            id, title, intent_summary, status, priority,
+            owner_agent_id, fencing_token, depends_on_json, scope_globs_json,
+            created_at, updated_at
+          )
+          VALUES (?, ?, ?, 'queued', ?, NULL, NULL, ?, ?, ?, ?)
+        `).run(
+        id,
+        params.title,
+        params.intentSummary ?? params.title,
+        params.priority ?? 10,
+        JSON.stringify(dependsOn),
+        JSON.stringify(scopeGlobs),
+        now,
+        now
+      );
+      this.coordDb.logEvent(null, "task_queued", { id, title: params.title, dependsOn });
+      return this.getTask(id);
+    });
+  }
+  hasPathInDag(startId, targetId, visited = /* @__PURE__ */ new Set()) {
+    if (startId === targetId) return true;
+    if (visited.has(startId)) return false;
+    visited.add(startId);
+    const task = this.getTask(startId);
+    if (!task) return false;
+    for (const dep of task.depends_on) {
+      if (this.hasPathInDag(dep, targetId, visited)) return true;
+    }
+    return false;
+  }
+  /**
+   * Orchestrator Mode: Atomically claims the highest-priority unblocked task whose scope locks are available.
+   */
+  claimNextTask(agentId) {
+    this.fencing.reapDeadAgents();
+    return this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(agentId);
+      const allTasks = this.listTasks();
+      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" };
+      }
+      for (const candidate of queued) {
+        const depsSatisfied = candidate.depends_on.every(
+          (depId) => taskById.get(depId)?.status === "done"
+        );
+        if (!depsSatisfied) continue;
+        let fencingToken = this.coordDb.currentFencingEpoch();
+        let locks = [];
+        if (candidate.scope_globs.length > 0) {
+          const lockRes = this.lockEngine.acquireLocks({
+            agentId,
+            patterns: candidate.scope_globs,
+            taskId: candidate.id,
+            reason: candidate.title
+          });
+          if (!lockRes.ok) {
+            continue;
+          }
+          fencingToken = lockRes.fencingToken;
+          locks = lockRes.locks;
+        } else {
+          fencingToken = this.coordDb.nextFencingToken();
+        }
+        const now = Date.now();
+        this.coordDb.db.prepare(`
+            UPDATE tasks
+            SET status = 'active', owner_agent_id = ?, fencing_token = ?, updated_at = ?
+            WHERE id = ?
+          `).run(agentId, fencingToken, now, candidate.id);
+        this.coordDb.logEvent(agentId, "task_claimed", {
+          taskId: candidate.id,
+          title: candidate.title,
+          fencingToken
+        });
+        return {
+          claimed: true,
+          task: this.getTask(candidate.id),
+          fencingToken,
+          locks
+        };
+      }
+      return {
+        claimed: false,
+        task: null,
+        fencingToken: null,
+        locks: [],
+        reason: "all_queued_tasks_blocked_by_dependencies_or_locks"
+      };
+    });
+  }
+  completeTask(params) {
+    return this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(params.agentId);
+      const rows = params.taskId ? [this.getTask(params.taskId)].filter((t) => t !== null) : this.listTasks({ status: "active" }).filter((t) => t.owner_agent_id === params.agentId);
+      const now = Date.now();
+      const completed = [];
+      for (const task of rows) {
+        if (task.status !== "active" || task.owner_agent_id !== params.agentId) {
+          throw new Error(
+            `Task '${task.id}' is owned by '${task.owner_agent_id}', not '${params.agentId}'.`
+          );
+        }
+        if (params.fencingToken !== void 0 && task.fencing_token !== null) {
+          this.fencing.verifyFencingToken(task.id, params.fencingToken, task.fencing_token);
+        }
+        this.coordDb.db.prepare(`UPDATE tasks SET status = 'done', updated_at = ? WHERE id = ?`).run(now, task.id);
+        if (params.releaseLocks !== false) {
+          this.coordDb.db.prepare(`DELETE FROM locks WHERE owner_agent_id = ? AND task_id = ?`).run(params.agentId, task.id);
+        }
+        this.coordDb.logEvent(params.agentId, "task_completed", { taskId: task.id });
+        completed.push(this.getTask(task.id));
+      }
+      return completed;
+    });
+  }
+  getTask(taskId) {
+    const row = this.coordDb.db.prepare(`SELECT * FROM tasks WHERE id = ?`).get(taskId);
+    if (!row) return null;
+    return {
+      id: row.id,
+      title: row.title,
+      intent_summary: row.intent_summary,
+      status: row.status,
+      priority: row.priority,
+      owner_agent_id: row.owner_agent_id,
+      fencing_token: row.fencing_token,
+      depends_on: JSON.parse(row.depends_on_json),
+      scope_globs: JSON.parse(row.scope_globs_json),
+      created_at: row.created_at,
+      updated_at: row.updated_at
+    };
+  }
+  listTasks(filter) {
+    this.fencing.reapDeadAgents();
+    const rows = filter?.status ? this.coordDb.db.prepare(`SELECT * FROM tasks WHERE status = ? ORDER BY priority DESC, created_at ASC`).all(filter.status) : this.coordDb.db.prepare(`SELECT * FROM tasks ORDER BY priority DESC, created_at ASC`).all();
+    return rows.map((row) => ({
+      id: String(row.id),
+      title: String(row.title),
+      intent_summary: String(row.intent_summary),
+      status: row.status,
+      priority: Number(row.priority),
+      owner_agent_id: row.owner_agent_id ?? null,
+      fencing_token: row.fencing_token ?? null,
+      depends_on: JSON.parse(String(row.depends_on_json)),
+      scope_globs: JSON.parse(String(row.scope_globs_json)),
+      created_at: Number(row.created_at),
+      updated_at: Number(row.updated_at)
+    }));
+  }
+};
+
+// src/core/merge-train.ts
+import { execFileSync as execFileSync4, execSync } from "child_process";
+import crypto8 from "crypto";
+import fs9 from "fs";
+import path7 from "path";
+var SpeculativeMergeTrain = class {
+  constructor(coordDb, fencing) {
+    this.coordDb = coordDb;
+    this.fencing = fencing;
+  }
+  coordDb;
+  fencing;
+  /**
+   * Enqueues and executes a Bors-style speculative integration test in an isolated staging
+   * worktree before advancing the main repository branch.
+   * Refuses Git conflicts and runs `verificationCmd` (e.g. `tsc --noEmit` or `npm test`) before fast-forwarding `main`.
+   */
+  enqueueAndMerge(params) {
+    this.fencing.assertSession(params.agentId);
+    const sessionEnv = this.fencing.sessionEnvironment(params.agentId);
+    const now = Date.now();
+    const id = `mrg_${crypto8.randomBytes(6).toString("hex")}`;
+    const token = this.coordDb.nextFencingToken();
+    this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(params.agentId);
+      this.coordDb.db.prepare(`
+          INSERT INTO merge_queue (
+            id, agent_id, branch, worktree_path, status,
+            fencing_token, verification_cmd, diagnostics_output,
+            created_at, updated_at
+          )
+          VALUES (?, ?, ?, ?, 'testing', ?, ?, NULL, ?, ?)
+        `).run(
+        id,
+        params.agentId,
+        params.branch,
+        params.worktreePath ?? null,
+        token,
+        params.verificationCmd ?? null,
+        now,
+        now
+      );
+    });
+    const stageDir = path7.join(this.coordDb.coordDir, "worktrees", `_merge_train_${id}`);
+    const lockPath = path7.join(this.coordDb.coordDir, "merge-train.lock");
+    let lockFd;
+    try {
+      try {
+        lockFd = fs9.openSync(lockPath, "wx", 384);
+        fs9.writeFileSync(lockFd, JSON.stringify({ pid: process.pid, entryId: id }));
+      } catch {
+        throw new Error("Merge train is busy. If its owner crashed, inspect .coord/merge-train.lock before removing it.");
+      }
+      const baseHead = this.gitHead(this.coordDb.repoRoot);
+      const targetBranch = this.gitBranch(this.coordDb.repoRoot);
+      if (!targetBranch) throw new Error("Merge target must be on a branch, not a detached HEAD.");
+      this.requireCleanTarget();
+      if (params.worktreePath) {
+        const registered = this.fencing.getAgent(params.agentId)?.worktree_path;
+        if (!registered || physicalPath(registered) !== physicalPath(params.worktreePath)) {
+          throw new Error("Source checkout must be the agent's registered worktree.");
+        }
+        const source = discoverRepository(params.worktreePath);
+        if (source.commonGitDir !== this.coordDb.commonGitDir || source.checkoutRoot !== physicalPath(params.worktreePath) || this.gitBranch(source.checkoutRoot) !== params.branch.replace(/^refs\/heads\//, "")) {
+          throw new Error("Source checkout repository or branch does not match the requested integration.");
+        }
+      }
+      if (params.worktreePath) {
+        const statusOut = execFileSync4("git", ["status", "--porcelain"], {
+          cwd: params.worktreePath,
+          encoding: "utf8"
+        }).trim();
+        if (statusOut.length > 0) {
+          execFileSync4("git", ["add", "-A"], { cwd: params.worktreePath, env: sessionEnv, stdio: "ignore" });
+          execFileSync4(
+            "git",
+            [
+              "commit",
+              "-m",
+              params.commitMessage ?? `feat(${params.agentId}): automated worktree checkpoint`
+            ],
+            { cwd: params.worktreePath, env: sessionEnv, stdio: "ignore" }
+          );
+        }
+      }
+      const sourceSha = execFileSync4("git", ["rev-parse", "--verify", "--end-of-options", `${params.branch}^{commit}`], {
+        cwd: this.coordDb.repoRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+      }).trim();
+      this.cleanupStageWorktree(stageDir);
+      execFileSync4("git", ["worktree", "add", "--detach", stageDir, baseHead], {
+        cwd: this.coordDb.repoRoot,
+        stdio: "ignore"
+      });
+      const rootNodeModules = path7.join(this.coordDb.repoRoot, "node_modules");
+      const stageNodeModules = path7.join(stageDir, "node_modules");
+      const hydratedNodeModules = fs9.existsSync(rootNodeModules) && !fs9.existsSync(stageNodeModules);
+      if (hydratedNodeModules) {
+        fs9.symlinkSync(rootNodeModules, stageNodeModules, "dir");
+      }
+      try {
+        execFileSync4(
+          "git",
+          ["merge", "--no-ff", "-m", `Merge branch '${params.branch}' (${params.agentId})`, sourceSha],
+          {
+            cwd: stageDir,
+            env: sessionEnv,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"]
+          }
+        );
+      } catch {
+        const conflictedFiles = execFileSync4("git", ["diff", "--name-only", "--diff-filter=U", "-z"], {
+          cwd: stageDir,
+          encoding: "utf8"
+        }).split("\0").filter(Boolean);
+        throw new Error(conflictedFiles.length ? `Merge conflicts in ${conflictedFiles.map((file) => JSON.stringify(file)).join(", ")}. Resolve conflicts in '${params.branch}' before merging.` : `git merge failed on branch '${params.branch}'.`);
+      }
+      const verifiedSha = this.gitHead(stageDir);
+      let diagnostics = "Speculative merge clean.";
+      if (params.verificationCmd) {
+        try {
+          const out = execSync(params.verificationCmd, {
+            cwd: stageDir,
+            env: sessionEnv,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 12e4
+          });
+          diagnostics = `Verification passed (${params.verificationCmd}):
+${out.trim()}`.trim();
+        } catch (verifyErr) {
+          const stdout = verifyErr?.stdout ?? "";
+          const stderr = verifyErr?.stderr ?? "";
+          const combined = `${stdout}
+${stderr}`.trim();
+          throw new Error(
+            `Speculative verification failed ('${params.verificationCmd}'):
+${combined}`
+          );
+        }
+      }
+      const stageChanges = execFileSync4("git", ["status", "--porcelain", "-z", "--untracked-files=normal"], {
+        cwd: stageDir,
+        encoding: "utf8"
+      }).split("\0").filter(Boolean);
+      const unchangedHydration = hydratedNodeModules && fs9.lstatSync(stageNodeModules, { throwIfNoEntry: false })?.isSymbolicLink() && fs9.readlinkSync(stageNodeModules) === rootNodeModules;
+      if (this.gitHead(stageDir) !== verifiedSha || stageChanges.some((change) => !(unchangedHydration && change === "?? node_modules"))) {
+        throw new Error("Verification changed the staging checkout. Apply fixes in the source worktree and retry with a read-only check.");
+      }
+      if (this.gitHead(this.coordDb.repoRoot) !== baseHead || this.gitBranch(this.coordDb.repoRoot) !== targetBranch) {
+        throw new Error("Merge target changed during verification. Retry against the new target.");
+      }
+      this.fencing.assertSession(params.agentId);
+      this.requireCleanTarget();
+      execFileSync4("git", ["merge", "--ff-only", verifiedSha], {
+        cwd: this.coordDb.repoRoot,
+        stdio: "ignore"
+      });
+      this.cleanupStageWorktree(stageDir);
+      const updatedAt = Date.now();
+      this.coordDb.withTransaction(() => {
+        this.coordDb.db.prepare(`
+            UPDATE merge_queue
+            SET status = 'merged', diagnostics_output = ?, updated_at = ?
+            WHERE id = ?
+          `).run(diagnostics, updatedAt, id);
+        this.coordDb.logEvent(params.agentId, "merge_train_succeeded", {
+          id,
+          branch: params.branch,
+          verifiedSha
+        });
+      });
+      return {
+        merged: true,
+        entry: this.getEntry(id),
+        mergedCommitSha: verifiedSha,
+        diagnostics
+      };
+    } catch (err) {
+      this.cleanupStageWorktree(stageDir);
+      const diagnostics = err instanceof Error ? err.message : String(err);
+      const updatedAt = Date.now();
+      this.coordDb.withTransaction(() => {
+        this.coordDb.db.prepare(`
+            UPDATE merge_queue
+            SET status = 'failed', diagnostics_output = ?, updated_at = ?
+            WHERE id = ?
+          `).run(diagnostics, updatedAt, id);
+        this.coordDb.logEvent(params.agentId, "merge_train_failed", {
+          id,
+          branch: params.branch,
+          diagnostics
+        });
+      });
+      return {
+        merged: false,
+        entry: this.getEntry(id),
+        mergedCommitSha: null,
+        diagnostics
+      };
+    } finally {
+      if (lockFd !== void 0) {
+        fs9.closeSync(lockFd);
+        fs9.unlinkSync(lockPath);
+      }
+    }
+  }
+  gitHead(cwd) {
+    return execFileSync4("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" }).trim();
+  }
+  gitBranch(cwd) {
+    return execFileSync4("git", ["symbolic-ref", "--quiet", "--short", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  }
+  requireCleanTarget() {
+    const status = execFileSync4("git", ["status", "--porcelain", "--untracked-files=normal"], {
+      cwd: this.coordDb.repoRoot,
+      encoding: "utf8"
+    });
+    if (status.split(/\r?\n/).some((line) => line && line !== "?? .coord/")) {
+      throw new Error("Merge target has local changes. Commit or preserve them before integrating.");
+    }
+  }
+  cleanupStageWorktree(stageDir) {
+    if (!fs9.existsSync(stageDir)) return;
+    try {
+      execFileSync4("git", ["worktree", "remove", "--force", stageDir], {
+        cwd: this.coordDb.repoRoot,
+        stdio: "ignore"
+      });
+    } catch {
+      if (fs9.existsSync(stageDir)) {
+        fs9.rmSync(stageDir, { recursive: true, force: true });
+      }
+      try {
+        execFileSync4("git", ["worktree", "prune"], {
+          cwd: this.coordDb.repoRoot,
+          stdio: "ignore"
+        });
+      } catch {
+      }
+    }
+  }
+  getEntry(id) {
+    const row = this.coordDb.db.prepare(`SELECT * FROM merge_queue WHERE id = ?`).get(id);
+    return row ?? null;
+  }
+  listQueue() {
+    return this.coordDb.db.prepare(`SELECT * FROM merge_queue ORDER BY created_at DESC`).all();
+  }
+};
+
+// src/core/shadow-git.ts
+import { execFileSync as execFileSync5 } from "child_process";
+import crypto9 from "crypto";
+import fs10 from "fs";
+import path8 from "path";
+var ShadowGitEngine = class {
+  constructor(coordDb, fencing) {
+    this.coordDb = coordDb;
+    this.fencing = fencing;
+  }
+  coordDb;
+  fencing;
+  isGitRepository(dir = this.coordDb.repoRoot) {
+    try {
+      execFileSync5("git", ["rev-parse", "--is-inside-work-tree"], {
+        cwd: dir,
+        stdio: "ignore"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getHeadCommit(dir = this.coordDb.repoRoot) {
+    try {
+      return execFileSync5("git", ["rev-parse", "HEAD"], {
+        cwd: dir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+    } catch {
+      return null;
+    }
+  }
+  getShadowIndexPath(agentId) {
+    const safeId = agentId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const epoch = this.fencing.assertSession(agentId);
+    return path8.join(this.coordDb.coordDir, "shadow-index", `${safeId}-${epoch}.index`);
+  }
+  /**
+   * Updates an agent's ephemeral shadow Git index (`.coord/shadow-index/<agent-id>.index`)
+   * without touching the repository's real `.git/index`, and creates a synthetic shadow
+   * commit object in `.git/objects` so `git merge-tree --write-tree` can run 3-way merges
+   * across uncommitted files in <15ms.
+   */
+  updateAgentShadowTree(params) {
+    this.fencing.assertSession(params.agentId);
+    const targetDir = params.worktreeDir ?? this.coordDb.repoRoot;
+    if (!this.isGitRepository(targetDir)) return null;
+    const headCommit = this.getHeadCommit(targetDir);
+    if (!headCommit) return null;
+    const shadowIndex = this.getShadowIndexPath(params.agentId);
+    const env = { ...process.env, GIT_INDEX_FILE: shadowIndex };
+    if (!fs10.existsSync(shadowIndex)) {
+      execFileSync5("git", ["read-tree", headCommit], {
+        cwd: targetDir,
+        env,
+        stdio: "ignore"
+      });
+    }
+    if (params.worktreeDir && (!params.modifiedFiles || params.modifiedFiles.length === 0)) {
+      execFileSync5("git", ["read-tree", headCommit], {
+        cwd: targetDir,
+        env,
+        stdio: "ignore"
+      });
+      execFileSync5("git", ["add", "-A"], {
+        cwd: targetDir,
+        env,
+        stdio: "ignore"
+      });
+    } else if (params.modifiedFiles && params.modifiedFiles.length > 0) {
+      for (const mod of params.modifiedFiles) {
+        const relPath = LockEngine.normalizeFile(targetDir, mod.filePath);
+        const absPath = path8.join(targetDir, relPath);
+        const content = mod.content ?? (fs10.existsSync(absPath) ? fs10.readFileSync(absPath, "utf8") : null);
+        if (content === null) {
+          {
+            execFileSync5("git", ["--literal-pathspecs", "update-index", "--force-remove", "--", relPath], {
+              cwd: targetDir,
+              env,
+              stdio: "ignore"
+            });
+          }
+        } else {
+          const tracked = execFileSync5("git", ["--literal-pathspecs", "ls-files", "--stage", "-z", "--", relPath], {
+            cwd: targetDir,
+            env,
+            encoding: "utf8"
+          }).split("\0").find(Boolean);
+          const trackedMode = tracked?.split(" ")[0];
+          const stat = fs10.existsSync(absPath) ? fs10.lstatSync(absPath) : null;
+          if (trackedMode && !["100644", "100755"].includes(trackedMode) || stat?.isSymbolicLink()) {
+            throw new Error(`Cannot report symlinks or special entries as source content: ${relPath}`);
+          }
+          const mode = trackedMode ?? (stat && stat.mode & 73 ? "100755" : "100644");
+          const blobSha = execFileSync5("git", ["hash-object", "-w", "--stdin"], {
+            cwd: targetDir,
+            input: content,
+            encoding: "utf8"
+          }).trim();
+          execFileSync5(
+            "git",
+            ["update-index", "--add", "--cacheinfo", `${mode},${blobSha},${relPath}`],
+            {
+              cwd: targetDir,
+              env,
+              stdio: "ignore"
+            }
+          );
+        }
+      }
+    }
+    const treeSha = execFileSync5("git", ["write-tree"], {
+      cwd: targetDir,
+      env,
+      encoding: "utf8"
+    }).trim();
+    const shadowCommitSha = execFileSync5(
+      "git",
+      ["commit-tree", treeSha, "-p", headCommit, "-m", `kith-shadow:${params.agentId}`],
+      {
+        cwd: targetDir,
+        encoding: "utf8"
+      }
+    ).trim();
+    this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(params.agentId);
+      this.coordDb.db.prepare(`UPDATE agents SET shadow_tree_sha = ? WHERE id = ?`).run(shadowCommitSha, params.agentId);
+    });
+    return shadowCommitSha;
+  }
+  /**
+   * Runs `git merge-tree --write-tree` across `agentId`'s dirty shadow commit and every
+   * other active agent's dirty shadow commit (or branch).
+   */
+  probeAllActiveConflicts(agentId, modifiedFiles, worktreeDir) {
+    const myShadowCommit = this.updateAgentShadowTree({
+      agentId,
+      modifiedFiles,
+      worktreeDir
+    });
+    if (!myShadowCommit) {
+      return { clean: true, mergedTreeSha: null, conflicts: [] };
+    }
+    const activeAgents = this.fencing.listAgents(true).filter((a) => a.id !== agentId && a.shadow_tree_sha);
+    const allConflicts = [];
+    let lastMergedTreeSha = null;
+    this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(agentId);
+      this.coordDb.db.prepare(`DELETE FROM conflicts WHERE (agent_a = ? OR agent_b = ?) AND severity IN ('text_conflict', 'ast_conflict', 'auto_mergeable')`).run(agentId, agentId);
+    });
+    for (const peer of activeAgents) {
+      if (!peer.shadow_tree_sha) continue;
+      const res = this.probePairConflict(
+        agentId,
+        myShadowCommit,
+        peer.id,
+        peer.shadow_tree_sha
+      );
+      if (res.mergedTreeSha) {
+        lastMergedTreeSha = res.mergedTreeSha;
+      }
+      allConflicts.push(...res.conflicts);
+    }
+    return {
+      clean: allConflicts.length === 0,
+      mergedTreeSha: lastMergedTreeSha,
+      conflicts: allConflicts
+    };
+  }
+  probePairConflict(agentA, commitA, agentB, commitB) {
+    this.fencing.assertSession(agentA);
+    try {
+      const stdout = execFileSync5(
+        "git",
+        ["merge-tree", "--write-tree", "-z", commitA, commitB],
+        {
+          cwd: this.coordDb.repoRoot,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"]
+        }
+      ).trim();
+      const mergedTreeSha = stdout.split("\0")[0]?.trim() ?? null;
+      return {
+        clean: true,
+        mergedTreeSha,
+        conflicts: []
+      };
+    } catch (err) {
+      const stdout = typeof err?.stdout === "string" ? err.stdout ?? "" : "";
+      const stageBlobsByFile = /* @__PURE__ */ new Map();
+      for (const line of stdout.split("\0")) {
+        const m = line.match(/^(\d{6}) ([0-9a-f]+) ([123])\t([\s\S]+)$/);
+        if (m) {
+          const [, , blobSha, stage, filePath] = m;
+          const entry = stageBlobsByFile.get(filePath) ?? {};
+          if (stage === "1") entry.stage1 = blobSha;
+          if (stage === "2") entry.stage2 = blobSha;
+          if (stage === "3") entry.stage3 = blobSha;
+          stageBlobsByFile.set(filePath, entry);
+        }
+      }
+      if (stageBlobsByFile.size === 0) {
+        throw new Error(`git merge-tree failed without a usable conflict result: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      const conflicts = [];
+      const now = Date.now();
+      for (const [filePath, stages] of stageBlobsByFile.entries()) {
+        const severity = "text_conflict";
+        const record = {
+          id: `conf_${crypto9.randomBytes(6).toString("hex")}`,
+          agent_a: agentA,
+          agent_b: agentB,
+          file_path: filePath,
+          severity,
+          details: {
+            reason: "Git merge conflict requires explicit resolution",
+            baseBlob: stages.stage1,
+            blobA: stages.stage2,
+            blobB: stages.stage3
+          },
+          detected_at: now
+        };
+        this.coordDb.withTransaction(() => {
+          this.fencing.assertSession(agentA);
+          this.coordDb.db.prepare(`
+            INSERT OR REPLACE INTO conflicts (
+              id, agent_a, agent_b, file_path, severity, details_json, detected_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+          `).run(
+            record.id,
+            agentA,
+            agentB,
+            filePath,
+            severity,
+            JSON.stringify(record.details),
+            now
+          );
+        });
+        conflicts.push(record);
+      }
+      this.fencing.assertSession(agentA);
+      if (conflicts.length) {
+        this.coordDb.logEvent(agentA, "dirty_merge_conflict", {
+          peerAgent: agentB,
+          files: conflicts.map((c) => c.file_path)
+        });
+      }
+      return {
+        clean: false,
+        mergedTreeSha: null,
+        conflicts
+      };
+    }
+  }
+  listConflicts() {
+    this.fencing.reapDeadAgents();
+    const rows = this.coordDb.db.prepare(`SELECT * FROM conflicts ORDER BY detected_at DESC`).all();
+    return rows.map((r) => ({
+      id: String(r.id),
+      agent_a: String(r.agent_a),
+      agent_b: String(r.agent_b),
+      file_path: String(r.file_path),
+      severity: r.severity,
+      details: JSON.parse(String(r.details_json)),
+      detected_at: Number(r.detected_at)
+    }));
+  }
+};
+
+// src/core/worktree-cow.ts
+import { execFileSync as execFileSync6 } from "child_process";
+import fs11 from "fs";
+import path9 from "path";
+var CoWWorktreeManager = class _CoWWorktreeManager {
+  constructor(coordDb, fencing) {
+    this.coordDb = coordDb;
+    this.fencing = fencing;
+  }
+  coordDb;
+  fencing;
+  static HYDRATABLE_DIRS = ["node_modules", ".venv", "venv", ".turbo"];
+  static ENV_FILES = [".env", ".env.local", ".env.development", ".env.test"];
+  /**
+   * Spawns an isolated Git worktree for `agentId` and hydrates `node_modules` / `.env`
+   * using APFS Copy-on-Write (`cp -cR`) on macOS or reflink on Linux (with independent-copy fallback).
+   */
+  spawnWorktree(params) {
+    this.fencing.assertSession(params.agentId);
+    const start = Date.now();
+    const safeId = params.agentId.replace(/[^a-zA-Z0-9_-]/g, "-");
+    const branch = params.branch ?? `kith/${safeId}`;
+    const baseRef = params.baseRef ?? "HEAD";
+    const worktreePath = path9.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)) {
+      throw new Error(`Worktree already exists: ${worktreePath}. Commit or preserve its work before removing it.`);
+    }
+    fs11.mkdirSync(path9.dirname(worktreePath), { recursive: true });
+    execFileSync6("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 = path9.join(this.coordDb.repoRoot, dirName);
+      const destDir = path9.join(worktreePath, dirName);
+      if (!fs11.existsSync(srcDir) || fs11.existsSync(destDir)) continue;
+      const method = this.cloneDirectoryCoW(srcDir, destDir);
+      hydrationMethod = method;
+      hydratedDirs.push(dirName);
+    }
+    for (const envName of _CoWWorktreeManager.ENV_FILES) {
+      const srcEnv = path9.join(this.coordDb.repoRoot, envName);
+      const destEnv = path9.join(worktreePath, envName);
+      if (fs11.existsSync(srcEnv) && !fs11.existsSync(destEnv)) {
+        fs11.copyFileSync(srcEnv, destEnv);
+      }
+    }
+    this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(params.agentId);
+      this.coordDb.db.prepare(`UPDATE agents SET worktree_path = ?, branch = ? WHERE id = ?`).run(worktreePath, branch, params.agentId);
+      this.coordDb.logEvent(params.agentId, "worktree_spawned", {
+        worktreePath,
+        branch,
+        hydrationMethod,
+        hydratedDirs
+      });
+    });
+    return {
+      agentId: params.agentId,
+      worktreePath,
+      branch,
+      hydrationMethod,
+      hydratedDirs,
+      durationMs: Date.now() - start
+    };
+  }
+  cloneDirectoryCoW(srcDir, destDir) {
+    if (process.platform === "darwin") {
+      try {
+        execFileSync6("cp", ["-cR", srcDir, destDir], {
+          stdio: "ignore",
+          timeout: 5e3
+        });
+        return "apfs-cow";
+      } catch {
+      }
+    } else if (process.platform === "linux") {
+      try {
+        execFileSync6("cp", ["--reflink=always", "-R", srcDir, destDir], {
+          stdio: "ignore",
+          timeout: 5e3
+        });
+        return "reflink-cow";
+      } catch {
+      }
+    }
+    fs11.rmSync(destDir, { recursive: true, force: true });
+    fs11.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 = path9.join(this.coordDb.coordDir, "worktrees", safeId);
+    if (!fs11.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"], {
+      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], {
+      cwd: this.coordDb.repoRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.coordDb.withTransaction(() => {
+      this.fencing.assertSession(agentId);
+      this.coordDb.db.prepare(`UPDATE agents SET worktree_path = NULL, branch = NULL WHERE id = ?`).run(agentId);
+    });
+    return true;
+  }
+  listWorktrees() {
+    try {
+      const out = execFileSync6("git", ["worktree", "list", "--porcelain"], {
+        cwd: this.coordDb.repoRoot,
+        encoding: "utf8"
+      });
+      const entries = [];
+      let current = null;
+      for (const line of out.split(/\r?\n/)) {
+        if (line.startsWith("worktree ")) {
+          if (current) entries.push(current);
+          current = { path: line.slice("worktree ".length).trim(), head: "", branch: null };
+        } else if (line.startsWith("HEAD ") && current) {
+          current.head = line.slice("HEAD ".length).trim();
+        } else if (line.startsWith("branch ") && current) {
+          current.branch = line.slice("branch ".length).replace(/^refs\/heads\//, "").trim();
+        }
+      }
+      if (current) entries.push(current);
+      return entries;
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/core/engine.ts
+var KithEngine = class {
+  coordDb;
+  fencing;
+  locks;
+  intents;
+  depGraph;
+  shadowGit;
+  worktrees;
+  mergeTrain;
+  bashGuard;
+  broker;
+  constructor(repoRoot = process.cwd(), customDbPath) {
+    this.coordDb = new CoordDatabase(repoRoot, customDbPath);
+    this.fencing = new FencingAndAgentManager(this.coordDb);
+    this.locks = new LockEngine(this.coordDb, this.fencing);
+    this.intents = new IntentAndTaskEngine(this.coordDb, this.fencing, this.locks);
+    this.depGraph = new DependencyAndContractEngine(this.coordDb, this.locks, this.fencing);
+    this.shadowGit = new ShadowGitEngine(this.coordDb, this.fencing);
+    this.worktrees = new CoWWorktreeManager(this.coordDb, this.fencing);
+    this.mergeTrain = new SpeculativeMergeTrain(this.coordDb, this.fencing);
+    this.bashGuard = new BashMerkleGuard(
+      this.coordDb,
+      this.fencing,
+      this.locks,
+      this.depGraph,
+      this.shadowGit
+    );
+    this.broker = new ResourceBroker(this.coordDb, this.fencing);
+  }
+  /**
+   * Executes the complete PostToolUse pipeline whenever an agent writes or edits a file:
+   * 1. Extracts AST exports/imports and updates the Contract Blackboard & Import Graph
+   * 2. Computes transitive breaking-change blast radius across downstream dependent files
+   * 3. Updates the agent's shadow Git index (`GIT_INDEX_FILE`) and runs `git merge-tree` against sibling dirty trees
+   */
+  processPostFileEdit(params) {
+    this.fencing.heartbeat(params.agentId);
+    const targetRoot = params.worktreeDir ?? this.fencing.getAgent(params.agentId)?.worktree_path ?? this.coordDb.repoRoot;
+    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(path10.join(targetRoot, file)) ? fs12.readFileSync(path10.join(targetRoot, file), "utf8") : "");
+    const contractReport = this.depGraph.recordFileModification(
+      params.agentId,
+      file,
+      content
+    );
+    const mergeProbe = this.shadowGit.probeAllActiveConflicts(
+      params.agentId,
+      [{ filePath: file, content }],
+      targetRoot
+    );
+    const warnings = [];
+    const existingSymbols = this.coordDb.db.prepare(`
+      SELECT peer.symbol_name, peer.kind, peer.file_path
+      FROM contracts AS edited JOIN contracts AS peer
+        ON peer.symbol_name = edited.symbol_name COLLATE BINARY AND peer.kind = edited.kind
+      WHERE edited.file_path = ? AND peer.file_path != edited.file_path
+      ORDER BY peer.symbol_name, peer.file_path
+    `).all(file);
+    for (const symbol of existingSymbols) {
+      warnings.push(`[EXISTING SYMBOL] '${symbol.symbol_name}' (${symbol.kind}) is also recorded in '${symbol.file_path}'. Consider reuse if it serves the same purpose.`);
+    }
+    for (const brk of contractReport.breakingChanges) {
+      const targetWho = brk.affectedAgentId ? ` (actively locked by agent '${brk.affectedAgentId}')` : "";
+      warnings.push(
+        `[BLAST RADIUS ALERT] Breaking signature change on '${brk.symbolName}' in '${brk.modifiedFile}' impacts downstream consumer '${brk.affectedDownstreamFile}' (${brk.hopDistance} hop(s) away)${targetWho}.`
+      );
+    }
+    for (const conf of mergeProbe.conflicts) {
+      const peer = conf.agent_a === params.agentId ? conf.agent_b : conf.agent_a;
+      warnings.push(
+        `[LIVE DIRTY-TREE CONFLICT] Uncommitted changes in '${conf.file_path}' conflict with active agent '${peer}' (${conf.severity}: ${conf.details.reason}).`
+      );
+    }
+    return {
+      filePath: file,
+      contractReport,
+      dirtyMergeConflicts: mergeProbe.conflicts,
+      warnings
+    };
+  }
+  /**
+   * Consumes unread coordination events and active conflicts for `agentId` since its last tool call
+   * and formats a concise context-delta footer to append to MCP/CLI responses.
+   */
+  consumeAgentDelta(agentId) {
+    this.fencing.assertSession(agentId);
+    const agent = this.fencing.getAgent(agentId);
+    const sinceId = agent?.last_seen_event_id ?? 0;
+    const page = this.coordDb.getEventsSince(sinceId, 50);
+    const allNewEvents = page.filter((e) => e.agent_id !== agentId);
+    const deliveredId = page.at(-1)?.id ?? sinceId;
+    if (agent && deliveredId > sinceId) {
+      this.coordDb.withTransaction(() => {
+        this.fencing.assertSession(agentId);
+        this.coordDb.db.prepare(`UPDATE agents SET last_seen_event_id = ? WHERE id = ?`).run(deliveredId, agentId);
+      });
+    }
+    const activeConflicts = this.shadowGit.listConflicts().filter(
+      (c) => c.agent_a === agentId || c.agent_b === agentId
+    );
+    const lines = [];
+    for (const ev of allNewEvents) {
+      if (ev.event_type === "contracts_updated" || ev.event_type === "contract_published" || ev.event_type === "contract_breaking_change" || ev.event_type === "intent_declared") {
+        lines.push(`\u2022 [${ev.event_type}] by ${ev.agent_id ?? "system"}: ${JSON.stringify(ev.payload)}`);
+      }
+    }
+    for (const c of activeConflicts) {
+      const peer = c.agent_a === agentId ? c.agent_b : c.agent_a;
+      lines.push(
+        `\u2022 [ACTIVE CONFLICT] ${c.file_path} with agent '${peer}' (${c.severity}: ${c.details.reason})`
+      );
+    }
+    const formattedFooter = lines.length > 0 ? `
+
+--- KITH LIVE SIBLING DELTA ---
+${lines.join("\n")}` : "";
+    return {
+      events: allNewEvents,
+      activeConflicts,
+      formattedFooter
+    };
+  }
+  getStatus() {
+    const agents = this.fencing.listAgents(true);
+    return {
+      protocolVersion: KITH_PROTOCOL_VERSION,
+      repository: { root: this.coordDb.repoRoot, commonGitDir: this.coordDb.commonGitDir, coordDir: this.coordDb.coordDir },
+      runtime: { node: process.version },
+      fencingEpoch: this.coordDb.currentFencingEpoch(),
+      agents,
+      locks: this.locks.listLocks(),
+      tasks: this.intents.listTasks(),
+      conflicts: this.shadowGit.listConflicts(),
+      contracts: this.depGraph.listContracts(),
+      resources: this.broker.listResources(),
+      mergeQueue: this.mergeTrain.listQueue(),
+      quarantined: this.bashGuard.listQuarantined(),
+      mutexWaiters: this.coordDb.db.prepare("SELECT ticket,mutex_name,owner_agent_id,session_epoch,expires_at FROM mutex_waiters ORDER BY ticket").all(),
+      commandGuards: this.coordDb.db.prepare("SELECT mutex_name,owner_agent_id,worker_pid,supervisor_pid FROM mutex_runs ORDER BY mutex_name").all(),
+      workspaces: observeWorkspaces(this.coordDb.repoRoot, agents)
+    };
+  }
+  previewIntegration(agentId) {
+    this.fencing.assertSession(agentId);
+    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 };
+  }
+  completeWork(params) {
+    this.fencing.assertSession(params.agentId);
+    const agent = this.fencing.getAgent(params.agentId);
+    const branch = params.mergeBranch ?? agent?.branch;
+    const mergeResult = branch ? this.mergeTrain.enqueueAndMerge({
+      agentId: params.agentId,
+      branch,
+      worktreePath: agent?.worktree_path,
+      verificationCmd: params.verificationCmd
+    }) : null;
+    if (mergeResult && !mergeResult.merged) return {
+      ok: false,
+      mergeResult,
+      error: "Speculative merge train failed. Fix the reported issues before completing work."
+    };
+    const completedTasks = this.intents.completeTask(params);
+    this.fencing.completeAgentSession(params.agentId);
+    return { ok: true, completedTasks, mergeResult };
+  }
+  close() {
+    if (this.broker.hasActiveCommands()) throw new Error("Await or cancel active mutex commands before closing Kith");
+    this.coordDb.close();
+  }
+};
+
+// src/core/observation.ts
+import fs13 from "fs";
+import os from "os";
+import path11 from "path";
+import { createRequire as createRequire2 } from "module";
+var { DatabaseSync: DatabaseSync2 } = createRequire2(import.meta.url)("node:sqlite");
+function readCoordinationState(directory = process.cwd()) {
+  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 = path11.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 = path11.dirname(current)) {
+      const local = path11.join(current, ".coord");
+      if (local !== layout.coordDir && fs13.existsSync(path11.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(path11.join(layout.coordDir, name))) || ["-wal", "-shm", "-journal"].some((s) => fs13.existsSync(file + s)) || ["worktrees", "quarantine", "snapshots", "shadow-index", "setup"].some((name) => {
+        const p = path11.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(path11.join(os.tmpdir(), "kith-observe-"));
+    for (let i = 0; i < files.length; i++) if (before[i]) {
+      const target = path11.join(scratch, path11.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(path11.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; 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");
+    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 = path11.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: path11.join(retainedRoot, entry.name),
+    symlink: entry.isSymbolicLink(),
+    agentIds: state.agents.filter((a) => a.worktree_path === path11.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: path11.join(state.repository.coordDir, "setup.lock"), present: fs13.existsSync(path11.join(state.repository.coordDir, "setup.lock")) },
+    integrationLock: { path: path11.join(state.repository.coordDir, "merge-train.lock"), present: fs13.existsSync(path11.join(state.repository.coordDir, "merge-train.lock")) }
+  };
+}
+export {
+  AstAnalyzer,
+  BashMerkleGuard,
+  CoWWorktreeManager,
+  CoordDatabase,
+  DependencyAndContractEngine,
+  FencingAndAgentManager,
+  IntentAndTaskEngine,
+  KITH_PROTOCOL_VERSION,
+  KITH_VERSION,
+  KithEngine,
+  LockEngine,
+  ResourceBroker,
+  SessionOwnershipError,
+  ShadowGitEngine,
+  SpeculativeMergeTrain,
+  StaleFencingTokenError,
+  caseSensitivePaths,
+  discoverRepository,
+  isWithin,
+  observeWorkspaces,
+  physicalPath,
+  previewIntegration,
+  readCoordinationState,
+  recoveryReport,
+  repositoryFile,
+  worktreeChanges
+};
+//# sourceMappingURL=index.js.map