@systemdox/mcp-server 0.1.46 → 0.1.48

package/dist/lib/memory-sync.d.ts

@@ -0,0 +1,150 @@
+/**
+ * The team memory's merge (ADR-217 §2.3, specs/changes/team-setup/contract.md
+ * "sync-memory and the MCP tool sync_memory"), pure: no disk, no network.
+ * `src/sync-memory.ts` reads the folders and calls the API around it.
+ *
+ * - **What is shared** (`isShareable`): a `*.md` file whose frontmatter `type`
+ *   is `feedback`, `project` or `reference`, and `MEMORY.md`; never a file
+ *   with `share: false` or a `<name>.local-<date>.md` conflict copy.
+ * - **The merge** (`decide`, `planMerge`): three-way per path, with the base
+ *   (the manifest of the last sync), the team's latest version and the local
+ *   folder, row by row as the contract's table says.
+ * - **`MEMORY.md`** (`mergeIndex`): line by line, keyed by the file each line
+ *   links to; never a `.local-` copy.
+ * - **People** (`collectValues`, `rewriteValues`, `personToken`): every value
+ *   the detector finds, grouped by its normalised form, and the rewrite the
+ *   member agrees to.
+ */
+import { type Finding, type ValueKind } from "./person-values.js";
+export declare const INDEX_FILE = "MEMORY.md";
+export declare const SHAREABLE_TYPES: readonly ["feedback", "project", "reference"];
+/** `{path: sha256}` (openapi Manifest). */
+export type Manifest = Record<string, string>;
+export declare function sha256(text: string): string;
+export declare function isFilePath(path: string): boolean;
+export declare function isConflictCopy(path: string): boolean;
+export interface Frontmatter {
+    type?: string;
+    /** True when the block says `share: false` (or another YAML false). */
+    shareFalse: boolean;
+}
+/** The frontmatter's `type` and `share`, or undefined when the file has no
+ * leading block. Only top-level `key: value` lines are read. */
+export declare function readFrontmatter(text: string): Frontmatter | undefined;
+/**
+ * Shared with the team: `MEMORY.md` at the folder's root, or a `*.md` file
+ * whose frontmatter `type` is feedback, project or reference. Never a file
+ * with `share: false`, a `.local-` conflict copy, or anything else.
+ */
+export declare function isShareable(path: string, text: string): boolean;
+/** `text` with `share: false` in its frontmatter: the line is added before the
+ * block's closing `---` (or replaces a `share:` line), or a block is added. */
+export declare function addShareFalse(text: string): string;
+/** The member's calendar date, `YYYY-MM-DD`. */
+export declare function localDate(now: Date): string;
+/** `a.md` → `a.local-<date>.md`, then `a.local-<date>-2.md`, `-3` … when the
+ * name is taken. */
+export declare function conflictCopyName(path: string, date: string, taken: Set<string>): string;
+/**
+ * One path's row of the contract's table (base → team, base → local):
+ * - `unchanged`: both sides hold the same (or neither holds it);
+ * - `local`: the team did not change it and the member changed or added it;
+ *   also a file the team deleted and the member changed (the member's text
+ *   is kept, never lost);
+ * - `delete-team`: the team did not change it and the member deleted it;
+ * - `team`: the member did not change it and the team changed or added it;
+ *   also a file the member deleted and the team changed (the team's text
+ *   comes back, never lost);
+ * - `delete-local`: the member did not change it and the team deleted it;
+ * - `conflict`: both changed it differently;
+ * - `index`: `MEMORY.md` changed on both sides, merged line by line.
+ */
+export type Row = "unchanged" | "local" | "delete-team" | "team" | "delete-local" | "conflict" | "index";
+export declare function decide(path: string, base: string | undefined, team: string | undefined, local: string | undefined): Row;
+export interface MergeInput {
+    base: Manifest;
+    team: Manifest;
+    /** The local folder's shared files, `{path: text}`. */
+    local: Record<string, string>;
+    /** Paths left as they are on both sides: a file held back this run, or a
+     * local file that is not shared. The team's entry is kept; nothing is
+     * written to the path. */
+    excluded: Set<string>;
+    /** Every file name in the folder (lower case), so a conflict copy never
+     * takes a name in use. */
+    taken: Set<string>;
+    date: string;
+}
+/** The rows by path, and the team hashes whose text the plan needs. */
+export declare function decideAll(input: Omit<MergeInput, "taken" | "date">): {
+    rows: Record<string, Row>;
+    needed: string[];
+};
+export interface MergePlan {
+    /** The manifest to push. */
+    manifest: Manifest;
+    /** The text of each path whose hash the team does not hold yet. */
+    upload: Record<string, string>;
+    /** Files to write in the local folder (pulled, conflict pairs, the index). */
+    writes: Record<string, string>;
+    /** Files to delete in the local folder. */
+    deletes: string[];
+    pulled: string[];
+    pushed: string[];
+    deletedHere: string[];
+    deletedFromTeam: string[];
+    conflicts: {
+        path: string;
+        copy: string;
+    }[];
+    /** `MEMORY.md` lines the team changed where the member's line was kept. */
+    indexTeamLines: string[];
+}
+/** The plan for the rows of `decideAll`, given the text of every hash it
+ * named (`texts`, `{sha256: text}`). A base `MEMORY.md` no longer readable is
+ * merged as if empty. */
+export declare function planMerge(input: MergeInput, rows: Record<string, Row>, texts: Record<string, string>): MergePlan;
+/**
+ * `MEMORY.md` merged line by line, keyed by the file each line links to
+ * (ADR-217 §2.3.3):
+ * - a team line for a new file is added under the same heading (after the
+ *   line it follows in the team's copy);
+ * - a line the team removed and the member did not change is removed;
+ * - a line with no link takes the team's text unless the member changed it;
+ * - when both changed the same line, the member's line is kept and the
+ *   team's is returned in `teamLines`, to be listed.
+ */
+export declare function mergeIndex(base: string | undefined, team: string, local: string): {
+    text: string;
+    teamLines: string[];
+};
+export interface ValueGroup {
+    kind: ValueKind;
+    /** As first written. */
+    value: string;
+    normalised: string;
+    files: string[];
+    /** Where it first appears: the file, the line number and the line. */
+    first: {
+        path: string;
+        line: number;
+        text: string;
+    };
+}
+export declare const groupKey: (kind: string, normalised: string) => string;
+/** Every phone number and email address in `files`, grouped by normalised
+ * value in the order first found; and the files holding a home-folder path. */
+export declare function collectValues(files: Record<string, string>): {
+    groups: ValueGroup[];
+    homePaths: string[];
+    findings: Record<string, Finding[]>;
+};
+/** `` `<personId>` (<label>) ``: the identifier exactly as the server
+ * returned it, and the role label when there is one. */
+export declare function personToken(personId: string, label?: string): string;
+/** `text` with each finding replaced as `replacement` says (undefined leaves
+ * it as written). */
+export declare function rewriteValues(text: string, findings: Finding[], replacement: (f: Finding) => string | undefined): string;
+/** The lines that differ between two versions of a file, as `- old` and
+ * `+ new` pairs, in order. */
+export declare function lineDiff(before: string, after: string): string[];

package/dist/lib/memory-sync.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+
+// src/lib/memory-sync.ts
+import { createHash } from "crypto";
+
+// src/lib/person-values.ts
+var PHONE = "phone";
+var EMAIL = "email";
+var HOME_PATH = "home-path";
+var NATIONAL_PREFIX = "+44";
+var W = "[\\p{L}\\p{N}_]";
+var D = "\\p{Nd}";
+var WORD_OR = (extra) => `[\\p{L}\\p{N}_${extra}]`;
+var PERSON_ID = "(?:(?:con|ctc)_[0-9A-Za-z]{10,40}|usr_[0-9A-Za-z-]{10,40})";
+var PERSON_TOKEN = `\`${PERSON_ID}\`(?:[ \\t]*\\([^()\\n]*\\))?`;
+var BEFORE = `(?<!${WORD_OR("+.:/\\\\\\-")})(?<!${D}[ -])`;
+var AFTER = `(?!${WORD_OR(":/\\\\")}|\\.${D}|[ -]?${D}|-${W})`;
+var E164 = `${BEFORE}\\+${D}+(?:[ -]${D}+)*${AFTER}`;
+var NATIONAL = `${BEFORE}0${D}*(?:[ -]${D}+)*${AFTER}`;
+var GROUP_SIZES = /* @__PURE__ */ new Set([2, 3, 4, 5, 6]);
+var ATEXT = "[A-Za-z0-9!#$%&'*+/=?^_{|}~\\-]";
+var EMAIL_RE = "(?<![A-Za-z0-9!#$%&*+/=?^_{|}~.@\\-])[A-Za-z0-9_]" + ATEXT + "*(?:\\." + ATEXT + "+)*@(?:[A-Za-z0-9](?:[A-Za-z0-9\\-]{0,61}[A-Za-z0-9])?\\.)+[A-Za-z]{2,63}(?![A-Za-z0-9\\-]|\\.[A-Za-z0-9])";
+var HOME_PREFIX = "(?:[A-Za-z]:\\\\+Users\\\\+|[A-Za-z]:/+Users/+|/Users/|/home/)";
+var HOME = `(?<!${WORD_OR(".~:/\\\\$}\\-")})${HOME_PREFIX}[^\\\\/\\s"'\`<>|:*?]+`;
+var KEY_PREFIX = `(?<!${W})(?:pweb_[a-z]+_key_|sk-ant-|sk_live_|rk_live_|github_pat_|gh[pousr]_|sntrys_|xox[baprs]-)[A-Za-z0-9_\\-]{4,}`;
+var global = (source, flags = "") => new RegExp(source, `gu${flags}`);
+var whole = (source, flags = "") => new RegExp(`^(?:${source})$`, `u${flags}`);
+function lineOf(text, start) {
+  let line = 1;
+  for (let i = text.indexOf("\n"); i !== -1 && i < start; i = text.indexOf("\n", i + 1)) line++;
+  return line;
+}
+function phoneShape(value) {
+  const groups = value.replace(/^\++/, "").split(/[ -]/);
+  const digits = [...groups.join("")];
+  if (value.startsWith("+")) return digits.length >= 8 && digits.length <= 15 && digits[0] !== "0";
+  if (digits.length < 10 || digits.length > 11) return false;
+  return groups.length === 1 || groups.slice(1).every((g) => GROUP_SIZES.has([...g].length));
+}
+function normalise(kind, value) {
+  const v = typeof value === "string" ? value.trim() : "";
+  if (kind === PHONE) {
+    if (!(whole(E164).test(v) || whole(NATIONAL).test(v)) || !phoneShape(v)) {
+      throw new Error("not a phone number");
+    }
+    const digits = v.replace(/[ -]/g, "");
+    return digits.startsWith("+") ? digits : NATIONAL_PREFIX + digits.slice(1);
+  }
+  if (kind === EMAIL) {
+    if (!whole(EMAIL_RE).test(v)) throw new Error("not an email address");
+    return v.toLowerCase();
+  }
+  throw new Error(`not a value kind: ${JSON.stringify(kind)}`);
+}
+function findPersonValues(text) {
+  if (typeof text !== "string" || !text) return [];
+  const skipped = [...text.matchAll(global(PERSON_TOKEN))].map((m) => [m.index, m.index + m[0].length]);
+  const found = [];
+  const add = (kind, m, normalised) => {
+    const start = m.index;
+    const end = start + m[0].length;
+    if (skipped.some(([s, e]) => s <= start && end <= e)) return;
+    if (found.some((f) => f.start < end && start < f.end)) return;
+    found.push({ kind, value: m[0], normalised, line: lineOf(text, start), start, end });
+  };
+  for (const m of text.matchAll(global(EMAIL_RE))) add(EMAIL, m, m[0].toLowerCase());
+  for (const source of [E164, NATIONAL]) {
+    for (const m of text.matchAll(global(source))) {
+      if (phoneShape(m[0])) add(PHONE, m, normalise(PHONE, m[0]));
+    }
+  }
+  for (const m of text.matchAll(global(HOME, "i"))) add(HOME_PATH, m, m[0]);
+  return found.sort((a, b) => a.start - b.start);
+}
+
+// src/lib/memory-sync.ts
+var INDEX_FILE = "MEMORY.md";
+var SHAREABLE_TYPES = ["feedback", "project", "reference"];
+var FILE_PATH_RE = /^[A-Za-z0-9._-]+(\/[A-Za-z0-9._-]+)*$/;
+var CONFLICT_COPY_RE = /\.local-\d{4}-\d{2}-\d{2}(?:-\d+)?\.md$/;
+function sha256(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function isFilePath(path) {
+  return path.length <= 512 && FILE_PATH_RE.test(path) && !path.split("/").some((s) => s === "." || s === "..");
+}
+function isConflictCopy(path) {
+  return CONFLICT_COPY_RE.test(path.split("/").pop() ?? path);
+}
+var BLOCK_RE = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+var YAML_FALSE = /* @__PURE__ */ new Set(["false", "False", "FALSE", "no", "No", "NO", "off", "Off", "OFF"]);
+function readFrontmatter(text) {
+  const m = BLOCK_RE.exec(text);
+  if (!m) return void 0;
+  const front = { shareFalse: false };
+  for (const line of m[1].split(/\r?\n/)) {
+    const kv = /^([A-Za-z_][\w-]*)[ \t]*:[ \t]*(.*?)[ \t]*$/.exec(line);
+    if (!kv) continue;
+    const raw = kv[2].replace(/[ \t]+#.*$/, "");
+    const quoted = /^(["'])(.*)\1$/.exec(raw);
+    const value = quoted ? quoted[2] : raw;
+    if (kv[1] === "type") front.type = value.trim().toLowerCase();
+    if (kv[1] === "share") front.shareFalse = quoted ? value.trim().toLowerCase() === "false" : YAML_FALSE.has(value);
+  }
+  return front;
+}
+function isShareable(path, text) {
+  if (isConflictCopy(path) || !path.endsWith(".md")) return false;
+  const front = readFrontmatter(text);
+  if (front?.shareFalse) return false;
+  if (path === INDEX_FILE) return true;
+  return !!front && SHAREABLE_TYPES.includes(front.type ?? "");
+}
+function addShareFalse(text) {
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const m = BLOCK_RE.exec(text);
+  if (!m) return `---${eol}share: false${eol}---${eol}${text}`;
+  const lines = m[1].split(/\r?\n/).filter((l) => !/^share[ \t]*:/.test(l));
+  lines.push("share: false");
+  const closing = m[0].slice(m[0].lastIndexOf("---"));
+  return `---${eol}${lines.join(eol)}${eol}${closing}${text.slice(m[0].length)}`;
+}
+function localDate(now) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${p(now.getMonth() + 1)}-${p(now.getDate())}`;
+}
+function conflictCopyName(path, date, taken) {
+  const stem = path.replace(/\.md$/, "");
+  for (let n = 1; ; n++) {
+    const name = `${stem}.local-${date}${n === 1 ? "" : `-${n}`}.md`;
+    if (!taken.has(name.toLowerCase())) return name;
+  }
+}
+function decide(path, base, team, local) {
+  if (team === local) return "unchanged";
+  if (team === base) return local === void 0 ? "delete-team" : "local";
+  if (local === base) return team === void 0 ? "delete-local" : "team";
+  if (path === INDEX_FILE && team !== void 0 && local !== void 0) return "index";
+  if (team === void 0) return "local";
+  if (local === void 0) return "team";
+  return "conflict";
+}
+function decideAll(input) {
+  const localHashes = Object.fromEntries(Object.entries(input.local).map(([p, t]) => [p, sha256(t)]));
+  const paths = /* @__PURE__ */ new Set([...Object.keys(input.base), ...Object.keys(input.team), ...Object.keys(localHashes)]);
+  const rows = {};
+  const needed = /* @__PURE__ */ new Set();
+  for (const path of [...paths].sort()) {
+    if (input.excluded.has(path)) continue;
+    const row = decide(path, input.base[path], input.team[path], localHashes[path]);
+    rows[path] = row;
+    if (row === "team" || row === "conflict" || row === "index") needed.add(input.team[path]);
+    if (row === "index" && input.base[path]) needed.add(input.base[path]);
+  }
+  return { rows, needed: [...needed] };
+}
+function planMerge(input, rows, texts) {
+  const plan = {
+    manifest: {},
+    upload: {},
+    writes: {},
+    deletes: [],
+    pulled: [],
+    pushed: [],
+    deletedHere: [],
+    deletedFromTeam: [],
+    conflicts: [],
+    indexTeamLines: []
+  };
+  const taken = new Set(input.taken);
+  const teamText = (path) => {
+    const text = texts[input.team[path]];
+    if (text === void 0) throw new Error(`the team's ${path} could not be read`);
+    return text;
+  };
+  for (const path of input.excluded) if (input.team[path]) plan.manifest[path] = input.team[path];
+  for (const [path, row] of Object.entries(rows)) {
+    const team = input.team[path];
+    const local = input.local[path];
+    switch (row) {
+      case "unchanged":
+        if (team) plan.manifest[path] = team;
+        break;
+      case "local":
+        plan.manifest[path] = sha256(local);
+        plan.upload[path] = local;
+        plan.pushed.push(path);
+        break;
+      case "delete-team":
+        plan.deletedFromTeam.push(path);
+        break;
+      case "team":
+        plan.manifest[path] = team;
+        plan.writes[path] = teamText(path);
+        plan.pulled.push(path);
+        break;
+      case "delete-local":
+        plan.deletes.push(path);
+        plan.deletedHere.push(path);
+        break;
+      case "conflict": {
+        const copy = conflictCopyName(path, input.date, taken);
+        taken.add(copy.toLowerCase());
+        plan.manifest[path] = team;
+        plan.writes[path] = teamText(path);
+        plan.writes[copy] = local;
+        plan.conflicts.push({ path, copy });
+        break;
+      }
+      case "index": {
+        const base = input.base[path] ? texts[input.base[path]] : void 0;
+        const merged = mergeIndex(base, teamText(path), local);
+        const hash = sha256(merged.text);
+        plan.manifest[path] = hash;
+        if (merged.text !== local) {
+          plan.writes[path] = merged.text;
+          plan.pulled.push(path);
+        }
+        if (hash !== team) {
+          plan.upload[path] = merged.text;
+          plan.pushed.push(path);
+        }
+        plan.indexTeamLines.push(...merged.teamLines);
+        break;
+      }
+    }
+  }
+  return plan;
+}
+var LINK_RE = /\]\(\s*<?([^)\s>]+)>?(?:\s+["'(][^)]*)?\)/;
+function entries(lines) {
+  const seen = /* @__PURE__ */ new Map();
+  return lines.map((line) => {
+    const link = LINK_RE.exec(line);
+    const id = link ? `link:${link[1]}` : `text:${line}`;
+    const n = seen.get(id) ?? 0;
+    seen.set(id, n + 1);
+    return { key: n ? `${id}#${n}` : id, line };
+  });
+}
+var splitLines = (text) => text.split(/\r?\n/);
+function mergeIndex(base, team, local) {
+  const eol = local.includes("\r\n") ? "\r\n" : "\n";
+  const b = new Map(entries(base === void 0 ? [] : splitLines(base)).map((e) => [e.key, e.line]));
+  const teamEntries = entries(splitLines(team));
+  const t = new Map(teamEntries.map((e) => [e.key, e.line]));
+  const localEntries = entries(splitLines(local));
+  const result = [];
+  const teamLines = [];
+  for (const e of localEntries) {
+    const was = b.get(e.key);
+    const theirs = t.get(e.key);
+    if (theirs === e.line || theirs === was) result.push(e);
+    else if (e.line === was) {
+      if (theirs !== void 0) result.push({ key: e.key, line: theirs });
+    } else {
+      result.push(e);
+      if (theirs !== void 0) teamLines.push(theirs);
+    }
+  }
+  const baseEntries = entries(base === void 0 ? [] : splitLines(base));
+  const localKeys = new Set(localEntries.map((e) => e.key));
+  const replacedHere = /* @__PURE__ */ new Map();
+  baseEntries.forEach((e, i) => {
+    if (e.key.startsWith("text:") && !t.has(e.key) && !localKeys.has(e.key)) {
+      replacedHere.set(e.key, i ? baseEntries[i - 1].key : "");
+    }
+  });
+  const inResult = (key) => result.findIndex((e) => e.key === key);
+  teamEntries.forEach((e, i) => {
+    if (inResult(e.key) !== -1) return;
+    const was = b.get(e.key);
+    const before = i ? teamEntries[i - 1].key : "";
+    const both = e.key.startsWith("text:") && [...replacedHere].find(([, prev]) => prev === before);
+    if (was === void 0 && both) {
+      replacedHere.delete(both[0]);
+      teamLines.push(e.line);
+    } else if (was === void 0) {
+      let at = -1;
+      for (let j = i - 1; j >= 0 && at === -1; j--) at = inResult(teamEntries[j].key);
+      result.splice(at + 1, 0, e);
+    } else if (e.line !== was) {
+      teamLines.push(e.line);
+    }
+  });
+  return { text: result.map((e) => e.line).join(eol), teamLines };
+}
+var groupKey = (kind, normalised) => `${kind}:${normalised}`;
+function collectValues(files) {
+  const groups = /* @__PURE__ */ new Map();
+  const homePaths = [];
+  const findings = {};
+  for (const path of Object.keys(files).sort()) {
+    const found = findPersonValues(files[path]);
+    findings[path] = found;
+    for (const f of found) {
+      if (f.kind === HOME_PATH) {
+        if (!homePaths.includes(path)) homePaths.push(path);
+        continue;
+      }
+      const key = groupKey(f.kind, f.normalised);
+      const group = groups.get(key);
+      if (group) {
+        if (!group.files.includes(path)) group.files.push(path);
+      } else {
+        groups.set(key, {
+          kind: f.kind,
+          value: f.value,
+          normalised: f.normalised,
+          files: [path],
+          first: { path, line: f.line, text: splitLines(files[path])[f.line - 1].trim() }
+        });
+      }
+    }
+  }
+  return { groups: [...groups.values()], homePaths, findings };
+}
+function personToken(personId, label) {
+  return label ? `\`${personId}\` (${label})` : `\`${personId}\``;
+}
+function rewriteValues(text, findings, replacement) {
+  let out = "";
+  let last = 0;
+  for (const f of [...findings].sort((a, b) => a.start - b.start)) {
+    const to = replacement(f);
+    if (to === void 0) continue;
+    out += text.slice(last, f.start) + to;
+    last = f.end;
+  }
+  return out + text.slice(last);
+}
+function lineDiff(before, after) {
+  const a = splitLines(before);
+  const b = splitLines(after);
+  const out = [];
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    if (a[i] === b[i]) continue;
+    if (a[i] !== void 0) out.push(`- ${a[i]}`);
+    if (b[i] !== void 0) out.push(`+ ${b[i]}`);
+  }
+  return out;
+}
+export {
+  INDEX_FILE,
+  SHAREABLE_TYPES,
+  addShareFalse,
+  collectValues,
+  conflictCopyName,
+  decide,
+  decideAll,
+  groupKey,
+  isConflictCopy,
+  isFilePath,
+  isShareable,
+  lineDiff,
+  localDate,
+  mergeIndex,
+  personToken,
+  planMerge,
+  readFrontmatter,
+  rewriteValues,
+  sha256
+};

package/dist/lib/person-values.d.ts

@@ -57,11 +57,14 @@ export interface SecretFinding {
 /** openapi PersonId, unanchored: THE one copy of the pattern on the client.
  * The person token below and `resolve_person`'s input check
  * (team-setup-types PERSON_ID_RE) are both built from it, so a change to the
- * contract's PersonId is this one line (and the backend's `_PERSON_TOKEN`). */
-export declare const PERSON_ID = "(?:con|ctc|usr)_[0-9A-Za-z]{10,40}";
+ * contract's PersonId is this one line (and the backend's `PERSON_ID` in
+ * common/person_values.py). A `con_` (a ULID) or `ctc_` is letters and
+ * digits; a `usr_` is shared-auth's `usr_<Cognito sub>`, a UUID with its
+ * hyphens (proposal item 22). */
+export declare const PERSON_ID = "(?:(?:con|ctc)_[0-9A-Za-z]{10,40}|usr_[0-9A-Za-z-]{10,40})";
 /** `con_…` (label), `ctc_…` (label), `usr_…` (label): a PersonId in
  * backticks, with its role label after it. Skipped by the detector. */
-export declare const PERSON_TOKEN = "`(?:con|ctc|usr)_[0-9A-Za-z]{10,40}`(?:[ \\t]*\\([^()\\n]*\\))?";
+export declare const PERSON_TOKEN = "`(?:(?:con|ctc)_[0-9A-Za-z]{10,40}|usr_[0-9A-Za-z-]{10,40})`(?:[ \\t]*\\([^()\\n]*\\))?";
 /**
  * The form an answer is keyed by: E.164 for a phone number, lower case for an
  * email address. Throws when `value` is not one of `kind` (the server answers

package/dist/lib/person-values.js

@@ -9,7 +9,7 @@ var NATIONAL_PREFIX = "+44";
 var W = "[\\p{L}\\p{N}_]";
 var D = "\\p{Nd}";
 var WORD_OR = (extra) => `[\\p{L}\\p{N}_${extra}]`;
-var PERSON_ID = "(?:con|ctc|usr)_[0-9A-Za-z]{10,40}";
+var PERSON_ID = "(?:(?:con|ctc)_[0-9A-Za-z]{10,40}|usr_[0-9A-Za-z-]{10,40})";
 var PERSON_TOKEN = `\`${PERSON_ID}\`(?:[ \\t]*\\([^()\\n]*\\))?`;
 var BEFORE = `(?<!${WORD_OR("+.:/\\\\\\-")})(?<!${D}[ -])`;
 var AFTER = `(?!${WORD_OR(":/\\\\")}|\\.${D}|[ -]?${D}|-${W})`;

package/dist/setup-team.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The team setup that `systemdox-mcp-server setup [--project <name>]
+ * [--dir <checkout>] [--yes] [--overwrite]` runs after it has written the MCP
+ * server into an AI tool's config (ADR-217 with Amendments 1 and 2,
+ * specs/changes/team-setup/contract.md "setup").
+ *
+ * 1. Check: `GET /team-setup` names the workspace; `claude --version` must be
+ *    at least `minClaudeCodeVersion` (exit 3 otherwise, nothing changed).
+ * 2. Show, then ask once (y/N). On an update only what changed is shown, with
+ *    a line diff for hooks and instructions. `--yes` without a terminal goes
+ *    no further than what the member accepted before (exit 4 otherwise).
+ * 3. Do, in this order, stopping at a failed step: credentials.json; the team
+ *    instructions (exit 2 if the member edited them, unless --overwrite); the
+ *    import block in ~/.claude/CLAUDE.md; the marketplace in
+ *    ~/.claude/settings.json; the project's `autoMemoryDirectory` in
+ *    <checkout>/.claude/settings.local.json, then its sync.
+ * 4. Finish: the two steps a person must take in Claude Code.
+ *
+ * It never runs `claude plugin marketplace add` and never sets
+ * `enabledPlugins`. The key is written to credentials.json only.
+ *
+ * Exit codes: 0 done; 1 usage, no key or the API refused; 2 an edited team
+ * CLAUDE.md would be replaced; 3 Claude Code missing or too old; 4 not
+ * confirmed.
+ */
+import { SystemDoxApiClient } from "./lib/api-client.js";
+import { type SyncClient } from "./sync-memory.js";
+export declare const SETUP_USAGE = "Usage: systemdox-mcp-server setup [--project <name>] [--dir <checkout>] [--yes] [--overwrite]";
+export declare const HEADERS_HELPER = "npx -y @systemdox/mcp-server marketplace-auth";
+export interface TeamSetupArgs {
+    project?: string;
+    dir?: string;
+    yes: boolean;
+    overwrite: boolean;
+}
+export type TeamSetupClient = SyncClient & Pick<SystemDoxApiClient, "getPartVersion" | "getPlugin">;
+export interface TeamSetupOptions extends TeamSetupArgs {
+    client: TeamSetupClient;
+    apiKey: string;
+    /** Where the key came from: a key read from credentials.json is not written back. */
+    keySource: "prompt" | "environment" | "credentials";
+    out: (line: string) => void;
+    /** Asks the member a question. Absent: nobody can answer. */
+    ask?: (question: string) => Promise<string>;
+    /** stdin is a terminal (`--yes` counts only when it is not). */
+    terminal: boolean;
+    /** The checkout when `--dir` is absent. */
+    cwd?: string;
+    /** `claude --version`'s output, or undefined when Claude Code is not found. */
+    claudeVersion?: () => Promise<string | undefined>;
+    now?: () => Date;
+}
+export declare function parseSetupArgs(argv: string[]): TeamSetupArgs;
+/** `claude --version`'s output, or undefined when it cannot be run. On
+ * Windows through the shell, so `claude.cmd` (npm) and `claude.exe` both resolve. */
+export declare function claudeCodeVersion(): Promise<string | undefined>;
+/**
+ * `text` (a JSON object) with `keys` set to `value`, every other byte kept:
+ * an existing value is replaced in place, a missing member is added after the
+ * last one in the file's own indentation and line ending.
+ */
+export declare function setJsonMember(text: string, keys: string[], value: unknown): string;
+export declare function importBlock(workspace: string, eol?: string): string;
+/** `text` with the workspace's marked block added at the end, or replaced
+ * where it is; nothing outside the block changes. */
+export declare function withImportBlock(text: string, workspace: string): string;
+/**
+ * The team setup for the key's workspace. Returns the exit code; every line
+ * goes to `opts.out`.
+ */
+export declare function runTeamSetup(opts: TeamSetupOptions): Promise<number>;
+/** The command, after the MCP server step: the key and URL that step took. */
+export declare function runTeamSetupCommand(args: TeamSetupArgs, key: {
+    apiKey: string;
+    apiUrl: string;
+}, io: {
+    out: (line: string) => void;
+    ask?: (question: string) => Promise<string>;
+    terminal: boolean;
+}): Promise<number>;