@systemdox/mcp-server 0.1.57 → 0.1.59

package/dist/server.js

@@ -604,8 +604,8 @@ function registerGetPlanBoard(server, apiClient) {
             ]
           };
         }
-        const open = boards.filter((b) => !b.closed);
-        if (open.length === 0) {
+        const open2 = boards.filter((b) => !b.closed);
+        if (open2.length === 0) {
           return {
             content: [
               {
@@ -615,16 +615,16 @@ function registerGetPlanBoard(server, apiClient) {
             ]
           };
         }
-        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.`
             }
@@ -2707,7 +2707,7 @@ var PERSON_ID_RE = new RegExp(`^${PERSON_ID}$`);
 
 // src/sync-memory.ts
 import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir3, readdir as readdir2, readFile as readFile4, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { appendFile, mkdir as mkdir3, open, readdir as readdir2, readFile as readFile4, rename as rename2, rm as rm3, stat, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
 
 // src/lib/memory-sync.ts
@@ -2731,15 +2731,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) {
@@ -2980,18 +3006,50 @@ function lineDiff(before, after) {
 }
 
 // src/sync-memory.ts
+var HOOK_LOG_MAX_BYTES = 1024 * 1024;
 var SYNC_MEMORY_COMMAND = "npx -y @systemdox/mcp-server sync-memory";
 var SyncFailed = class extends Error {
 };
+var SyncStopped = class extends Error {
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+  }
+  reason;
+};
+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 mkdir3(dirname3(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    await writeFile3(tmp, text3, "utf8");
+    await rename2(tmp, path);
+  } catch (e) {
+    await rm3(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 };
 }
 var toPath = (root, rel) => join4(root, ...rel.split("/"));
+var LEFT_TEMP_RE = /\.\d+\.[a-z0-9]+\.tmp$/;
 async function readFolder(root) {
   const files = {};
   const names = /* @__PURE__ */ new Set();
+  const temps = [];
   async function walk2(dir, prefix) {
     for (const e of await readdir2(dir, { withFileTypes: true })) {
       if (e.name.startsWith(".")) continue;
@@ -2999,12 +3057,13 @@ async function readFolder(root) {
       if (e.isDirectory()) await walk2(join4(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 readFile4(join4(dir, e.name), "utf8");
       }
     }
   }
   if (existsSync3(root)) await walk2(root, "");
-  return { files, names };
+  return { files, names, temps };
 }
 async function pullTeam(client, ws, project) {
   try {
@@ -3053,7 +3112,11 @@ var Report = class {
   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) {
@@ -3061,12 +3124,32 @@ var Report = class {
     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) => {
@@ -3169,7 +3252,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 writeFile3(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 });
@@ -3272,7 +3355,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 writeFile3(toPath(opts.dir, path), rewritten[path], "utf8");
+        await writeWhole(toPath(opts.dir, path), rewritten[path]);
         current[path] = rewritten[path];
       }
     }
@@ -3287,11 +3370,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) {
@@ -3302,12 +3385,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 rm3(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 mkdir3(dirname3(full), { recursive: true });
-    await writeFile3(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 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);
@@ -3352,8 +3434,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(
@@ -3367,6 +3460,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 = {};
@@ -3379,14 +3478,16 @@ async function syncMemory(opts) {
       } else shared[path] = text3;
     }
     const importWrites = {};
-    if (opts.importDir) {
-      const other = await readFolder(resolve3(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(resolve3(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) {
@@ -3394,16 +3495,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 mkdir3(dirname3(full), { recursive: true });
-          await writeFile3(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(run2, ws, shared, report, hint);
     for (const path of found.leftOut) {
@@ -3428,12 +3527,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) {
@@ -3445,6 +3548,7 @@ async function syncMemory(opts) {
                 false
               )
             );
+            opts.summary?.(report.summary("moved-on", team.version, "moved on twice"));
             return 2;
           }
           base = team;
@@ -3469,10 +3573,21 @@ 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;
   }
 }
@@ -3644,7 +3759,9 @@ function registerTeamSetupTools(server, apiClient, { localFiles }) {
         project: args.project,
         dryRun: !!args.dryRun,
         client: apiClient,
-        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 } : {} };
     }
@@ -3652,7 +3769,7 @@ function registerTeamSetupTools(server, apiClient, { localFiles }) {
 }
 
 // src/server.ts
-var SERVER_VERSION = true ? "0.1.57" : "0.0.0-dev";
+var SERVER_VERSION = true ? "0.1.59" : "0.0.0-dev";
 var READ_TOOLS = [
   "get_context",
   "get_checks",

package/dist/setup-mcp.js

@@ -359,8 +359,9 @@ var KEY_PREFIX = `(?<!${W})(?:pweb_[a-z]+_key_|sk-ant-|sk_live_|rk_live_|github_
 
 // src/sync-memory.ts
 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";
+var HOOK_LOG_MAX_BYTES = 1024 * 1024;
 
 // src/setup-team.ts
 var SetupFailed = class extends Error {
@@ -399,9 +400,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);
@@ -428,13 +429,13 @@ function setJsonMember(text, keys, value) {
   const eol = text.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(text, 0);
+  let open2 = skipSpace(text, 0);
   for (let k = 0; k < keys.length; k++) {
-    const { members, close } = objectMembers(text, open);
+    const { members, close } = objectMembers(text, open2);
     const found = members.filter((m) => m.key === keys[k]).at(-1);
     if (found) {
       if (k < keys.length - 1 && text[found.valueStart] === "{") {
-        open = found.valueStart;
+        open2 = found.valueStart;
         continue;
       }
       return text.slice(0, found.valueStart) + render(nest(k + 1), lineIndent(text, found.keyStart)) + text.slice(found.valueEnd);
@@ -443,16 +444,16 @@ function setJsonMember(text, keys, value) {
     if (compact) {
       const member = `${name}:${render(nest(k + 1), "")}`;
       if (members.length) return text.slice(0, members.at(-1).valueEnd) + "," + member + text.slice(members.at(-1).valueEnd);
-      return text.slice(0, open + 1) + member + text.slice(close);
+      return text.slice(0, open2 + 1) + member + text.slice(close);
     }
     if (members.length) {
       const last = members.at(-1);
       const indent2 = lineIndent(text, last.keyStart);
       return text.slice(0, last.valueEnd) + `,${eol}${indent2}${name}: ${render(nest(k + 1), indent2)}` + text.slice(last.valueEnd);
     }
-    const outer = lineIndent(text, open);
+    const outer = lineIndent(text, open2);
     const indent = outer + unit;
-    return text.slice(0, open + 1) + `${eol}${indent}${name}: ${render(nest(k + 1), indent)}${eol}${outer}` + text.slice(close);
+    return text.slice(0, open2 + 1) + `${eol}${indent}${name}: ${render(nest(k + 1), indent)}${eol}${outer}` + text.slice(close);
   }
   return text;
 }

package/dist/setup-team.d.ts

@@ -1,8 +1,8 @@
 /**
  * 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").
+ * [--dir <checkout>] [--import <folder>]... [--yes] [--overwrite]` runs after
+ * it has written the MCP server into an AI tool's config (ADR-217 with
+ * Amendments 1 to 3, 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).
@@ -13,7 +13,12 @@
  *    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.
+ *    <checkout>/.claude/settings.local.json, then its sync. On the project's
+ *    first sync on this computer, the sync imports the memory Claude Code kept
+ *    for the checkout (`~/.claude/projects/<slug>/memory/`, for the checkout's
+ *    path and, inside a Git repository, the repository's top folder) and each
+ *    folder `--import` names, every one shown with its file count first
+ *    (Amendment 3).
  * 4. Finish: the two steps a person must take in Claude Code.
  *
  * It never runs `claude plugin marketplace add` and never sets
@@ -26,11 +31,13 @@
  */
 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 SETUP_USAGE = "Usage: systemdox-mcp-server setup [--project <name>] [--dir <checkout>] [--import <folder>]... [--yes] [--overwrite]";
 export declare const HEADERS_HELPER = "npx -y @systemdox/mcp-server marketplace-auth";
 export interface TeamSetupArgs {
     project?: string;
     dir?: string;
+    /** Folders to import on the project's first sync on this computer (`--import`, repeatable). */
+    importDirs?: string[];
     yes: boolean;
     overwrite: boolean;
 }
@@ -49,12 +56,38 @@ export interface TeamSetupOptions extends TeamSetupArgs {
     cwd?: string;
     /** `claude --version`'s output, or undefined when Claude Code is not found. */
     claudeVersion?: () => Promise<string | undefined>;
+    /** The top folder of the Git repository holding `dir`, or undefined outside one. */
+    gitTop?: (dir: string) => 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>;
+/** The top folder of the Git repository holding `dir`, or undefined outside one. */
+export declare function gitTopFolder(dir: string): Promise<string | undefined>;
+/** `~/.claude/projects/<slug>/memory/` for an absolute path: Claude Code's slug
+ * replaces every character that is not a letter or a digit with `-`
+ * (`/home/jo/git` → `-home-jo-git`; `C:\Users\jo\git` → `C--Users-jo-git`). */
+export declare function claudeMemoryFolder(path: string): string;
+/** How many files of a folder a sync would share (hidden entries left out):
+ * the `feedback`, `project` and `reference` memories and `MEMORY.md`. A `user`
+ * memory, a `share: false` file and a conflict copy stay where they are, so
+ * they are not counted. 0 when the folder is missing. */
+export declare function countMemoryFiles(folder: string): Promise<number>;
+export interface MemoryImport {
+    folder: string;
+    files: number;
+    /** Named by `--import`, as opposed to found for the checkout. */
+    named: boolean;
+}
+/**
+ * The folders a project's first sync imports (contract.md "setup", step 3.5):
+ * the memory Claude Code kept for the checkout's own path and, inside a Git
+ * repository, for the repository's top folder, each when it holds a file and
+ * is not the team folder itself; then each folder `--import` names.
+ */
+export declare function memoryImports(checkout: string, teamFolder: string, named: string[], gitTop?: (dir: string) => Promise<string | undefined>): Promise<MemoryImport[]>;
 /**
  * `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