quilltap 4.10.0-dev.18 → 4.10.0-dev.183

package/lib/recall-replay-command.js

@@ -1,11 +1,17 @@
 'use strict';
 
+const { resolveServerPort } = require('./lock-helpers');
+
 /**
  * `quilltap recall-replay <chatId>` — replay a turn's memory recall against
  * the running server and print the candidate table, old path (episodic
  * signals inert) vs. new path (retrospective flip + time window + entity
  * anchors + multi-probe) side by side.
  *
+ * Then the text fallback's table and the stage trace (query, gather, hydrate,
+ * score, select, assemble): what the archive removed, what the budget cut, what
+ * the inter-character section took.
+ *
  * Thin wrapper over POST /api/v1/chats/<chatId>?action=recall-replay.
  * Read-only; nothing is persisted server-side.
  */
@@ -28,25 +34,62 @@ Replays the per-turn memory recall for a chat turn against the running
 Quilltap server and prints the full candidate table twice — the pre-overhaul
 ranking and the episodic (retrospective/time-window/entity) ranking — so the
 recall constants can be tuned against real "the character forgot" turns.
+After them: what the text fallback would have returned, and the stage trace
+(query → gather → hydrate → score → select → assemble). The anti-repetition
+ring is the one in force at that turn, read from the chat's recall records.
 
 Options:
+  -d, --data-dir <path>      Instance root; used to find the server's port
+  -i, --instance <name>      Registered instance whose server to call (see 'quilltap instances')
+      --passphrase <pass>    Accepted and ignored (this tool never opens the database)
       --turn <number>        1-based interchange to replay at (default: last)
       --char <characterId>   Character whose memories are searched
                              (default: first LLM-controlled participant)
-      --limit <number>       Candidate rows per path (default: 25, max: 100)
-      --port <number>        Server port for API calls (default: 3000)
+      --limit <number>       Candidate rows per path (default: the larger of 25
+                             and the new path's head size + 10; max: 100)
+      --memory-budget <tokens>
+                             Memory token budget (positive integer). The new
+                             path's selected rows then follow the budget-sized
+                             dynamic head (the head scales with the model's
+                             memory budget); the old path keeps the historical
+                             fixed 5-entry head.
+      --tuning '<json>'      Retuning constants for the NEW path only, e.g.
+                             '{"boostGateAbs":0.45,"boostGateMargin":0.15,
+                             "boostGateRamp":0.1,"boostCap":1.6}'. Keys:
+                             boostGateAbs, boostGateMargin, boostGateRamp,
+                             boostCap, freshBypassesGate, windowBypassesGate,
+                             multipliers
+                             {RECALL_MULTIPLIERS key:
+                             value}, specificAnchors, anchorMinHits,
+                             anchorOrder, backgroundReserve.
+                             Unknown keys are rejected.
+      --tuning-file <path>   Read the --tuning JSON from a file
+      --signals-from <path>  Reuse the signals saved in a previous --json
+                             replay of the same chat and turn, instead of a
+                             fresh (non-deterministic) distillation
+      --as-of                Search only memories created before the turn's
+                             opening message (the corpus as it stood then)
+      --port <number>        Server port for API calls. Default: the port recorded in the
+                             --instance/--data-dir server's lock file, else 3000
       --json                 Print the raw JSON result instead of tables
   -h, --help                 Show this help
 
 Examples:
   quilltap recall-replay <chatId>
   quilltap recall-replay <chatId> --turn 42
+  quilltap recall-replay <chatId> --turn 42 --memory-budget 4000
   quilltap recall-replay <chatId> --turn 42 --json > replay.json
+  quilltap recall-replay <chatId> --turn 42 --signals-from replay.json --as-of \
+    --tuning-file tuning-r1.json
 `);
 }
 
 function parseFlags(args) {
-  const flags = { turn: undefined, char: undefined, limit: undefined, port: 3000, json: false, help: false };
+  const flags = {
+    turn: undefined, char: undefined, limit: undefined, memoryBudget: undefined,
+    tuning: undefined, tuningFile: undefined, signalsFrom: undefined, asOf: false,
+    port: undefined, dataDir: '', instance: '', json: false, help: false,
+  };
   const positional = [];
   let i = 0;
   while (i < args.length) {
@@ -73,6 +116,40 @@ function parseFlags(args) {
         flags.limit = n;
         break;
       }
+      case '--memory-budget': {
+        const n = Number(args[++i]);
+        if (!Number.isInteger(n) || n < 1) {
+          console.error('Error: --memory-budget must be a positive integer');
+          process.exit(1);
+        }
+        flags.memoryBudget = n;
+        break;
+      }
+      case '--tuning':
+        flags.tuning = args[++i];
+        break;
+      case '--tuning-file':
+        flags.tuningFile = args[++i];
+        break;
+      case '--signals-from':
+        flags.signalsFrom = args[++i];
+        break;
+      case '--as-of':
+        flags.asOf = true;
+        break;
+      case '-d':
+      case '--data-dir':
+        flags.dataDir = args[++i];
+        break;
+      case '-i':
+      case '--instance':
+        flags.instance = args[++i];
+        break;
+      case '--passphrase':
+        // Accepted so universal flags never error; these tools talk to the
+        // running server and never open the database themselves.
+        i++;
+        break;
       case '--port': {
         const p = parseInt(args[++i], 10);
         if (isNaN(p) || p < 1 || p > 65535) {
@@ -106,8 +183,9 @@ function fmt(n, digits = 3) {
   return n.toFixed(digits);
 }
 
-function printPath(label, rows) {
-  console.log(`\n${BOLD}${label}${RESET} (${rows.length} candidates)`);
+function printPath(label, rows, headSize) {
+  const head = typeof headSize === 'number' ? `, head ${headSize}` : '';
+  console.log(`\n${BOLD}${label}${RESET} (${rows.length} candidates${head})`);
   if (rows.length === 0) {
     console.log(`  ${DIM}(none)${RESET}`);
     return;
@@ -127,6 +205,73 @@ function printPath(label, rows) {
   }
 }
 
+/** The stage trace: one line per stage entry (query → gather → … → assemble). */
+function printTrace(trace) {
+  if (!Array.isArray(trace) || trace.length === 0) return;
+  console.log(`\n${BOLD}STAGE TRACE${RESET}`);
+  for (const entry of trace) {
+    const label = entry.label ? `${DIM}(${entry.label})${RESET} ` : '';
+    const detail = Object.entries(entry.detail || {})
+      .map(([k, v]) => `${k}=${typeof v === 'object' && v !== null ? JSON.stringify(v) : v}`)
+      .join(' ');
+    console.log(`  ${CYAN}${String(entry.stage).padEnd(9)}${RESET}${label}${detail}`);
+  }
+}
+
+function readJson(text, what) {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    console.error(`${RED}Could not parse ${what} as JSON: ${err.message}${RESET}`);
+    process.exit(1);
+  }
+}
+
+function readJsonFile(path, what) {
+  const fs = require('fs');
+  let text;
+  try {
+    text = fs.readFileSync(path, 'utf8');
+  } catch (err) {
+    console.error(`${RED}Could not read ${what} ${path}: ${err.message}${RESET}`);
+    process.exit(1);
+  }
+  return readJson(text, `${what} ${path}`);
+}
+
+/** The tuning object from --tuning or --tuning-file (never both). */
+function loadTuning(flags) {
+  if (flags.tuning !== undefined && flags.tuningFile !== undefined) {
+    console.error('Error: pass --tuning or --tuning-file, not both');
+    process.exit(1);
+  }
+  if (flags.tuning !== undefined) return readJson(flags.tuning, '--tuning');
+  if (flags.tuningFile !== undefined) return readJsonFile(flags.tuningFile, '--tuning-file');
+  return undefined;
+}
+
+/**
+ * The signals saved in a previous --json replay. Refuses a file from another
+ * chat or turn — reusing its signals would replay a different question.
+ */
+function loadSignals(path, chatId, turn) {
+  const saved = readJsonFile(path, '--signals-from');
+  const result = saved.data ?? saved;
+  if (!result.signals) {
+    console.error(`${RED}${path} has no saved signals (its distillation failed); replay without --signals-from${RESET}`);
+    process.exit(1);
+  }
+  if (result.chatId && result.chatId !== chatId) {
+    console.error(`${RED}${path} is a replay of chat ${result.chatId}, not ${chatId}${RESET}`);
+    process.exit(1);
+  }
+  if (turn !== undefined && result.turnIndex !== undefined && result.turnIndex !== turn) {
+    console.error(`${RED}${path} is a replay of turn ${result.turnIndex}, not ${turn}${RESET}`);
+    process.exit(1);
+  }
+  return result.signals;
+}
+
 async function recallReplayCommand(args) {
   const { flags, positional } = parseFlags(args);
 
@@ -140,11 +285,26 @@ async function recallReplayCommand(args) {
   }
   const chatId = positional[0];
 
-  const url = `http://localhost:${flags.port}/api/v1/chats/${encodeURIComponent(chatId)}?action=recall-replay`;
+  let target;
+  try {
+    target = resolveServerPort({ port: flags.port, instance: flags.instance, dataDir: flags.dataDir });
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+  const port = target.port;
+  if (target.note) process.stderr.write(`${DIM}${target.note}${RESET}\n`);
+
+  const url = `http://localhost:${port}/api/v1/chats/${encodeURIComponent(chatId)}?action=recall-replay`;
   const body = {};
   if (flags.turn !== undefined) body.turnIndex = flags.turn;
   if (flags.char) body.characterId = flags.char;
   if (flags.limit !== undefined) body.limit = flags.limit;
+  if (flags.memoryBudget !== undefined) body.memoryBudget = flags.memoryBudget;
+  const tuning = loadTuning(flags);
+  if (tuning !== undefined) body.tuning = tuning;
+  if (flags.signalsFrom !== undefined) body.signals = loadSignals(flags.signalsFrom, chatId, flags.turn);
+  if (flags.asOf) body.asOf = true;
 
   process.stderr.write(`${BOLD}Replaying recall${RESET} for chat ${DIM}${chatId}${RESET} via ${DIM}${url}${RESET}\n`);
 
@@ -156,8 +316,8 @@ async function recallReplayCommand(args) {
       body: JSON.stringify(body),
     });
   } catch (err) {
-    console.error(`${RED}Could not reach Quilltap server at http://localhost:${flags.port}: ${err.message}${RESET}`);
-    console.error('Start the server (npm run dev) or pass --port to match a non-default port.');
+    console.error(`${RED}Could not reach Quilltap server at http://localhost:${port}: ${err.message}${RESET}`);
+    console.error(target.hint);
     process.exit(1);
   }
 
@@ -170,6 +330,11 @@ async function recallReplayCommand(args) {
   }
   if (!res.ok || payload?.success === false) {
     console.error(`${RED}Replay failed (status ${res.status}): ${payload?.error || payload?.message || 'unknown error'}${RESET}`);
+    if (Array.isArray(payload?.details)) {
+      for (const issue of payload.details) {
+        console.error(`  ${(issue.path || []).join('.') || '(body)'}: ${issue.message}`);
+      }
+    }
     process.exit(1);
   }
 
@@ -193,9 +358,26 @@ async function recallReplayCommand(args) {
     console.log(`${BOLD}Signals${RESET}   ${YELLOW}distillation failed — new path ran inert${RESET}`);
   }
 
-  printPath('OLD PATH (episodic signals inert)', result.oldPath || []);
-  printPath('NEW PATH (retrospective/window/entities live)', result.newPath || []);
+  const pinned = result.signalsPinned ? `${CYAN}pinned${RESET}` : `${DIM}fresh distillation${RESET}`;
+  const asOf = result.asOf
+    ? `${CYAN}as of ${result.asOf}${RESET} ${DIM}(${result.excludedAfterAsOf} later memories left out)${RESET}`
+    : `${DIM}whole corpus${RESET}`;
+  console.log(`${BOLD}Harness${RESET}   signals ${pinned} · ${asOf}`);
+  console.log(`${BOLD}Tuning${RESET}    ${result.tuning === 'defaults' || !result.tuning ? `${DIM}defaults${RESET}` : `${YELLOW}${result.tuning}${RESET}`} ${DIM}(new path only)${RESET}`);
+  if (result.ringSource) {
+    const source = result.ringSource === 'debug-log'
+      ? `${DIM}as of the turn, from its recall records${RESET}`
+      : `${YELLOW}the chat's current ring (no recall records that early)${RESET}`;
+    console.log(`${BOLD}Ring${RESET}      ${(result.ring || []).length} recently whispered · ${source}`);
+  }
+
+  printPath('OLD PATH (episodic signals inert)', result.oldPath || [], result.oldHeadSize);
+  printPath('NEW PATH (retrospective/window/entities live)', result.newPath || [], result.newHeadSize);
+  if (Array.isArray(result.fallbackPath)) {
+    printPath('TEXT FALLBACK (what the new path returns with no usable vector)', result.fallbackPath, result.newHeadSize);
+  }
+  printTrace(result.trace);
   console.log('');
 }
 
-module.exports = { recallReplayCommand };
+module.exports = { recallReplayCommand, parseFlags };

package/lib/sync-command.js

@@ -0,0 +1,323 @@
+'use strict';
+
+/**
+ * `quilltap sync <store> <path>` — keep a database-backed document store and a
+ * directory on disk in step with each other.
+ *
+ * This file is a thin client. Every decision the sync makes — which side wins,
+ * what counts as a deletion, when to refuse — is made by the engine in the
+ * server (`lib/mount-index/sync/`), and every flag is validated by the route's
+ * own schema, which is the single source of truth. The CLI resolves the store
+ * name to a UUID (the one thing it opens the database for, read-only), posts
+ * the request, and prints what came back.
+ *
+ * The engine lives in the server rather than here because the sync writes
+ * through the store's own chokepoints — `linkDocumentContent`, the folder-row
+ * helper, the hard-link fan-out, the post-write re-chunk — and those are
+ * TypeScript in `lib/`, unreachable from this plain-JS package. A direct
+ * SQLite writer would be a second copy of all of them, and a lock-gated one
+ * could not re-chunk at all. `docs write` on a database store already requires
+ * the server for exactly this reason; `deconvert` already takes a server-local
+ * target path. This is that shape, not a new one.
+ *
+ * `<path>` is therefore resolved on the SERVER. Running under Docker, it must
+ * sit inside a bind mount — `quilltap docs docker-mounts` plans those.
+ *
+ * @module sync-command
+ */
+
+const path = require('path');
+const os = require('os');
+const {
+  resolveDataDirAndPassphrase,
+  printDefaultInstanceHint,
+  loadDbKey,
+  openMountIndexDb,
+  UUID_RE,
+} = require('./db-helpers');
+const { isQtapUri, parseQtapUri } = require('./qtap-uri');
+const { formatActionLines, formatSummary, exitCodeFor } = require('./sync-report');
+
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+const YELLOW = '\x1b[33m';
+
+function printSyncHelp() {
+  console.log(`
+Quilltap Document Store Sync
+
+Usage: quilltap sync <store|qtap://store/> <path> [options]
+
+Mirrors a database-backed document store and a directory on disk in both
+directions. The two sides are compared by SHA-256 first and by modification
+time second: equal bytes with unequal clocks are re-stamped, not re-copied.
+Whichever side changed is copied to the other; when both changed since the
+last run it is reported as a conflict and left alone.
+
+The directory is created if it is missing. A document store is never created.
+
+Options:
+  --dry-run                 Plan and print; change nothing on either side
+  --direction <which>       both (default), to-disk, or to-store
+  --prefer <which>          newer (default), store, or disk — resolves conflicts
+  --no-delete               Never propagate a deletion to the other side
+  --no-manifest             Ignore .quilltap-sync.json (first-run rules every time)
+  --json                    Machine-readable plan and results on stdout
+  -p, --port <number>       Server port (default: 3000)
+  -d, --data-dir <path>     Override data directory
+  -i, --instance <name>     Use a registered instance
+  --passphrase <pass>       Decrypt .dbkey if peppered
+  -h, --help                Show this help
+
+Exit codes: 0 clean, 1 an error or a failed action, 2 an unresolved conflict.
+--dry-run uses the same codes, so a script can gate on a clean plan.
+
+Files and folders whose names begin with a dot are INVISIBLE to the sync in
+both directions — never copied, never deleted, on either side. The one
+exception is .quilltap-sync.json, the record the verb keeps of what the last
+run left; it lives in the directory and never enters the store.
+
+A binary's description travels beside it as <file>.description.md. Editing
+that file changes the caption in the store; deleting it clears the caption.
+A text document's description is not synced.
+
+The server must be running: a database-backed store's writes go through it,
+as they already do for 'quilltap docs write'. <path> is resolved on the
+server — under Docker it must sit inside a bind mount (see
+'quilltap docs docker-mounts').
+
+Examples:
+  quilltap sync Lore ~/Documents/lore --dry-run
+  quilltap sync Lore ~/Documents/lore
+  quilltap sync Lore ~/Documents/lore --prefer disk
+  quilltap sync qtap://Lore/ ~/Documents/lore --direction to-disk
+`);
+}
+
+function parseFlags(args) {
+  const flags = {
+    dataDir: '',
+    instance: '',
+    passphrase: '',
+    port: 3000,
+    json: false,
+    dryRun: false,
+    direction: 'both',
+    prefer: 'newer',
+    noDelete: false,
+    noManifest: false,
+    help: false,
+  };
+  const positional = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case '-d': case '--data-dir':    flags.dataDir = args[++i] || ''; break;
+      case '-i': case '--instance':    flags.instance = args[++i] || ''; break;
+      case '--passphrase':             flags.passphrase = args[++i] || ''; break;
+      case '-p': case '--port':        flags.port = parseInt(args[++i], 10) || 3000; break;
+      case '--json':                   flags.json = true; break;
+      case '--dry-run':                flags.dryRun = true; break;
+      case '--direction':              flags.direction = args[++i] || ''; break;
+      case '--prefer':                 flags.prefer = args[++i] || ''; break;
+      case '--no-delete':              flags.noDelete = true; break;
+      case '--no-manifest':            flags.noManifest = true; break;
+      case '-h': case '--help':        flags.help = true; break;
+      default:
+        if (arg.startsWith('-')) {
+          console.error(`Unknown option: ${arg}`);
+          process.exit(1);
+        }
+        positional.push(arg);
+    }
+  }
+  return { flags, positional };
+}
+
+/** `~/x` → an absolute path. The server sees only what we send it. */
+function expandPath(input) {
+  let expanded = input;
+  if (expanded === '~') expanded = os.homedir();
+  else if (expanded.startsWith('~/')) expanded = path.join(os.homedir(), expanded.slice(2));
+  return path.resolve(expanded);
+}
+
+/**
+ * A store name or UUID, or a `qtap://store/` URI with an empty path. This is
+ * the only thing the verb opens the database for, and it opens it read-only.
+ */
+function resolveStoreSpec(spec) {
+  if (!isQtapUri(spec)) return spec;
+  const parsed = parseQtapUri(spec);
+  if (parsed.scope !== 'document_store') {
+    throw new Error(
+      'sync addresses document stores only; qtap://project/… and qtap://general/… are not CLI-addressable.'
+    );
+  }
+  if (parsed.path) {
+    throw new Error(`sync takes a whole store, not a path inside one: ${spec}`);
+  }
+  if (!parsed.mountPoint || parsed.mountPoint.toLowerCase() === 'self') {
+    throw new Error('"self" requires a character context and is not resolvable from the CLI.');
+  }
+  return parsed.mountPoint;
+}
+
+/** Name-first, UUID fallback — the same resolution the `docs` verbs use. */
+function requireMount(db, spec) {
+  if (UUID_RE.test(spec)) {
+    const row = db.prepare('SELECT * FROM doc_mount_points WHERE id = ?').get(spec);
+    if (!row) {
+      console.error(`No document store found with id ${spec}`);
+      process.exit(1);
+    }
+    return row;
+  }
+  const rows = db.prepare(
+    `SELECT * FROM doc_mount_points WHERE LOWER(name) = LOWER(?) ORDER BY name COLLATE NOCASE`
+  ).all(spec);
+  if (rows.length === 0) {
+    console.error(`No document store found with name "${spec}"`);
+    process.exit(1);
+  }
+  if (rows.length > 1) {
+    console.error(`Ambiguous store name "${spec}" matches multiple stores:`);
+    for (const r of rows) console.error(`  ${r.id}  ${r.name}  (${r.mountType})`);
+    console.error('Pass the UUID instead.');
+    process.exit(1);
+  }
+  return rows[0];
+}
+
+function isConnectionRefused(err) {
+  if (!err) return false;
+  const code = err.cause && err.cause.code ? err.cause.code : err.code;
+  return code === 'ECONNREFUSED' || code === 'ENOTFOUND' ||
+         code === 'EHOSTUNREACH' || code === 'ECONNRESET';
+}
+
+async function syncCommand(args) {
+  const { flags, positional } = parseFlags(args);
+  if (flags.help || positional.length === 0) {
+    printSyncHelp();
+    process.exit(flags.help ? 0 : 1);
+  }
+
+  const [storeSpec, targetSpec] = positional;
+  if (!targetSpec) {
+    console.error('Usage: quilltap sync <store> <path> [options]');
+    console.error("Run 'quilltap sync --help' for the full list of options.");
+    process.exit(1);
+  }
+  if (positional.length > 2) {
+    console.error(`sync takes one store and one path; got ${positional.length} arguments.`);
+    process.exit(1);
+  }
+
+  let storeName;
+  try {
+    storeName = resolveStoreSpec(storeSpec);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+
+  const targetPath = expandPath(targetSpec);
+
+  // Resolve the store from the local database — read-only, and the only thing
+  // the CLI opens it for.
+  const resolved = resolveDataDirAndPassphrase({
+    dataDir: flags.dataDir,
+    instance: flags.instance,
+    passphrase: flags.passphrase,
+  });
+  printDefaultInstanceHint(resolved);
+  const pepper = await loadDbKey(resolved.dataDir, resolved.passphrase);
+  const db = openMountIndexDb(resolved.dataDir, pepper, { readonly: true });
+  let mount;
+  try {
+    mount = requireMount(db, storeName);
+  } finally {
+    db.close();
+  }
+
+  if (mount.mountType !== 'database') {
+    console.error(
+      `"${mount.name}" is a ${mount.mountType} store — it already IS a directory` +
+      (mount.basePath ? ` (${mount.basePath})` : '') + '.'
+    );
+    console.error('sync mirrors database-backed stores only.');
+    process.exit(1);
+  }
+
+  const url =
+    `http://localhost:${flags.port}/api/v1/mount-points/${encodeURIComponent(mount.id)}?action=sync`;
+
+  // The route's schema is the single source of truth for these; the CLI does
+  // not re-validate, so a bad --direction is refused by the server with the
+  // server's own wording.
+  const body = {
+    targetPath,
+    dryRun: flags.dryRun,
+    direction: flags.direction,
+    prefer: flags.prefer,
+    propagateDeletes: !flags.noDelete,
+    useManifest: !flags.noManifest,
+  };
+
+  let res;
+  try {
+    res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+  } catch (err) {
+    if (isConnectionRefused(err)) {
+      console.error(
+        `Cannot sync database-backed store "${mount.name}" without the Quilltap server.`
+      );
+      console.error('Start the server (`quilltap`) or pass --port to match a non-default port.');
+      process.exit(1);
+    }
+    throw err;
+  }
+
+  const payload = await res.json().catch(() => null);
+  if (!res.ok) {
+    const message = payload && payload.error ? payload.error : `HTTP ${res.status}`;
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+
+  const report = payload && payload.data !== undefined ? payload.data : payload;
+
+  if (flags.json) {
+    console.log(JSON.stringify(report, null, 2));
+    process.exit(exitCodeFor(report.summary));
+  }
+
+  const colour = Boolean(process.stdout.isTTY);
+  for (const line of formatActionLines(report.actions, colour)) {
+    console.log(line);
+  }
+
+  // Advisory text goes to stderr so stdout stays greppable.
+  for (const warning of report.warnings || []) {
+    console.error(colour ? `${YELLOW}warning:${RESET} ${warning}` : `warning: ${warning}`);
+  }
+  const summary = formatSummary(report.summary, report.elapsedMs, report.dryRun);
+  console.error(colour ? `${DIM}${summary}${RESET}` : summary);
+  if (report.summary.conflicts > 0) {
+    console.error(
+      colour
+        ? `${DIM}Re-run with --prefer store or --prefer disk to resolve the conflicts.${RESET}`
+        : 'Re-run with --prefer store or --prefer disk to resolve the conflicts.'
+    );
+  }
+
+  process.exit(exitCodeFor(report.summary));
+}
+
+module.exports = { syncCommand, printSyncHelp, expandPath, resolveStoreSpec };