@systemdox/mcp-server 0.1.46 → 0.1.47

package/dist/tools/team-setup.js

@@ -2,10 +2,10 @@
 
 // src/tools/team-setup.ts
 import { z } from "zod";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { lstat as lstat2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join2, resolve as resolve2 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join4, resolve as resolve3 } from "path";
 
 // src/lib/skills.ts
 import { createHash } from "crypto";
@@ -67,25 +67,912 @@ async function readTextFiles(root, paths, what) {
 }
 
 // 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|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})`;
 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(text2, start) {
+  let line = 1;
+  for (let i = text2.indexOf("\n"); i !== -1 && i < start; i = text2.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(text2) {
+  if (typeof text2 !== "string" || !text2) return [];
+  const skipped = [...text2.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(text2, start), start, end });
+  };
+  for (const m of text2.matchAll(global(EMAIL_RE))) add(EMAIL, m, m[0].toLowerCase());
+  for (const source of [E164, NATIONAL]) {
+    for (const m of text2.matchAll(global(source))) {
+      if (phoneShape(m[0])) add(PHONE, m, normalise(PHONE, m[0]));
+    }
+  }
+  for (const m of text2.matchAll(global(HOME, "i"))) add(HOME_PATH, m, m[0]);
+  return found.sort((a, b) => a.start - b.start);
+}
+function findSecrets(text2) {
+  if (typeof text2 !== "string" || !text2) return [];
+  return [...text2.matchAll(global(KEY_PREFIX))].map((m) => ({ kind: "key-prefix", line: lineOf(text2, m.index) }));
+}
 
 // src/lib/team-setup-types.ts
 var PARTS = ["hooks", "mcp", "agents", "commands", "instructions"];
 var PERSON_ID_RE = new RegExp(`^${PERSON_ID}$`);
 
+// src/sync-memory.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join3, resolve as resolve2 } from "path";
+
+// src/lib/memory-sync.ts
+import { createHash as createHash2 } from "crypto";
+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(text2) {
+  return createHash2("sha256").update(text2, "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(text2) {
+  const m = BLOCK_RE.exec(text2);
+  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, text2) {
+  if (isConflictCopy(path) || !path.endsWith(".md")) return false;
+  const front = readFrontmatter(text2);
+  if (front?.shareFalse) return false;
+  if (path === INDEX_FILE) return true;
+  return !!front && SHAREABLE_TYPES.includes(front.type ?? "");
+}
+function addShareFalse(text2) {
+  const eol = text2.includes("\r\n") ? "\r\n" : "\n";
+  const m = BLOCK_RE.exec(text2);
+  if (!m) return `---${eol}share: false${eol}---${eol}${text2}`;
+  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}${text2.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 text2 = texts[input.team[path]];
+    if (text2 === void 0) throw new Error(`the team's ${path} could not be read`);
+    return text2;
+  };
+  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 = (text2) => text2.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(text2, 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 += text2.slice(last, f.start) + to;
+    last = f.end;
+  }
+  return out + text2.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;
+}
+
+// src/lib/team-setup-files.ts
+import { execFile } from "child_process";
+import { chmod, mkdir as mkdir2, readFile as readFile2, rename, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2, userInfo } from "os";
+import { dirname as dirname2, join as join2 } from "path";
+import { promisify } from "util";
+var SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function isWorkspace(value) {
+  return typeof value === "string" && value.length <= 64 && SLUG_RE.test(value);
+}
+function homeDir() {
+  return homedir2();
+}
+function systemdoxDir() {
+  return join2(homeDir(), ".claude", "systemdox");
+}
+function workspaceDir(workspace) {
+  if (!isWorkspace(workspace)) throw new Error(`${JSON.stringify(workspace)} is not a workspace name`);
+  return join2(systemdoxDir(), workspace);
+}
+function statePath(workspace) {
+  return join2(workspaceDir(workspace), "state.json");
+}
+async function readJson(path, empty) {
+  let text2;
+  try {
+    text2 = await readFile2(path, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT") return empty;
+    throw e;
+  }
+  try {
+    return JSON.parse(text2);
+  } catch {
+    throw new Error(`${path} is not valid JSON: fix or remove it, then run this again`);
+  }
+}
+async function writeJsonAtomically(path, value, mode) {
+  await mkdir2(dirname2(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  await writeFile2(tmp, JSON.stringify(value, null, 2) + "\n", mode === void 0 ? "utf8" : { encoding: "utf8", mode });
+  await rename(tmp, path);
+}
+var run = promisify(execFile);
+async function readState(workspace) {
+  return readJson(statePath(workspace), {});
+}
+async function writeState(workspace, state) {
+  await writeJsonAtomically(statePath(workspace), state);
+}
+async function updateState(workspace, change) {
+  const state = await readState(workspace);
+  change(state);
+  await writeState(workspace, state);
+  return state;
+}
+
+// src/sync-memory.ts
+var SYNC_MEMORY_COMMAND = "npx -y @systemdox/mcp-server sync-memory";
+var SyncFailed = class extends Error {
+};
+function refusal(e) {
+  if (!(e instanceof Error)) return {};
+  const { status, code } = e;
+  return { status: typeof status === "number" ? status : void 0, code: typeof code === "string" ? code : void 0 };
+}
+var toPath = (root, rel) => join3(root, ...rel.split("/"));
+async function readFolder(root) {
+  const files = {};
+  const names = /* @__PURE__ */ new Set();
+  async function walk2(dir, prefix) {
+    for (const e of await readdir2(dir, { withFileTypes: true })) {
+      if (e.name.startsWith(".")) continue;
+      const rel = prefix ? `${prefix}/${e.name}` : e.name;
+      if (e.isDirectory()) await walk2(join3(dir, e.name), rel);
+      else if (e.isFile()) {
+        names.add(rel.toLowerCase());
+        if (e.name.endsWith(".md")) files[rel] = await readFile3(join3(dir, e.name), "utf8");
+      }
+    }
+  }
+  if (existsSync2(root)) await walk2(root, "");
+  return { files, names };
+}
+async function pullTeam(client, ws, project) {
+  try {
+    const latest = await client.getMemory(ws, project);
+    return {
+      version: latest.version,
+      manifest: Object.fromEntries(Object.entries(latest.files).map(([p, f]) => [p, f.sha256])),
+      exists: true
+    };
+  } catch (e) {
+    if (refusal(e).status === 404) return { version: 0, manifest: {}, exists: false };
+    throw e;
+  }
+}
+async function readTexts(client, ws, project, hashes) {
+  const texts = {};
+  const one = async (batch) => {
+    let left = batch;
+    while (left.length) {
+      const got = await client.readBlobs(ws, project, left);
+      for (const b of got.blobs) texts[b.sha256] = b.content;
+      if (!got.blobs.length) break;
+      left = got.remaining;
+    }
+  };
+  for (let i = 0; i < hashes.length; i += 1e3) {
+    const batch = hashes.slice(i, i + 1e3);
+    try {
+      await one(batch);
+    } catch (e) {
+      if (!(refusal(e).status === 404)) throw e;
+      for (const h of batch) {
+        try {
+          await one([h]);
+        } catch (err) {
+          if (!(refusal(err).status === 404)) throw err;
+        }
+      }
+    }
+  }
+  return texts;
+}
+var Report = class {
+  pulled = /* @__PURE__ */ new Set();
+  pushed = /* @__PURE__ */ new Set();
+  deletedHere = /* @__PURE__ */ new Set();
+  deletedFromTeam = /* @__PURE__ */ new Set();
+  conflicts = [];
+  skipped = /* @__PURE__ */ new Map();
+  people = [];
+  toAnswer = /* @__PURE__ */ new Map();
+  add(plan) {
+    plan.pulled.forEach((p) => this.pulled.add(p));
+    plan.pushed.forEach((p) => this.pushed.add(p));
+    plan.deletedHere.forEach((p) => this.deletedHere.add(p));
+    plan.deletedFromTeam.forEach((p) => this.deletedFromTeam.add(p));
+    for (const c of plan.conflicts) this.conflicts.push(`${c.path}: the team's text; yours is beside it as ${c.copy}`);
+    for (const line of plan.indexTeamLines) this.conflicts.push(`${INDEX_FILE}: your line was kept; the team's was: ${line}`);
+  }
+  skip(path, reason) {
+    if (!this.skipped.has(path)) this.skipped.set(path, reason);
+  }
+  lines(summary, dryRun) {
+    const out = [summary];
+    const section = (title, items) => {
+      if (items.length) out.push("", `${title}:`, ...items.map((i) => `- ${i}`));
+    };
+    const sorted = (s) => [...s].sort();
+    section(dryRun ? "Would pull" : "Pulled", sorted(this.pulled));
+    section(dryRun ? "Would push" : "Pushed", sorted(this.pushed));
+    section(dryRun ? "Would delete" : "Deleted", [
+      ...sorted(this.deletedHere).map((p) => `${p} (here: the team deleted it)`),
+      ...sorted(this.deletedFromTeam).map((p) => `${p} (from the team: you deleted it)`)
+    ]);
+    section("Conflicts", this.conflicts);
+    section(
+      "Skipped",
+      [...this.skipped.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([p, why]) => `${p}: ${why}`)
+    );
+    section(
+      "People",
+      this.people.map(
+        (a) => [a.kind, a.answer, a.label, a.personId && `\`${a.personId}\``, a.files !== void 0 && `${a.files} files`].filter(Boolean).join(", ")
+      )
+    );
+    if (this.toAnswer.size) {
+      out.push(
+        "",
+        `Values still to answer: ${[...this.toAnswer.entries()].map(([kind, n]) => `${n} ${kind}`).join(", ")}.`
+      );
+    }
+    return out;
+  }
+};
+var ANSWER_WORDS = {
+  member: "a member's contact",
+  person: "someone else",
+  ours: "ours, not a person"
+};
+function labelProblem(label) {
+  if (!label) return "a label is needed";
+  if (label.length > 60) return "a label is at most 60 characters";
+  if (findPersonValues(label).length) return "a label is a role, never a phone number, an email address or a path";
+  return void 0;
+}
+async function askLabel(ask, out, question, optional) {
+  for (; ; ) {
+    const label = (await ask(question)).trim();
+    if (optional && !label) return void 0;
+    const problem = labelProblem(label);
+    if (!problem) return label;
+    out(`  ${problem}.`);
+  }
+}
+async function people(opts, ws, files, report, hint) {
+  const { client, out, ask, dryRun } = opts;
+  const terminal = !!ask && !dryRun;
+  const held = /* @__PURE__ */ new Set();
+  const leftOut = /* @__PURE__ */ new Set();
+  const current = { ...files };
+  for (const [path, text2] of Object.entries(current)) {
+    const secret = findSecrets(text2)[0];
+    if (secret) {
+      held.add(path);
+      report.skip(path, `a secret (${secret.kind}) on line ${secret.line}: remove it, then sync again`);
+    }
+  }
+  const { groups, findings } = collectValues(current);
+  const answers = /* @__PURE__ */ new Map();
+  for (let i = 0; i < groups.length; i += 500) {
+    const batch = groups.slice(i, i + 500);
+    const got = await client.lookupValues(ws, batch.map((g) => ({ kind: g.kind, value: g.value })));
+    batch.forEach((g, j) => {
+      const a = got.answers[j];
+      if (a && a.answer !== "unanswered") answers.set(groupKey(g.kind, g.normalised), a);
+    });
+  }
+  const vaultDown = /* @__PURE__ */ new Set();
+  if (terminal) {
+    const filed = [];
+    for (const g of groups) {
+      const key = groupKey(g.kind, g.normalised);
+      if (answers.has(key)) continue;
+      let choices = ["m", "p", "o", "x", "s"];
+      for (; ; ) {
+        const question = [
+          `${g.value} (${g.kind}) is in ${g.files.length} file${g.files.length === 1 ? "" : "s"}. First line it appears on, in ${g.first.path}:`,
+          `  ${g.first.text}`,
+          [
+            choices.includes("m") && "[m] a member's contact",
+            "[p] someone else",
+            "[o] ours, not a person",
+            "[x] leave these files out",
+            "[s] skip for now"
+          ].filter(Boolean).join("  "),
+          `Answer (${choices.join("/")}): `
+        ].join("\n");
+        const answer = (await ask(question)).trim().toLowerCase();
+        if (!choices.includes(answer)) continue;
+        if (answer === "s") break;
+        if (answer === "x") {
+          for (const path of g.files) {
+            if (leftOut.has(path)) continue;
+            current[path] = addShareFalse(current[path]);
+            await writeFile3(toPath(opts.dir, path), current[path], "utf8");
+            leftOut.add(path);
+          }
+          report.people.push({ kind: g.kind, answer: "left out (share: false)", files: g.files.length });
+          break;
+        }
+        if (answer === "p") {
+          const label2 = await askLabel(ask, out, "Their role, as a label (e.g. reseller, sales; never a name): ", false);
+          let entry = filed.length ? await (async () => {
+            const list = filed.map((f, i) => `  ${i + 1}. ${f.label}: ${f.groups.map((x) => x.value).join(", ")}`);
+            for (; ; ) {
+              const same = (await ask(["The same person as one filed above?", ...list, "Number, or Enter for a new person: "].join("\n"))).trim();
+              if (!same) return void 0;
+              const n = Number(same);
+              if (Number.isInteger(n) && n >= 1 && n <= filed.length && filed[n - 1].groups.length < 4) return filed[n - 1];
+            }
+          })() : void 0;
+          if (!entry) {
+            entry = { groups: [], label: label2 };
+            filed.push(entry);
+          }
+          entry.groups.push(g);
+          break;
+        }
+        const label = answer === "m" ? await askLabel(ask, out, "A role label for it (e.g. owner, business mobile), or Enter for none: ", true) : void 0;
+        let result;
+        try {
+          result = await client.answerValues(ws, [
+            { kind: g.kind, value: g.value, answer: answer === "m" ? "member" : "ours", ...label ? { label } : {} }
+          ]);
+        } catch (e) {
+          if (refusal(e).code === "SYD-K019") {
+            vaultDown.add(key);
+            out("  The vault did not answer (SYD-K019): the files holding it wait for the next sync.");
+            break;
+          }
+          throw e;
+        }
+        if (result.stored[0]) {
+          answers.set(key, result.stored[0]);
+          report.people.push({ kind: g.kind, answer: ANSWER_WORDS[result.stored[0].answer], label: result.stored[0].label, personId: result.stored[0].personId });
+          break;
+        }
+        const refused = result.refused[0];
+        if (refused?.code === "SYD-K021") {
+          out(`  ${refused.detail}. Add them in Staff first, or answer p to file them.`);
+          choices = choices.filter((c) => c !== "m");
+        } else if (refused) out(`  ${refused.detail}`);
+      }
+    }
+    for (let i = 0; i < filed.length; i += 50) {
+      const batch = filed.slice(i, i + 50);
+      let result;
+      try {
+        result = await client.fileMemoryPeople(
+          ws,
+          batch.map((f) => ({ values: f.groups.map((g) => ({ kind: g.kind, value: g.value })), label: f.label }))
+        );
+      } catch (e) {
+        if (refusal(e).code === "SYD-K019") {
+          out("Contacts did not answer (SYD-K019): the files holding those values wait for the next sync.");
+          batch.forEach((f) => f.groups.forEach((g) => vaultDown.add(groupKey(g.kind, g.normalised))));
+          continue;
+        }
+        throw e;
+      }
+      for (const stored of result.stored) {
+        let key;
+        try {
+          key = groupKey(stored.kind, normalise(stored.kind, stored.value));
+        } catch {
+          continue;
+        }
+        answers.set(key, stored);
+      }
+      for (const r of result.refused) {
+        out(`  ${batch[r.index]?.label ?? ""}: ${r.detail}`);
+      }
+      for (const f of batch) {
+        const a = answers.get(groupKey(f.groups[0].kind, f.groups[0].normalised));
+        if (a?.answer === "person") {
+          for (const g of f.groups) report.people.push({ kind: g.kind, answer: ANSWER_WORDS.person, label: a.label, personId: a.personId });
+        }
+      }
+    }
+  }
+  const rewritten = {};
+  for (const [path, text2] of Object.entries(current)) {
+    if (leftOut.has(path) || held.has(path)) continue;
+    const next = rewriteValues(text2, findings[path] ?? [], (f) => {
+      if (f.kind === HOME_PATH) return "~";
+      const a = answers.get(groupKey(f.kind, f.normalised));
+      return a && (a.answer === "member" || a.answer === "person") && a.personId ? personToken(a.personId, a.label) : void 0;
+    });
+    if (next !== text2) rewritten[path] = next;
+  }
+  const paths = Object.keys(rewritten).sort();
+  if (paths.length && terminal) {
+    out("", "The rewrite:");
+    for (const path of paths) out(path, ...lineDiff(current[path], rewritten[path]).map((l) => `  ${l}`));
+    const yes = /^y(es)?$/i.test((await ask(`Rewrite ${paths.length} file${paths.length === 1 ? "" : "s"} as shown? [y/N] `)).trim());
+    if (yes) {
+      for (const path of paths) {
+        await writeFile3(toPath(opts.dir, path), rewritten[path], "utf8");
+        current[path] = rewritten[path];
+      }
+    }
+  }
+  for (const [path, text2] of Object.entries(current)) {
+    if (leftOut.has(path) || held.has(path)) continue;
+    const pending = findPersonValues(text2).filter((f) => {
+      if (f.kind === HOME_PATH) return true;
+      return answers.get(groupKey(f.kind, f.normalised))?.answer !== "ours";
+    });
+    if (!pending.length) continue;
+    held.add(path);
+    const keys = pending.filter((f) => f.kind !== HOME_PATH).map((f) => groupKey(f.kind, f.normalised));
+    if (keys.some((k) => vaultDown.has(k))) {
+      report.skip(path, "the vault did not answer (SYD-K019) for a value in it; it syncs once the value is filed");
+    } else if (keys.some((k) => !answers.has(k))) {
+      report.skip(path, `it holds a value nobody has answered for: run \`${hint}\` in a terminal`);
+    } else {
+      report.skip(path, `it holds a value to rewrite as its identifier or ~: run \`${hint}\` in a terminal`);
+    }
+  }
+  for (const g of groups) {
+    const key = groupKey(g.kind, g.normalised);
+    if (!answers.has(key) && g.files.some((p) => !leftOut.has(p))) {
+      report.toAnswer.set(g.kind, (report.toAnswer.get(g.kind) ?? 0) + 1);
+    }
+  }
+  return { files: current, held, leftOut };
+}
+async function applyPlan(dir, plan) {
+  for (const [path, text2] of Object.entries(plan.writes)) {
+    const full = toPath(dir, path);
+    await mkdir3(dirname3(full), { recursive: true });
+    await writeFile3(full, text2, "utf8");
+  }
+  for (const path of plan.deletes) await rm3(toPath(dir, path), { force: true });
+}
+var sameManifest = (a, b) => Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([p, h]) => b[p] === h);
+async function upload(client, ws, project, plan, team, report) {
+  const byHash = /* @__PURE__ */ new Map();
+  for (const path of Object.keys(plan.upload)) {
+    const h = plan.manifest[path];
+    byHash.set(h, [...byHash.get(h) ?? [], path]);
+  }
+  const hashes = [...byHash.keys()];
+  const missing = [];
+  for (let i = 0; i < hashes.length; i += 1e4) {
+    missing.push(...(await client.findMissingBlobs(ws, project, hashes.slice(i, i + 1e4))).missing);
+  }
+  const blobs = missing.map((h) => ({ sha256: h, content: plan.upload[byHash.get(h)[0]] }));
+  let batch = [];
+  let bytes = 0;
+  const send = async () => {
+    if (!batch.length) return;
+    const result = await client.uploadBlobs(ws, project, batch);
+    for (const r of result.refused) {
+      for (const path of byHash.get(r.sha256) ?? []) {
+        if (team[path]) plan.manifest[path] = team[path];
+        else delete plan.manifest[path];
+        plan.pushed = plan.pushed.filter((p) => p !== path);
+        report.pushed.delete(path);
+        report.skip(path, `refused by SystemDox, ${r.detail.startsWith(r.code) ? r.detail : `${r.code}: ${r.detail}`}`);
+      }
+    }
+    batch = [];
+    bytes = 0;
+  };
+  for (const blob of blobs) {
+    const size = Buffer.byteLength(blob.content, "utf8");
+    if (batch.length === 100 || batch.length && bytes + size > 5 * 1024 * 1024 - 64 * 1024) await send();
+    batch.push(blob);
+    bytes += size;
+  }
+  await send();
+}
+async function syncMemory(opts) {
+  const { client, out } = opts;
+  const now = opts.now?.() ?? /* @__PURE__ */ new Date();
+  try {
+    const own = await client.getOwnTeamSetup();
+    const ws = own.workspace;
+    const project = opts.project ?? (own.memory.length === 1 ? own.memory[0].project : void 0);
+    if (!project) {
+      throw new SyncFailed(
+        own.memory.length ? `${ws} has ${own.memory.length} team memories (${own.memory.map((m) => m.project).join(", ")}): name one with --project.` : `${ws} has no team memory yet: name the project to start with --project.`
+      );
+    }
+    const dir = resolve2(opts.dir ?? join3(workspaceDir(ws), "memory", project));
+    const run2 = { ...opts, dir };
+    const hint = [SYNC_MEMORY_COMMAND, `--project ${project}`, opts.dir ? `--dir "${opts.dir}"` : ""].filter(Boolean).join(" ");
+    const report = new Report();
+    const date = localDate(now);
+    const stored = (await readState(ws)).memory?.[project];
+    let team = await pullTeam(client, ws, project);
+    let base = stored ? { version: stored.version, manifest: stored.manifest, exists: true } : { version: 0, manifest: {}, exists: false };
+    const folder = await readFolder(dir);
+    const shared = {};
+    const notShared = /* @__PURE__ */ new Set();
+    for (const [path, text2] of Object.entries(folder.files)) {
+      if (!isShareable(path, text2)) notShared.add(path);
+      else if (!isFilePath(path)) {
+        notShared.add(path);
+        report.skip(path, "its name has characters a team memory path cannot hold (letters, digits, '.', '_', '-')");
+      } else shared[path] = text2;
+    }
+    const importWrites = {};
+    if (opts.importDir) {
+      const other = await readFolder(resolve2(opts.importDir));
+      const taken = new Set(folder.names);
+      for (const [path, text2] of Object.entries(other.files).sort(([a], [b]) => a.localeCompare(b))) {
+        if (!isShareable(path, text2) || !isFilePath(path)) continue;
+        const here = folder.files[path];
+        if (here === void 0) {
+          shared[path] = text2;
+          importWrites[path] = text2;
+          taken.add(path.toLowerCase());
+        } else if (here !== text2) {
+          const copy = conflictCopyName(path, date, taken);
+          taken.add(copy.toLowerCase());
+          importWrites[copy] = text2;
+          report.conflicts.push(`${path}: this folder's text; the imported one is beside it as ${copy}`);
+        }
+      }
+      folder.names = taken;
+      if (!opts.dryRun) {
+        for (const [path, text2] of Object.entries(importWrites)) {
+          const full = toPath(dir, path);
+          await mkdir3(dirname3(full), { recursive: true });
+          await writeFile3(full, text2, "utf8");
+        }
+      }
+    }
+    const found = await people(run2, ws, shared, report, hint);
+    for (const path of found.leftOut) {
+      delete found.files[path];
+      notShared.add(path);
+    }
+    const excluded = /* @__PURE__ */ new Set([...found.held, ...notShared]);
+    for (const path of found.held) delete found.files[path];
+    for (let attempt = 1; ; attempt++) {
+      const input = { base: base.manifest, team: team.manifest, local: found.files, excluded, taken: folder.names, date };
+      const { rows, needed } = decideAll(input);
+      const texts = needed.length ? await readTexts(client, ws, project, needed) : {};
+      const plan = planMerge(input, rows, texts);
+      report.add(plan);
+      if (opts.dryRun) {
+        const skipped = report.skipped.size;
+        out(
+          ...report.lines(
+            `Dry run of ${ws}/${project} against version ${team.version}: would pull ${report.pulled.size}, push ${report.pushed.size} and delete ${report.deletedHere.size + report.deletedFromTeam.size}; ${report.conflicts.length} conflicts, ${skipped} skipped. Nothing was asked, written or sent.`,
+            true
+          )
+        );
+        return 0;
+      }
+      await applyPlan(dir, plan);
+      let version = team.version;
+      if (!sameManifest(plan.manifest, team.manifest)) {
+        await upload(client, ws, project, plan, team.manifest, report);
+      }
+      if (!sameManifest(plan.manifest, team.manifest)) {
+        try {
+          version = (await client.pushMemoryVersion(ws, project, { baseVersion: team.version, manifest: plan.manifest })).version;
+        } catch (e) {
+          if (!(refusal(e).status === 409 && refusal(e).code === "SYD-K010")) throw e;
+          if (attempt === 2) {
+            out(
+              ...report.lines(
+                `Not pushed: ${ws}/${project} moved on twice while this sync merged. Your folder holds the merge; run sync-memory again.`,
+                false
+              )
+            );
+            return 2;
+          }
+          base = team;
+          for (const p of plan.pushed) report.pushed.delete(p);
+          const again = await readFolder(dir);
+          folder.names = again.names;
+          found.files = {};
+          for (const [path, text2] of Object.entries(again.files)) {
+            if (excluded.has(path) || !isShareable(path, text2) || !isFilePath(path)) continue;
+            found.files[path] = text2;
+          }
+          team = await pullTeam(client, ws, project);
+          continue;
+        }
+      }
+      await updateState(ws, (state) => {
+        state.memory = { ...state.memory, [project]: { version, manifest: plan.manifest } };
+      });
+      out(
+        ...report.lines(
+          `Synced ${ws}/${project} at version ${version}: ${report.pulled.size} pulled, ${report.pushed.size} pushed, ${report.deletedHere.size + report.deletedFromTeam.size} deleted, ${report.conflicts.length} conflicts, ${report.skipped.size} skipped.`,
+          false
+        )
+      );
+      return 0;
+    }
+  } catch (e) {
+    out(e.message);
+    return 1;
+  }
+}
+
 // src/tools/team-setup.ts
 var LAYOUT = {
   hooks: { files: ["hooks/hooks.json"], folders: [{ dir: "scripts", md: false }], required: "hooks/hooks.json" },
@@ -95,7 +982,7 @@ var LAYOUT = {
   instructions: { files: ["CLAUDE.md"], folders: [], required: "CLAUDE.md" }
 };
 function expandHome(path) {
-  return path.replace(/^~(?=$|[\\/])/, homedir2());
+  return path.replace(/^~(?=$|[\\/])/, homedir3());
 }
 function text(t) {
   return { content: [{ type: "text", text: t }] };
@@ -109,7 +996,7 @@ async function isLink(path) {
   }
 }
 async function readPartDirectory(part, directory) {
-  const root = resolve2(directory);
+  const root = resolve3(directory);
   const layout = LAYOUT[part];
   const paths = [];
   const leftOut = [];
@@ -119,21 +1006,21 @@ async function readPartDirectory(part, directory) {
     let present = true;
     for (let i = 1; i <= segments.length; i++) {
       const rel = segments.slice(0, i).join("/");
-      if (await isLink(join2(root, ...segments.slice(0, i)))) {
+      if (await isLink(join4(root, ...segments.slice(0, i)))) {
         links.push(rel);
         present = false;
         break;
       }
     }
-    if (present && existsSync2(join2(root, ...segments))) paths.push(path);
+    if (present && existsSync3(join4(root, ...segments))) paths.push(path);
   }
   for (const { dir, md } of layout.folders) {
-    const full = join2(root, dir);
+    const full = join4(root, dir);
     if (await isLink(full)) {
       links.push(dir);
       continue;
     }
-    if (!existsSync2(full)) continue;
+    if (!existsSync3(full)) continue;
     const walked = await walk(full, { skipHidden: true });
     links.push(...walked.links.map((p) => `${dir}/${p}`));
     leftOut.push(...walked.hidden.map((p) => `${dir}/${p}`));
@@ -235,6 +1122,29 @@ function registerTeamSetupTools(server, apiClient, { localFiles }) {
       return text(describePerson(args.id, person));
     }
   );
+  if (!localFiles) return;
+  server.registerTool(
+    "sync_memory",
+    {
+      title: "Sync Memory",
+      description: `Sync one project's team memory on this computer with SystemDox: pull the files the team changed, push the ones changed here, keep both texts of a file changed on both sides. It never answers for a person: a file that still holds a phone number, an email address or a home-folder path is skipped and listed, with the command for the member to run in their own terminal (\`${SYNC_MEMORY_COMMAND}\`). Pass dryRun to see what it would do without writing or sending anything.`,
+      inputSchema: {
+        project: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "a project name: lower case letters, digits and -").optional().describe("The project's team memory, e.g. puglieseweb-ltd; needed when the workspace has more than one"),
+        dryRun: z.boolean().optional().describe("Show what would be pulled, pushed, deleted, conflicted and skipped, and change nothing")
+      },
+      annotations: { readOnlyHint: false }
+    },
+    async (args) => {
+      const lines = [];
+      const code = await syncMemory({
+        project: args.project,
+        dryRun: !!args.dryRun,
+        client: apiClient,
+        out: (...l) => lines.push(...l)
+      });
+      return { ...text(lines.join("\n")), ...code ? { isError: true } : {} };
+    }
+  );
 }
 export {
   readPartDirectory,