agent-coord-mcp 0.26.17 → 0.26.18

package/src/tools/transport.ts

@@ -79,6 +79,7 @@ import {
   setOffset,
   sysMsg,
   moveFile,
+  agentIdFromCursorFilename,
   STALE_MS,
   EVICT_MS,
   MAX_WAIT_MS,
@@ -1623,7 +1624,7 @@ export async function doctorTool(args: { fix?: boolean; maxFileBytes?: number })
     }
     const orphanCursor: string[] = [];
     for (const fname of await listCursorFiles()) {
-      const id = fname.replace(/\.json$/, "");
+      const { id } = agentIdFromCursorFilename(fname);
       if (!known.has(id)) {
         orphanCursor.push(id);
         if (fix) {
@@ -1652,10 +1653,17 @@ export async function doctorTool(args: { fix?: boolean; maxFileBytes?: number })
   };
 
   // 4. Cursor offsets past end-of-file (would return [] forever).
+  //
+  // q-40449919: `id` must be the AGENT's id, not the cursor filename minus
+  // one extension — a push cursor's filename is `<agent>.push.json`, and
+  // `inboxFile(id)` on the unfixed `<agent>.push` resolves to a file that
+  // never existed, so `inboxMax` reads 0 and the cursor's real, correct
+  // offset compares as past-EOF against an empty file that was never the
+  // agent's inbox in the first place.
   {
     const broken: string[] = [];
     for (const fname of await listCursorFiles()) {
-      const id = fname.replace(/\.json$/, "");
+      const { id, kind } = agentIdFromCursorFilename(fname);
       const cursorPath = path.join(CURSOR_DIR, fname);
       const cursor = await readJson<Cursor>(cursorPath, {});
       const overflow: string[] = [];
@@ -1670,7 +1678,7 @@ export async function doctorTool(args: { fix?: boolean; maxFileBytes?: number })
         if (off > max) overflow.push(`roomOffsets[${chan}] ${off}>${max}`);
       }
       if (overflow.length) {
-        broken.push(`${id}: ${overflow.join(", ")}`);
+        broken.push(`${id}${kind === "push" ? " (push)" : ""}: ${overflow.join(", ")}`);
         if (fix) {
           await updateJson<Cursor>(cursorPath, {}, (c) => {
             if ((c.inboxOffset ?? 0) > inboxMax) c.inboxOffset = inboxMax;
@@ -1684,7 +1692,7 @@ export async function doctorTool(args: { fix?: boolean; maxFileBytes?: number })
             }
             return c;
           });
-          fixed.push(`clamped cursor offsets for ${id}`);
+          fixed.push(`clamped cursor offsets for ${id}${kind === "push" ? " (push)" : ""}`);
         }
       }
     }

package/src/tools/work.ts

@@ -13,6 +13,8 @@ import {
   projectV1ToLanes,
   queueItemsOf,
   renderWorkDoc,
+  renderWorkDocForWrite,
+  zeroIsUnparsed,
   workDocIssues,
   workDocLegacyWriteIssues,
   LANES_V0_WRITE_ISSUE,
@@ -55,6 +57,13 @@ export type StoredWorkDoc = {
   kind: "queue" | "done" | "board" | "legacy";
   path: string;
   doc: WorkDoc;
+  /**
+   * The bytes as read. Kept because a COUNT OF ZERO cannot be interpreted
+   * without them: `zeroIsUnparsed` needs to know whether the document had
+   * content the parser did not understand, and the parsed doc has already
+   * discarded that distinction (q-3e7c81a5).
+   */
+  source: string;
 };
 
 export type StoredFactsDoc = {
@@ -77,7 +86,7 @@ async function loadDoc(repo: string, f: { kind: WorkFileKind; path: string }): P
     const parsed = parseFactsDoc(source);
     return { kind: "facts", path: f.path, source, entries: parsed.entries, issues: parsed.issues };
   }
-  return { kind: f.kind, path: f.path, doc: parseWorkDoc(source) };
+  return { kind: f.kind, path: f.path, doc: parseWorkDoc(source), source };
 }
 
 function docIssues(d: StoredDoc): string[] {
@@ -97,12 +106,56 @@ function importedSummary(d: StoredDoc) {
     };
   }
   const issues = [...workDocIssues(d.doc), ...workDocLegacyWriteIssues(d.doc)];
-  return {
-    path: d.path,
-    kind: d.kind,
+  const counts = {
     queue: queueItemsOf(d.doc).length,
     done: doneEntriesOf(d.doc).length,
     board: listWorkBoardOf(d.doc).length,
+  };
+  // A ZERO THAT CANNOT BE TRUSTED IS NAMED, NOT RETURNED BARE.
+  //
+  // These three were plain `.length`, so a document the parser did not
+  // understand reported the same zero as an empty one. A consumer's dashboard
+  // read that and showed a fleet as IDLE on a night it merged 27 PRs; they
+  // declined to enable these verbs rather than ship a display they could not
+  // trust (q-3e7c81a5).
+  //
+  // The counts keep their shape and meaning — a reader that only wants numbers
+  // is unaffected — and `unparsed` says which of them are unanswered questions
+  // rather than answers. The predicate is the SEAM's, shared with `doctor`'s
+  // queue-done-loop rather than restated here.
+  // ONLY THE AXES THIS DOCUMENT CLAIMS TO CARRY.
+  //
+  // Caught by the test's own output rather than by review: qualifying all three
+  // for every file reported `docs/QUEUE.md` as having unparsed `done` and `board`
+  // axes, which is nonsense — a queue document is not expected to hold done
+  // entries, so its zero there is not an unanswered question, it is a category
+  // error on my part. Scoping the qualification to the document's KIND is the
+  // same population discipline the count itself needed: a claim about an axis a
+  // file never carried is noise, and noise is what teaches a reader to skip the
+  // real one. `legacy` is the single-file BACKLOG.md, which carries both regions.
+  const AXES_BY_KIND = {
+    queue: ["queue"],
+    done: ["done"],
+    board: ["board"],
+    legacy: ["queue", "done"],
+  } as const;
+  const unparsed = (AXES_BY_KIND[d.kind] as readonly (keyof typeof counts)[]).filter((axis) =>
+    zeroIsUnparsed(counts[axis], d.source),
+  );
+  return {
+    path: d.path,
+    kind: d.kind,
+    ...counts,
+    ...(unparsed.length
+      ? {
+          unparsed,
+          unparsedNote:
+            `${d.path} has content the parser did not understand: ${unparsed.join(", ")} parsed to ZERO. ` +
+            `That is an unanswered question, not an empty document — do not render it as idle, empty or done. ` +
+            `Either the file uses a shape this grammar does not accept, or it is malformed; both need a human, and ` +
+            `neither is "nothing there".`,
+        }
+      : {}),
     ...(issues.length ? { issues } : {}),
   };
 }
@@ -359,6 +412,19 @@ export async function exportWorkTool(args: {
       });
       continue;
     }
+    // DELIBERATELY THE PURE RENDER, NOT THE STAMPING ONE (q-c50e9b83).
+    //
+    // I routed this through `renderWorkDocForWrite` first and it broke three
+    // pre-existing tests that assert `import → export` writes the real documents
+    // back BYTE-IDENTICALLY. They were right and the change was wrong: this is a
+    // TRANSPORT, not an authoring path. Its contract is to reproduce a document,
+    // and a transport that silently edits content the caller never asked it to
+    // touch is a worse defect than the one being fixed — it would also mean
+    // exporting into ANOTHER project's documents mutates them.
+    //
+    // So the primary is scoped to the AUTHORING writer (`land`, via records.ts),
+    // and an unstamped item arriving through this path is the backstop's
+    // population: it cannot reach `main` without passing a push.
     const rendered = renderWorkDoc(d.doc);
     const current = existsSync(target) ? await fsp.readFile(target, "utf8") : null;
     const declared = scopes.documents.find((s) => s.path === d.path);

package/src/tools/worktrees.ts

@@ -264,6 +264,45 @@ export async function refreshWorktreesTool(args: { repo: string; base: string; a
     return { ok: false as const, error: `${ref} does not resolve — nothing to fast-forward onto` };
   }
 
+/**
+ * Are the commits HEAD has beyond `tip` ALREADY LANDED there?
+ *
+ * `rev-list --count <tip>..HEAD` is pure ANCESTRY, and under squash merge a landed
+ * branch's own shas never enter the base's history — so `ahead` stays > 0 FOREVER
+ * for work that shipped (q-5c40db91; 20 of the last 20 merges on this repo's main
+ * are single-parent). Reading `ahead > 0` as "this tree holds unlanded work" makes
+ * the verb whose job is fast-forwarding idle trees classify a FINISHED tree as
+ * mid-slice, permanently.
+ *
+ * MEASURED, and it cost a lane cycle: a `claim` was refused because a worker's tree
+ * "reads as 1 commit not on origin/main" while that branch had been squash-merged an
+ * hour earlier. Same inverted alarm as the item's headline — landed work reported as
+ * unmerged, inviting preservation of work already shipped — inside our own tooling.
+ *
+ * `git cherry` compares PATCH IDS, so every line marked `-` means every commit's patch
+ * is already upstream. It is NOT complete: several commits squashed into one carry a
+ * different combined patch id, so a negative is INCONCLUSIVE and is reported as
+ * mid-slice exactly as before. Only a positive changes the verdict, which keeps the
+ * failure direction the same as today's for everything this cannot prove.
+ */
+function aheadIsLanded(at: string, tip: string): boolean {
+  // `git` here THROWS rather than returning null, so the catch is what keeps an
+  // UNREADABLE answer out of the landed bucket: not measured is not landed, and
+  // the tree stays mid-slice, which is the direction that refuses rather than
+  // the direction that tells someone their work is safe to discard.
+  let cherry: string;
+  try {
+    cherry = git(at, ["cherry", tip, "HEAD"]);
+  } catch {
+    return false;
+  }
+  if (cherry.trim().length === 0) return false;
+  return cherry
+    .trim()
+    .split("\n")
+    .every((l) => l.trim().startsWith("-"));
+}
+
   const results = [];
   for (const w of listWorktrees(repo)) {
     const at = w.path;
@@ -308,7 +347,9 @@ export async function refreshWorktreesTool(args: { repo: string; base: string; a
               (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`
+                  ? aheadIsLanded(at, tip)
+                    ? ` and ${ahead} ahead whose patches are ALREADY UPSTREAM — squash-merged, so ancestry will never agree; not fast-forwarded, but nothing here needs preserving`
+                    : ` and ${ahead} ahead — not fast-forwarded; it has commits ${ref} does not`
                   : args.apply
                     ? ""
                     : " — pass apply:true to fast-forward it"),
@@ -337,7 +378,28 @@ export async function refreshWorktreesTool(args: { repo: string; base: string; a
       /* treated as diverged below */
     }
     if (ahead !== "0") {
-      results.push({ path: w.path, action: "refused", why: `MID-SLICE: ${ahead} commit(s) not on ${ref}. Refusing rather than --force.` });
+      // LANDED, NOT MID-SLICE — the ancestry count cannot tell these apart.
+      if (aheadIsLanded(at, tip)) {
+        results.push({
+          path: w.path,
+          action: "landed",
+          why:
+            `${ahead} commit(s) are not ancestors of ${ref}, but every one of their PATCHES is already upstream — ` +
+            `this branch was SQUASH-MERGED and its work has shipped. Ancestry can never say so: a squash writes a new ` +
+            `commit, so these shas will read as "not on ${ref}" forever. Nothing here needs preserving; detach to ${ref} ` +
+            `(or delete the branch) and this tree is reusable. NOT fast-forwarded automatically — moving a tree off ` +
+            `committed work is a decision, not a refresh.`,
+        });
+        continue;
+      }
+      results.push({
+        path: w.path,
+        action: "refused",
+        why:
+          `MID-SLICE: ${ahead} commit(s) not on ${ref}, and their patches are NOT upstream. Refusing rather than --force. ` +
+          `(A squash of SEVERAL commits into one changes the combined patch id, so this cannot prove the negative — ` +
+          `it reports mid-slice, which is the same direction it always failed in.)`,
+      });
       continue;
     }
     if (!args.apply) {

package/src/work.ts

@@ -17,6 +17,10 @@ export {
   renderBoardRow,
   parseWorkDoc,
   renderWorkDoc,
+  renderWorkDocForWrite,
+  stampQueueIds,
+  zeroIsUnparsed,
+  substantiveLines,
   queueItemsOf,
   doneEntriesOf,
   boardRowsOf,

package/dist/build.js

@@ -1,113 +0,0 @@
-// Build identity of the RUNNING server process.
-//
-// The principle is the #28 pusher-freshness fix carried one layer up: stamp
-// what you LOADED at init, compare against what's on disk NOW, and resolve the
-// measured artifact from the code that is actually executing
-// (import.meta.url), never from configuration — the thing that measures must
-// be the thing that ran. A server process outlives `npm run build`; without a
-// load-time sample there is nothing truthful to compare the on-disk build to,
-// and a server running pre-rebuild code stamps transport markers with logic
-// the rebuild replaced (observed live 2026-07-29: post-#28 attach spawned a
-// pusher with no `--agent` argv and a single-file freshness stamp, agreeing
-// with the new on-disk check only by coincidence).
-import { readdirSync, statSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-// Newest mtime (epoch ms) across every file under `dir` (recursive) whose
-// name ends with one of `exts`. Returns undefined when the dir is missing or
-// unreadable — callers skip their check rather than guess. Pure over its
-// arguments so tests exercise it on temp trees instead of touching real
-// sources (a utimes on a shared checkout flips every live pusher's freshness
-// while the suite runs files in parallel).
-export function newestMtimeUnder(dir, exts) {
-    try {
-        let newest;
-        for (const rel of readdirSync(dir, { recursive: true })) {
-            const name = String(rel);
-            if (!exts.some((e) => name.endsWith(e)))
-                continue;
-            let m;
-            try {
-                m = statSync(path.join(dir, name)).mtimeMs;
-            }
-            catch {
-                continue; // deleted mid-scan
-            }
-            if (newest === undefined || m > newest)
-                newest = m;
-        }
-        return newest;
-    }
-    catch {
-        return undefined;
-    }
-}
-// The dir this module was loaded FROM: dist/ in production, src/ under tsx.
-// Either way it is the code actually running, which is the point.
-export const BUILD_DIR = path.dirname(fileURLToPath(import.meta.url));
-// .js for the compiled build, .ts for dev-mode (tsx src/server.ts) — both
-// sides of every comparison use the same list, so the two modes are each
-// self-consistent and can never be compared across.
-const BUILD_EXTS = [".js", ".ts"];
-// Sampled ONCE at module load: the newest mtime across the build this server
-// process actually imported. A later `npm run build` rewrites dist/ under a
-// still-running server; this value stays behind, which is exactly what
-// doctor's server-build-drift check compares against.
-export const SERVER_BUILD_MTIME = newestMtimeUnder(BUILD_DIR, BUILD_EXTS);
-// The on-disk side of the comparison, statted fresh per call.
-// AGENT_COORD_DIST_DIR is a test seam only: it redirects what doctor
-// MEASURES so tests can stage a newer/older build in a temp dir — it never
-// changes what the server loads.
-export function onDiskBuildMtime() {
-    const dir = process.env.AGENT_COORD_DIST_DIR ?? BUILD_DIR;
-    return newestMtimeUnder(dir, BUILD_EXTS);
-}
-// The uncompiled side of the dist-behind-source comparison: newest mtime
-// across src/**/*.ts, resolved as BUILD_DIR's sibling. undefined on a
-// packaged install with no src/ (callers report "nothing to compare", never
-// warn). Under tsx dev-mode BUILD_DIR *is* src/, so the comparison degrades
-// to src-vs-src and reads ok — dev-mode has no build to fall behind.
-// AGENT_COORD_SRC_DIR is the same test seam as AGENT_COORD_DIST_DIR:
-// it redirects measurement only.
-export function onDiskSourceMtime() {
-    const dir = process.env.AGENT_COORD_SRC_DIR ?? path.resolve(BUILD_DIR, "..", "src");
-    return newestMtimeUnder(dir, [".ts"]);
-}
-// Best-effort checkout identity, report-only: lets doctor NAME the build
-// (`branch@sha` would be nicer, but HEAD's sha alone already makes
-// mutable-checkout drift visible, which is all this claims). undefined when
-// not a git checkout (npm install) — never an error.
-export const SERVER_BUILD_SHA = (() => {
-    try {
-        let gitDir = path.resolve(BUILD_DIR, "..", ".git");
-        const st = statSync(gitDir);
-        if (st.isFile()) {
-            // A worktree's .git is a pointer file: "gitdir: <real dir>".
-            const ptr = readFileSync(gitDir, "utf8").trim();
-            if (!ptr.startsWith("gitdir:"))
-                return undefined;
-            gitDir = ptr.slice("gitdir:".length).trim();
-        }
-        const head = readFileSync(path.join(gitDir, "HEAD"), "utf8").trim();
-        if (!head.startsWith("ref:"))
-            return head.slice(0, 12); // detached
-        const ref = head.slice(4).trim();
-        try {
-            return readFileSync(path.join(gitDir, ref), "utf8").trim().slice(0, 12);
-        }
-        catch {
-            // Ref may be packed. commondir handling is deliberately out of scope —
-            // best-effort means undefined beats wrong.
-            const packed = readFileSync(path.join(gitDir, "packed-refs"), "utf8");
-            for (const line of packed.split("\n")) {
-                if (line.endsWith(` ${ref}`))
-                    return line.slice(0, 12);
-            }
-            return undefined;
-        }
-    }
-    catch {
-        return undefined;
-    }
-})();
-//# sourceMappingURL=build.js.map

package/dist/build.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"build.js","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"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"}

package/dist/capabilities.js

@@ -1,158 +0,0 @@
-/*
- * Phase 5.1 Task 11 — CLOSE THE LOOP: answer a capability question by
- * EXERCISING the capability, in the process that would serve it.
- *
- * 11.1: NO TIMESTAMP ON THIS BOX CAN ANSWER A CAPABILITY QUESTION. Every
- * artefact people reach for is a proxy that fails differently:
- *
- *   an mtime          tracks WRITES. A reinstall of byte-identical code moves
- *                     it, and an edit that never got built does not.
- *   serverBuildMtime  is stamped at ATTACH, so it tells you when a transport
- *                     started, not what the running process contains.
- *   a version string  is a LABEL someone typed into package.json. Measured
- *                     today: a tarball published as 0.5.23 contained a change
- *                     the version numbering said it could not, and the number
- *                     was believed over the artefact for an hour.
- *   `npm view`        answers from a cache, and told this fleet the wrong
- *                     published version twice in one morning.
- *
- * Each is honest about something and dishonest about capability, and the
- * failure is always the same shape: an ANSWER ABOUT A LABEL read as an answer
- * about behaviour.
- *
- * 11.2: A RELEASE IS NOT DELIVERED UNTIL A SERVER THAT RESTARTED ANSWERS.
- * `merged · published · installed · restarted · observed` — five states, and
- * the last two are the ones that keep being skipped. A probe run INSIDE the
- * server process is the only artefact that speaks for the loaded code: it
- * cannot be satisfied by a file that exists, a version that matches, or a
- * package that installed, because it calls the code and reports what happened.
- *
- * WHY A PROBE MAY NEVER READ A VERSION: if a probe branched on a version
- * string it would inherit that string's dishonesty, and a fleet would then
- * have a capability check that passes on a restarted-but-not-upgraded server.
- * Probes call behaviour. The version travels beside the answer as CONTEXT and
- * is labelled as such.
- */
-import { prRefsIn } from "./tools/record-events.js";
-import { EVENT_KIND_IDS } from "./tools/event-kinds.js";
-import { suggestRecordType, typedRecordMode } from "./typed-records.js";
-import { LEAD_REFUSED, PARKED_CATEGORIES } from "./tools/away.js";
-import { recordAuthorityFor } from "./roles.js";
-import { subscriptionHealth } from "./tools/events.js";
-/**
- * Each probe calls a behaviour that did not exist before its release and
- * reports what it observed. A probe that could pass without the code being
- * loaded is not a probe — it is a restatement of the version.
- */
-const PROBES = [
-    {
-        id: "typed-records-obligatory",
-        since: "0.26.10",
-        run: () => {
-            const s = suggestRecordType("DONE: shipped it", []);
-            const mode = typedRecordMode();
-            return {
-                present: s.type === "done" && (mode === "warn" || mode === "refuse"),
-                evidence: `suggestRecordType("DONE: …") -> '${s.type}', policy mode '${mode}'`,
-            };
-        },
-    },
-    {
-        id: "record-events-all-kinds",
-        since: "0.26.12",
-        run: () => {
-            const kinds = [...EVENT_KIND_IDS].sort();
-            const present = ["item", "phase", "pr", "task"].every((k) => kinds.includes(k));
-            return { present, evidence: `subscribable kinds: ${kinds.join(", ")}` };
-        },
-    },
-    {
-        id: "multi-pr-citation",
-        since: "0.26.14",
-        run: () => {
-            const refs = prRefsIn("owner/repo#170, #173");
-            return {
-                present: refs.length === 2 && refs[1] === "owner/repo#173",
-                evidence: `prRefsIn("owner/repo#170, #173") -> [${refs.join(", ")}]`,
-            };
-        },
-    },
-    {
-        id: "away-means-david-away",
-        since: "0.26.13",
-        run: () => {
-            const present = "merge" in LEAD_REFUSED && PARKED_CATEGORIES.includes("licence");
-            return {
-                present,
-                evidence: `coord_away refuses [${Object.keys(LEAD_REFUSED).join(", ")}] for the lead; parks ${PARKED_CATEGORIES.length} categories`,
-            };
-        },
-    },
-    {
-        id: "subscription-scanned-vs-evaluated",
-        since: "0.26.15",
-        run: () => {
-            // The capability is that "the machinery ran" and "your kind fired" are
-            // separable. Probed by asking for the state that used to be reported as
-            // broken: scanned, never evaluated — a healthy idle watch.
-            const base = { id: "p", agentId: "p", kind: "item", target: "t", createdAt: 0, lastEvaluatedAt: null, lastEventAt: null, delivered: [] };
-            const quiet = subscriptionHealth({ ...base, lastScannedAt: Date.now() });
-            const unscanned = subscriptionHealth({ ...base, lastScannedAt: null });
-            return {
-                present: quiet.level === "ok" && unscanned.level === "error",
-                evidence: `scanned+quiet -> '${quiet.level}', never-scanned -> '${unscanned.level}'`,
-            };
-        },
-    },
-    {
-        id: "record-authority",
-        since: "0.24.0",
-        run: () => {
-            const worker = recordAuthorityFor({ roleId: "worker" });
-            return {
-                present: worker.mayNotEmit.includes("verdict"),
-                evidence: `a worker mayNotEmit: [${worker.mayNotEmit.join(", ")}]`,
-            };
-        },
-    },
-];
-export function probeCapabilities(context) {
-    const probes = PROBES.map((p) => {
-        try {
-            const r = p.run();
-            return { id: p.id, since: p.since, present: r.present, evidence: r.evidence };
-        }
-        catch (e) {
-            // A THROWN PROBE IS AN ABSENT CAPABILITY, NOT A BROKEN CHECK. Older code
-            // that lacks the symbol throws exactly here, and reporting that as an
-            // error rather than an absence would make the common case look like a
-            // malfunction.
-            return { id: p.id, since: p.since, present: false, evidence: `probe threw: ${e.message}` };
-        }
-    });
-    const missing = probes.filter((p) => !p.present).map((p) => p.id);
-    return {
-        answeredBy: {
-            pid: process.pid,
-            startedAtIso: new Date(Date.now() - Math.round(process.uptime() * 1000)).toISOString(),
-            module: context.module,
-            versionLabel: context.versionLabel,
-        },
-        probes,
-        missing,
-        ok: missing.length === 0,
-        note: "Every line above was produced by CALLING the code in this process. `versionLabel` is a label someone typed " +
-            "into package.json and is context, never evidence — a published tarball has already been observed carrying a " +
-            "change its version said it could not. THIS ANSWER IS ABOUT ONE PROCESS: a release is delivered when every " +
-            "live agent's OWN server answers, which is the fifth state (merged · published · installed · restarted · observed). " +
-            "A server that has not restarted answers honestly about the old code it is still running.",
-    };
-}
-/* ── the verb ──────────────────────────────────────────────────────────────── */
-import { resolveServerIdentity } from "./server-identity.js";
-export const capabilitiesSchema = {};
-export async function capabilitiesTool() {
-    const id = resolveServerIdentity();
-    return probeCapabilities({ module: id.path, versionLabel: id.version });
-}
-//# sourceMappingURL=capabilities.js.map

package/dist/capabilities.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"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"}

package/dist/prefix.js

@@ -1,64 +0,0 @@
-/*
- * WHERE WILL A NEW GLOBAL INSTALL LAND, AND IS IT WHERE THE FLEET LOADS FROM?
- *
- * These are two different questions and neither answers the other. The
- * `server-build-drift` check names which copy is RUNNING; this names where the
- * NEXT copy will be written. A run of `npm i -g agent-coord-mcp` that prints
- * "added 1 package" is not evidence it landed anywhere that runs.
- *
- * MEASURED ON THIS BOX, 2026-08-28 — the divergence is not hypothetical:
- *   npm prefix -g          -> .../node/v22.22.2
- *   every live fleet server-> .../node/v22.21.1/lib/node_modules/agent-coord-mcp
- * Three prefixes exist here (two nvm, one /opt/homebrew), `npm prefix -g` is
- * PATH-dependent, and nvm switches it per shell. So the install target and the
- * load target had silently diverged, and a successful install would have
- * updated a copy nothing loads. That gap cost the fleet a day.
- */
-import path from "node:path";
-/**
- * The global root a module path sits under, or null if it is not in one.
- * `/p/lib/node_modules/agent-coord-mcp/dist` -> `/p`
- */
-export function prefixOf(modulePath) {
-    if (!modulePath)
-        return null;
-    // Split on the LAST occurrence: a global prefix can itself live under a path
-    // containing `node_modules`, and taking the first match would name an
-    // ancestor that installs nothing.
-    const marker = `${path.sep}lib${path.sep}node_modules${path.sep}`;
-    const i = modulePath.lastIndexOf(marker);
-    if (i === -1)
-        return null;
-    return modulePath.slice(0, i);
-}
-/**
- * `loadPrefix` is where THIS server was loaded from; `installPrefix` is what
- * `npm prefix -g` answered, and `npmPath` is which npm answered it — because a
- * prefix without the binary that reported it cannot be reproduced by anyone.
- */
-export function prefixVerdict(loadPrefix, installPrefix, npmPath) {
-    const via = npmPath ? ` (asked: ${npmPath})` : "";
-    // NOT DETERMINED IS NOT MATCHING. Both unknown branches are warnings that say
-    // what could not be established, never an "ok" over an unasked question.
-    // NOT APPLICABLE IS NOT THE SAME AS UNCHECKED, and conflating them is how a
-    // check earns its way into being ignored. A dev checkout has no load prefix
-    // BY CONSTRUCTION: this process is not the copy the fleet loads, so there is
-    // no divergence for it to have. Warning on every dev run would fire on every
-    // test run and every local session — noise, which is what a denylist does.
-    //
-    // The question is still ASKED where it can be answered: a session running
-    // from a global install has a load prefix, and that is where the fleet lives.
-    if (!loadPrefix)
-        return { level: "ok", detail: `not applicable: this server runs from a dev checkout, not a global install${via}, so it is not the copy the fleet loads and has no prefix to diverge from. Run \`doctor\` in an installed session to compare install target against load target.` };
-    if (!installPrefix)
-        return { level: "warn", detail: `could not determine the global install prefix${via} — \`npm prefix -g\` gave no answer, so where a new copy would land is UNKNOWN. Running from ${loadPrefix}.` };
-    if (path.resolve(loadPrefix) === path.resolve(installPrefix))
-        return { level: "ok", detail: `a global install would land where this server loads from (${loadPrefix})${via}` };
-    return {
-        level: "error",
-        detail: `INSTALL PREFIX AND LOAD PREFIX DIVERGE. A global install from this shell writes to ${installPrefix}${via}, but this server is running from ${loadPrefix}. ` +
-            `A successful "added 1 package" would update a copy nothing loads, and every check that reads a VERSION would keep reporting the old one truthfully. ` +
-            `Install with an explicit prefix (\`npm i -g --prefix ${loadPrefix} <pkg>\`) or switch node/nvm to the version owning ${loadPrefix} before installing.`,
-    };
-}
-//# sourceMappingURL=prefix.js.map

package/dist/prefix.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"prefix.js","sourceRoot":"","sources":["../src/prefix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,UAA8B;IACrD,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC;IAC7B,6EAA6E;IAC7E,sEAAsE;IACtE,kCAAkC;IAClC,MAAM,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,GAAG,eAAe,IAAI,CAAC,GAAG,EAAE,CAAC;IAClE,MAAM,CAAC,GAAG,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,KAAK,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1B,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAChC,CAAC;AAOD;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,UAAyB,EAAE,aAA4B,EAAE,OAAgB;IACrG,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,YAAY,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAElD,8EAA8E;IAC9E,yEAAyE;IACzE,4EAA4E;IAC5E,4EAA4E;IAC5E,6EAA6E;IAC7E,6EAA6E;IAC7E,2EAA2E;IAC3E,EAAE;IACF,0EAA0E;IAC1E,8EAA8E;IAC9E,IAAI,CAAC,UAAU;QACb,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,6EAA6E,GAAG,kKAAkK,EAAE,CAAC;IACrR,IAAI,CAAC,aAAa;QAChB,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,gDAAgD,GAAG,gGAAgG,UAAU,GAAG,EAAE,CAAC;IAErM,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC;QAC1D,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,6DAA6D,UAAU,IAAI,GAAG,EAAE,EAAE,CAAC;IAEnH,OAAO;QACL,KAAK,EAAE,OAAO;QACd,MAAM,EACJ,sFAAsF,aAAa,GAAG,GAAG,qCAAqC,UAAU,IAAI;YAC5J,sJAAsJ;YACtJ,wDAAwD,UAAU,sDAAsD,UAAU,qBAAqB;KAC1J,CAAC;AACJ,CAAC"}