syncstaff-mcp 0.2.3 → 0.2.4

package/README.md

@@ -9,7 +9,7 @@ driver, and arbiter SDK are not part of this package.
 Run this from the repository you want your agent to edit:
 
 ```bash
-npx -y syncstaff-mcp@0.2.3 setup
+npx -y syncstaff-mcp@0.2.4 setup
 ```
 
 It uses the folder name as the project and defaults to the hosted server, so
@@ -28,7 +28,7 @@ when it finishes.
 From the repository the agent will edit, start a device login:
 
 ```bash
-npx -y syncstaff-mcp@0.2.3 login \
+npx -y syncstaff-mcp@0.2.4 login \
   --server https://api.syncstaff.ai \
   --project your-project \
   --vendor codex
@@ -36,8 +36,8 @@ npx -y syncstaff-mcp@0.2.3 login \
 
 Open the displayed link, approve the short code, and leave the command running
 until it confirms the connection. Syncstaff stores the returned credential in
-`.keel/config.json` with owner-only permissions and never prints the token.
-The repository's `.keel/` directory should remain ignored by Git.
+`.syncstaff/config.json` with owner-only permissions and never prints the token.
+The repository's `.syncstaff/` directory should remain ignored by Git.
 
 ## MCP configuration
 
@@ -49,7 +49,7 @@ that checkout for call sites and unleased writes:
   "mcpServers": {
     "sync": {
       "command": "npx",
-      "args": ["-y", "syncstaff-mcp@0.2.3"]
+      "args": ["-y", "syncstaff-mcp@0.2.4"]
     }
   }
 }
@@ -75,7 +75,7 @@ so the server and adapter can be deployed in either order.
 
 ## Release verification
 
-From `keel/`, run:
+From `sync/`, run:
 
 ```bash
 npm run test:mcp-package

package/dist/lib/agent-state.js

@@ -1,7 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { keelEnv } from "./env-compat.js";
 /** Resolve the git root used by both the MCP process and lifecycle hooks. */
 export function repoRoot(cwd = process.cwd()) {
     try {
@@ -22,14 +21,14 @@ const slug = (s) => s.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 160);
  * Every supported client exports one to its child processes, which is what
  * lets a hook process and an MCP process for the *same* session agree on an
  * identity without either being told: they read the same variable. The
- * generic `CHARTER_SESSION_ID` wins so a harness can pin one explicitly.
+ * generic `SYNCSTAFF_SESSION_ID` wins so a harness can pin one explicitly.
  *
  * This must be consulted for **every** vendor. It previously read only
  * `CODEX_THREAD_ID`, which is why Codex was the only client whose parallel
  * sessions were ever isolated — see the note on `stateFile`.
  */
 export function vendorSessionId() {
-    return (process.env.CHARTER_SESSION_ID ||
+    return (process.env.SYNCSTAFF_SESSION_ID ||
         process.env.CODEX_THREAD_ID ||
         process.env.CLAUDE_CODE_SESSION_ID ||
         undefined);
@@ -51,8 +50,8 @@ export function vendorSessionId() {
  * null or undefined is what that bug looked like, so prefer
  * :func:`vendorSessionId` over passing nothing.
  */
-export function stateFile(root = repoRoot(), sessionId = vendorSessionId(), vendor = process.env.CHARTER_VENDOR) {
-    const explicit = keelEnv("STATE_FILE");
+export function stateFile(root = repoRoot(), sessionId = vendorSessionId(), vendor = process.env.SYNCSTAFF_VENDOR) {
+    const explicit = process.env.SYNCSTAFF_STATE_FILE;
     if (explicit)
         return explicit;
     const parts = ["state"];
@@ -60,7 +59,7 @@ export function stateFile(root = repoRoot(), sessionId = vendorSessionId(), vend
         parts.push(slug(vendor));
     if (sessionId)
         parts.push(slug(sessionId));
-    return join(root, ".keel", `${parts.join("-")}.json`);
+    return join(root, ".syncstaff", `${parts.join("-")}.json`);
 }
 /**
  * The state file to *read*, tolerating identities written before sessions were
@@ -84,8 +83,8 @@ export function stateFile(root = repoRoot(), sessionId = vendorSessionId(), vend
  * prevent. A missing scoped file now simply means "not registered under this
  * session yet"; the caller re-registers, which is cheap and correct.
  */
-export function resolveStateFile(root = repoRoot(), sessionId = vendorSessionId(), vendor = process.env.CHARTER_VENDOR) {
-    const explicit = keelEnv("STATE_FILE");
+export function resolveStateFile(root = repoRoot(), sessionId = vendorSessionId(), vendor = process.env.SYNCSTAFF_VENDOR) {
+    const explicit = process.env.SYNCSTAFF_STATE_FILE;
     if (explicit)
         return explicit;
     const scoped = stateFile(root, sessionId, vendor);

package/dist/lib/blast.js

@@ -14,7 +14,7 @@ const MAX_REPORTED_SITES = 20_000;
 const MAX_CONTEXT_CHARS = 200;
 const SKIP_DIRS = new Set([
     "node_modules", ".git", "dist", "build", "out", ".venv", "venv",
-    "__pycache__", ".next", ".turbo", "coverage", ".keel",
+    "__pycache__", ".next", ".turbo", "coverage", ".syncstaff",
 ]);
 /**
  * Files git is tracking, for resolving call sites against.
@@ -221,7 +221,7 @@ export function attachClientCallSiteReports(repoPath, interfaces, options = {})
         // now resolve through one function (R12.0), because two analyzers that
         // answer "what references this symbol" differently is how an agent learns
         // to trust neither. Before this, declaring an intent over a constant found
-        // only what grep found — `KEEL_RELEASE_VERSION(` appears nowhere, so a
+        // only what grep found — `SYNCSTAFF_RELEASE_VERSION(` appears nowhere, so a
         // change to a constant four modules read produced an empty confirmed set.
         //
         // Import lines are the one kind left out, and the reason is not tidiness.
@@ -261,12 +261,12 @@ export function attachClientCallSiteReports(repoPath, interfaces, options = {})
 /**
  * Analyzers whose reports this server will read.
  *
- * "grep-v1" is the original. "keel-graph-v1(...)" carries a parser signature,
- * and a union report is "keel-graph-v1(...)+grep-v1". Matching by prefix means
+ * "grep-v1" is the original. "syncstaff-graph-v1(...)" carries a parser signature,
+ * and a union report is "syncstaff-graph-v1(...)+grep-v1". Matching by prefix means
  * a client with an upgraded parser is not rejected by an older server, which
  * is the failure mode that makes an agent's analysis silently disappear.
  */
-const KNOWN_ANALYZER_PREFIXES = ["grep-v1", "keel-graph-v1"];
+const KNOWN_ANALYZER_PREFIXES = ["grep-v1", "syncstaff-graph-v1"];
 function isKnownAnalyzer(analyzer) {
     return (typeof analyzer === "string" &&
         KNOWN_ANALYZER_PREFIXES.some((prefix) => analyzer.startsWith(prefix)));

package/dist/lib/client-config.js

@@ -1,19 +1,19 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
 import { dirname, join } from "node:path";
 function configPath(root) {
-    return join(root, ".keel", "config.json");
+    return join(root, ".syncstaff", "config.json");
 }
 function validate(value, path) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error(`invalid Keel client config at ${path}: expected an object`);
+        throw new Error(`invalid Syncstaff client config at ${path}: expected an object`);
     }
     const candidate = value;
     if (candidate.version !== 1) {
-        throw new Error(`invalid Keel client config at ${path}: unsupported version`);
+        throw new Error(`invalid Syncstaff client config at ${path}: unsupported version`);
     }
     for (const key of ["server", "project", "token", "vendor"]) {
         if (typeof candidate[key] !== "string" || !candidate[key].trim()) {
-            throw new Error(`invalid Keel client config at ${path}: ${key} is required`);
+            throw new Error(`invalid Syncstaff client config at ${path}: ${key} is required`);
         }
     }
     let server;
@@ -21,16 +21,16 @@ function validate(value, path) {
         server = new URL(candidate.server);
     }
     catch {
-        throw new Error(`invalid Keel client config at ${path}: server must be an absolute URL`);
+        throw new Error(`invalid Syncstaff client config at ${path}: server must be an absolute URL`);
     }
     if (!["http:", "https:"].includes(server.protocol) || server.username || server.password) {
-        throw new Error(`invalid Keel client config at ${path}: server must be an HTTP(S) URL without credentials`);
+        throw new Error(`invalid Syncstaff client config at ${path}: server must be an HTTP(S) URL without credentials`);
     }
     if (server.search || server.hash) {
-        throw new Error(`invalid Keel client config at ${path}: server must not contain a query or fragment`);
+        throw new Error(`invalid Syncstaff client config at ${path}: server must not contain a query or fragment`);
     }
     if (!/^ch_[A-Za-z0-9_-]+$/.test(candidate.token)) {
-        throw new Error(`invalid Keel client config at ${path}: token has an unexpected format`);
+        throw new Error(`invalid Syncstaff client config at ${path}: token has an unexpected format`);
     }
     return {
         version: 1,
@@ -40,7 +40,7 @@ function validate(value, path) {
         vendor: candidate.vendor.trim(),
     };
 }
-/** Load repo-local adapter credentials, or null before `keel login`. */
+/** Load repo-local adapter credentials, or null before `syncstaff login`. */
 export function loadClientConfig(root) {
     const path = configPath(root);
     if (!existsSync(path))
@@ -50,7 +50,7 @@ export function loadClientConfig(root) {
         parsed = JSON.parse(readFileSync(path, "utf8"));
     }
     catch {
-        throw new Error(`invalid Keel client config at ${path}: file is not valid JSON`);
+        throw new Error(`invalid Syncstaff client config at ${path}: file is not valid JSON`);
     }
     return validate(parsed, path);
 }

package/dist/lib/env-compat.js

@@ -1,66 +1,16 @@
 /**
- * KEEL_* ⇄ CHARTER_* environment aliasing.
+ * Reject configuration from retired product eras before any module-scope
+ * environment read can silently fall back to a default.
  *
- * The service is renamed Charter → Keel. Twenty-six environment variables
- * carry the old prefix, and they are read from ~30 files, three agent hook
- * configs, two MCP configs, a CI workflow, and a systemd unit on a host this
- * repo does not control. Renaming all of that in one commit means every one
- * of those has to land simultaneously, and anything that restarts in between
- * comes up misconfigured.
- *
- * That is not a hypothetical here. `src/mcp/index.ts` was switched to KEEL_*
- * before the configs that feed it were, so the adapter would have thrown
- * "KEEL_PROJECT env var is required" on the first tool call after any agent
- * restarted — while `dist/` still held a pre-rename build, so the breakage was
- * invisible until the next `npm run build`. A test run would have armed it.
- *
- * So instead: alias both directions, once, at process start. Every variable
- * answers to both names, the running fleet keeps working on CHARTER_*, new
- * code can read KEEL_*, and the configs migrate one at a time instead of all
- * at once. This module is the reason the rename does not need a window.
- *
- * Remove it only when nothing sets CHARTER_* anywhere — including the VPS
- * systemd unit and every developer's shell profile, which is the part nobody
- * remembers.
- */
-const PREFIXES = ["SYNCSTAFF_", "NAIB_", "KEEL_", "CHARTER_"];
-/**
- * Mirror SYNCSTAFF_x ⇄ NAIB_x ⇄ KEEL_x ⇄ CHARTER_x across all naming eras.
- *
- * An explicitly set value always wins: if multiple names are present with
- * different values, neither is overwritten.
- *
- * Idempotent, so entry points may call it more than once.
- */
-export function aliasEnv(env = process.env) {
-    for (const [key, value] of Object.entries(env)) {
-        if (value === undefined)
-            continue;
-        for (const sourcePrefix of PREFIXES) {
-            if (key.startsWith(sourcePrefix)) {
-                const suffix = key.slice(sourcePrefix.length);
-                for (const targetPrefix of PREFIXES) {
-                    if (targetPrefix !== sourcePrefix) {
-                        const renamed = targetPrefix + suffix;
-                        if (env[renamed] === undefined)
-                            env[renamed] = value;
-                    }
-                }
-                break;
-            }
-        }
-    }
-}
-/**
- * Read a variable by its suffix under NAIB_, KEEL_, or CHARTER_ prefix (newest first).
+ * Every process entry point imports this module first. Syncstaff is a hard
+ * cutover: old prefixes are errors with an exact replacement, not aliases.
  */
-export function naibEnv(suffix) {
-    return process.env["SYNCSTAFF_" + suffix] ?? process.env["NAIB_" + suffix] ?? process.env["KEEL_" + suffix] ?? process.env["CHARTER_" + suffix];
+const RETIRED_PREFIXES = ["KE" + "EL_", "NA" + "IB_", "CHAR" + "TER_"];
+for (const key of Object.keys(process.env)) {
+    const prefix = RETIRED_PREFIXES.find((candidate) => key.startsWith(candidate));
+    if (!prefix)
+        continue;
+    const replacement = `SYNCSTAFF_${key.slice(prefix.length)}`;
+    throw new Error(`Retired environment variable ${key} is not supported. Rename it to ${replacement}.`);
 }
-export const keelEnv = naibEnv;
-// Aliasing on import is deliberate. Several modules read process.env at module
-// scope (`const SERVER = process.env.KEEL_URL ?? …`), which runs before any
-// entry point's first statement. A function an entry point must remember to
-// call would therefore be called too late, and the failure would be a silent
-// fallback to a default rather than an error.
-aliasEnv();
+export {};

package/dist/lib/index/aliases.js

@@ -9,7 +9,7 @@
  * That was true of this repository until now. web/tsconfig.json declares
  * `"@/*": ["./src/*"]`, six files import through it, and the graph saw none of
  * those edges. The real-repo tests passed only because they were scoped to
- * keel/src, which uses relative imports throughout — the blind spot was hiding
+ * sync/src, which uses relative imports throughout — the blind spot was hiding
  * behind the choice of test corpus, which is the most comfortable place for a
  * blind spot to hide.
  *
@@ -17,7 +17,7 @@
  * implementation is worse:
  *
  * SCOPE. A monorepo has several tsconfigs. web/tsconfig.json's aliases apply
- * to web/, not to keel/. Applying every alias everywhere would invent edges
+ * to web/, not to sync/. Applying every alias everywhere would invent edges
  * across package boundaries — the same class of error as matching a name in an
  * unrelated language. Each mapping records the directory it governs, and the
  * nearest governing config wins.

package/dist/lib/index/call-sites.js

@@ -91,7 +91,7 @@ export function buildGraphCallSiteIndex(repoPath, loadParsers, options = {}) {
      * then pools them back together, undoing the resolution that just happened.
      *
      * What that looked like here: `now`, exported by lib/ids.ts, collected the
-     * two reads of a `const now` local to lib/slack.ts; `keelEnv`, exported by
+     * two reads of a `const now` local to lib/slack.ts; a retired environment helper exported by
      * lib/env-compat.ts, collected five calls to a same-named local in a script
      * that does not import it. Both were labelled "confirmed" — the label that
      * tells a human these are the trustworthy ones. Across this repository 268
@@ -173,6 +173,6 @@ export function buildGraphCallSiteIndex(repoPath, loadParsers, options = {}) {
         blindSpots: index.blindSpots.length,
         unresolvedCalls: calls.unresolved.length,
         unresolvedReferences: references.unresolved.length,
-        analyzer: `keel-graph-v1(${registry.signature()})`,
+        analyzer: `syncstaff-graph-v1(${registry.signature()})`,
     };
 }

package/dist/lib/index/checker-resolver.js

@@ -8,7 +8,7 @@
  * precision has held at 1.00 against the compiler. The cost of that refusal
  * was never measured until now, and it is much larger than assumed:
  *
- *   keel (plain functions)   470 edges found, checker finds 695   — 64% recall
+ *   sync (plain functions)   470 edges found, checker finds 695   — 64% recall
  *   zod  (fluent API)        722 edges found, checker finds 3178  — 14% recall
  *
  * `z.string()` is 2,591 calls in zod that the syntactic pass cannot see, and
@@ -18,7 +18,7 @@
  * inferred.
  *
  * WHAT THIS IS NOT. It does not replace the syntactic backend. It is slower by
- * 6-7x (4.1s on keel, 11.2s on zod, against 0.7s and 1.6s), it needs a
+ * 6-7x (4.1s on sync, 11.2s on zod, against 0.7s and 1.6s), it needs a
  * tsconfig, and it wants node_modules present to resolve external types. The
  * syntactic pass still answers when those are missing, which is the ordinary
  * case in a fresh checkout. Callers choose, and the result says which backend
@@ -77,7 +77,7 @@ export function findProjectConfigs(ts, root) {
     for (const candidate of NAMES)
         visit(join(root, candidate), 0);
     // Monorepos keep the tsconfig one level down. `repoRoot()` returns the git
-    // root, so asking about a symbol in keel/ resolved to /home/.../sync, which
+    // root, so asking about a symbol in sync/ resolved to the monorepo root, which
     // has no tsconfig — findProjectConfigs returned nothing, the checker backend
     // reported "cannot run here", and the hook fell back to the parser while
     // still claiming it had been asked for the checker. A silent downgrade is

package/dist/lib/index/lexical.js

@@ -8,7 +8,7 @@ const tokenise = (value) => value
     .filter(Boolean) ?? [];
 const fields = (page) => [page.title, page.content, page.summary, page.target_path, page.body ?? "", page.lexical_vocabulary ?? ""].join(" ");
 /** Parse the candidate-only vocabulary weight; malformed values fail closed. */
-export function vocabularyWeightFromEnv(raw = process.env.KEEL_RETRIEVAL_VOCABULARY) {
+export function vocabularyWeightFromEnv(raw = process.env.SYNCSTAFF_RETRIEVAL_VOCABULARY) {
     if (!raw?.trim())
         return 0;
     const value = Number(raw.trim());
@@ -45,7 +45,7 @@ export const IDENTITY_FIELD_WEIGHTS = { path: 1, facts: 1, summary: 1, body: 1,
  *
  * A degenerate baseline (rule 2) makes the confounder concrete. Serving the ten
  * largest files in the corpus, ignoring the query completely, scores recall@10
- * of 0.1596 on keel200 and 0.0793 on pw1200 — far below real retrieval, but
+ * of 0.1596 on private200 and 0.0793 on pw1200 — far below real retrieval, but
  * three to twenty-five times a same-sized random pick. File size genuinely
  * correlates with being edited, so any mechanism whose gain arrives together
  * with a file-size increase has to be assumed guilty until separated.
@@ -62,14 +62,14 @@ const FIELD_ORDER = ["path", "facts", "summary", "body"];
  * Parse `path=4,facts=3,summary=1,body=1` from the environment.
  *
  * One build serves every weighting, so a sweep cannot be confounded with
- * anything else that changed between two builds — the same reason `KEEL_CHUNK`
- * and `KEEL_NO_GRAPH` are switches rather than branches.
+ * anything else that changed between two builds — the same reason `SYNCSTAFF_CHUNK`
+ * and `SYNCSTAFF_NO_GRAPH` are switches rather than branches.
  *
  * Anything unparseable falls back to the identity weighting rather than
  * throwing. A malformed weight string in a benchmark harness should produce the
  * documented default, not abort a run that has already paid for its index.
  */
-export function fieldWeightsFromEnv(raw = process.env.KEEL_FIELD_WEIGHTS ?? process.env.CHARTER_FIELD_WEIGHTS) {
+export function fieldWeightsFromEnv(raw = process.env.SYNCSTAFF_FIELD_WEIGHTS) {
     if (!raw)
         return IDENTITY_FIELD_WEIGHTS;
     const weights = { ...IDENTITY_FIELD_WEIGHTS };

package/dist/lib/index/pages.js

@@ -234,7 +234,7 @@ function chunkPages(file, page) {
     // rejected is the economic case for chunking on top of it. Re-open this only
     // with a measurement that beats the per-instance figure above, not a pooled
     // one.
-    if (process.env.KEEL_CHUNK !== "1" && process.env.CHARTER_CHUNK !== "1")
+    if (process.env.SYNCSTAFF_CHUNK !== "1")
         return [];
     const original = page.body ?? "";
     const body = distillBody(original);

package/dist/lib/index/pipeline.js

@@ -8,7 +8,7 @@ import { buildDependencyGraph } from "./graph.js";
 import { buildSymbolTable, resolveCallEdges } from "./symbols.js";
 import { byCodeUnit } from "./order.js";
 /** Parse the local rollout switch. Unknown values fail closed to stable. */
-export function retrievalModeFromEnv(value = process.env.KEEL_RETRIEVAL_MODE) {
+export function retrievalModeFromEnv(value = process.env.SYNCSTAFF_RETRIEVAL_MODE) {
     const normalized = value?.trim().toLowerCase();
     return normalized === "candidate" || normalized === "shadow" ? normalized : "stable";
 }
@@ -225,9 +225,9 @@ export async function retrieve(pages, query, options = {}) {
     // The default model is also opt-in even when the caller expresses no
     // preference: loading ~200-300MB of ONNX weights on every retrieve() call
     // is exactly the duplicate-memory cost tsk_01M1MQ01E1D7JSEHFVE2RCK8DJ
-    // flagged across concurrent agent processes. KEEL_RETRIEVAL_SEMANTIC=1
+    // flagged across concurrent agent processes. SYNCSTAFF_RETRIEVAL_SEMANTIC=1
     // opts back in; lexical + symbol stays the default high-precision path.
-    const semanticOptIn = process.env.KEEL_RETRIEVAL_SEMANTIC === "1";
+    const semanticOptIn = process.env.SYNCSTAFF_RETRIEVAL_SEMANTIC === "1";
     const embedder = options.embedder === undefined
         ? (semanticOptIn ? await createTransformersEmbedder() : null)
         : options.embedder;
@@ -373,8 +373,8 @@ export async function retrieve(pages, query, options = {}) {
         // Ablation switch. A corpus measured for the first time has no pre-graph
         // baseline to compare against, and producing one from an older build would
         // confound the comparison with everything else that changed in between —
-        // the same reason KEEL_CHUNK exists.
-        ...(graphArtifacts && process.env.KEEL_NO_GRAPH !== "1" && process.env.CHARTER_NO_GRAPH !== "1"
+        // the same reason SYNCSTAFF_CHUNK exists.
+        ...(graphArtifacts && process.env.SYNCSTAFF_NO_GRAPH !== "1"
             ? { expandFromSeeds: expandFromSeeds(graphArtifacts.graph, graphArtifacts.calls, pagesByPath, graphRankablePaths) }
             : {}),
         ...(cochangeExpander ? { expandFromCoChange: cochangeExpander } : {}),

package/dist/lib/index/registry.js

@@ -1,5 +1,5 @@
 /**
- * The language/parser contract for Keel's local index.
+ * The language/parser contract for Syncstaff's local index.
  *
  * Everything here runs on the agent's machine, beside the checkout, per
  * inv_01KZWPAM9QCZ0DD7789N55X647 and ADR 002: the central server routes
@@ -9,7 +9,7 @@
  *
  *   A confident wrong answer is worse than an admitted gap.
  *
- * Keel already has the counter-example in production. `grep-v1` resolves call
+ * Syncstaff already has the counter-example in production. `grep-v1` resolves call
  * sites by matching a bare symbol name across the repository, so declaring a
  * TypeScript method named `check` matched a Python comment reading
  * "# side of the ORPHAN check" and sixteen other files in an unrelated tree.

package/dist/lib/index/symbols.js

@@ -160,7 +160,7 @@ export function resolveCallEdges(index, table) {
  * This is the answer to "what would break if I changed this symbol", and it is
  * the single path both blast-radius surfaces read. Before it existed, the graph
  * could name every caller of a function and not one user of a constant: the
- * extractor only fired inside `isCallExpression`, so `KEEL_RELEASE_VERSION`,
+ * extractor only fired inside `isCallExpression`, so `SYNCSTAFF_RELEASE_VERSION`,
  * read in four files, resolved to silence.
  *
  * Deterministic, for the same reason as resolveCallEdges: two machines with the

package/dist/lib/index/transformers-embedder.js

@@ -23,7 +23,7 @@ export class TransformersEmbedder {
         if (!this.pipelinePromise) {
             this.pipelinePromise = (async () => {
                 try {
-                    // Dynamic import allows Keel to run if the dependency is missing (R4.2)
+                    // Dynamic import allows Syncstaff to run if the dependency is missing (R4.2)
                     const { pipeline } = await import("@xenova/transformers");
                     return await pipeline("feature-extraction", this.modelId, {
                         quantized: true // Use INT8 quantization for smaller size and faster CPU inference

package/dist/lib/index/typescript-parser.js

@@ -9,7 +9,7 @@ const EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"
 const PARSER_VERSION = "4";
 export function createTypeScriptParser(tsApi) {
     return {
-        id: "keel-typescript",
+        id: "syncstaff-typescript",
         version: PARSER_VERSION,
         language: "typescript",
         extensions: EXTENSIONS,
@@ -385,7 +385,7 @@ function parseSource(tsApi, source, path) {
             }
         }
         // ---- plain reads -------------------------------------------------------
-        // The branch that was missing entirely. `KEEL_RELEASE_VERSION` is read in
+        // The branch that was missing entirely. `SYNCSTAFF_RELEASE_VERSION` is read in
         // four files and invoked in none, so every extractor above walks straight
         // past it and the graph reports that nothing uses a constant three modules
         // depend on. Everything already handled above is excluded here rather than

package/dist/lib/index/vector-cache.js

@@ -35,7 +35,7 @@ export function embedderIdentity(embedder) {
  * keeps the representations in separate cache entries. `facts` is the
  * narrower candidate; `1` additionally includes the bounded vocabulary.
  */
-const vectorDocumentFactsMode = () => process.env.KEEL_VECTOR_DOCUMENT_FACTS ?? "";
+const vectorDocumentFactsMode = () => process.env.SYNCSTAFF_VECTOR_DOCUMENT_FACTS ?? "";
 /**
  * The exact text sent to the embedder for one page.
  *

package/dist/lib/mcp-compaction.js

@@ -4,7 +4,7 @@
  * Every function here is pure, and that is the point: the MCP adapter is a
  * process that connects on import, so nothing inside it can be unit tested.
  * These were measured against 40 sessions of real transcripts — 960,307
- * response tokens across 1,837 keel tool calls, against roughly 6,000 tokens
+ * response tokens across 1,837 Sync tool calls, against roughly 6,000 tokens
  * per session of static tool schemas and protocol instructions. Responses
  * outweigh definitions about four to one, so this is where the budget is.
  *

package/dist/lib/model-roles.js

@@ -65,9 +65,7 @@ const inferProvider = (model) => /^claude[-.]/i.test(model) ? "anthropic" : "ope
  * environment is per server and set by whoever runs it; the default is what
  * ships.
  *
- * Environment names are `NAIB_MODEL_<ROLE>_MODEL` and friends, with the
- * `KEEL_`/`CHARTER_` aliases honoured directly so this works whether or not
- * `aliasEnv` has run.
+ * Environment names are `SYNCSTAFF_MODEL_<ROLE>_MODEL` and friends.
  *
  * Never throws. A misconfiguration disables one role and explains itself; the
  * caller degrades per `whenUnavailable` rather than failing.
@@ -79,17 +77,12 @@ export function resolveRole(role, settings, env = {}) {
     }
     const upper = role.toUpperCase();
     const scoped = (scope, suffix) => {
-        for (const prefix of ["NAIB_", "KEEL_", "CHARTER_"]) {
-            const v = env[`${prefix}MODEL_${scope}_${suffix}`]?.trim();
-            if (v)
-                return v;
-        }
-        return undefined;
+        return env[`SYNCSTAFF_MODEL_${scope}_${suffix}`]?.trim() || undefined;
     };
     /**
      * Per-role first, then the server-wide default.
      *
-     * `NAIB_MODEL_DEFAULT_*` exists because "plug whatever model in" should not
+     * `SYNCSTAFF_MODEL_DEFAULT_*` exists because "plug whatever model in" should not
      * mean repeating the same endpoint and key variable once per role, and
      * repeating them again when a role is added.
      */
@@ -105,7 +98,7 @@ export function resolveRole(role, settings, env = {}) {
      * The default's endpoint and key belong to the default's *model*, and must
      * not follow a role that points somewhere else.
      *
-     * Setting `NAIB_MODEL_DEFAULT_*` to GLM and then overriding one role to a
+     * Setting `SYNCSTAFF_MODEL_DEFAULT_*` to GLM and then overriding one role to a
      * Claude model used to leave that role resolving to Anthropic while still
      * inheriting `GLM_API_KEY`, so every request came back
      * `401 invalid x-api-key` — naming a key the operator had never pointed at

package/dist/lib/path-warnings.js

@@ -6,7 +6,7 @@
  * copy of the repository on the server's own disk, at whatever commit it last
  * pulled, which is nobody's working tree. That made the same declaration
  * warn on one instance and stay silent on another, and it was the last thing
- * keeping a filesystem dependency inside a Keel process
+ * keeping a filesystem dependency inside a Syncstaff process
  * (inv_01KZWPAT93H32HB3X48FNPTA1E).
  *
  * Only filenames are read, never file contents, so this never breached the
@@ -22,8 +22,8 @@ export function declaredPathWarnings(paths, files) {
     // An EMPTY file list is "could not look", not "the repository is empty",
     // and conflating them turns this into a machine for crying wolf. That is not
     // hypothetical: `repo_path` still said /opt/charter/sync after the
-    // Charter -> Keel rename, the walk returned [], and every declared path came
-    // back as a warning — including `keel/src/server/app.ts`, which obviously
+    // Charter -> Syncstaff rename, the walk returned [], and every declared path came
+    // back as a warning — including `sync/src/server/app.ts`, which obviously
     // exists. A check that fires on everything is worse than no check, because
     // it teaches the reader to skip the one that matters.
     //

package/dist/lib/version.js

@@ -1,5 +1,5 @@
 /** Release version shared by the server and the published MCP adapter. */
-export const KEEL_RELEASE_VERSION = "0.2.3";
+export const SYNCSTAFF_RELEASE_VERSION = "0.2.4";
 /**
  * Adapter/API compatibility level.
  *
@@ -7,15 +7,18 @@ export const KEEL_RELEASE_VERSION = "0.2.3";
  * the server. It is deliberately separate from the npm package version so a
  * bug-fix release does not manufacture a protocol break.
  */
-export const KEEL_ADAPTER_PROTOCOL_VERSION = 1;
-export const KEEL_ADAPTER_VERSION_HEADER = "x-keel-adapter-version";
-export const KEEL_ADAPTER_PROTOCOL_HEADER = "x-keel-adapter-protocol";
-export const KEEL_SERVER_VERSION_HEADER = "x-keel-server-version";
-export const KEEL_SUPPORTED_ADAPTER_PROTOCOL_HEADER = "x-keel-supported-adapter-protocol";
+export const SYNCSTAFF_ADAPTER_PROTOCOL_VERSION = 2;
+export const SYNCSTAFF_ADAPTER_VERSION_HEADER = "x-syncstaff-adapter-version";
+export const SYNCSTAFF_ADAPTER_PROTOCOL_HEADER = "x-syncstaff-adapter-protocol";
+export const SYNCSTAFF_SERVER_VERSION_HEADER = "x-syncstaff-server-version";
+export const SYNCSTAFF_SUPPORTED_ADAPTER_PROTOCOL_HEADER = "x-syncstaff-supported-adapter-protocol";
+const RETIRED_PRODUCT_SLUG = ["ke", "el"].join("");
+export const RETIRED_ADAPTER_VERSION_HEADER = `x-${RETIRED_PRODUCT_SLUG}-adapter-version`;
+export const RETIRED_ADAPTER_PROTOCOL_HEADER = `x-${RETIRED_PRODUCT_SLUG}-adapter-protocol`;
 /** Headers attached to every adapter-to-server request. */
 export function adapterRequestHeaders() {
     return {
-        [KEEL_ADAPTER_VERSION_HEADER]: KEEL_RELEASE_VERSION,
-        [KEEL_ADAPTER_PROTOCOL_HEADER]: String(KEEL_ADAPTER_PROTOCOL_VERSION),
+        [SYNCSTAFF_ADAPTER_VERSION_HEADER]: SYNCSTAFF_RELEASE_VERSION,
+        [SYNCSTAFF_ADAPTER_PROTOCOL_HEADER]: String(SYNCSTAFF_ADAPTER_PROTOCOL_VERSION),
     };
 }

package/dist/lib/worktree.js

@@ -101,7 +101,7 @@ export function upstreamLandingReport(repoRoot) {
         return {
             upstream_status: "unknown",
             ahead_count: null,
-            warning: "Intent completed, but Keel could not verify whether HEAD is published to an " +
+            warning: "Intent completed, but Syncstaff could not verify whether HEAD is published to an " +
                 "upstream branch. Configure a tracking branch or verify and push manually.",
         };
     }
@@ -122,7 +122,7 @@ export function listWorktreeChanges(repoRoot) {
 /**
  * Changed paths not covered by any of `leasedPaths`.
  *
- * `ignore` drops paths that are never coordination-relevant (Keel's own
+ * `ignore` drops paths that are never coordination-relevant (Syncstaff's own
  * per-session state, build output, dependencies). Directories must be given
  * with a trailing slash.
  */
@@ -196,7 +196,7 @@ export function formatUnleasedWriteAlert(report, writes) {
     return lines.join("\n");
 }
 export const DEFAULT_IGNORES = [
-    ".keel/",
+    ".syncstaff/",
     "node_modules/",
     "dist/",
     "build/",

package/dist/mcp/daemon-client.js

@@ -19,11 +19,11 @@ function envSeconds(name, fallback) {
     return Number.isFinite(value) && value >= 0 ? value : fallback;
 }
 /** 0 disables the daemon path entirely — every call falls back to local computation, same as before this module existed. */
-const REQUEST_TIMEOUT_MS = envSeconds("KEEL_MCP_DAEMON_TIMEOUT_SECONDS", 20) * 1000;
+const REQUEST_TIMEOUT_MS = envSeconds("SYNCSTAFF_MCP_DAEMON_TIMEOUT_SECONDS", 20) * 1000;
 const CONNECT_TIMEOUT_MS = 500;
 /** Opt-in: off by default, so existing behavior is unchanged unless a caller sets this. */
 export function daemonEnabled() {
-    const v = process.env.KEEL_MCP_DAEMON?.trim().toLowerCase();
+    const v = process.env.SYNCSTAFF_MCP_DAEMON?.trim().toLowerCase();
     return v === "1" || v === "true" || v === "on";
 }
 function connectTo(target) {

package/dist/mcp/daemon-protocol.js

@@ -88,13 +88,13 @@ export function daemonInstanceId(root) {
  * daemon's socket happened to still exist.
  */
 export function socketPathFor(root) {
-    return join(baseDir(), `keel-daemon-${daemonInstanceId(root)}.sock`);
+    return join(baseDir(), `sync-daemon-${daemonInstanceId(root)}.sock`);
 }
 /** Where the TCP fallback (used when the socket path can't be bound — see daemon.ts) records its port. */
 export function tcpPortFileFor(root) {
-    return join(baseDir(), `keel-daemon-${daemonInstanceId(root)}.port`);
+    return join(baseDir(), `sync-daemon-${daemonInstanceId(root)}.port`);
 }
 /** The pidfile a running daemon maintains so a stale one can be told apart from a live one before connecting. */
 export function pidFileFor(root) {
-    return join(baseDir(), `keel-daemon-${daemonInstanceId(root)}.pid`);
+    return join(baseDir(), `sync-daemon-${daemonInstanceId(root)}.pid`);
 }

package/dist/mcp/graph-ops.js

@@ -47,8 +47,8 @@ export async function buildLocalGraph(root) {
     let keepArchiveOpen = false;
     let indexed;
     try {
-        mkdirSync(join(root, ".keel"), { recursive: true });
-        archive = new persistenceMod.IndexSnapshotArchive(join(root, ".keel", "index.sqlite"));
+        mkdirSync(join(root, ".syncstaff"), { recursive: true });
+        archive = new persistenceMod.IndexSnapshotArchive(join(root, ".syncstaff", "index.sqlite"));
         vectorCache = new vectorCacheMod.VectorCache(archive);
         indexed = incrementalMod.loadOrUpdateFileIndex(root, registry, {
             archive,
@@ -151,9 +151,9 @@ export async function runRetrieve(local, args) {
         vectorCache: vectorCache ?? undefined,
         retrievalMode,
         lexicalVocabularyWeight: vocabularyWeightFromEnv(),
-        queryRouting: retrievalMode !== "stable" && envFlag("KEEL_RETRIEVAL_ROUTING", false),
+        queryRouting: retrievalMode !== "stable" && envFlag("SYNCSTAFF_RETRIEVAL_ROUTING", false),
         coChangeIndex,
-        ...(retrievalMode !== "stable" && envFlag("KEEL_RETRIEVAL_VERIFY", false) ? { verify: { root } } : {}),
+        ...(retrievalMode !== "stable" && envFlag("SYNCSTAFF_RETRIEVAL_VERIFY", false) ? { verify: { root } } : {}),
     });
     return {
         ...answer,

package/dist/mcp/index.js

@@ -1,36 +1,36 @@
 #!/usr/bin/env node
 /**
- * keel-mcp — MCP adapter exposing the coordination tool surface (§6.4).
+ * sync-mcp — MCP adapter exposing the coordination tool surface (§6.4).
  *
- * Connection settings come from KEEL_URL / KEEL_PROJECT / KEEL_VENDOR /
- * KEEL_TOKEN first, then the repo-local config written by `keel login`.
- * KEEL_URL defaults to http://localhost:7377. Set
- * KEEL_BLAST_INCLUDE_CONTEXT=0 to omit source snippets from client-side
+ * Connection settings come from SYNCSTAFF_URL / SYNCSTAFF_PROJECT / SYNCSTAFF_VENDOR /
+ * SYNCSTAFF_TOKEN first, then the repo-local config written by `sync login`.
+ * SYNCSTAFF_URL defaults to http://localhost:7377. Set
+ * SYNCSTAFF_BLAST_INCLUDE_CONTEXT=0 to omit source snippets from client-side
  * call-site reports. Retrieval rollout is local and fail-closed: use
- * KEEL_RETRIEVAL_MODE=stable (default), candidate, or shadow. Set
- * KEEL_RETRIEVAL_VOCABULARY=1 only for candidate/shadow testing of the
+ * SYNCSTAFF_RETRIEVAL_MODE=stable (default), candidate, or shadow. Set
+ * SYNCSTAFF_RETRIEVAL_VOCABULARY=1 only for candidate/shadow testing of the
  * bounded parser-derived lexical vocabulary; stable mode ignores it. Set
- * KEEL_RETRIEVAL_ROUTING=1 to test candidate-only intent-specific query
+ * SYNCSTAFF_RETRIEVAL_ROUTING=1 to test candidate-only intent-specific query
  * routing; stable mode ignores it.
- * KEEL_RETRIEVAL_VERIFY=1 to run the local TypeScript checker against
+ * SYNCSTAFF_RETRIEVAL_VERIFY=1 to run the local TypeScript checker against
  * candidate-mode results and promote only candidates with call-site evidence;
  * stable mode ignores it. Verification is budgeted and degrades to the
  * unverified ranking when the checkout cannot be checked.
- * KEEL_API_TIMEOUT_SECONDS (default 45, 0 disables) bounds every HTTP call
+ * SYNCSTAFF_API_TIMEOUT_SECONDS (default 45, 0 disables) bounds every HTTP call
  * this adapter makes to the Sync server, so a stalled request fails with a
  * clear error instead of hanging for as long as the calling harness allows.
- * KEEL_MCP_DAEMON=1 shares the local graph index (sync_impact /
+ * SYNCSTAFF_MCP_DAEMON=1 shares the local graph index (sync_impact /
  * sync_context_card / sync_retrieve) across every agent CLI on this checkout
  * through one background process instead of one per adapter process. Off by
  * default — unset, this adapter's behavior is unchanged from before daemon
- * mode existed. See daemon.ts for KEEL_MCP_DAEMON_IDLE_MINUTES (default 15)
- * and KEEL_MCP_DAEMON_TIMEOUT_SECONDS (default 20).
+ * mode existed. See daemon.ts for SYNCSTAFF_MCP_DAEMON_IDLE_MINUTES (default 15)
+ * and SYNCSTAFF_MCP_DAEMON_TIMEOUT_SECONDS (default 20).
  *
  * The agent is registered lazily on the first tool call. When a lifecycle
  * hook registered the session first, the MCP process adopts that same id so
  * lease checks and lease acquisition refer to one agent.
  */
-// FIRST import, deliberately: it aliases KEEL_* ⇄ CHARTER_* on load, and the
+// FIRST import, deliberately: it aliases SYNCSTAFF_* ⇄ SYNCSTAFF_* on load, and the
 // module-scope reads below (and in agent-state) would otherwise run first and
 // see whichever prefix the caller happened not to set.
 import "../lib/env-compat.js";
@@ -49,7 +49,7 @@ import { PROTOCOL_INSTRUCTIONS } from "../lib/protocol.js";
 import { globMatches, isGlob, pathsOverlap } from "../lib/globs.js";
 import { declaredPathWarnings } from "../lib/path-warnings.js";
 import { BOARD_KINDS, BOARD_STATUSES } from "../lib/types.js";
-import { adapterRequestHeaders, KEEL_ADAPTER_PROTOCOL_VERSION, KEEL_RELEASE_VERSION, } from "../lib/version.js";
+import { adapterRequestHeaders, SYNCSTAFF_ADAPTER_PROTOCOL_VERSION, SYNCSTAFF_RELEASE_VERSION, } from "../lib/version.js";
 import { DEFAULT_IGNORES, findUnleasedWrites, fingerprintWrites, listWorktreeChanges, listWorktreeChangesStrict, upstreamLandingReport, } from "../lib/worktree.js";
 import { createApprovalGate } from "./approval.js";
 import { runLogin } from "./login.js";
@@ -63,10 +63,10 @@ const LOGIN_MODE = process.argv[2] === "login";
 const SETUP_MODE = process.argv[2] === "setup";
 const TEST_IMPORT_MODE = process.argv[2] === "__test_import__";
 const CLIENT_CONFIG = LOGIN_MODE ? null : loadClientConfig(repoRoot());
-const SERVER = process.env.KEEL_URL ?? CLIENT_CONFIG?.server ?? "http://localhost:7377";
-const PROJECT = process.env.KEEL_PROJECT ?? CLIENT_CONFIG?.project;
-const VENDOR = process.env.KEEL_VENDOR ?? CLIENT_CONFIG?.vendor ?? "other";
-const TOKEN = process.env.KEEL_TOKEN?.trim() ||
+const SERVER = process.env.SYNCSTAFF_URL ?? CLIENT_CONFIG?.server ?? "http://localhost:7377";
+const PROJECT = process.env.SYNCSTAFF_PROJECT ?? CLIENT_CONFIG?.project;
+const VENDOR = process.env.SYNCSTAFF_VENDOR ?? CLIENT_CONFIG?.vendor ?? "other";
+const TOKEN = process.env.SYNCSTAFF_TOKEN?.trim() ||
     (CLIENT_CONFIG?.server.replace(/\/+$/, "") === SERVER.replace(/\/+$/, "")
         ? CLIENT_CONFIG.token
         : undefined);
@@ -78,8 +78,8 @@ const TOKEN = process.env.KEEL_TOKEN?.trim() ||
  */
 export function localAutoRunnerCommand(root, statePath) {
     const candidates = [
-        join(root, "keel", "dist", "src", "cli", "keel-cli.js"),
-        join(root, "dist", "src", "cli", "keel-cli.js"),
+        join(root, "sync", "dist", "src", "cli", "syncstaff-cli.js"),
+        join(root, "dist", "src", "cli", "syncstaff-cli.js"),
     ];
     const cli = candidates.find((candidate) => existsSync(candidate));
     return cli ? { command: process.execPath, args: [cli, "auto-run", "--state-file", statePath] } : null;
@@ -93,7 +93,7 @@ function ensureLocalAutoRunner(root, statePath) {
         detached: true,
         stdio: "ignore",
         windowsHide: true,
-        env: { ...process.env, KEEL_VENDOR: VENDOR },
+        env: { ...process.env, SYNCSTAFF_VENDOR: VENDOR },
     });
     child.unref();
     return true;
@@ -146,10 +146,10 @@ function apiHeaders() {
  * half of the same fix, one level up the call chain.
  *
  * A generous default: legitimate calls finish in low seconds even with the
- * arbiter in the loop. `KEEL_API_TIMEOUT_SECONDS=0` disables it for a slow
+ * arbiter in the loop. `SYNCSTAFF_API_TIMEOUT_SECONDS=0` disables it for a slow
  * link where 45s is provably too tight, rather than editing this file.
  */
-const API_TIMEOUT_MS = envSeconds("KEEL_API_TIMEOUT_SECONDS", 45) * 1000;
+const API_TIMEOUT_MS = envSeconds("SYNCSTAFF_API_TIMEOUT_SECONDS", 45) * 1000;
 async function api(method, path, body, extraHeaders = {}) {
     const controller = new AbortController();
     const timer = API_TIMEOUT_MS > 0 ? setTimeout(() => controller.abort(), API_TIMEOUT_MS) : undefined;
@@ -172,7 +172,7 @@ async function api(method, path, body, extraHeaders = {}) {
             // where the tool accepts one rather than declaring blind.
             throw new Error(`${method} ${path} timed out after ${API_TIMEOUT_MS / 1000}s with no response. ` +
                 `It may still have landed server-side — check before retrying blind ` +
-                `(e.g. intent_list_active for an intents call). Raise KEEL_API_TIMEOUT_SECONDS ` +
+                `(e.g. intent_list_active for an intents call). Raise SYNCSTAFF_API_TIMEOUT_SECONDS ` +
                 `if this route is legitimately slower than that.`);
         }
         throw e;
@@ -189,10 +189,10 @@ async function api(method, path, body, extraHeaders = {}) {
         // on. Everything else keeps the literal response.
         if (res.status === 401) {
             throw new Error(`${method} ${path} -> 401: this machine has no valid Sync credential.\n` +
-                `Run:  npm --prefix keel run login -- --server ${SERVER}` +
+                `Run:  npm --prefix sync run login -- --server ${SERVER}` +
                 (PROJECT ? ` --project ${PROJECT}` : "") +
                 ` --vendor ${VENDOR}\n` +
-                `Then run:  node keel/dist/src/cli/keel-cli.js doctor`);
+                `Then run:  node sync/dist/src/cli/syncstaff-cli.js doctor`);
         }
         throw new Error(`${method} ${path} -> ${res.status}: ${JSON.stringify(data)}`);
     }
@@ -261,10 +261,10 @@ function hookBindingRequired(root) {
         try {
             const config = readFileSync(join(root, relative), "utf8");
             // Either binary name. The rename briefly broke this: the check looked for
-            // "keel-cli" while the config still said "charter-cli", so it returned
+            // "syncstaff-cli" while the config still said "charter-cli", so it returned
             // false and Codex's session-binding requirement silently stopped being
             // enforced — a guard that fails open reads exactly like a guard that passes.
-            const wired = config.includes("keel-cli") || config.includes("charter-cli");
+            const wired = config.includes("syncstaff-cli") || config.includes("charter-cli");
             if (wired && config.includes("preflight"))
                 return true;
         }
@@ -346,7 +346,7 @@ const interfaceSchema = z.object({
     change: z.enum(["none", "signature", "added", "removed", "behavior"]),
 });
 function withLocalCallSites(subjects, analyzeChanges) {
-    const contextSetting = process.env.KEEL_BLAST_INCLUDE_CONTEXT?.toLowerCase();
+    const contextSetting = process.env.SYNCSTAFF_BLAST_INCLUDE_CONTEXT?.toLowerCase();
     const includeContext = !["0", "false", "off", "no"].includes(contextSetting ?? "");
     return attachClientCallSiteReports(repoRoot(), subjects, {
         includeContext,
@@ -356,7 +356,7 @@ function withLocalCallSites(subjects, analyzeChanges) {
 export function createSyncMcpServer(requestContext) {
     async function ensureAgent(extra, sessionIdFromArg) {
         if (!PROJECT)
-            throw new Error("KEEL_PROJECT env var is required");
+            throw new Error("SYNCSTAFF_PROJECT env var is required");
         const root = repoRoot();
         if (!requestContext)
             requestContext = {};
@@ -419,7 +419,7 @@ export function createSyncMcpServer(requestContext) {
                 project_id: projectId,
                 vendor: VENDOR,
                 vendor_session_id: requestedSessionId,
-                human_owner: process.env.KEEL_HUMAN ?? process.env.USER ?? "unknown",
+                human_owner: process.env.SYNCSTAFF_HUMAN ?? process.env.USER ?? "unknown",
                 machine_id: hostname(),
                 checkout_path: root,
                 enforcement_level: "advisory",
@@ -468,8 +468,8 @@ export function createSyncMcpServer(requestContext) {
                 projectId,
                 machineId: hostname(),
                 displayName: hostname(),
-                clientVersion: KEEL_RELEASE_VERSION,
-                protocolVersion: String(KEEL_ADAPTER_PROTOCOL_VERSION),
+                clientVersion: SYNCSTAFF_RELEASE_VERSION,
+                protocolVersion: String(SYNCSTAFF_ADAPTER_PROTOCOL_VERSION),
                 platform: `${process.platform}-${process.arch}`,
             });
         }
@@ -488,15 +488,15 @@ export function createSyncMcpServer(requestContext) {
         project: PROJECT ?? "",
         repoRoot: repoRoot(),
         token: TOKEN,
-        key: process.env.KEEL_REQUEST_STATE_KEY,
-        resolvedBy: process.env.KEEL_HUMAN ?? process.env.USER ?? "unknown",
+        key: process.env.SYNCSTAFF_REQUEST_STATE_KEY,
+        resolvedBy: process.env.SYNCSTAFF_HUMAN ?? process.env.USER ?? "unknown",
         // The era belongs to the connection, and `serveStdio` puts it on the
         // context it builds this server with — there is no accessor on the server
         // itself because a modern instance and a legacy one are different
         // instances, not two modes of one.
         era: () => requestContext?.era,
     });
-    const mcp = new McpServer({ name: "sync", version: KEEL_RELEASE_VERSION }, {
+    const mcp = new McpServer({ name: "sync", version: SYNCSTAFF_RELEASE_VERSION }, {
         instructions: PROTOCOL_INSTRUCTIONS,
         requestState: { verify: approval.verify },
     });
@@ -527,7 +527,7 @@ export function createSyncMcpServer(requestContext) {
                 project_id: projectId,
                 repo_root: repoRoot(),
                 vendor: VENDOR,
-                human_owner: process.env.NAIB_HUMAN ?? process.env.KEEL_HUMAN ?? process.env.USER ?? "unknown",
+                human_owner: process.env.SYNCSTAFF_HUMAN ?? process.env.USER ?? "unknown",
                 path_convention: "All paths are relative to repo_root, never to your cwd.",
             });
         });
@@ -608,8 +608,8 @@ export function createSyncMcpServer(requestContext) {
      * Do the declared paths exist? Answered here, in the checkout being edited.
      *
      * inv_01KYRCZX78VK0YYMHC4FYEHR5W says every path is git-root-relative, and
-     * nothing enforced it: a lease on `keel/src/server/db.ts` when the file is at
-     * `keel/src/lib/db.ts` is granted, renewed and released without complaint
+     * nothing enforced it: a lease on `sync/src/server/db.ts` when the file is at
+     * `sync/src/lib/db.ts` is granted, renewed and released without complaint
      * while the agent edits a file no lease covers.
      *
      * The server used to answer this from its own `repo_path`, which is a
@@ -634,7 +634,7 @@ export function createSyncMcpServer(requestContext) {
             return null;
         }
     }
-    mcp.registerTool("intent_declare", { description: "Declare what you are about to do BEFORE editing any file: a one-sentence summary, the paths you will touch, and every interface you will add/remove/change. Returns an arbiter verdict and blast radius. If the coordinator escalates the declaration, this call waits briefly (KEEL_ESCALATION_WAIT_SECONDS, default 60) in case the decision is fast or already automated, then returns either way with the escalation_id. On a timeout the escalation is already durable — run `node keel/scripts/await-escalation.mjs <escalation_id>` in the background to keep watching it while you do something else, rather than re-declaring or retrying this call.", inputSchema: z.object({
+    mcp.registerTool("intent_declare", { description: "Declare what you are about to do BEFORE editing any file: a one-sentence summary, the paths you will touch, and every interface you will add/remove/change. Returns an arbiter verdict and blast radius. If the coordinator escalates the declaration, this call waits briefly (SYNCSTAFF_ESCALATION_WAIT_SECONDS, default 60) in case the decision is fast or already automated, then returns either way with the escalation_id. On a timeout the escalation is already durable — run `node sync/scripts/await-escalation.mjs <escalation_id>` in the background to keep watching it while you do something else, rather than re-declaring or retrying this call.", inputSchema: z.object({
             summary: z.string(),
             paths: z.array(z.string()),
             interfaces_touched: z.array(interfaceSchema).default([]),
@@ -671,7 +671,7 @@ export function createSyncMcpServer(requestContext) {
                     `${foreignWrites.slice(0, 8).join(", ")}${foreignWrites.length > 8 ? `, +${foreignWrites.length - 8} more` : ""}. ` +
                     `Only stage and commit the paths you actually declared.`;
         }
-        if (!declared.escalation_id || !envFlag("KEEL_AUTO_WAIT_ESCALATIONS", true)) {
+        if (!declared.escalation_id || !envFlag("SYNCSTAFF_AUTO_WAIT_ESCALATIONS", true)) {
             return text(compactDeclaration(declared));
         }
         const waited = await waitForEscalation({
@@ -687,14 +687,14 @@ export function createSyncMcpServer(requestContext) {
             // automated resolution inline; anything slower should be watched with
             // scripts/await-escalation.mjs instead of held open here. See
             // tsk_01M17NJ3KKTEVTYEVGPCN957D7.
-            timeoutMs: envSeconds("KEEL_ESCALATION_WAIT_SECONDS", 60) * 1000,
+            timeoutMs: envSeconds("SYNCSTAFF_ESCALATION_WAIT_SECONDS", 60) * 1000,
         });
         return text({
             ...compactDeclaration(declared),
             escalation_wait: waited,
             next_step: waited.status === "resolved"
                 ? "The durable human decision is applied. Continue based on escalation_wait.resolution and escalation_wait.changes."
-                : `The human decision did not arrive within the wait. The escalation is durable — run in the background: node keel/scripts/await-escalation.mjs ${declared.escalation_id}. Do not re-declare the same intent to keep waiting; that creates a duplicate.`,
+                : `The human decision did not arrive within the wait. The escalation is durable — run in the background: node sync/scripts/await-escalation.mjs ${declared.escalation_id}. Do not re-declare the same intent to keep waiting; that creates a duplicate.`,
         });
     });
     /**
@@ -1034,7 +1034,7 @@ export function createSyncMcpServer(requestContext) {
     /**
      * One index per process, keyed by root. Rebuilding per call would be absurd
      * — and so, at N agent CLIs sharing one checkout, is N processes each
-     * holding their own copy. `KEEL_MCP_DAEMON=1` moves that copy into one
+     * holding their own copy. `SYNCSTAFF_MCP_DAEMON=1` moves that copy into one
      * shared background process (daemon.ts); `daemonEnabled()` off (the
      * default) or the daemon being unreachable both fall through to exactly
      * this process's own build, unchanged from before daemon mode existed.

package/dist/mcp/login.js

@@ -14,34 +14,34 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 /**
- * Where Keel is, when nobody said.
+ * Where Syncstaff is, when nobody said.
  *
  * This used to be `http://localhost:7377`, which is right for one developer
  * running a server on their own machine and wrong for everyone else — and
  * "everyone else" is who runs this command. They got a connection refused
- * against a host they never chose, which reads as "Keel is down" rather than
- * "you didn't say where Keel is".
+ * against a host they never chose, which reads as "Syncstaff is down" rather than
+ * "you didn't say where Syncstaff is".
  *
  * A hosted default is the honest one for a package whose whole purpose is
- * connecting to a hosted server. Override with `--server` or `KEEL_URL`;
+ * connecting to a hosted server. Override with `--server` or `SYNCSTAFF_URL`;
  * self-hosters set it once at login and it is remembered in
- * `.keel/config.json` thereafter.
+ * `.syncstaff/config.json` thereafter.
  */
-export const DEFAULT_KEEL_SERVER = "https://openclaw212onubuntu-s-2vcpu-4gb-amd-nyc3-01.taild4ce34.ts.net";
+export const DEFAULT_SYNCSTAFF_SERVER = "https://openclaw212onubuntu-s-2vcpu-4gb-amd-nyc3-01.taild4ce34.ts.net";
 function normalizeServer(value) {
     let server;
     try {
         server = new URL(value.trim());
     }
     catch {
-        throw new Error("keel login: --server must be an absolute HTTP(S) URL");
+        throw new Error("syncstaff login: --server must be an absolute HTTP(S) URL");
     }
     if (!["http:", "https:"].includes(server.protocol) ||
         server.username ||
         server.password ||
         server.search ||
         server.hash) {
-        throw new Error("keel login: --server must be an HTTP(S) URL without credentials, a query, or a fragment");
+        throw new Error("syncstaff login: --server must be an HTTP(S) URL without credentials, a query, or a fragment");
     }
     return server.toString().replace(/\/+$/, "");
 }
@@ -49,7 +49,7 @@ function apiError(method, path, status, body) {
     const detail = typeof body.error === "string" ? body.error : JSON.stringify(body);
     return new Error(`${method} ${path} -> ${status}: ${detail}`);
 }
-/** Run the interactive device login used by both the public `keel` bin and the local hook CLI. */
+/** Run the interactive device login used by both the public `syncstaff` bin and the local hook CLI. */
 export async function runLogin(args, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const root = repoRoot(cwd);
@@ -58,23 +58,23 @@ export async function runLogin(args, deps = {}) {
     const write = deps.write ?? ((message) => process.stdout.write(`${message}\n`));
     const wait = deps.wait ?? sleep;
     const existing = loadClientConfig(root);
-    const chosenServer = option(args, "server") ?? env.KEEL_URL ?? env.CHARTER_URL ?? existing?.server;
+    const chosenServer = option(args, "server") ?? env.SYNCSTAFF_URL ?? existing?.server;
     // Keep the localhost fallback so a developer running a local server still
     // needs no flags — but remember that nobody asked for it.
     //
-    // Whoever set this project up has a `.keel/config.json` with the real
+    // Whoever set this project up has a `.syncstaff/config.json` with the real
     // server in it, so they never reach this line. The next person to clone
     // does, gets ECONNREFUSED against a host they never chose, and reads it as
-    // "Keel is down". Three lines below, `--project` refuses to guess at all;
+    // "Syncstaff is down". Three lines below, `--project` refuses to guess at all;
     // there is no principled reason these two behave differently, and the
     // asymmetry is invisible to everyone who already has a config.
     const serverWasDefaulted = !chosenServer;
-    const server = normalizeServer(chosenServer ?? DEFAULT_KEEL_SERVER);
-    const project = option(args, "project") ?? env.KEEL_PROJECT ?? env.CHARTER_PROJECT ?? existing?.project;
+    const server = normalizeServer(chosenServer ?? DEFAULT_SYNCSTAFF_SERVER);
+    const project = option(args, "project") ?? env.SYNCSTAFF_PROJECT ?? existing?.project;
     if (!project?.trim()) {
-        throw new Error("keel login: --project <id|name> (or KEEL_PROJECT) is required");
+        throw new Error("syncstaff login: --project <id|name> (or SYNCSTAFF_PROJECT) is required");
     }
-    const vendor = option(args, "vendor") ?? env.KEEL_VENDOR ?? env.CHARTER_VENDOR ?? existing?.vendor ?? "other";
+    const vendor = option(args, "vendor") ?? env.SYNCSTAFF_VENDOR ?? existing?.vendor ?? "other";
     const clientName = option(args, "name") ?? `${vendor} on ${hostname()}`;
     const request = async (path, body) => {
         const response = await fetchImpl(`${server}${path}`, {
@@ -94,7 +94,7 @@ export async function runLogin(args, deps = {}) {
             return error;
         error.message +=
             `\n\nNo --server was given, so this defaulted to ${server}.` +
-                `\nIf you meant a hosted Keel, pass --server <url> or set KEEL_URL.`;
+                `\nIf you meant hosted Syncstaff, pass --server <url> or set SYNCSTAFF_URL.`;
         return error;
     };
     let issued;
@@ -115,7 +115,7 @@ export async function runLogin(args, deps = {}) {
     if (typeof issued.body.device_code !== "string" ||
         typeof issued.body.user_code !== "string" ||
         typeof issued.body.verification_uri_complete !== "string") {
-        throw new Error("keel login: server returned an invalid device authorization response");
+        throw new Error("syncstaff login: server returned an invalid device authorization response");
     }
     const verificationUrl = new URL(issued.body.verification_uri_complete, `${server}/`).toString();
     write(`Open this link in your browser:\n${verificationUrl}`);
@@ -125,7 +125,7 @@ export async function runLogin(args, deps = {}) {
         ? Date.parse(issued.body.expires_at)
         : Date.now() + Number(issued.body.expires_in_seconds ?? 600) * 1000;
     if (!Number.isFinite(expiresAt)) {
-        throw new Error("keel login: server returned an invalid device authorization expiry");
+        throw new Error("syncstaff login: server returned an invalid device authorization expiry");
     }
     const initialInterval = Number(issued.body.interval_seconds ?? 2);
     let intervalSeconds = Number.isFinite(initialInterval) ? Math.max(0, initialInterval) : 2;
@@ -146,7 +146,7 @@ export async function runLogin(args, deps = {}) {
         }
         for (const key of ["token", "team_id", "project_id", "project_name"]) {
             if (typeof polled.body[key] !== "string" || !polled.body[key]) {
-                throw new Error(`keel login: token response omitted ${key}`);
+                throw new Error(`syncstaff login: token response omitted ${key}`);
             }
         }
         const config = {
@@ -165,5 +165,5 @@ export async function runLogin(args, deps = {}) {
             teamId: polled.body.team_id,
         };
     }
-    throw new Error("keel login: device authorization expired before approval");
+    throw new Error("syncstaff login: device authorization expired before approval");
 }

package/dist/mcp/setup.js

@@ -3,8 +3,8 @@ import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { repoRoot } from "../lib/agent-state.js";
-import { DEFAULT_KEEL_SERVER, runLogin } from "./login.js";
-const PACKAGE_VERSION = "0.2.2";
+import { SYNCSTAFF_RELEASE_VERSION } from "../lib/version.js";
+import { DEFAULT_SYNCSTAFF_SERVER, runLogin } from "./login.js";
 function option(args, name) {
     const flag = `--${name}`;
     const index = args.indexOf(flag);
@@ -22,7 +22,7 @@ export function defaultProjectName(root) {
     const base = root.split(/[\\/]/).filter(Boolean).pop() ?? "";
     return base.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
-export function writeMcpConfig(root, packageVersion = PACKAGE_VERSION) {
+export function writeMcpConfig(root, packageVersion = SYNCSTAFF_RELEASE_VERSION) {
     const path = join(root, ".mcp.json");
     let config = {};
     if (existsSync(path)) {
@@ -35,8 +35,14 @@ export function writeMcpConfig(root, packageVersion = PACKAGE_VERSION) {
             throw new Error(`Syncstaff setup: ${path} exists but is not valid JSON`);
         }
     }
+    const servers = config.mcpServers && typeof config.mcpServers === "object"
+        ? { ...config.mcpServers }
+        : {};
+    for (const retired of [["ke", "el"].join(""), ["na", "ib"].join(""), "charter"]) {
+        delete servers[retired];
+    }
     config.mcpServers = {
-        ...(config.mcpServers && typeof config.mcpServers === "object" ? config.mcpServers : {}),
+        ...servers,
         sync: {
             command: "npx",
             // The public Syncstaff adapter package. Keep generated client configs on
@@ -65,13 +71,13 @@ export async function runSetup(args, deps = {}) {
                 return supplied;
             return (await rl.question(`${label}: `)).trim();
         };
-        const server = await ask("Syncstaff server", option(args, "server") ?? env.SYNCSTAFF_URL ?? env.NAIB_URL ?? env.KEEL_URL ?? DEFAULT_KEEL_SERVER);
+        const server = await ask("Syncstaff server", option(args, "server") ?? env.SYNCSTAFF_URL ?? DEFAULT_SYNCSTAFF_SERVER);
         // Default to the directory being set up. Asking someone to name a project
         // while they are standing inside it is asking them to read it off their
         // own screen — and the name they invent instead is the one that then has
         // to match at approval time.
-        const project = await ask("Project id or name", option(args, "project") ?? env.SYNCSTAFF_PROJECT ?? env.NAIB_PROJECT ?? env.KEEL_PROJECT ?? defaultProjectName(root));
-        const vendor = await ask("Agent vendor", option(args, "vendor") ?? env.SYNCSTAFF_VENDOR ?? env.NAIB_VENDOR ?? env.KEEL_VENDOR ?? "other");
+        const project = await ask("Project id or name", option(args, "project") ?? env.SYNCSTAFF_PROJECT ?? defaultProjectName(root));
+        const vendor = await ask("Agent vendor", option(args, "vendor") ?? env.SYNCSTAFF_VENDOR ?? "other");
         if (!project)
             throw new Error("Syncstaff setup: project is required");
         const result = await runLogin(["--server", server, "--project", project, "--vendor", vendor], {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "syncstaff-mcp",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "MCP adapter for Syncstaff cross-agent coordination",
   "type": "module",
   "bin": {
@@ -30,7 +30,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jb63126/sync.git",
-    "directory": "keel/packages/mcp"
+    "directory": "sync/packages/mcp"
   },
   "keywords": [
     "syncstaff",