@jaimevalasek/aioson 1.8.0 → 1.9.0

package/src/commands/memory-archive.js

@@ -0,0 +1,193 @@
+'use strict';
+
+/**
+ * aioson memory:archive --id=<rule|learning|brain>:<slug> --reason="<text>" [--dry-run] [--json]
+ *
+ * Tier-2 human-actioned command (PMD-4 / Article VII / BR-ALL-01). Moves a
+ * curated artifact to `_archived/{YYYY-MM-DD}/` and records the transition in
+ * `evolution_log` using the validity-window pattern (BR-ALL-02 append-only):
+ *  - supersedes the prior active entry (sets `end_at`)
+ *  - inserts a new `event_type='archived'` row
+ *  - for learnings: also flips `project_learnings.status` to 'archived'
+ *
+ * Refuses to run when `process.env.AIOSON_RUNTIME_HOOK === '1'` (BR-ALL-01:
+ * hook code paths are never permitted to archive — only direct invocation by
+ * a human).
+ *
+ * Emits `aioson notify --level=warn` BEFORE mutating disk or DB (BR-ALL-06).
+ */
+
+const path = require('node:path');
+const { openRuntimeDb } = require('../runtime-store');
+const { runNotify } = require('./notify');
+const {
+  parseTargetId,
+  normalizeKind,
+  archiveTarget,
+  TARGET_TYPES
+} = require('../learning-loop-archive');
+
+function tFn(t, key, params) {
+  if (typeof t === 'function') {
+    try { return t(key, params || {}); } catch { /* fall through */ }
+  }
+  return null;
+}
+
+function isHookContext() {
+  return process.env.AIOSON_RUNTIME_HOOK === '1';
+}
+
+async function runMemoryArchive({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args && args[0] ? args[0] : '.');
+  const wantJson = Boolean(options.json);
+  const dryRun = Boolean(options['dry-run'] || options.dryRun);
+  const log = (msg) => { if (logger && typeof logger.log === 'function') logger.log(msg); };
+
+  if (isHookContext()) {
+    const msg = tFn(t, 'memory_archive.hook_blocked')
+      || 'memory:archive cannot be invoked from a runtime hook (BR-ALL-01: tier-2 requires human action).';
+    if (wantJson) return { ok: false, reason: 'hook_blocked' };
+    log(msg);
+    return { ok: false, reason: 'hook_blocked' };
+  }
+
+  const rawId = options.id || options.target || '';
+  const reason = options.reason ? String(options.reason).trim() : '';
+
+  if (!rawId) {
+    const msg = tFn(t, 'memory_archive.id_required')
+      || 'memory:archive requires --id=<rule|learning|brain>:<slug>.';
+    if (wantJson) return { ok: false, reason: 'missing_id' };
+    log(msg);
+    return { ok: false, reason: 'missing_id' };
+  }
+  if (!reason) {
+    const msg = tFn(t, 'memory_archive.reason_required')
+      || 'memory:archive requires --reason="<text>".';
+    if (wantJson) return { ok: false, reason: 'missing_reason' };
+    log(msg);
+    return { ok: false, reason: 'missing_reason' };
+  }
+
+  const parsed = parseTargetId(rawId);
+  const kind = normalizeKind(parsed.kind);
+  if (!kind || !TARGET_TYPES.has(kind)) {
+    const msg = tFn(t, 'memory_archive.invalid_id', { value: rawId })
+      || `memory:archive invalid --id value: "${rawId}". Expected rule|learning|brain:<slug>.`;
+    if (wantJson) return { ok: false, reason: 'invalid_id', value: rawId };
+    log(msg);
+    return { ok: false, reason: 'invalid_id' };
+  }
+  if (!parsed.slug) {
+    const msg = tFn(t, 'memory_archive.invalid_id', { value: rawId })
+      || `memory:archive invalid --id value: "${rawId}". Missing slug after ":".`;
+    if (wantJson) return { ok: false, reason: 'invalid_id', value: rawId };
+    log(msg);
+    return { ok: false, reason: 'invalid_id' };
+  }
+
+  // BR-ALL-06: emit tier-2 notify BEFORE any mutation (defense in depth).
+  // notify.runNotify returns { ok, exitCode } — non-zero aborts.
+  const notifyMessage = tFn(t, 'memory_archive.notify_template', { kind, slug: parsed.slug, reason })
+    || `archiving ${kind} "${parsed.slug}": ${reason}`;
+  let notifyResult;
+  try {
+    notifyResult = await runNotify({
+      args: [targetDir],
+      options: {
+        level: 'warn',
+        topic: 'memory',
+        message: notifyMessage,
+        agent: 'memory-archive',
+        json: wantJson ? true : undefined
+      },
+      logger: logger || { log: () => {} }
+    });
+  } catch (err) {
+    if (wantJson) return { ok: false, reason: 'notify_failed', error: String(err && err.message || err) };
+    log(`memory:archive notify failed: ${err && err.message ? err.message : err}`);
+    return { ok: false, reason: 'notify_failed' };
+  }
+  if (notifyResult && notifyResult.ok === false) {
+    if (wantJson) return { ok: false, reason: 'notify_blocked', exitCode: notifyResult.exitCode };
+    log('memory:archive aborted: tier-2 notify returned non-zero exit code.');
+    return { ok: false, reason: 'notify_blocked' };
+  }
+
+  let dbHandle;
+  try {
+    dbHandle = await openRuntimeDb(targetDir);
+  } catch (err) {
+    if (wantJson) return { ok: false, reason: 'runtime_db_unavailable', error: String(err && err.message || err) };
+    log(`memory:archive runtime db unavailable: ${err && err.message ? err.message : err}`);
+    return { ok: false, reason: 'runtime_db_unavailable' };
+  }
+
+  const { db } = dbHandle;
+  let outcome;
+  try {
+    outcome = archiveTarget(db, {
+      targetDir,
+      kind,
+      slug: parsed.slug,
+      reason,
+      actor: 'human',
+      featureSlug: options.feature ? String(options.feature).trim() : null,
+      dryRun
+    });
+  } finally {
+    db.close();
+  }
+
+  if (!outcome.ok) {
+    if (wantJson) return outcome;
+    if (outcome.reason === 'already_archived') {
+      const msg = tFn(t, 'memory_archive.already_archived', { path: outcome.archivedAt })
+        || `memory:archive: "${parsed.slug}" already archived (${outcome.archivedAt || 'unknown path'}). No-op.`;
+      log(msg);
+    } else if (outcome.reason === 'target_not_found') {
+      const msg = tFn(t, 'memory_archive.target_not_found', { kind, slug: parsed.slug })
+        || `memory:archive: ${kind} "${parsed.slug}" not found in active state.`;
+      log(msg);
+    } else {
+      log(`memory:archive failed: ${outcome.reason}${outcome.error ? ' — ' + outcome.error : ''}`);
+    }
+    return outcome;
+  }
+
+  if (wantJson) {
+    return {
+      ok: true,
+      dry_run: Boolean(outcome.dryRun),
+      kind,
+      slug: parsed.slug,
+      source_path: outcome.sourcePath,
+      dest_path: outcome.destPath,
+      archived_entry_id: outcome.archivedEntryId || null,
+      superseded_entry_id: outcome.supersededEntryId || null,
+      start_at: outcome.startAt || null
+    };
+  }
+
+  if (outcome.dryRun) {
+    const msg = tFn(t, 'memory_archive.dry_run_summary', {
+      kind,
+      slug: parsed.slug,
+      source: outcome.sourcePath || '(no source path)',
+      dest: outcome.destPath,
+      has_active: outcome.hasActiveEntry ? 'yes' : 'no'
+    }) || `memory:archive [dry-run]: would move ${outcome.sourcePath || kind + ':' + parsed.slug} → ${outcome.destPath} (active entry: ${outcome.hasActiveEntry ? 'yes' : 'no'}).`;
+    log(msg);
+  } else {
+    const msg = tFn(t, 'memory_archive.archived_success', {
+      kind,
+      slug: parsed.slug,
+      dest: outcome.destPath
+    }) || `memory:archive ✓ ${kind} "${parsed.slug}" archived to ${outcome.destPath}.`;
+    log(msg);
+  }
+  return outcome;
+}
+
+module.exports = { runMemoryArchive };

package/src/commands/memory-reflect-commit.js

@@ -0,0 +1,148 @@
+'use strict';
+
+// aioson memory:reflect-commit [.] --agent=<name> [--output=<path-to-json>] [--json]
+//
+// Reads the reflect manifest written by memory:reflect-prepare, accepts the
+// agent's reflected output (as a JSON map of relative path → new content),
+// validates it, and writes the approved files to .aioson/context/bootstrap/*.md.
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { openRuntimeDb, logAgentEvent } = require('../runtime-store');
+const { validate, readBootstrapSnapshot } = require('../memory-reflect-engine');
+const { REFLECT_PROMPT_RELATIVE } = require('./memory-reflect-prepare');
+const { stripInjectionChars } = require('../lib/llm-content-sanitizer');
+
+async function readJsonFile(filePath) {
+  const raw = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(raw);
+}
+
+async function readStdin() {
+  if (process.stdin.isTTY) return '';
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', reject);
+  });
+}
+
+async function loadAgentOutput(options) {
+  if (options.files && typeof options.files === 'object') {
+    return { files: options.files };
+  }
+  if (options.output) {
+    const outputPath = path.resolve(process.cwd(), String(options.output));
+    return readJsonFile(outputPath);
+  }
+  const stdinData = await readStdin();
+  if (stdinData.trim()) return JSON.parse(stdinData);
+  throw new Error('memory:reflect-commit requires --output=<path> or JSON on stdin');
+}
+
+async function emitEvent(targetDir, agent, type, message, payload) {
+  try {
+    const { db, runtimeDir } = await openRuntimeDb(targetDir);
+    try {
+      await logAgentEvent(db, runtimeDir, {
+        agentName: agent,
+        message,
+        type,
+        meta: payload || undefined
+      });
+    } finally {
+      db.close();
+    }
+  } catch {
+    // best-effort
+  }
+}
+
+async function runMemoryReflectCommit({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args?.[0] || '.');
+  const agent = String(options.agent || '').trim() || 'unknown';
+
+  const manifestPath = path.join(targetDir, REFLECT_PROMPT_RELATIVE);
+  let manifest;
+  try {
+    manifest = await readJsonFile(manifestPath);
+  } catch {
+    const message = `manifest not found at ${path.relative(targetDir, manifestPath)} — run memory:reflect-prepare first`;
+    if (!options.json) logger.log(`✗ ${message}`);
+    return { ok: false, error: 'missing_manifest', message };
+  }
+
+  let payload;
+  try {
+    payload = await loadAgentOutput(options);
+  } catch (err) {
+    if (!options.json) logger.log(`✗ ${err.message}`);
+    return { ok: false, error: 'bad_input', message: err.message };
+  }
+
+  const files = (payload && payload.files) || {};
+  const currentSnapshot = await readBootstrapSnapshot(targetDir);
+  const result = validate({ manifest, files, currentSnapshot });
+
+  if (!result.ok) {
+    if (!options.json) {
+      logger.log('✗ reflect-commit validation failed:');
+      for (const err of result.errors) logger.log(`  - ${err}`);
+    }
+    await emitEvent(targetDir, agent, 'memory_reflect_failed', 'validation failed', {
+      errors: result.errors,
+      snapshot_hash: manifest.snapshot_hash
+    });
+    return { ok: false, error: 'validation_failed', errors: result.errors };
+  }
+
+  // SECURITY: defense in depth — even after validate() approves the paths,
+  // verify that every resolved absolute path stays under the project's
+  // bootstrap directory. validate() already rejects absolute paths and
+  // `..` segments, but this is the second wall in case the manifest's
+  // allowed_paths is ever extended beyond bootstrap/.
+  const bootstrapRoot = path.resolve(targetDir, '.aioson/context/bootstrap');
+  const written = [];
+  for (const [relPath, content] of Object.entries(files)) {
+    const absPath = path.resolve(targetDir, relPath);
+    if (!absPath.startsWith(bootstrapRoot + path.sep) && absPath !== bootstrapRoot) {
+      const msg = `refused write outside bootstrap/: ${relPath}`;
+      if (!options.json) logger.log(`✗ ${msg}`);
+      await emitEvent(targetDir, agent, 'memory_reflect_failed', msg, {
+        attempted_path: relPath,
+        resolved: absPath
+      });
+      return { ok: false, error: 'path_escape', message: msg };
+    }
+    // SF-project-22: scrub zero-width / bidi / HTML-comment injection carriers
+    // from the LLM-authored content before it lands in bootstrap. Path
+    // containment is already enforced above; this is the content layer of the
+    // same defense pattern (SF-08/09).
+    const safeContent = stripInjectionChars(content);
+    await fs.mkdir(path.dirname(absPath), { recursive: true });
+    await fs.writeFile(absPath, safeContent, 'utf8');
+    written.push(relPath);
+  }
+
+  // remove the manifest — it's been consumed
+  try { await fs.unlink(manifestPath); } catch { /* ignore */ }
+
+  if (!options.json) {
+    logger.log(`✓ reflect committed: ${written.length} file(s)`);
+    for (const w of written) logger.log(`  - ${w}`);
+  }
+
+  await emitEvent(targetDir, agent, 'memory_reflect_committed', `wrote ${written.length} bootstrap file(s)`, {
+    files: written,
+    snapshot_hash: manifest.snapshot_hash,
+    targets: manifest.targets
+  });
+
+  return { ok: true, written, manifest };
+}
+
+module.exports = {
+  runMemoryReflectCommit
+};

package/src/commands/memory-reflect-prepare.js

@@ -0,0 +1,97 @@
+'use strict';
+
+// aioson memory:reflect-prepare [.] --agent=<name> [--git-range=<range>] [--force] [--json]
+//
+// Reads project state, asks the reflect engine for a verdict, and (if relevant)
+// writes the in-harness manifest the agent will consume on the next turn.
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { openRuntimeDb, logAgentEvent } = require('../runtime-store');
+const { evaluate, buildPrompt } = require('../memory-reflect-engine');
+
+const REFLECT_PROMPT_RELATIVE = path.join('.aioson', 'runtime', 'reflect-prompt.json');
+
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+async function emitEvent(targetDir, agent, type, message, payload) {
+  try {
+    const { db, runtimeDir } = await openRuntimeDb(targetDir);
+    try {
+      await logAgentEvent(db, runtimeDir, {
+        agentName: agent,
+        message,
+        type,
+        meta: payload || undefined
+      });
+    } finally {
+      db.close();
+    }
+  } catch {
+    // telemetry is best-effort; never fail prepare/commit due to event emission
+  }
+}
+
+async function runMemoryReflectPrepare({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args?.[0] || '.');
+  const agent = String(options.agent || '').trim() || 'unknown';
+  const gitRange = options['git-range'] || options.range || undefined;
+  const force = Boolean(options.force);
+
+  const evaluation = await evaluate(targetDir, { agent, gitRange });
+
+  if (!evaluation.bootstrapPresent) {
+    const message = `bootstrap/ missing at ${path.join(targetDir, '.aioson/context/bootstrap')} — run /discover to seed it.`;
+    if (!options.json) logger.log(`! memory:reflect-prepare: ${message}`);
+    await emitEvent(targetDir, agent, 'memory_reflect_skipped', message, { reason: 'missing_bootstrap' });
+    return { ok: false, skipped: true, reason: 'missing_bootstrap', message };
+  }
+
+  if (evaluation.verdict === 'skip' && !force) {
+    const message = 'reflect skipped: no relevant signals in diff';
+    if (!options.json) logger.log(`· ${message}`);
+    await emitEvent(targetDir, agent, 'memory_reflect_skipped', message, {
+      reasons: evaluation.reasons,
+      shortstat: evaluation.shortstat
+    });
+    return { ok: true, skipped: true, evaluation };
+  }
+
+  const manifest = await buildPrompt({
+    targetDir,
+    agent,
+    evaluation,
+    sessionId: options['session-id'] || undefined
+  });
+
+  const promptPath = path.join(targetDir, REFLECT_PROMPT_RELATIVE);
+  await ensureDir(path.dirname(promptPath));
+  await fs.writeFile(promptPath, JSON.stringify(manifest, null, 2), 'utf8');
+
+  const promptRelative = path.relative(targetDir, promptPath);
+  if (!options.json) {
+    logger.log(`✓ reflect manifest written: ${promptRelative}`);
+    logger.log(`  verdict: ${evaluation.verdict}`);
+    logger.log(`  targets: ${manifest.targets.join(', ')}`);
+    if (evaluation.reasons.length > 0) {
+      logger.log(`  reasons: ${evaluation.reasons.join('; ')}`);
+    }
+    logger.log('  next: agent edits listed bootstrap files, then run `aioson memory:reflect-commit`.');
+  }
+
+  await emitEvent(targetDir, agent, 'memory_reflect_prepared', `reflect manifest at ${promptRelative}`, {
+    targets: manifest.targets,
+    snapshot_hash: manifest.snapshot_hash,
+    reasons: evaluation.reasons,
+    forced: force && evaluation.verdict === 'skip'
+  });
+
+  return { ok: true, manifest, manifestPath: promptPath, evaluation };
+}
+
+module.exports = {
+  REFLECT_PROMPT_RELATIVE,
+  runMemoryReflectPrepare
+};

package/src/commands/memory-restore.js

@@ -0,0 +1,177 @@
+'use strict';
+
+/**
+ * aioson memory:restore --id=<rule|learning|brain>:<slug> [--reason="<text>"] [--dry-run] [--json]
+ *
+ * Tier-2 human-actioned command. Moves an archived artifact back to its
+ * active path and records an `event_type='restored'` entry with a fresh
+ * `start_at` (PMD-10). History is preserved: the prior `archived` entry
+ * keeps its `end_at`.
+ *
+ * Refuses to run when `process.env.AIOSON_RUNTIME_HOOK === '1'` (BR-ALL-01).
+ * Emits `aioson notify --level=warn` BEFORE mutation (BR-ALL-06).
+ */
+
+const path = require('node:path');
+const { openRuntimeDb } = require('../runtime-store');
+const { runNotify } = require('./notify');
+const {
+  parseTargetId,
+  normalizeKind,
+  restoreTarget,
+  TARGET_TYPES
+} = require('../learning-loop-archive');
+
+function tFn(t, key, params) {
+  if (typeof t === 'function') {
+    try { return t(key, params || {}); } catch { /* fall through */ }
+  }
+  return null;
+}
+
+function isHookContext() {
+  return process.env.AIOSON_RUNTIME_HOOK === '1';
+}
+
+async function runMemoryRestore({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args && args[0] ? args[0] : '.');
+  const wantJson = Boolean(options.json);
+  const dryRun = Boolean(options['dry-run'] || options.dryRun);
+  const log = (msg) => { if (logger && typeof logger.log === 'function') logger.log(msg); };
+
+  if (isHookContext()) {
+    const msg = tFn(t, 'memory_restore.hook_blocked')
+      || 'memory:restore cannot be invoked from a runtime hook (BR-ALL-01: tier-2 requires human action).';
+    if (wantJson) return { ok: false, reason: 'hook_blocked' };
+    log(msg);
+    return { ok: false, reason: 'hook_blocked' };
+  }
+
+  const rawId = options.id || options.target || '';
+  const reason = options.reason ? String(options.reason).trim() : '';
+
+  if (!rawId) {
+    const msg = tFn(t, 'memory_restore.id_required')
+      || 'memory:restore requires --id=<rule|learning|brain>:<slug>.';
+    if (wantJson) return { ok: false, reason: 'missing_id' };
+    log(msg);
+    return { ok: false, reason: 'missing_id' };
+  }
+
+  const parsed = parseTargetId(rawId);
+  const kind = normalizeKind(parsed.kind);
+  if (!kind || !TARGET_TYPES.has(kind) || !parsed.slug) {
+    const msg = tFn(t, 'memory_restore.invalid_id', { value: rawId })
+      || `memory:restore invalid --id value: "${rawId}". Expected rule|learning|brain:<slug>.`;
+    if (wantJson) return { ok: false, reason: 'invalid_id', value: rawId };
+    log(msg);
+    return { ok: false, reason: 'invalid_id' };
+  }
+
+  const notifyMessage = tFn(t, 'memory_restore.notify_template', {
+    kind,
+    slug: parsed.slug,
+    reason: reason || 'restoring archived artifact'
+  }) || `restoring ${kind} "${parsed.slug}"${reason ? `: ${reason}` : ''}`;
+  let notifyResult;
+  try {
+    notifyResult = await runNotify({
+      args: [targetDir],
+      options: {
+        level: 'warn',
+        topic: 'memory',
+        message: notifyMessage,
+        agent: 'memory-restore',
+        json: wantJson ? true : undefined
+      },
+      logger: logger || { log: () => {} }
+    });
+  } catch (err) {
+    if (wantJson) return { ok: false, reason: 'notify_failed', error: String(err && err.message || err) };
+    log(`memory:restore notify failed: ${err && err.message ? err.message : err}`);
+    return { ok: false, reason: 'notify_failed' };
+  }
+  if (notifyResult && notifyResult.ok === false) {
+    if (wantJson) return { ok: false, reason: 'notify_blocked', exitCode: notifyResult.exitCode };
+    log('memory:restore aborted: tier-2 notify returned non-zero exit code.');
+    return { ok: false, reason: 'notify_blocked' };
+  }
+
+  let dbHandle;
+  try {
+    dbHandle = await openRuntimeDb(targetDir);
+  } catch (err) {
+    if (wantJson) return { ok: false, reason: 'runtime_db_unavailable', error: String(err && err.message || err) };
+    log(`memory:restore runtime db unavailable: ${err && err.message ? err.message : err}`);
+    return { ok: false, reason: 'runtime_db_unavailable' };
+  }
+
+  const { db } = dbHandle;
+  let outcome;
+  try {
+    outcome = restoreTarget(db, {
+      targetDir,
+      kind,
+      slug: parsed.slug,
+      reason: reason || null,
+      actor: 'human',
+      featureSlug: options.feature ? String(options.feature).trim() : null,
+      dryRun
+    });
+  } finally {
+    db.close();
+  }
+
+  if (!outcome.ok) {
+    if (wantJson) return outcome;
+    if (outcome.reason === 'target_not_archived') {
+      const msg = tFn(t, 'memory_restore.target_not_archived', { kind, slug: parsed.slug })
+        || `memory:restore: ${kind} "${parsed.slug}" not found in archive.`;
+      log(msg);
+    } else if (outcome.reason === 'target_already_active') {
+      const msg = tFn(t, 'memory_restore.target_already_active', { kind, slug: parsed.slug })
+        || `memory:restore: ${kind} "${parsed.slug}" already active. No-op.`;
+      log(msg);
+    } else if (outcome.reason === 'target_not_found') {
+      const msg = tFn(t, 'memory_restore.target_not_found', { kind, slug: parsed.slug })
+        || `memory:restore: ${kind} "${parsed.slug}" not found.`;
+      log(msg);
+    } else {
+      log(`memory:restore failed: ${outcome.reason}${outcome.error ? ' — ' + outcome.error : ''}`);
+    }
+    return outcome;
+  }
+
+  if (wantJson) {
+    return {
+      ok: true,
+      dry_run: Boolean(outcome.dryRun),
+      kind,
+      slug: parsed.slug,
+      source_path: outcome.sourcePath,
+      dest_path: outcome.destPath,
+      restored_entry_id: outcome.restoredEntryId || null,
+      start_at: outcome.startAt || null
+    };
+  }
+
+  if (outcome.dryRun) {
+    const msg = tFn(t, 'memory_restore.dry_run_summary', {
+      kind,
+      slug: parsed.slug,
+      source: outcome.sourcePath || kind,
+      dest: outcome.destPath || '(no dest)'
+    }) || `memory:restore [dry-run]: would move ${outcome.sourcePath || kind} → ${outcome.destPath || '(no dest)'}.`;
+    log(msg);
+  } else {
+    const msg = tFn(t, 'memory_restore.restored_success', {
+      kind,
+      slug: parsed.slug,
+      dest: outcome.destPath || ''
+    }) || `memory:restore ✓ ${kind} "${parsed.slug}" restored${outcome.destPath ? ' to ' + outcome.destPath : ''}.`;
+    log(msg);
+  }
+  return outcome;
+}
+
+module.exports = { runMemoryRestore };