agent-coord-mcp 0.26.13 → 0.26.15

package/src/tools/transport.ts

@@ -5,6 +5,15 @@ import { execFileSync } from "node:child_process";
 import { registerTool } from "./registry.js";
 import { roleInputSchema, type RoleArg } from "../roles.js";
 import { attributeWriter, isGitRepo, lastWriterOf, loadScopes, ownsDocument } from "./scopes.js";
+// Moved to a LEAF so `status` can report capabilities without a cycle — see
+// src/server-identity.ts. Re-exported so every existing importer is untouched.
+export { resolveServerIdentity } from "../server-identity.js";
+import { resolveServerIdentity } from "../server-identity.js";
+// ONE-WAY EDGE, and the direction is the point: `status` CALLS the capabilities
+// verb rather than re-deriving its probes. Two probes of the same thing is the
+// four-matchers defect committed deliberately, which is why 17.4 was deferred
+// behind 13.7 instead of built beside it.
+import { capabilitiesTool } from "../capabilities.js";
 import { sendMessageTool, readMessagesTool } from "./messaging.js";
 import { randomUUID } from "node:crypto";
 import { existsSync, openSync, readFileSync, watch } from "node:fs";
@@ -835,63 +844,6 @@ function resolvePusherPath(): string {
   return path.resolve(here, "..", "..", "hooks", "tmux-pusher.mjs");
 }
 
-/** Running server package + optional git identity. `fromDir` is a test seam. */
-export function resolveServerIdentity(fromDir?: string): {
-  path: string;
-  version: string;
-  branch?: string;
-  sha?: string;
-} {
-  const start = fromDir ?? path.dirname(fileURLToPath(import.meta.url));
-  let dir = start;
-  let pkgFile: string | undefined;
-  for (let i = 0; i < 8; i++) {
-    const candidate = path.join(dir, "package.json");
-    if (existsSync(candidate)) {
-      pkgFile = candidate;
-      break;
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  const pkgPath = pkgFile ?? path.resolve(start, "..", "..", "package.json");
-  const pkgDir = path.dirname(pkgPath);
-  let version = "unknown";
-  try {
-    const raw = JSON.parse(readFileSync(pkgPath, "utf8")) as { version?: string };
-    if (typeof raw.version === "string" && raw.version) version = raw.version;
-  } catch {
-    /* leave unknown — never invent a version */
-  }
-
-  const out: { path: string; version: string; branch?: string; sha?: string } = {
-    path: pkgDir,
-    version,
-  };
-
-  dir = pkgDir;
-  let gitRoot: string | undefined;
-  for (let i = 0; i < 10; i++) {
-    if (existsSync(path.join(dir, ".git"))) {
-      gitRoot = dir;
-      break;
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  if (gitRoot && isGitRepo(gitRoot)) {
-    const branch = spawnSync("git", ["-C", gitRoot, "rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8" });
-    const sha = spawnSync("git", ["-C", gitRoot, "rev-parse", "HEAD"], { encoding: "utf8" });
-    const b = branch.status === 0 ? String(branch.stdout).trim() : "";
-    const s = sha.status === 0 ? String(sha.stdout).trim() : "";
-    if (b) out.branch = b;
-    if (s) out.sha = s;
-  }
-  return out;
-}
-
 /** An epoch-ms stamp as ISO-8601 UTC, or an explicit absence — never a blank. */
 function stamp(ms: number | undefined): string {
   return ms === undefined ? "(no stamp)" : new Date(ms).toISOString();
@@ -925,6 +877,22 @@ export async function statusTool(args: { agentId: string }) {
   const cursor = await readJson<Cursor>(cursorFile(args.agentId), {});
   const inboxOffset = cursor.inboxOffset ?? 0;
   const unread = Math.max(0, inbox.length - inboxOffset);
+  // WHAT THIS PROCESS CAN ACTUALLY DO, embedded WHOLE.
+  //
+  // A new tool otherwise lands silently: an agent reading an old listing
+  // asserts the tool does not exist, and it is right about its own listing and
+  // wrong about the world. Three wrong conclusions in two days came from
+  // exactly that, each about which build a pane was running.
+  //
+  // The full report travels, not a summary. Flattening it to a boolean would
+  // hand the caller a tidier answer and a worse one: `versionLabel` stays
+  // CONTEXT rather than evidence, a THROWN probe stays an absent capability
+  // rather than a broken check, and `answeredBy` keeps naming which pid
+  // answered — two servers disagreeing mid-rollout is the normal case, and it
+  // is the case every other instrument here reports as if the fleet were one
+  // thing.
+  const capabilities = await capabilitiesTool();
+
   return {
     agentId: args.agentId,
     registered: !!entry,
@@ -935,6 +903,7 @@ export async function statusTool(args: { agentId: string }) {
     inboxUnread: unread,
     inTmux: !!process.env.TMUX_PANE,
     tmuxPane: process.env.TMUX_PANE,
+    capabilities,
   };
 }
 

package/src/tools/work.ts

@@ -17,10 +17,11 @@ import {
   workDocLegacyWriteIssues,
   LANES_V0_WRITE_ISSUE,
 } from "../work.js";
-import { parseFactsDoc, type FactEntry } from "@davidbalzan/groundwork-seam";
+import { parseFactsDoc, type FactEntry, type Priority } from "@davidbalzan/groundwork-seam";
 import { loadScopes, ownsDocument } from "./scopes.js";
 import { AGENTS_FILE } from "../store.js";
 import type { AgentRegistry } from "./shared.js";
+import { summarize, blockedBy } from "./records.js";
 
 // ---------- work state as data (Phase 8 Task 5) ----------
 //
@@ -189,8 +190,42 @@ export const listWorkSchema = {
   // native (default): discriminated v1 | lanes-v0. lanes: lossy projection of v1.
   view: z.enum(["native", "lanes"]).optional(),
   repo: z.string().optional(),
+  // Fetch ONE full record by id — the second call Task 15.1 asks for.
+  // Identity rows (below) never carry the body; this is how a caller gets it,
+  // and only for the one row it actually needs rather than every row's.
+  id: z.string().optional(),
 };
 
+// A queue row without its body — id, priority, a bounded headline, and
+// blocked-by, the fields the doc names. `owner` is NOT included: QueueItem
+// carries no structured owner field, and the free-text `origin:` phrase some
+// items end with ("origin: coordinator retracting its own broadcast canon…")
+// is prose, not an id — extracting one heuristically would fabricate a field
+// this data model does not have. Omitted rather than guessed, same
+// discipline as `list_agents`' heartbeatSource (Task 13.5).
+export type QueueIdentityRow = {
+  id: string;
+  priority: Priority | null;
+  headline: string;
+  truncated: boolean;
+  blockedBy: string | null;
+};
+
+function identityRowOf(item: QueueItem): QueueIdentityRow {
+  const flat = String(item.text).replace(/\s+/g, " ").replace(/\*\*/g, "").trim();
+  return {
+    id: item.id,
+    priority: item.priority,
+    headline: summarize(item.text),
+    // `summarize` itself decides where to cut; re-deriving "did it cut" here
+    // from a second pass over the same text would be the two-matchers-one-
+    // question shape this phase keeps finding elsewhere (refsIn, COMMIT_REF).
+    // Comparing against its own bound is exact and free.
+    truncated: flat.length > 96,
+    blockedBy: blockedBy(item),
+  };
+}
+
 export async function listWorkTool(args: {
   project: string;
   kind?: "queue" | "done" | "board" | "facts";
@@ -198,6 +233,7 @@ export async function listWorkTool(args: {
   includeDone?: boolean;
   view?: "native" | "lanes";
   repo?: string;
+  id?: string;
 }) {
   // No import yet (or the store was deleted) → read the documents directly.
   // This is the fallback that makes "the markdown stands alone" true in code
@@ -231,6 +267,17 @@ export async function listWorkTool(args: {
   }
   if (args.view === "lanes") board = board.map(projectV1ToLanes);
 
+  // THE SECOND CALL — one row, whole. Searches queue then done (a done entry
+  // shares the id space; an id is unique within a project's work state), so
+  // the caller does not have to know which kind its own id belongs to.
+  if (args.id !== undefined) {
+    const queueHit = queue.find((q) => q.id === args.id);
+    if (queueHit) return { ok: true as const, project: state.project, repo: state.repo, source, kind: "queue" as const, item: queueHit };
+    const doneHit = done.find((d) => d.id === args.id);
+    if (doneHit) return { ok: true as const, project: state.project, repo: state.repo, source, kind: "done" as const, item: doneHit };
+    return { ok: false as const, error: `no queue item or DONE entry with id '${args.id}' in project '${state.project}'` };
+  }
+
   const openQueue = args.includeDone ? queue : queue.filter((q) => !q.done);
   const filtered = args.priority ? openQueue.filter((q) => q.priority === args.priority) : openQueue;
 
@@ -239,7 +286,12 @@ export async function listWorkTool(args: {
     project: state.project,
     repo: state.repo,
     source,
-    ...(args.kind === "queue" || args.kind === undefined ? { queue: filtered } : {}),
+    // IDENTITY ONLY (Task 15.1) — id, priority, a bounded headline, and
+    // blocked-by; never the full item text. Call again with `id` for one
+    // row's body. This is the change that makes the tool cheap: the same
+    // question that used to return every open item's ~1,500-char body now
+    // returns a fixed-width row per item.
+    ...(args.kind === "queue" || args.kind === undefined ? { queue: filtered.map(identityRowOf) } : {}),
     ...(args.kind === "done" || args.kind === undefined ? { done } : {}),
     ...(args.kind === "board" || args.kind === undefined ? { board } : {}),
     ...(args.kind === "facts" || args.kind === undefined ? { facts } : {}),

package/src/tools/worktrees.ts

@@ -268,7 +268,51 @@ export async function refreshWorktreesTool(args: { repo: string; base: string; a
   for (const w of listWorktrees(repo)) {
     const at = w.path;
     if (samePath(at, primaryOf(repo) ?? "")) {
-      results.push({ path: w.path, action: "skipped", why: "primary checkout — not a slice tree" });
+      // THE PRIMARY CHECKOUT IS REPORTED, ALWAYS — it used to be skipped with
+      // "not a slice tree", which is true and useless. It is the tree David
+      // reads, the one every hand-run measurement runs in, and a silent skip
+      // let it sit arbitrarily far behind while this verb reported a clean
+      // sweep. "Not ours to fast-forward" and "nothing to say about it" are
+      // different claims and only the first one was intended.
+      let behind = "unknown";
+      let ahead = "unknown";
+      try {
+        behind = git(at, ["rev-list", "--count", `HEAD..${tip}`]);
+        ahead = git(at, ["rev-list", "--count", `${tip}..HEAD`]);
+      } catch {
+        /* left as unknown — an unreadable count must not read as zero */
+      }
+      const dirty = isDirty(at);
+      // FAST-FORWARD ONLY, AND ONLY WHEN CLEAN. A ff-only merge cannot rewrite
+      // history or resolve a conflict, so the worst case is a refusal. Dirty is
+      // refused for the same reason a slice tree is: uncommitted work is what a
+      // diff cannot show and git cannot give back.
+      const canFf = !dirty && ahead === "0" && behind !== "0" && behind !== "unknown";
+      if (args.apply && canFf) {
+        try {
+          git(at, ["merge", "--ff-only", ref]);
+          results.push({ path: w.path, action: "fast-forwarded", why: `primary checkout advanced ${behind} commit(s) to ${ref}` });
+          continue;
+        } catch (e) {
+          results.push({ path: w.path, action: "refused", why: `primary checkout: ff-only merge failed — ${(e as Error).message}` });
+          continue;
+        }
+      }
+      results.push({
+        path: w.path,
+        action: behind === "0" ? "current" : "stale",
+        why:
+          behind === "0"
+            ? `primary checkout is at ${ref}`
+            : `primary checkout is ${behind} commit(s) behind ${ref}` +
+              (dirty
+                ? " and DIRTY — not fast-forwarded; uncommitted work is what a diff cannot show"
+                : ahead !== "0"
+                  ? ` and ${ahead} ahead — not fast-forwarded; it has commits ${ref} does not`
+                  : args.apply
+                    ? ""
+                    : " — pass apply:true to fast-forward it"),
+      });
       continue;
     }
     if (isDirty(at)) {