godpowers 3.0.2 → 3.13.0

package/lib/cli-dispatch.js

@@ -149,6 +149,395 @@ function runExtensionScaffoldCommand(opts) {
   }
 }
 
+function verifyFailure(opts, id, reason) {
+  return {
+    command: 'verify',
+    verdict: 'fail',
+    project: opts.project,
+    kind: null,
+    verified: false,
+    checks: [{ id, status: 'fail', artifact: '.godpowers/ledger/verifications.jsonl', reason }],
+    findings: [{ id, severity: 'error', artifact: '.godpowers/ledger/verifications.jsonl', reason }]
+  };
+}
+
+function relLedger(opts, absPath) {
+  const path = require('path');
+  return path.relative(opts.project, absPath);
+}
+
+function renderVerify(result) {
+  const lines = [];
+  lines.push('Godpowers Verify');
+  lines.push('');
+  if (result.verdict === 'fail' && result.findings && result.findings.length > 0 && !result.record) {
+    lines.push('Verdict: fail');
+    for (const finding of result.findings) {
+      lines.push(`Error: ${finding.reason}`);
+    }
+    return lines.join('\n');
+  }
+  const verdictLabel = result.kind === 'attested'
+    ? 'attested (self-reported, not machine-checked)'
+    : result.verdict;
+  lines.push(`Verdict: ${verdictLabel}`);
+  lines.push(`Command: ${result.commandText ? '`' + result.commandText + '`' : '(none)'}`);
+  if (result.substep) lines.push(`Substep: ${result.substep}`);
+  if (result.kind === 'executed') {
+    lines.push(`Exit: ${result.exitCode} (${result.durationMs} ms)`);
+  }
+  if (result.claim) lines.push(`Claim: ${result.claim}`);
+  lines.push(`Ledger: ${result.ledger}`);
+  if (result.rollup) {
+    lines.push(result.rollup.applied
+      ? `Rollup: applied ${result.rollup.substep} verification.commands (${result.rollup.status})`
+      : `Rollup: skipped (${result.rollup.reason})`);
+  }
+  if (result.event) {
+    lines.push(result.event.emitted
+      ? `Event: ${result.event.name} -> runs/${result.event.runId}/events.jsonl`
+      : `Event: not emitted (${result.event.error})`);
+  }
+  if (result.kind === 'executed' && !result.verified && result.diagnostics) {
+    lines.push('');
+    lines.push('Diagnostics:');
+    lines.push(result.diagnostics);
+  }
+  return lines.join('\n');
+}
+
+function runVerifyCommand(opts) {
+  const evidence = require('./evidence');
+
+  if (opts.attest) {
+    if (!opts.claim) {
+      const result = verifyFailure(opts, 'claim-required', 'verify --attest requires --claim="<claim>"');
+      if (opts.json) console.log(JSON.stringify(result, null, 2));
+      else console.log(renderVerify(result));
+      process.exitCode = 1;
+      return;
+    }
+    const outcome = evidence.verifyClaim(opts.claim, opts.evidence, {
+      substep: opts.substep || undefined,
+      projectRoot: opts.project
+    });
+    const result = {
+      command: 'verify',
+      kind: 'attested',
+      verdict: 'attested',
+      verified: null,
+      project: opts.project,
+      commandText: null,
+      substep: outcome.record.substep,
+      claim: outcome.record.claim,
+      ledger: relLedger(opts, outcome.ledger),
+      rollup: null,
+      event: null,
+      record: outcome.record
+    };
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+    else console.log(renderVerify(result));
+    return;
+  }
+
+  if (!opts.verifyCommand) {
+    const result = verifyFailure(opts, 'command-required', 'verify requires a command, for example: npx godpowers verify "npm test" --substep tier-2.build');
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+    else console.log(renderVerify(result));
+    process.exitCode = 1;
+    return;
+  }
+  if (!opts.substep) {
+    const result = verifyFailure(opts, 'substep-required', 'verify requires --substep=<id>, for example --substep=tier-2.build');
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+    else console.log(renderVerify(result));
+    process.exitCode = 1;
+    return;
+  }
+
+  const outcome = evidence.verify(opts.verifyCommand, {
+    substep: opts.substep,
+    claim: opts.claim || undefined,
+    timeout: opts.timeout || undefined,
+    projectRoot: opts.project
+  });
+  const result = {
+    command: 'verify',
+    kind: 'executed',
+    verdict: outcome.verified ? 'pass' : 'fail',
+    verified: outcome.verified,
+    project: opts.project,
+    commandText: outcome.record.command,
+    substep: outcome.record.substep,
+    claim: outcome.record.claim,
+    exitCode: outcome.record.exit_code,
+    durationMs: Math.max(0, Math.round(outcome.record.duration_seconds * 1000)),
+    diagnostics: outcome.rollup && outcome.rollup.applied
+      ? undefined
+      : (outcome.record.stderr_tail || outcome.record.stdout_tail || ''),
+    ledger: relLedger(opts, outcome.ledger),
+    rollup: outcome.rollup,
+    event: outcome.event,
+    record: outcome.record
+  };
+  // Surface diagnostics on failure regardless of rollup state.
+  if (!outcome.verified) {
+    result.diagnostics = outcome.record.stderr_tail || outcome.record.stdout_tail || `exit ${outcome.record.exit_code}`;
+  }
+  if (opts.json) console.log(JSON.stringify(result, null, 2));
+  else console.log(renderVerify(result));
+  if (!outcome.verified) process.exitCode = 1;
+}
+
+function renderCanClose(result) {
+  const lines = [];
+  lines.push('Godpowers Can-Close');
+  lines.push('');
+  lines.push(`Substep: ${result.substep || '(none)'}`);
+  lines.push(`Can close: ${result.canClose ? 'yes' : 'no'}`);
+  lines.push(`Reason: ${result.reason}`);
+  if (result.strategy) lines.push(`Strategy: ${result.strategy}`);
+  if (result.wentInFlightAt) lines.push(`In-flight since: ${result.wentInFlightAt}`);
+  return lines.join('\n');
+}
+
+function runCanCloseCommand(opts) {
+  const evidence = require('./evidence');
+  if (!opts.substep) {
+    const result = {
+      command: 'can-close',
+      project: opts.project,
+      canClose: false,
+      reason: 'substep-required',
+      strategy: null,
+      substep: null
+    };
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+    else console.log(`${renderCanClose(result)}\n\nError: can-close requires --substep=<id>, for example --substep=tier-2.build`);
+    process.exitCode = 1;
+    return;
+  }
+  const verdict = evidence.canClose(opts.substep, { projectRoot: opts.project });
+  const result = { command: 'can-close', project: opts.project, ...verdict };
+  if (opts.json) console.log(JSON.stringify(result, null, 2));
+  else console.log(renderCanClose(result));
+  if (!verdict.canClose) process.exitCode = 1;
+}
+
+function renderRoute(result) {
+  const lines = [];
+  lines.push('Godpowers Route');
+  lines.push('');
+  lines.push(`Route: ${result.route}`);
+  lines.push(`Reason: ${result.reason}`);
+  lines.push(`Next command: ${result.nextCommand || '(answer inline)'}`);
+  lines.push(`Ceremony: ${result.ceremony}`);
+  lines.push(`Verification: ${result.verificationStrategy}`);
+  lines.push(`Chat policy: ${result.chatPolicy}`);
+  const ev = result.evidence || {};
+  lines.push(`Evidence: classification=${ev.classification}, latest verdict=${ev.latestVerdict}, open findings=${ev.openFindings}`);
+  return lines.join('\n');
+}
+
+function runRouteCommand(opts) {
+  const quarterback = require('./quarterback');
+  const result = quarterback.route(opts.routePrompt || '', { projectRoot: opts.project });
+  if (opts.json) console.log(JSON.stringify(result, null, 2));
+  else console.log(renderRoute(result));
+}
+
+function runReportCommand(opts) {
+  const workReport = require('./work-report');
+  const result = workReport.report({
+    since: opts.since || 'last',
+    peek: opts.peek,
+    projectRoot: opts.project
+  });
+  if (opts.json) console.log(JSON.stringify(result, null, 2));
+  else console.log(workReport.render(result));
+}
+
+function runReflectCommand(opts) {
+  const evidence = require('./evidence');
+  if (!opts.reflectAction) {
+    const result = {
+      command: 'reflect',
+      verdict: 'fail',
+      project: opts.project,
+      findings: [{ id: 'action-required', severity: 'error', artifact: '.godpowers/ledger/reflections.jsonl', reason: 'reflect requires --action="<what was attempted>"' }]
+    };
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+    else console.log('Godpowers Reflect\n\nError: reflect requires --action="<what was attempted>"');
+    process.exitCode = 1;
+    return;
+  }
+  const outcome = evidence.reflect({
+    action: opts.reflectAction,
+    outcome: opts.outcome || undefined,
+    observation: opts.observation || undefined,
+    rootCause: opts.rootCause || undefined,
+    next: opts.nextAction || undefined,
+    lesson: opts.lesson || undefined
+  }, { substep: opts.substep || undefined, projectRoot: opts.project });
+  if (opts.json) {
+    console.log(JSON.stringify(outcome, null, 2));
+  } else {
+    const r = outcome.record;
+    const lines = ['Godpowers Reflect', '', `Outcome: ${r.outcome}`, `Action: ${r.action}`];
+    if (r.substep) lines.push(`Substep: ${r.substep}`);
+    if (r.next) lines.push(`Next: ${r.next}`);
+    if (r.lesson) lines.push(`Lesson: ${r.lesson}`);
+    lines.push('Recorded to .godpowers/ledger/reflections.jsonl');
+    console.log(lines.join('\n'));
+  }
+}
+
+function memoryError(opts, reason) {
+  if (opts.json) {
+    console.log(JSON.stringify({ command: 'memory', verdict: 'fail', project: opts.project, reason }, null, 2));
+  } else {
+    console.log(`Godpowers Memory\n\nError: ${reason}`);
+  }
+  process.exitCode = 1;
+}
+
+function runMemoryCommand(opts) {
+  const evidence = require('./evidence');
+  const action = opts.memoryAction;
+  if (!action || !['set', 'get', 'list', 'clear'].includes(action)) {
+    return memoryError(opts, 'memory requires an action: set, get, list, or clear');
+  }
+  const projectRoot = opts.project;
+  let result;
+  if (action === 'set') {
+    if (!opts.memoryKey || opts.memoryValue === null) {
+      return memoryError(opts, 'memory set requires a key and value, for example: memory set decision "use postgres"');
+    }
+    result = evidence.memory.set(opts.memoryKey, opts.memoryValue, { category: opts.category || undefined, projectRoot });
+  } else if (action === 'get') {
+    if (!opts.memoryKey) return memoryError(opts, 'memory get requires a key');
+    result = evidence.memory.get(opts.memoryKey, { projectRoot });
+  } else if (action === 'list') {
+    result = evidence.memory.list({ category: opts.category || undefined, projectRoot });
+  } else {
+    result = evidence.memory.clear(opts.memoryKey || undefined, { projectRoot });
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({ command: 'memory', action, result }, null, 2));
+  } else {
+    const lines = ['Godpowers Memory', '', `Action: ${action}`];
+    if (action === 'list') {
+      const entries = result || [];
+      lines.push(`Entries: ${entries.length}`);
+      for (const e of entries) lines.push(`  [${e.category}] ${e.key} = ${e.value}`);
+    } else if (action === 'get') {
+      lines.push(result ? `[${result.category}] ${result.key} = ${result.value}` : '(not found)');
+    } else if (action === 'set') {
+      lines.push(`Set [${result.category}] ${result.key} = ${result.value}`);
+    } else {
+      lines.push(`Removed ${result.removed} entr${result.removed === 1 ? 'y' : 'ies'}`);
+    }
+    console.log(lines.join('\n'));
+  }
+  if (action === 'get' && !result) process.exitCode = 1;
+}
+
+function runLessonCommand(opts) {
+  const evidence = require('./evidence');
+  const action = opts.lessonAction;
+  if (!action || !['add', 'list'].includes(action)) {
+    if (opts.json) console.log(JSON.stringify({ command: 'lesson', verdict: 'fail', reason: 'lesson requires an action: add or list' }, null, 2));
+    else console.log('Godpowers Lesson\n\nError: lesson requires an action: add or list');
+    process.exitCode = 1;
+    return;
+  }
+  const projectRoot = opts.project;
+  if (action === 'add') {
+    if (!opts.lessonText) {
+      if (opts.json) console.log(JSON.stringify({ command: 'lesson', verdict: 'fail', reason: 'lesson add requires the lesson text' }, null, 2));
+      else console.log('Godpowers Lesson\n\nError: lesson add requires the lesson text, for example: lesson add "guard inputs before parsing"');
+      process.exitCode = 1;
+      return;
+    }
+    const tags = opts.tags ? String(opts.tags).split(',').map((t) => t.trim()).filter(Boolean) : [];
+    const record = evidence.lesson.add(opts.lessonText, { tags, scope: opts.scope || undefined, projectRoot });
+    if (opts.json) console.log(JSON.stringify({ command: 'lesson', action, result: record }, null, 2));
+    else console.log(`Godpowers Lesson\n\nAdded [${record.scope}]${record.tags.length ? ` (${record.tags.join(',')})` : ''}: ${record.lesson}`);
+    return;
+  }
+  const records = evidence.lesson.list({ scope: opts.scope || undefined, projectRoot });
+  if (opts.json) {
+    console.log(JSON.stringify({ command: 'lesson', action, result: records }, null, 2));
+  } else {
+    const lines = ['Godpowers Lesson', '', `Lessons: ${records.length}`];
+    for (const r of records) lines.push(`  [${r.scope}]${r.tags && r.tags.length ? ` (${r.tags.join(',')})` : ''} ${r.lesson}`);
+    console.log(lines.join('\n'));
+  }
+}
+
+function outcomeError(opts, reason) {
+  if (opts.json) console.log(JSON.stringify({ command: 'outcome', verdict: 'fail', reason }, null, 2));
+  else console.log(`Godpowers Outcome\n\nError: ${reason}`);
+  process.exitCode = 1;
+}
+
+function runOutcomeCommand(opts) {
+  const evidence = require('./evidence');
+  const action = opts.outcomeAction;
+  if (!action || !['start', 'check', 'stop', 'status'].includes(action)) {
+    return outcomeError(opts, 'outcome requires an action: start, check, stop, or status');
+  }
+  if (!opts.outcomeSlug) {
+    return outcomeError(opts, `outcome ${action} requires a name, for example: outcome ${action} green-build`);
+  }
+  const projectRoot = opts.project;
+  let payload;
+  if (action === 'start') {
+    payload = evidence.outcome.start(opts.outcomeSlug, {
+      goal: opts.outcomeGoal || undefined,
+      verifier: opts.outcomeVerify || undefined,
+      budget: opts.budget || undefined,
+      substep: opts.substep || undefined,
+      projectRoot
+    });
+  } else if (action === 'check') {
+    payload = evidence.outcome.check(opts.outcomeSlug, { projectRoot });
+  } else if (action === 'stop') {
+    payload = evidence.outcome.stop(opts.outcomeSlug, opts.reason || undefined, { projectRoot });
+  } else {
+    payload = evidence.outcome.status(opts.outcomeSlug, { projectRoot });
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({ command: 'outcome', action, result: payload }, null, 2));
+  } else {
+    const lines = ['Godpowers Outcome', '', `Action: ${action}`];
+    const goal = payload && (payload.goal || (payload.slug ? payload : null));
+    if (goal && goal.slug) {
+      lines.push(`Outcome: ${goal.slug}`);
+      lines.push(`Status: ${goal.status}`);
+      lines.push(`Iterations: ${goal.iterations}/${goal.budget}`);
+    }
+    if (payload && payload.verified !== undefined) lines.push(`This check: ${payload.verified ? 'verified' : 'unverified'}`);
+    if (payload && payload.reason) lines.push(`Note: ${payload.reason}`);
+    if (!payload) lines.push('(outcome not found)');
+    console.log(lines.join('\n'));
+  }
+  // A check that did not verify, or a missing outcome, exits non-zero.
+  if (action === 'check' && payload && payload.verified === false) process.exitCode = 1;
+  if ((action === 'status') && !payload) process.exitCode = 1;
+}
+
+function runImportLedgerCommand(opts) {
+  const importer = require('./evidence-import');
+  const result = importer.importMythify({
+    source: opts.importFrom || undefined,
+    projectRoot: opts.project
+  });
+  if (opts.json) console.log(JSON.stringify(result, null, 2));
+  else console.log(importer.render(result));
+  if (!result.found) process.exitCode = 1;
+}
+
 function runGateCommand(opts) {
   if (!opts.tier) {
     const result = {
@@ -223,7 +612,16 @@ const COMMAND_RUNNERS = {
   demo: runDemoCommand,
   surface: runSurfaceCommand,
   'extension-scaffold': runExtensionScaffoldCommand,
-  gate: runGateCommand
+  gate: runGateCommand,
+  verify: runVerifyCommand,
+  'can-close': runCanCloseCommand,
+  route: runRouteCommand,
+  report: runReportCommand,
+  reflect: runReflectCommand,
+  memory: runMemoryCommand,
+  lesson: runLessonCommand,
+  outcome: runOutcomeCommand,
+  'import-ledger': runImportLedgerCommand
 };
 
 function runCommand(opts) {
@@ -247,5 +645,14 @@ module.exports = {
   runMcpInfoCommand,
   runExtensionScaffoldCommand,
   runGateCommand,
-  runStateCommand
+  runStateCommand,
+  runVerifyCommand,
+  runCanCloseCommand,
+  runRouteCommand,
+  runReportCommand,
+  runReflectCommand,
+  runMemoryCommand,
+  runLessonCommand,
+  runOutcomeCommand,
+  runImportLedgerCommand
 };

package/lib/evidence/.provenance.json

@@ -0,0 +1,45 @@
+{
+  "source": "mythify-mcp",
+  "upstreamRepo": "mythify",
+  "upstreamPath": "mcp-server/src/index.js",
+  "engine": "verify_run + verify_claim (verification tools)",
+  "version": "3.6.3",
+  "commit": "7cbd601f9c4d5328a54921a051d450703e44c514",
+  "syncedAt": "2026-06-15",
+  "adaptations": [
+    "verificationStepContext (plan/step_id/step_title/step_status) rebound to substepContext (arc/substep/substep_status)",
+    "state dir .mythify/ rebound to .godpowers/ledger/",
+    "appendJsonl (fs.appendFileSync) rebound to an atomic read-modify-write append via lib/atomic-write.js",
+    "executed verdict additionally rolled up into state.json verification.commands[] via lib/state.js in the Godpowers gate shape",
+    "executed verdict additionally emitted as gate.pass / gate.fail to .godpowers/runs/<id>/events.jsonl via lib/events.js",
+    "verify_claim exposed as evidence.verifyClaim: attested, verified:null, never rolled up, never emitted"
+  ],
+  "upstreamRecordShape": {
+    "executed": [
+      "kind",
+      "claim",
+      "command",
+      "exit_code",
+      "duration_seconds",
+      "stdout_tail",
+      "stderr_tail",
+      "verified",
+      "timestamp",
+      "plan",
+      "step_id",
+      "step_title",
+      "step_status"
+    ],
+    "attested": [
+      "kind",
+      "claim",
+      "evidence",
+      "verified",
+      "timestamp",
+      "plan",
+      "step_id",
+      "step_title",
+      "step_status"
+    ]
+  }
+}

package/lib/evidence-import.js

@@ -0,0 +1,147 @@
+/**
+ * One-time importer for existing Mythify .mythify/ ledgers.
+ *
+ * Optional, best-effort, additive: it copies an existing Mythify state dir into
+ * the Godpowers ledger, rebinding the Mythify plan/step context to Godpowers'
+ * arc/substep on each record. It appends to the ledger and does NOT roll up into
+ * state.json or emit gate events; this is a historical import, not a re-run.
+ *
+ * See docs/FUSION-ARCHITECTURE.md (Phase 3, optional importer).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const atomic = require('./atomic-write');
+const evidence = require('./evidence');
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Rebind a Mythify record's plan/step context to Godpowers' arc/substep.
+ * Records that already carry arc/substep pass through unchanged.
+ */
+function rebindRecord(record) {
+  if (!record || typeof record !== 'object') return record;
+  const hasMythifyContext = 'plan' in record || 'step_id' in record
+    || 'step_title' in record || 'step_status' in record;
+  if (!hasMythifyContext) return { ...record };
+  const out = { ...record };
+  out.arc = record.arc !== undefined ? record.arc : (record.plan !== undefined ? record.plan : null);
+  out.substep = record.substep !== undefined ? record.substep : (record.step_id !== undefined ? record.step_id : null);
+  out.substep_status = record.substep_status !== undefined
+    ? record.substep_status
+    : (record.step_status !== undefined ? record.step_status : null);
+  delete out.plan;
+  delete out.step_id;
+  delete out.step_title;
+  delete out.step_status;
+  return out;
+}
+
+/**
+ * Import an existing .mythify/ ledger into the Godpowers ledger.
+ *
+ * @param {{ source?: string, projectRoot?: string }} [opts]
+ * @returns {{ source: string, projectRoot: string, found: boolean,
+ *   imported: { verifications: number, reflections: number, memory: number, lessons: number, outcomes: number },
+ *   error?: string }}
+ */
+function importMythify(opts = {}) {
+  const projectRoot = path.resolve(opts.projectRoot || process.cwd());
+  const source = path.resolve(opts.source || path.join(projectRoot, '.mythify'));
+  const result = {
+    source,
+    projectRoot,
+    found: false,
+    imported: { verifications: 0, reflections: 0, memory: 0, lessons: 0, outcomes: 0 }
+  };
+  if (!fs.existsSync(source)) {
+    result.error = 'source-not-found';
+    return result;
+  }
+  result.found = true;
+
+  // Verifications (rebind plan/step -> arc/substep).
+  for (const record of evidence.readJsonl(path.join(source, 'verifications.jsonl'))) {
+    evidence.appendJsonlAtomic(evidence.verificationsPath(projectRoot), rebindRecord(record));
+    result.imported.verifications += 1;
+  }
+
+  // Reflections (rebind for any bound context; mostly pass-through).
+  for (const record of evidence.readJsonl(path.join(source, 'reflections.jsonl'))) {
+    evidence.appendJsonlAtomic(evidence.reflectionsPath(projectRoot), rebindRecord(record));
+    result.imported.reflections += 1;
+  }
+
+  // Memory (merge entries by key).
+  const sourceMemory = readJson(path.join(source, 'memory.json'));
+  if (sourceMemory && Array.isArray(sourceMemory.entries) && sourceMemory.entries.length > 0) {
+    const dest = readJson(evidence.memoryPath(projectRoot)) || { entries: [], metadata: {} };
+    if (!Array.isArray(dest.entries)) dest.entries = [];
+    for (const entry of sourceMemory.entries) {
+      if (!entry || typeof entry.key !== 'string') continue;
+      const idx = dest.entries.findIndex((existing) => existing && existing.key === entry.key);
+      if (idx >= 0) dest.entries[idx] = entry;
+      else dest.entries.push(entry);
+      result.imported.memory += 1;
+    }
+    dest.metadata = dest.metadata || {};
+    dest.metadata.total_entries = dest.entries.length;
+    fs.mkdirSync(evidence.ledgerDir(projectRoot), { recursive: true });
+    atomic.writeJsonAtomic(evidence.memoryPath(projectRoot), dest);
+  }
+
+  // Lessons (Mythify lessons/*.json -> our lessons.jsonl).
+  const lessonsDir = path.join(source, 'lessons');
+  if (fs.existsSync(lessonsDir)) {
+    for (const name of fs.readdirSync(lessonsDir).filter((n) => n.endsWith('.json'))) {
+      const lesson = readJson(path.join(lessonsDir, name));
+      if (lesson) {
+        evidence.appendJsonlAtomic(evidence.lessonsPath(projectRoot, 'project'), lesson);
+        result.imported.lessons += 1;
+      }
+    }
+  }
+
+  // Outcomes (copy goal.json + iterations.jsonl per slug).
+  const outcomesDir = path.join(source, 'outcomes');
+  if (fs.existsSync(outcomesDir)) {
+    for (const slug of fs.readdirSync(outcomesDir)) {
+      const srcGoal = path.join(outcomesDir, slug, 'goal.json');
+      if (!fs.existsSync(srcGoal)) continue;
+      const destDir = path.join(evidence.ledgerDir(projectRoot), 'outcomes', slug);
+      fs.mkdirSync(destDir, { recursive: true });
+      atomic.writeFileAtomic(path.join(destDir, 'goal.json'), fs.readFileSync(srcGoal, 'utf8'));
+      const srcIters = path.join(outcomesDir, slug, 'iterations.jsonl');
+      if (fs.existsSync(srcIters)) {
+        atomic.writeFileAtomic(path.join(destDir, 'iterations.jsonl'), fs.readFileSync(srcIters, 'utf8'));
+      }
+      result.imported.outcomes += 1;
+    }
+  }
+
+  return result;
+}
+
+function render(result) {
+  const lines = ['Godpowers Ledger Import', ''];
+  lines.push(`Source: ${result.source}`);
+  if (!result.found) {
+    lines.push('');
+    lines.push('No .mythify/ ledger found at the source. Pass --from <path>.');
+    return lines.join('\n');
+  }
+  const i = result.imported;
+  lines.push(`Imported: ${i.verifications} verification(s), ${i.reflections} reflection(s), ${i.memory} memory entr(ies), ${i.lessons} lesson(s), ${i.outcomes} outcome(s)`);
+  lines.push('Records were appended to the Godpowers ledger (no state rollup, no gate events).');
+  return lines.join('\n');
+}
+
+module.exports = { importMythify, rebindRecord, render };