@systemdox/mcp-server 0.1.57 → 0.1.59

package/dist/cli.js

@@ -75,6 +75,12 @@ function workspaceDir(workspace) {
 function statePath(workspace) {
   return join(workspaceDir(workspace), "state.json");
 }
+function syncLogPath(workspace) {
+  return join(workspaceDir(workspace), "sync-memory.log");
+}
+function syncLockPath(workspace) {
+  return join(workspaceDir(workspace), "sync.lock");
+}
 function pluginRoot(workspace) {
   return join(workspaceDir(workspace), "plugin");
 }
@@ -585,15 +591,41 @@ function readFrontmatter(text3) {
   const m = BLOCK_RE.exec(text3);
   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);
+  const lines = m[1].split(/\r?\n/);
+  if (lines.some((l) => /^[ \t]*\t/.test(l) && l.trim())) return front;
+  let topType;
+  let topShare;
+  let nestedType;
+  let nestedShare;
+  let inMetadata = false;
+  let nestedIndent;
+  for (const line of lines) {
+    if (!line.trim() || /^[ \t]*#/.test(line)) continue;
+    const indent = /^ */.exec(line)[0].length;
+    if (indent === 0) {
+      inMetadata = /^metadata[ \t]*:[ \t]*(#.*)?$/.test(line);
+      nestedIndent = void 0;
+    }
+    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);
-  }
+    const isFalse = quoted ? value.trim().toLowerCase() === "false" : YAML_FALSE.has(value);
+    if (indent === 0) {
+      if (kv[1] === "type") topType = value.trim().toLowerCase();
+      if (kv[1] === "share") topShare = isFalse;
+      continue;
+    }
+    if (!inMetadata) continue;
+    nestedIndent ??= indent;
+    if (indent !== nestedIndent) continue;
+    if (kv[1] === "type") nestedType = value.trim().toLowerCase();
+    if (kv[1] === "share") nestedShare = isFalse;
+  }
+  const type = topType ?? nestedType;
+  if (type !== void 0) front.type = type;
+  front.shareFalse = (topShare ?? nestedShare) === true;
   return front;
 }
 function isShareable(path, text3) {
@@ -849,35 +881,70 @@ var init_memory_sync = __esm({
 // src/sync-memory.ts
 var sync_memory_exports = {};
 __export(sync_memory_exports, {
+  HOOK_BUDGET_MS: () => HOOK_BUDGET_MS,
+  HOOK_LOCK_STALE_MS: () => HOOK_LOCK_STALE_MS,
+  HOOK_LOG_MAX_BYTES: () => HOOK_LOG_MAX_BYTES,
+  HOOK_WAITING_NAMED: () => HOOK_WAITING_NAMED,
   SYNC_MEMORY_COMMAND: () => SYNC_MEMORY_COMMAND,
   SYNC_MEMORY_USAGE: () => SYNC_MEMORY_USAGE,
+  hookLines: () => hookLines,
   parseSyncMemoryArgs: () => parseSyncMemoryArgs,
+  runHookSync: () => runHookSync,
   runSyncMemory: () => runSyncMemory,
   syncMemory: () => syncMemory
 });
 import { existsSync } from "fs";
-import { mkdir as mkdir2, readdir, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { appendFile, mkdir as mkdir2, open, readdir, readFile as readFile2, rename as rename2, rm as rm2, stat, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname2, join as join2, resolve } from "path";
+function failureReason(e) {
+  if (e instanceof SyncStopped) return e.reason;
+  const { status, code } = refusal(e);
+  if (status !== void 0) return code ? `SystemDox refused it, ${code}` : "SystemDox refused it";
+  const err = e;
+  const net = err?.cause?.code ?? err?.code ?? "";
+  if (e instanceof TypeError || /^(ECONN|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|EHOSTUNREACH|ENETUNREACH|UND_ERR)/.test(net)) {
+    return "SystemDox could not be reached";
+  }
+  return "it could not finish";
+}
+async function writeWhole(path, text3) {
+  await mkdir2(dirname2(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    await writeFile2(tmp, text3, "utf8");
+    await rename2(tmp, path);
+  } catch (e) {
+    await rm2(tmp, { force: true });
+    throw e;
+  }
+}
 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 };
 }
 function parseSyncMemoryArgs(argv) {
-  const args2 = { dryRun: false };
+  const args2 = { dryRun: false, importDirs: [] };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--dry-run") args2.dryRun = true;
-    else if (a === "--project" || a === "--dir" || a === "--import") {
+    else if (a === "--project" || a === "--dir" || a === "--import" || a === "--hook") {
       const value = argv[++i];
       if (!value || value.startsWith("--")) throw new SyncFailed(`${a} needs a value
 ${SYNC_MEMORY_USAGE}`);
       if (a === "--project") {
         if (!isWorkspace(value)) throw new SyncFailed(`${value} is not a project name (lower case letters, digits and -)`);
         args2.project = value;
+      } else if (a === "--hook") {
+        if (!isWorkspace(value)) throw new SyncFailed(`${value} is not a workspace name (lower case letters, digits and -)`);
+        args2.hook = value;
       } else if (a === "--dir") args2.dir = value;
-      else args2.importDir = value;
+      else args2.importDirs.push(value);
     } else throw new SyncFailed(`Unexpected argument ${a}
+${SYNC_MEMORY_USAGE}`);
+  }
+  if (args2.hook && (args2.project || args2.dir || args2.importDirs.length || args2.dryRun)) {
+    throw new SyncFailed(`--hook takes no other option
 ${SYNC_MEMORY_USAGE}`);
   }
   return args2;
@@ -885,6 +952,7 @@ ${SYNC_MEMORY_USAGE}`);
 async function readFolder(root) {
   const files = {};
   const names = /* @__PURE__ */ new Set();
+  const temps = [];
   async function walk2(dir, prefix) {
     for (const e of await readdir(dir, { withFileTypes: true })) {
       if (e.name.startsWith(".")) continue;
@@ -892,12 +960,13 @@ async function readFolder(root) {
       if (e.isDirectory()) await walk2(join2(dir, e.name), rel);
       else if (e.isFile()) {
         names.add(rel.toLowerCase());
+        if (LEFT_TEMP_RE.test(e.name)) temps.push(rel);
         if (e.name.endsWith(".md")) files[rel] = await readFile2(join2(dir, e.name), "utf8");
       }
     }
   }
   if (existsSync(root)) await walk2(root, "");
-  return { files, names };
+  return { files, names, temps };
 }
 async function pullTeam(client, ws, project) {
   try {
@@ -1005,7 +1074,7 @@ async function people(opts, ws, files, report, hint) {
           for (const path of g.files) {
             if (leftOut.has(path)) continue;
             current[path] = addShareFalse(current[path]);
-            await writeFile2(toPath(opts.dir, path), current[path], "utf8");
+            await writeWhole(toPath(opts.dir, path), current[path]);
             leftOut.add(path);
           }
           report.people.push({ kind: g.kind, answer: "left out (share: false)", files: g.files.length });
@@ -1108,7 +1177,7 @@ async function people(opts, ws, files, report, hint) {
     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 writeFile2(toPath(opts.dir, path), rewritten[path], "utf8");
+        await writeWhole(toPath(opts.dir, path), rewritten[path]);
         current[path] = rewritten[path];
       }
     }
@@ -1123,11 +1192,11 @@ async function people(opts, ws, files, report, hint) {
     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");
+      report.wait(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`);
+      report.wait(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`);
+      report.wait(path, `it holds a value to rewrite as its identifier or ~: run \`${hint}\` in a terminal`);
     }
   }
   for (const g of groups) {
@@ -1138,12 +1207,11 @@ async function people(opts, ws, files, report, hint) {
   }
   return { files: current, held, leftOut };
 }
+async function removeLeftTemps(dir, temps) {
+  for (const rel of temps) await rm2(toPath(dir, rel), { force: true });
+}
 async function applyPlan(dir, plan) {
-  for (const [path, text3] of Object.entries(plan.writes)) {
-    const full = toPath(dir, path);
-    await mkdir2(dirname2(full), { recursive: true });
-    await writeFile2(full, text3, "utf8");
-  }
+  for (const [path, text3] of Object.entries(plan.writes)) await writeWhole(toPath(dir, path), text3);
   for (const path of plan.deletes) await rm2(toPath(dir, path), { force: true });
 }
 async function upload(client, ws, project, plan, team, report) {
@@ -1187,8 +1255,19 @@ async function syncMemory(opts) {
   const { client, out } = opts;
   const now = opts.now?.() ?? /* @__PURE__ */ new Date();
   try {
+    const checkDeadline = () => {
+      if (opts.deadline !== void 0 && Date.now() > opts.deadline) {
+        throw new SyncStopped("took too long", "Stopped: the sync's time ran out before anything more was written or sent.");
+      }
+    };
     const own = await client.getOwnTeamSetup();
     const ws = own.workspace;
+    if (opts.workspace && ws !== opts.workspace) {
+      throw new SyncStopped(
+        "the key is for another workspace",
+        `The key is for ${ws}, not ${opts.workspace}: nothing was synced. Set SYSTEMDOX_API_KEY to a key of ${opts.workspace}, or unset it.`
+      );
+    }
     const project = opts.project ?? (own.memory.length === 1 ? own.memory[0].project : void 0);
     if (!project) {
       throw new SyncFailed(
@@ -1202,6 +1281,12 @@ async function syncMemory(opts) {
     const date = localDate(now);
     const stored = (await readState(ws)).memory?.[project];
     let team = await pullTeam(client, ws, project);
+    if (opts.unattended && stored && !team.exists) {
+      throw new SyncStopped(
+        "the team memory could not be read",
+        `${ws}/${project} could not be read from SystemDox: nothing was changed. Run sync-memory in your terminal to see why.`
+      );
+    }
     let base = stored ? { version: stored.version, manifest: stored.manifest, exists: true } : { version: 0, manifest: {}, exists: false };
     const folder = await readFolder(dir);
     const shared = {};
@@ -1214,14 +1299,16 @@ async function syncMemory(opts) {
       } else shared[path] = text3;
     }
     const importWrites = {};
-    if (opts.importDir) {
-      const other = await readFolder(resolve(opts.importDir));
-      const taken = new Set(folder.names);
+    const current = { ...folder.files };
+    const taken = new Set(folder.names);
+    for (const importDir of opts.importDirs ?? []) {
+      const other = await readFolder(resolve(importDir));
       for (const [path, text3] of Object.entries(other.files).sort(([a], [b]) => a.localeCompare(b))) {
         if (!isShareable(path, text3) || !isFilePath(path)) continue;
-        const here = folder.files[path];
+        const here = current[path];
         if (here === void 0) {
           shared[path] = text3;
+          current[path] = text3;
           importWrites[path] = text3;
           taken.add(path.toLowerCase());
         } else if (here !== text3) {
@@ -1229,16 +1316,14 @@ async function syncMemory(opts) {
           taken.add(copy.toLowerCase());
           importWrites[copy] = text3;
           report.conflicts.push(`${path}: this folder's text; the imported one is beside it as ${copy}`);
+          report.copies.add(copy);
         }
       }
-      folder.names = taken;
-      if (!opts.dryRun) {
-        for (const [path, text3] of Object.entries(importWrites)) {
-          const full = toPath(dir, path);
-          await mkdir2(dirname2(full), { recursive: true });
-          await writeFile2(full, text3, "utf8");
-        }
-      }
+    }
+    folder.names = taken;
+    if (!opts.dryRun) {
+      checkDeadline();
+      for (const [path, text3] of Object.entries(importWrites)) await writeWhole(toPath(dir, path), text3);
     }
     const found = await people(run3, ws, shared, report, hint);
     for (const path of found.leftOut) {
@@ -1263,12 +1348,16 @@ async function syncMemory(opts) {
         );
         return 0;
       }
+      checkDeadline();
+      if (attempt === 1) await removeLeftTemps(dir, folder.temps);
       await applyPlan(dir, plan);
       let version = team.version;
       if (!sameManifest(plan.manifest, team.manifest)) {
+        checkDeadline();
         await upload(client, ws, project, plan, team.manifest, report);
       }
       if (!sameManifest(plan.manifest, team.manifest)) {
+        checkDeadline();
         try {
           version = (await client.pushMemoryVersion(ws, project, { baseVersion: team.version, manifest: plan.manifest })).version;
         } catch (e) {
@@ -1280,6 +1369,7 @@ async function syncMemory(opts) {
                 false
               )
             );
+            opts.summary?.(report.summary("moved-on", team.version, "moved on twice"));
             return 2;
           }
           base = team;
@@ -1304,18 +1394,202 @@ async function syncMemory(opts) {
           false
         )
       );
+      opts.summary?.(report.summary("synced", version));
       return 0;
     }
   } catch (e) {
     out(e.message);
+    opts.summary?.({
+      outcome: "failed",
+      reason: failureReason(e),
+      version: 0,
+      pulled: 0,
+      pushed: 0,
+      deleted: 0,
+      conflictCopies: [],
+      waiting: []
+    });
     return 1;
   }
 }
+function firstNames(names) {
+  const shown = names.slice(0, HOOK_WAITING_NAMED).join(", ");
+  const rest = names.length - HOOK_WAITING_NAMED;
+  return rest > 0 ? `${shown} and ${rest} more` : shown;
+}
+function hookLines(ws, project, folder, s) {
+  if (s.outcome !== "synced") {
+    return [`Team memory ${ws}/${project}: not synced (${s.reason ?? "it did not finish"}); the next session tries again.`];
+  }
+  const lines = [`Team memory ${ws}/${project}: version ${s.version}, ${s.pulled} pulled, ${s.pushed} pushed, ${s.deleted} deleted.`];
+  if (s.conflictCopies.length) {
+    lines.push(`  ${plural(s.conflictCopies.length, "conflict copy", "conflict copies")} to tidy in ${folder}: ${s.conflictCopies.join(", ")}`);
+  }
+  if (s.waiting.length) {
+    lines.push(
+      `  ${plural(s.waiting.length, "file waits", "files wait")} for you (${firstNames(s.waiting)}): run \`${SYNC_MEMORY_COMMAND} --project ${project}\` in your terminal.`
+    );
+  }
+  return lines;
+}
+async function appendLog(ws, lines) {
+  const path = syncLogPath(ws);
+  await mkdir2(dirname2(path), { recursive: true });
+  try {
+    if ((await stat(path)).size > HOOK_LOG_MAX_BYTES) await writeFile2(path, "", "utf8");
+  } catch {
+  }
+  await appendFile(path, lines.join("\n") + "\n", "utf8");
+}
+async function takeLock(lock, staleMs, now) {
+  await mkdir2(dirname2(lock), { recursive: true });
+  const body = JSON.stringify({ pid: process.pid, at: now.toISOString() }) + "\n";
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const handle = await open(lock, "wx");
+      try {
+        await handle.writeFile(body, "utf8");
+      } catch (err) {
+        await handle.close();
+        await rm2(lock, { force: true });
+        throw err;
+      }
+      await handle.close();
+      return true;
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+      let seen;
+      try {
+        seen = await stat(lock);
+      } catch {
+        continue;
+      }
+      if (Date.now() - seen.mtimeMs < staleMs || attempt === 1) return false;
+      try {
+        const now2 = await stat(lock);
+        if (now2.ino !== seen.ino || now2.mtimeMs !== seen.mtimeMs) return false;
+      } catch {
+        continue;
+      }
+      await rm2(lock, { force: true });
+    }
+  }
+  return false;
+}
+async function releaseLock(lock) {
+  try {
+    const held = JSON.parse(await readFile2(lock, "utf8"));
+    if (held.pid === process.pid) await rm2(lock, { force: true });
+  } catch {
+  }
+}
+async function runHookSync(workspace, io, env = process.env) {
+  try {
+    return await hookSync(workspace, io, env);
+  } catch (e) {
+    try {
+      io.err(`sync-memory --hook: ${e.message}`);
+    } catch {
+    }
+    return 0;
+  }
+}
+async function hookSync(workspace, io, env) {
+  if (!isWorkspace(workspace)) {
+    io.err(`sync-memory --hook: ${JSON.stringify(workspace)} is not a workspace name`);
+    return 0;
+  }
+  const now = io.now?.() ?? /* @__PURE__ */ new Date();
+  const deadline = (io.startedAt ?? Date.now()) + (io.budgetMs ?? HOOK_BUDGET_MS);
+  let client = io.client;
+  if (!client) {
+    let apiKey;
+    let apiUrl;
+    try {
+      apiKey = await apiKeyFor(workspace, env);
+      apiUrl = apiUrlFrom(env);
+    } catch {
+      return 0;
+    }
+    if (!apiKey) return 0;
+    client = new SystemDoxApiClient({ apiKey, apiUrl, cacheTtlMs: 0, defaultOrg: void 0 });
+  }
+  let projects;
+  try {
+    projects = Object.keys((await readState(workspace)).memory ?? {}).sort();
+  } catch {
+    return 0;
+  }
+  if (!projects.length) return 0;
+  const lock = syncLockPath(workspace);
+  if (!await takeLock(lock, io.lockStaleMs ?? HOOK_LOCK_STALE_MS, now)) {
+    io.out(`Team memory ${workspace}: a sync is already running.`);
+    return 0;
+  }
+  try {
+    for (const project of projects) {
+      const folder = join2(workspaceDir(workspace), "memory", project);
+      const report = [];
+      let summary;
+      const left = deadline - Date.now();
+      if (left > 0) {
+        let timer;
+        const timeout = new Promise((resolveTimeout) => {
+          timer = setTimeout(() => resolveTimeout("timeout"), left);
+        });
+        const run3 = syncMemory({
+          project,
+          dryRun: false,
+          client,
+          workspace,
+          deadline,
+          unattended: true,
+          out: (...lines2) => report.push(...lines2),
+          summary: (s) => summary = s,
+          now: io.now
+        });
+        const won = await Promise.race([run3.then(() => "done"), timeout]);
+        if (timer) clearTimeout(timer);
+        if (won === "timeout") summary = void 0;
+      }
+      const result = summary ?? {
+        outcome: "failed",
+        reason: "took too long",
+        version: 0,
+        pulled: 0,
+        pushed: 0,
+        deleted: 0,
+        conflictCopies: [],
+        waiting: []
+      };
+      const lines = hookLines(workspace, project, folder, result);
+      lines.forEach((l) => io.out(l));
+      try {
+        await appendLog(workspace, [`--- ${now.toISOString()} ${workspace}/${project}`, ...lines, ...report]);
+      } catch (e) {
+        io.err(`sync-memory --hook: the log could not be written: ${e.message}`);
+      }
+    }
+  } finally {
+    await releaseLock(lock);
+  }
+  return 0;
+}
 async function runSyncMemory(argv, io, env = process.env) {
   let args2;
   let client = io.client;
   try {
     args2 = parseSyncMemoryArgs(argv);
+  } catch (e) {
+    if (argv.includes("--hook")) {
+      io.err(`sync-memory --hook: ${e.message.split("\n")[0]}`);
+      return 0;
+    }
+    io.err(e.message);
+    return 1;
+  }
+  if (args2.hook) return runHookSync(args2.hook, io, env);
+  try {
     if (!client) {
       const apiUrl = apiUrlFrom(env);
       const apiKey = await localApiKey(env);
@@ -1327,7 +1601,7 @@ async function runSyncMemory(argv, io, env = process.env) {
   }
   return syncMemory({ ...args2, client, out: (...lines) => lines.forEach((l) => io.out(l)), ask: io.ask, now: io.now });
 }
-var SYNC_MEMORY_USAGE, SYNC_MEMORY_COMMAND, SyncFailed, toPath, Report, ANSWER_WORDS, sameManifest;
+var SYNC_MEMORY_USAGE, HOOK_BUDGET_MS, HOOK_LOCK_STALE_MS, HOOK_LOG_MAX_BYTES, SYNC_MEMORY_COMMAND, SyncFailed, SyncStopped, toPath, LEFT_TEMP_RE, Report, ANSWER_WORDS, sameManifest, plural, HOOK_WAITING_NAMED;
 var init_sync_memory = __esm({
   "src/sync-memory.ts"() {
     "use strict";
@@ -1335,18 +1609,33 @@ var init_sync_memory = __esm({
     init_memory_sync();
     init_person_values();
     init_team_setup_files();
-    SYNC_MEMORY_USAGE = "Usage: systemdox-mcp-server sync-memory [--project <name>] [--dir <folder>] [--import <folder>] [--dry-run]";
+    SYNC_MEMORY_USAGE = "Usage: systemdox-mcp-server sync-memory [--project <name>] [--dir <folder>] [--import <folder>]... [--dry-run]\n       systemdox-mcp-server sync-memory --hook <workspace>";
+    HOOK_BUDGET_MS = 2e4;
+    HOOK_LOCK_STALE_MS = 6e4;
+    HOOK_LOG_MAX_BYTES = 1024 * 1024;
     SYNC_MEMORY_COMMAND = "npx -y @systemdox/mcp-server sync-memory";
     SyncFailed = class extends Error {
     };
+    SyncStopped = class extends Error {
+      constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+      }
+      reason;
+    };
     toPath = (root, rel) => join2(root, ...rel.split("/"));
+    LEFT_TEMP_RE = /\.\d+\.[a-z0-9]+\.tmp$/;
     Report = class {
       pulled = /* @__PURE__ */ new Set();
       pushed = /* @__PURE__ */ new Set();
       deletedHere = /* @__PURE__ */ new Set();
       deletedFromTeam = /* @__PURE__ */ new Set();
       conflicts = [];
+      /** The conflict copies written this run, by name. */
+      copies = /* @__PURE__ */ new Set();
       skipped = /* @__PURE__ */ new Map();
+      /** Skipped files a sync in the member's terminal can send: held for a value, or for the vault. */
+      waiting = /* @__PURE__ */ new Set();
       people = [];
       toAnswer = /* @__PURE__ */ new Map();
       add(plan) {
@@ -1354,12 +1643,32 @@ var init_sync_memory = __esm({
         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 c of plan.conflicts) {
+          this.conflicts.push(`${c.path}: the team's text; yours is beside it as ${c.copy}`);
+          this.copies.add(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);
       }
+      /** Skipped, and waiting for the member at a terminal. */
+      wait(path, reason) {
+        this.skip(path, reason);
+        this.waiting.add(path);
+      }
+      summary(outcome, version, reason) {
+        return {
+          outcome,
+          ...reason ? { reason } : {},
+          version,
+          pulled: this.pulled.size,
+          pushed: this.pushed.size,
+          deleted: this.deletedHere.size + this.deletedFromTeam.size,
+          conflictCopies: [...this.copies].sort(),
+          waiting: [...this.waiting].sort()
+        };
+      }
       lines(summary, dryRun) {
         const out = [summary];
         const section = (title, items) => {
@@ -1398,6 +1707,8 @@ var init_sync_memory = __esm({
       ours: "ours, not a person"
     };
     sameManifest = (a, b) => Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([p, h]) => b[p] === h);
+    plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+    HOOK_WAITING_NAMED = 5;
   }
 });
 
@@ -1407,7 +1718,11 @@ __export(setup_team_exports, {
   HEADERS_HELPER: () => HEADERS_HELPER,
   SETUP_USAGE: () => SETUP_USAGE,
   claudeCodeVersion: () => claudeCodeVersion,
+  claudeMemoryFolder: () => claudeMemoryFolder,
+  countMemoryFiles: () => countMemoryFiles,
+  gitTopFolder: () => gitTopFolder,
   importBlock: () => importBlock,
+  memoryImports: () => memoryImports,
   parseSetupArgs: () => parseSetupArgs,
   runTeamSetup: () => runTeamSetup,
   runTeamSetupCommand: () => runTeamSetupCommand,
@@ -1422,19 +1737,20 @@ import { mkdir as mkdir3, readdir as readdir2, readFile as readFile3, writeFile
 import { dirname as dirname3, join as join3, resolve as resolve2 } from "path";
 import { promisify as promisify2 } from "util";
 function parseSetupArgs(argv) {
-  const args2 = { yes: false, overwrite: false };
+  const args2 = { yes: false, overwrite: false, importDirs: [] };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--yes") args2.yes = true;
     else if (a === "--overwrite") args2.overwrite = true;
-    else if (a === "--project" || a === "--dir") {
+    else if (a === "--project" || a === "--dir" || a === "--import") {
       const value = argv[++i];
       if (!value || value.startsWith("--")) throw new Error(`${a} needs a value
 ${SETUP_USAGE}`);
       if (a === "--project") {
         if (!isWorkspace(value)) throw new Error(`${value} is not a project name (lower case letters, digits and -)`);
         args2.project = value;
-      } else args2.dir = value;
+      } else if (a === "--dir") args2.dir = value;
+      else args2.importDirs.push(value);
     } else throw new Error(`Unexpected argument ${a}
 ${SETUP_USAGE}`);
   }
@@ -1452,6 +1768,60 @@ async function claudeCodeVersion() {
     return void 0;
   }
 }
+async function gitTopFolder(dir) {
+  try {
+    const { stdout } = await run2("git", ["-C", dir, "rev-parse", "--show-toplevel"], { timeout: 1e4, windowsHide: true });
+    const top = stdout.trim();
+    return top ? resolve2(top) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function claudeMemoryFolder(path) {
+  return join3(homeDir(), ".claude", "projects", path.replace(/[^A-Za-z0-9]/g, "-"), "memory");
+}
+async function countMemoryFiles(folder) {
+  let count = 0;
+  async function walk2(dir, prefix) {
+    let entries2;
+    try {
+      entries2 = await readdir2(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries2) {
+      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() && e.name.endsWith(".md")) {
+        try {
+          if (isShareable(rel, await readFile3(join3(dir, e.name), "utf8"))) count++;
+        } catch {
+        }
+      }
+    }
+  }
+  await walk2(folder, "");
+  return count;
+}
+async function memoryImports(checkout, teamFolder, named, gitTop = gitTopFolder) {
+  const candidates = [resolve2(checkout)];
+  const top = await gitTop(checkout);
+  if (top && !candidates.includes(top)) candidates.push(top);
+  const out = [];
+  for (const path of candidates) {
+    const folder = claudeMemoryFolder(path);
+    if (resolve2(folder) === resolve2(teamFolder)) continue;
+    const files = await countMemoryFiles(folder);
+    if (files) out.push({ folder, files, named: false });
+  }
+  for (const dir of named) {
+    const folder = resolve2(dir);
+    if (out.some((i) => i.folder === folder)) continue;
+    out.push({ folder, files: await countMemoryFiles(folder), named: true });
+  }
+  return out;
+}
 function parseVersion(text3) {
   const m = text3?.match(/(\d+)\.(\d+)\.(\d+)/);
   return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : void 0;
@@ -1493,9 +1863,9 @@ function skipValue(t, i) {
   while (i < t.length && !/[\s,}\]]/.test(t[i])) i++;
   return i;
 }
-function objectMembers(t, open) {
+function objectMembers(t, open2) {
   const members = [];
-  let i = skipSpace(t, open + 1);
+  let i = skipSpace(t, open2 + 1);
   if (t[i] === "}") return { members, close: i };
   for (; ; ) {
     i = skipSpace(t, i);
@@ -1522,13 +1892,13 @@ function setJsonMember(text3, keys, value) {
   const eol = text3.includes("\r\n") ? "\r\n" : "\n";
   const render = (v, indent) => compact ? JSON.stringify(v) : JSON.stringify(v, null, unit).split("\n").join(eol + indent);
   const nest = (from) => keys.slice(from).reduceRight((acc, k) => ({ [k]: acc }), value);
-  let open = skipSpace(text3, 0);
+  let open2 = skipSpace(text3, 0);
   for (let k = 0; k < keys.length; k++) {
-    const { members, close } = objectMembers(text3, open);
+    const { members, close } = objectMembers(text3, open2);
     const found = members.filter((m) => m.key === keys[k]).at(-1);
     if (found) {
       if (k < keys.length - 1 && text3[found.valueStart] === "{") {
-        open = found.valueStart;
+        open2 = found.valueStart;
         continue;
       }
       return text3.slice(0, found.valueStart) + render(nest(k + 1), lineIndent(text3, found.keyStart)) + text3.slice(found.valueEnd);
@@ -1537,16 +1907,16 @@ function setJsonMember(text3, keys, value) {
     if (compact) {
       const member = `${name}:${render(nest(k + 1), "")}`;
       if (members.length) return text3.slice(0, members.at(-1).valueEnd) + "," + member + text3.slice(members.at(-1).valueEnd);
-      return text3.slice(0, open + 1) + member + text3.slice(close);
+      return text3.slice(0, open2 + 1) + member + text3.slice(close);
     }
     if (members.length) {
       const last = members.at(-1);
       const indent2 = lineIndent(text3, last.keyStart);
       return text3.slice(0, last.valueEnd) + `,${eol}${indent2}${name}: ${render(nest(k + 1), indent2)}` + text3.slice(last.valueEnd);
     }
-    const outer = lineIndent(text3, open);
+    const outer = lineIndent(text3, open2);
     const indent = outer + unit;
-    return text3.slice(0, open + 1) + `${eol}${indent}${name}: ${render(nest(k + 1), indent)}${eol}${outer}` + text3.slice(close);
+    return text3.slice(0, open2 + 1) + `${eol}${indent}${name}: ${render(nest(k + 1), indent)}${eol}${outer}` + text3.slice(close);
   }
   return text3;
 }
@@ -1592,9 +1962,9 @@ function importBlock(workspace, eol = "\n") {
 function withImportBlock(text3, workspace) {
   const eol = text3.includes("\r\n") ? "\r\n" : "\n";
   const block = importBlock(workspace, eol);
-  const open = `<!-- systemdox:${workspace} -->`;
+  const open2 = `<!-- systemdox:${workspace} -->`;
   const close = `<!-- /systemdox:${workspace} -->`;
-  const start = text3.indexOf(open);
+  const start = text3.indexOf(open2);
   const end = start >= 0 ? text3.indexOf(close, start) : -1;
   if (start >= 0 && end >= 0) return text3.slice(0, start) + block + text3.slice(end + close.length);
   if (!text3) return block + eol;
@@ -1657,12 +2027,12 @@ async function runTeamSetup(opts) {
     const plugin = own.plugin;
     let previousPlugin;
     if (plugin) {
-      const hooks = hookLines(plugin);
+      const hooks = hookLines2(plugin);
       const hooksName = `the hook commands of ${ws}-setup`;
       const hooksItem = item(hooksName, hooks);
       if (update && hooks.length && !accepted.has(hooksItem.sha256)) {
         const versions = (await client.getPlugin(ws)).versions.filter((v) => v.version !== plugin.version);
-        previousPlugin = versions.sort((a, b) => b.version - a.version).find((v) => accepted.has(item(hooksName, hookLines(v)).sha256));
+        previousPlugin = versions.sort((a, b) => b.version - a.version).find((v) => accepted.has(item(hooksName, hookLines2(v)).sha256));
       }
       items.push(item(`the plugin ${ws}-setup, version ${plugin.version}`, [`${ws}-setup, version ${plugin.version}`]));
       if (hooks.length) {
@@ -1670,7 +2040,7 @@ async function runTeamSetup(opts) {
           item(
             hooksName,
             hooks,
-            previousPlugin ? lineDiff(hookLines(previousPlugin).join("\n"), hooks.join("\n")) : void 0
+            previousPlugin ? lineDiff(hookLines2(previousPlugin).join("\n"), hooks.join("\n")) : void 0
           )
         );
       }
@@ -1710,6 +2080,15 @@ async function runTeamSetup(opts) {
       }
       items.push(item(`autoMemoryDirectory in ${localSettings}`, [memoryFolder]));
     }
+    const imports = project && memoryFolder && !state.memory?.[project] ? await memoryImports(checkout, memoryFolder, opts.importDirs ?? [], opts.gitTop) : [];
+    for (const i of imports) {
+      items.push(
+        item(
+          `${i.named ? "the folder --import names" : "the memories Claude Code kept for this checkout"}, imported into ${project} on its first sync`,
+          [`${i.folder}: ${i.files} file${i.files === 1 ? "" : "s"} to share`]
+        )
+      );
+    }
     const pending = items.filter((i) => !accepted.has(i.sha256));
     if (pending.length) {
       if (!canAsk) {
@@ -1779,6 +2158,7 @@ async function runTeamSetup(opts) {
       const code = await syncMemory({
         project,
         dryRun: false,
+        importDirs: imports.map((i) => i.folder),
         client,
         out: (...lines) => lines.forEach((l) => out(l)),
         ask: opts.terminal ? opts.ask : void 0,
@@ -1819,7 +2199,7 @@ async function runTeamSetupCommand(args2, key, io) {
   const client = new SystemDoxApiClient({ apiKey: key.apiKey, apiUrl: key.apiUrl, cacheTtlMs: 0, defaultOrg: void 0 });
   return runTeamSetup({ ...args2, client, apiKey: key.apiKey, keySource: "prompt", ...io });
 }
-var SETUP_USAGE, HEADERS_HELPER, SetupFailed, sha2562, run2, item, hookLines, mcpLines;
+var SETUP_USAGE, HEADERS_HELPER, SetupFailed, sha2562, run2, item, hookLines2, mcpLines;
 var init_setup_team = __esm({
   "src/setup-team.ts"() {
     "use strict";
@@ -1827,7 +2207,7 @@ var init_setup_team = __esm({
     init_memory_sync();
     init_team_setup_files();
     init_sync_memory();
-    SETUP_USAGE = "Usage: systemdox-mcp-server setup [--project <name>] [--dir <checkout>] [--yes] [--overwrite]";
+    SETUP_USAGE = "Usage: systemdox-mcp-server setup [--project <name>] [--dir <checkout>] [--import <folder>]... [--yes] [--overwrite]";
     HEADERS_HELPER = "npx -y @systemdox/mcp-server marketplace-auth";
     SetupFailed = class extends Error {
     };
@@ -1839,7 +2219,7 @@ var init_setup_team = __esm({
       sha256: sha2562(`${name}
 ${lines.join("\n")}`)
     });
-    hookLines = (p) => p.hookCommands ?? [];
+    hookLines2 = (p) => p.hookCommands ?? [];
     mcpLines = (p) => (p.mcpServers ?? []).map((s) => `${s.name}: ${s.url ?? [s.command, ...s.args ?? []].filter(Boolean).join(" ")}`);
   }
 });
@@ -2326,7 +2706,7 @@ __export(plugin_path_exports, {
 });
 import { createHash as createHash4, randomBytes } from "crypto";
 import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir6, rename as rename2, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir6, rename as rename3, writeFile as writeFile5 } from "fs/promises";
 import { dirname as dirname5, join as join6, resolve as resolve5, sep as sep2 } from "path";
 import { inflateRawSync } from "zlib";
 function parsePluginPathArgs(argv) {
@@ -2494,7 +2874,7 @@ async function runPluginPath(argv, io) {
     } else {
       if (existsSync5(folder)) await removeFolder(folder);
       try {
-        await rename2(tmp, folder);
+        await rename3(tmp, folder);
       } catch (e) {
         if (!existsSync5(folder)) throw e;
         await removeFolder(tmp);
@@ -3315,8 +3695,8 @@ function registerGetPlanBoard(server, apiClient2) {
             ]
           };
         }
-        const open = boards.filter((b) => !b.closed);
-        if (open.length === 0) {
+        const open2 = boards.filter((b) => !b.closed);
+        if (open2.length === 0) {
           return {
             content: [
               {
@@ -3326,16 +3706,16 @@ function registerGetPlanBoard(server, apiClient2) {
             ]
           };
         }
-        const closedNote = boards.length > open.length ? `
+        const closedNote = boards.length > open2.length ? `
 
-_${boards.length - open.length} closed board(s) not listed._` : "";
+_${boards.length - open2.length} closed board(s) not listed._` : "";
         return {
           content: [
             {
               type: "text",
-              text: `${open.length} open project board(s):
+              text: `${open2.length} open project board(s):
 
-${formatBoards(open)}` + closedNote + `
+${formatBoards(open2)}` + closedNote + `
 
 Call get_plan_board with project_number to list a board's issues.`
             }
@@ -5295,7 +5675,9 @@ function registerTeamSetupTools(server, apiClient2, { localFiles }) {
         project: args2.project,
         dryRun: !!args2.dryRun,
         client: apiClient2,
-        out: (...l) => lines.push(...l)
+        out: (...l) => lines.push(...l),
+        // Nobody is at a terminal: a project the team no longer serves is left as it is.
+        unattended: true
       });
       return { ...text2(lines.join("\n")), ...code ? { isError: true } : {} };
     }
@@ -5383,7 +5765,7 @@ var init_server = __esm({
     init_create_prompt_template();
     init_skills2();
     init_team_setup();
-    SERVER_VERSION = true ? "0.1.57" : "0.0.0-dev";
+    SERVER_VERSION = true ? "0.1.59" : "0.0.0-dev";
     READ_TOOLS = [
       "get_context",
       "get_checks",
@@ -5512,21 +5894,26 @@ if (command === "setup") {
     ({ runPluginPath: runPluginPath2 }) => runPluginPath2(args.slice(1), { out: console.log, err: console.error })
   ).then((code) => process.exit(code));
 } else if (command === "sync-memory") {
-  const terminal = !!process.stdin.isTTY && !!process.stdout.isTTY;
+  const hook = args.includes("--hook");
+  const terminal = !hook && !!process.stdin.isTTY && !!process.stdout.isTTY;
   Promise.resolve().then(() => (init_sync_memory(), sync_memory_exports)).then(
     ({ runSyncMemory: runSyncMemory2 }) => runSyncMemory2(args.slice(1), {
       out: console.log,
       err: console.error,
-      ask: terminal ? (question) => prompt(question) : void 0
+      ask: terminal ? (question) => prompt(question) : void 0,
+      startedAt: performance.timeOrigin
     })
-  ).then((code) => process.exit(code));
+  ).then((code) => process.exit(code)).catch((err) => {
+    console.error(`  Error: ${err.message}`);
+    process.exit(hook ? 0 : 1);
+  });
 } else if (command === "--help" || command === "-h") {
   console.log(`
   SystemDox MCP Server
 
   Usage:
     systemdox-mcp-server          Start the MCP server (stdio transport)
-    systemdox-mcp-server setup [--project <name>] [--dir <checkout>] [--yes] [--overwrite]
+    systemdox-mcp-server setup [--project <name>] [--dir <checkout>] [--import <folder>]... [--yes] [--overwrite]
                                   Configure the MCP server in your AI coding tool,
                                   then your team's setup: the team instructions,
                                   the plugin's marketplace and the project's team
@@ -5543,10 +5930,15 @@ if (command === "setup") {
                                   Print the header for your team's marketplace
                                   (Claude Code runs it)
     systemdox-mcp-server sync-memory [--project <name>] [--dir <folder>]
-                                  [--import <folder>] [--dry-run]
+                                  [--import <folder>]... [--dry-run]
                                   Sync a project's team memory with SystemDox
                                   (default folder:
                                   ~/.claude/systemdox/<workspace>/memory/<project>)
+    systemdox-mcp-server sync-memory --hook <workspace>
+                                  The run the team plugin makes at the start and
+                                  the end of a session: the memories this computer
+                                  synced before, one line each, never a question,
+                                  never a held-up session (Claude Code runs it)
     systemdox-mcp-server --help   Show this help message
 
   Environment variables: