kith-coord 0.1.4 → 0.1.5

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.5 — 2026-10-22
+
+- Group read-only radar observations by checkout, distinguishing current recorded Kith leases, retained sessions, unregistered checkouts and unavailable ownership. Label counts as paths to review before integration, with full checkout/owner details and preservation guidance. Reuse the same snapshot in the optional editor view without extra status subprocesses. No ownership, recovery or cleanup behavior changes.
+- Label checkout counts as shared paths and recent file mtimes as the six shown within a five-minute window; improve read-only menu text contrast.
+
 ## 0.1.4 — 2026-10-22
 
 - Include the optional existing VS Code/Cursor adapter, bundling the same Kith core and a read-only view. Preserve existing MCP configuration and native trust/approval controls.

package/README.md

@@ -43,7 +43,7 @@ Git recording and integration require a commit identity configured for the repos
 Install the release:
 
 ```sh
-npm install --global kith-coord@0.1.4
+npm install --global kith-coord@0.1.5
 ```
 
 Choose the setup scope your client needs:

package/dist/cli/index.js

@@ -6,7 +6,7 @@ import path19 from "path";
 import { spawn } from "child_process";
 
 // src/version.ts
-var KITH_VERSION = "0.1.4";
+var KITH_VERSION = "0.1.5";
 var KITH_PROTOCOL_VERSION = "1.3.0";
 
 // src/cli/setup-ledger.ts
@@ -793,7 +793,7 @@ function previewIntegration(repoRoot, agent) {
 
 // src/core/observation.ts
 var { DatabaseSync: DatabaseSync2 } = createRequire2(import.meta.url)("node:sqlite");
-function readCoordinationState(directory = process.cwd()) {
+function readCoordinationState(directory = process.cwd(), options = {}) {
   const layout = discoverRepository(directory), observedAt = Date.now();
   const empty = {
     protocolVersion: KITH_PROTOCOL_VERSION,
@@ -852,6 +852,10 @@ function readCoordinationState(directory = process.cwd()) {
     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");
+    if (options.ownersOnly) {
+      db.exec("COMMIT");
+      return { ...empty, state: "ready", agents };
+    }
     const state = {
       ...empty,
       state: "ready",
@@ -4925,6 +4929,8 @@ var PassiveConflictWatcher = class _PassiveConflictWatcher {
   activeCollisions = /* @__PURE__ */ new Map();
   repositories = /* @__PURE__ */ new Map();
   errors = [];
+  primaryRoots = /* @__PURE__ */ new Map();
+  worktrees = [];
   static notifyMac(title, message) {
     if (process.platform !== "darwin") return;
     try {
@@ -4935,6 +4941,7 @@ var PassiveConflictWatcher = class _PassiveConflictWatcher {
   discoverGitRepos() {
     this.errors = [];
     this.repositories.clear();
+    this.primaryRoots.clear();
     const candidates = [];
     const marker = (dir) => {
       try {
@@ -4963,6 +4970,7 @@ var PassiveConflictWatcher = class _PassiveConflictWatcher {
         const layout = discoverRepository(candidate);
         if (!layout.commonGitDir) throw new Error("Git repository unavailable");
         this.repositories.set(layout.checkoutRoot, layout.commonGitDir);
+        if (!layout.isLinkedWorktree) this.primaryRoots.set(layout.commonGitDir, layout.checkoutRoot);
         if (inspected.has(layout.commonGitDir)) continue;
         inspected.add(layout.commonGitDir);
         const listing = execFileSync10("git", ["worktree", "list", "--porcelain", "-z"], { cwd: layout.checkoutRoot, encoding: "utf8", timeout: 4e3, maxBuffer: 4 * 1024 * 1024, stdio: ["ignore", "pipe", "pipe"] });
@@ -4970,6 +4978,7 @@ var PassiveConflictWatcher = class _PassiveConflictWatcher {
           const linked = discoverRepository(record.slice(9));
           if (linked.commonGitDir !== layout.commonGitDir) throw new Error("Worktree repository identity changed during discovery");
           this.repositories.set(linked.checkoutRoot, layout.commonGitDir);
+          if (!linked.isLinkedWorktree) this.primaryRoots.set(layout.commonGitDir, linked.checkoutRoot);
         }
       } catch (error) {
         this.errors.push({ repository: candidate, message: `Cannot inspect repository: ${error instanceof Error ? error.message : String(error)}` });
@@ -4982,10 +4991,11 @@ var PassiveConflictWatcher = class _PassiveConflictWatcher {
     const repos = this.discoverGitRepos();
     const now = Date.now();
     const seen = /* @__PURE__ */ new Set();
+    const dirtyCounts = /* @__PURE__ */ new Map();
     const overlaps = /* @__PURE__ */ new Map();
     for (const repo of repos) {
       try {
-        const { stdout } = await execFileAsync("git", ["-c", "core.fsmonitor=false", "status", "--porcelain=v1", "-z", "--untracked-files=all"], { cwd: repo, timeout: 4e3, maxBuffer: 4 * 1024 * 1024 });
+        const { stdout } = await execFileAsync("git", ["-c", "core.fsmonitor=false", "status", "--porcelain=v1", "-z", "--untracked-files=all"], { cwd: repo, timeout: 4e3, maxBuffer: 4 * 1024 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" } });
         const records = stdout.split("\0");
         const dirty = /* @__PURE__ */ new Map();
         for (let i = 0; i < records.length; i++) {
@@ -4995,6 +5005,7 @@ var PassiveConflictWatcher = class _PassiveConflictWatcher {
           dirty.set(record.slice(3), status);
           if (/[RC]/.test(status)) dirty.set(records[++i], status);
         }
+        dirtyCounts.set(repo, [...dirty.keys()].filter((file) => file && file !== ".coord" && !file.startsWith(".coord/")).length);
         for (const [file, status] of dirty) {
           if (!file || file === ".coord" || file.startsWith(".coord/")) continue;
           const key = JSON.stringify([repo, file]);
@@ -5051,6 +5062,39 @@ var PassiveConflictWatcher = class _PassiveConflictWatcher {
       }
     }
     this.activeCollisions = this.errors.length ? new Map([...this.activeCollisions, ...current]) : current;
+    const states = /* @__PURE__ */ new Map();
+    this.worktrees = repos.map((repo) => {
+      const common = this.repositories.get(repo);
+      const primary = this.primaryRoots.get(common);
+      const row = {
+        path: repo,
+        label: `${path17.basename(primary ?? path17.dirname(common))} / ${repo === primary ? "primary" : path17.basename(repo)}`,
+        activity: "unknown",
+        agentIds: [],
+        detail: "Ownership unavailable; inspect kith status --offline before recovery.",
+        dirtyFiles: dirtyCounts.get(repo) ?? null,
+        sharedDirtyPaths: [...this.activeCollisions.values()].filter((alert) => alert.repos.includes(repo)).length
+      };
+      try {
+        let state = states.get(common);
+        if (!state) {
+          state = readCoordinationState(primary ?? repo, { ownersOnly: true });
+          states.set(common, state);
+        }
+        if (state.state === "unavailable") {
+          row.detail += ` ${state.error}`;
+          return row;
+        }
+        const owners = state.agents.filter((agent) => agent.worktree_path ? physicalPath(agent.worktree_path) === repo : repo === primary);
+        const active = owners.filter((agent) => agent.status === "active" && Number.isFinite(agent.lease_expires_at) && agent.lease_expires_at > state.observedAt);
+        row.agentIds = (active.length ? active : owners).map((agent) => agent.id);
+        row.activity = active.length ? "active" : owners.length ? "retained" : "unregistered";
+        row.detail = active.length ? "Current recorded Kith lease; does not identify file writers." : owners.length ? `Recorded ${[...new Set(owners.map((agent) => agent.status === "active" ? "expired lease" : agent.status))].join(", ")}; preserve work and inspect before cleanup.` : "No recorded Kith session; activity and ownership outside Kith are unknown.";
+      } catch (error) {
+        row.detail += ` ${error instanceof Error ? error.message : String(error)}`;
+      }
+      return row;
+    });
     if (this.errors.length) this.options.onScanError?.(this.errors);
     return this.getActiveCollisions();
   }
@@ -5074,7 +5118,7 @@ var PassiveConflictWatcher = class _PassiveConflictWatcher {
     this.watchTimer = null;
   }
   getScanState() {
-    return { complete: this.errors.length === 0, errors: [...this.errors], repos: [...this.repositories.keys()] };
+    return { complete: this.errors.length === 0, errors: [...this.errors], repos: [...this.repositories.keys()], ownershipComplete: this.worktrees.every((row) => row.activity !== "unknown"), worktrees: this.worktrees.map((row) => ({ ...row, agentIds: [...row.agentIds] })) };
   }
   getActiveCollisions() {
     return [...this.activeCollisions.values()];
@@ -5375,13 +5419,13 @@ ${message}`);
         lastScanError = message;
       },
       onCollision: (alert) => {
-        if (!isRaw) {
+        if (!isRaw && !flags.once) {
           console.log(`
 \u26A0\uFE0F [WORKTREE OVERLAP] ${alert.message}`);
         }
       },
       onFileChange: (e) => {
-        if (!flags.quiet && !isRaw) {
+        if (!flags.quiet && !isRaw && !flags.once) {
           console.log(`\u{1F4DD} [FILE MTIME] ${path19.basename(e.repoPath)}/${e.filePath}`);
         }
       }
@@ -5400,6 +5444,12 @@ ${message}`);
 \u{1F4E1} Kith Passive Radar: ${targetDir}`);
       console.log(`   Repositories (${repos.length}): ${repos.map((r) => path19.basename(r)).join(", ")}`);
       console.log(`   Recent Modified Files: ${edits.length}`);
+      for (const row of state.worktrees) {
+        const activity = { active: "Active Kith lease", retained: "Retained", unregistered: "No Kith session", unknown: "Ownership unavailable" }[row.activity];
+        console.log(`   ${row.label} \u2014 ${activity}; ${row.dirtyFiles ?? "unknown"} Git changes; ${row.sharedDirtyPaths} shared dirty paths`);
+        console.log(`      ${row.path}${row.agentIds.length ? ` (${row.agentIds.join(", ")})` : ""}
+      ${row.detail}`);
+      }
       if (!state.complete) {
         console.error(`Scan unavailable:
 ${state.errors.map((error) => error.message).join("\n")}`);
@@ -5407,10 +5457,9 @@ ${state.errors.map((error) => error.message).join("\n")}`);
         console.log("\nNo differing or unverified shared dirty paths observed. Identical copies are excluded; compatibility is not verified.\n");
       } else {
         console.log(`
-  \u26A0\uFE0F  Observed worktree overlaps (${alerts.length}):`);
+  \u26A0\uFE0F  Review before integration: ${alerts.length} shared dirty paths:`);
         for (const a of alerts) {
           console.log(`   \u26A0\uFE0F ${a.message}`);
-          console.log(`      Files: ${a.filePath}`);
         }
         console.log("");
       }