driftseal 0.2.0 → 0.4.0

package/bin/driftseal.js

@@ -34,12 +34,48 @@ const DECISION_STATUSES = [
   'deprecated',
   'superseded',
 ];
-const EVENT_SCHEMA_VERSION = 2;
-const PROTOCOL_VERSION = 5;
+const EVENT_SCHEMA_VERSION = 3;
+const PROTOCOL_VERSION = 7;
 const LOCK_STALE_MS = 30 * 60 * 1000;
 const LOCK_INIT_STALE_MS = 5 * 1000;
 const MAX_DECISION_SLUG_LENGTH = 180;
 
+class DriftSealError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'DriftSealError';
+  }
+}
+
+let activeOutput = null;
+
+function printLine(value = '') {
+  const text = String(value);
+  if (activeOutput) {
+    activeOutput.stdout += text + '\n';
+    return;
+  }
+  console.log(text);
+}
+
+function printError(value = '') {
+  const text = String(value);
+  if (activeOutput) {
+    activeOutput.stderr += text + '\n';
+    return;
+  }
+  console.error(text);
+}
+
+function writeOutput(value) {
+  const text = String(value);
+  if (activeOutput) {
+    activeOutput.stdout += text;
+    return;
+  }
+  process.stdout.write(text);
+}
+
 if (process.env._DRIFTSEAL_TEST_UMASK) {
   process.umask(Number.parseInt(process.env._DRIFTSEAL_TEST_UMASK, 8));
 }
@@ -94,6 +130,13 @@ function normalizeEvent(event, line) {
     return event;
   }
 
+  if (event.type === 'reclaim' || event.type === 'unreclaim') {
+    if (typeof event.reason !== 'string' || event.reason.trim().length === 0) {
+      fail(`invalid ${event.type} event on log line ${line}`);
+    }
+    return event;
+  }
+
   if (
     event.type === 'decision_reconcile' ||
     event.type === 'decision_reconcile_prepare' ||
@@ -176,7 +219,8 @@ function readEvents({ repairTail = false } = {}) {
     .map((line, i) => {
       try {
         return normalizeEvent(JSON.parse(line), i + 1);
-      } catch {
+      } catch (err) {
+        if (err instanceof DriftSealError) throw err;
         fail(`corrupt log line ${i + 1} in ${file}`);
       }
     });
@@ -529,8 +573,28 @@ function fold(events) {
         tsEnd: null,
         note: null,
         verifyResult: null,
+        reclaimed: false,
+        reclaimReason: null,
+        reclaimedAt: null,
       });
       order.push(ev.id);
+    } else if (ev.type === 'reclaim' || ev.type === 'unreclaim') {
+      const rec = records.get(ev.id);
+      if (!rec) fail(`${ev.type} event references unknown intent id: ${ev.id}`);
+      if (ev.type === 'reclaim') {
+        if (rec.status === 'in_progress') {
+          fail(`cannot reclaim intent ${ev.id} while it is in_progress`);
+        }
+        if (rec.reclaimed) fail(`duplicate reclaim event for intent id: ${ev.id}`);
+        rec.reclaimed = true;
+        rec.reclaimReason = ev.reason;
+        rec.reclaimedAt = ev.ts;
+      } else {
+        if (!rec.reclaimed) fail(`unreclaim event for intent id that is not reclaimed: ${ev.id}`);
+        rec.reclaimed = false;
+        rec.reclaimReason = null;
+        rec.reclaimedAt = null;
+      }
     } else if (ev.type === 'end') {
       const rec = records.get(ev.id);
       if (!rec) fail(`end event references unknown intent id: ${ev.id}`);
@@ -928,8 +992,7 @@ function closeIntentAsEscape(events, record, requestedStatus, note, verifyResult
 }
 
 function fail(msg) {
-  console.error(`driftseal: error: ${msg}`);
-  process.exit(1);
+  throw new DriftSealError(msg);
 }
 
 function positiveInteger(value, flag) {
@@ -1002,9 +1065,39 @@ function render(rec) {
   if (rec.verifyResult) lines.push(`  verify-result: ${rec.verifyResult}`);
   if (rec.note) lines.push(`  note: ${rec.note}`);
   lines.push(`  began: ${rec.tsBegin}` + (rec.tsEnd ? `  ended: ${rec.tsEnd}` : ''));
+  if (rec.reclaimed) lines.push(`  reclaimed: ${rec.reclaimReason}`);
   return lines.join('\n');
 }
 
+function publicIntent(rec) {
+  if (!rec) return null;
+  return {
+    id: rec.id,
+    intent: rec.intent,
+    verify: rec.verify,
+    decisions: [...rec.decisions],
+    status: rec.status,
+    note: rec.note,
+    verifyResult: rec.verifyResult,
+    beganAt: rec.tsBegin,
+    endedAt: rec.tsEnd,
+    reclaimed: rec.reclaimed,
+    reclaimReason: rec.reclaimReason,
+    reclaimedAt: rec.reclaimedAt,
+  };
+}
+
+function publicDecision(decision, { includeContent = false } = {}) {
+  const record = {
+    id: decision.id,
+    title: decision.title,
+    status: decision.status,
+    file: decision.file,
+  };
+  if (includeContent) record.content = decision.content;
+  return record;
+}
+
 const INTENT_PROTOCOL_MARKER = '<!-- driftseal -->';
 const INTENT_PROTOCOL_END = '<!-- /driftseal -->';
 const DECISION_PROTOCOL_MARKER = '<!-- driftseal-decisions -->';
@@ -1040,14 +1133,38 @@ This repo uses DriftSeal (\`driftseal\`) to prevent agent drift. Every work roun
    just-closed log finalizes that round without requiring a new intent. Any content
    change made while preparing the commit does require a new intent.
 4. **Re-anchor after context loss**: run \`driftseal status\` and \`driftseal log --last 3\` before
-   doing anything else. The open intent is the source of truth.
+   doing anything else. The open intent is the source of truth: resume it when its
+   objective still matches the current task; otherwise close it (\`partial\` or
+   \`abandoned\`, with a note) and \`begin\` a new one.
+
+**Log access goes only through DriftSeal.** Never read, edit, move, or delete
+\`.intent-log/events.jsonl\` (or anything under \`$DRIFTSEAL_HOME\`) directly; use
+\`driftseal\` commands or the MCP tools. Retire meaningless closed records with
+\`driftseal reclaim [id ...] --reason "<why>"\` — it appends a marker, never
+deletes log lines; \`driftseal unreclaim <id> --reason "<why>"\` restores one.
 
 Log: \`.intent-log/events.jsonl\` (override with \`$DRIFTSEAL_HOME\`); commit it with the code.
 ${INTENT_PROTOCOL_END}`;
 }
 
 function previousIntentProtocolBlock(version) {
-  const v4 = intentProtocolBlock(version).replace(
+  const v6 = intentProtocolBlock(version).replace(
+    'doing anything else. The open intent is the source of truth: resume it when its\n' +
+      '   objective still matches the current task; otherwise close it (`partial` or\n' +
+      '   `abandoned`, with a note) and `begin` a new one.',
+    'doing anything else. The open intent is the source of truth.'
+  );
+  if (version >= 6) return v6;
+  const v5 = v6.replace(
+    '\n**Log access goes only through DriftSeal.** Never read, edit, move, or delete\n' +
+      '`.intent-log/events.jsonl` (or anything under `$DRIFTSEAL_HOME`) directly; use\n' +
+      '`driftseal` commands or the MCP tools. Retire meaningless closed records with\n' +
+      '`driftseal reclaim [id ...] --reason "<why>"` — it appends a marker, never\n' +
+      'deletes log lines; `driftseal unreclaim <id> --reason "<why>"` restores one.\n',
+    ''
+  );
+  if (version >= 5) return v5;
+  const v4 = v5.replace(
     '1. **Write intent first**, before modifying, creating, or deleting files, or\n' +
       '   making any other change that may need a rollback:\n' +
       '   `driftseal begin "<what this round will accomplish>" --verify "<command or check that proves it>"`.\n' +
@@ -1082,7 +1199,7 @@ revisiting, non-obvious rationale behind a long-lived or costly-to-reverse accep
 choice, or a deprecated or superseded decision. Do not record routine, local,
 readily reversible choices.
 
-\`driftseal decision add "<title>" --context "<problem and constraints>" --outcome "<decision and rationale>" --option "<considered option>" --consequence "<result>"\`
+\`driftseal decision add "<title>" --context "<problem and constraints>" --outcome "<decision and rationale>" --driver "<decision driver>" --option "<considered option>" --consequence "<result>"\`
 
 Add one \`--driver\`, \`--option\`, or \`--consequence\` flag per item. Use
 \`--status proposed|accepted|rejected|deferred|deprecated|superseded\` when needed.
@@ -1147,6 +1264,10 @@ When an intent declares an existing decision with \`--decision <id>\`, use
 Commit \`.decision-log/\` with the code.`;
 }
 
+function previousDecisionProtocolBlock(version) {
+  return decisionProtocolBlock(version).replace(' --driver "<decision driver>"', '');
+}
+
 function upgradeManagedBlock({
   content,
   marker,
@@ -1232,19 +1353,21 @@ const commands = {
         'superseded by --force',
         null
       );
-      console.error(`driftseal: ${status} ${open.id}`);
+      printError(`driftseal: ${status} ${open.id}`);
     }
 
     const id = nextId(events);
-    appendEvent({
+    events.push(appendEvent({
       type: 'begin',
       id,
       ts: new Date().toISOString(),
       intent,
       verify: flags.verify || null,
       decisions,
-    });
-    console.log(id);
+    }));
+    const record = fold(events).find((candidate) => candidate.id === id);
+    printLine(id);
+    return publicIntent(record);
   },
 
   end(argv) {
@@ -1279,8 +1402,9 @@ const commands = {
         flags.note,
         flags['verify-result']
       );
-      console.log(`${target.id} ${terminalStatus}`);
-      return;
+      const record = fold(events).find((candidate) => candidate.id === target.id);
+      printLine(`${target.id} ${terminalStatus}`);
+      return publicIntent(record);
     }
 
     if (['completed', 'partial'].includes(status) && target.decisions.length > 0) {
@@ -1317,15 +1441,17 @@ const commands = {
       }
     }
 
-    appendEvent({
+    events.push(appendEvent({
       type: 'end',
       id: target.id,
       ts: new Date().toISOString(),
       status,
       note: flags.note || null,
       verifyResult: flags['verify-result'] || null,
-    });
-    console.log(`${target.id} ${status}`);
+    }));
+    const record = fold(events).find((candidate) => candidate.id === target.id);
+    printLine(`${target.id} ${status}`);
+    return publicIntent(record);
   },
 
   status(argv) {
@@ -1333,25 +1459,131 @@ const commands = {
     if (positionals.length > 0) fail('usage: driftseal status');
     const open = openIntent(fold(readEvents({ repairTail: true })));
     if (!open) {
-      console.log('no intent in progress');
-      return;
+      printLine('no intent in progress');
+      return null;
     }
-    console.log(render(open));
+    printLine(render(open));
+    return publicIntent(open);
   },
 
   log(argv) {
-    const { positionals, flags } = parseArgs(argv, { last: '-n' });
-    if (positionals.length > 0) fail('usage: driftseal log [--last N]');
+    const { positionals, flags } = parseArgs(argv, { last: '-n', all: 'boolean' });
+    if (positionals.length > 0) fail('usage: driftseal log [--last N] [--all]');
     let records = fold(readEvents({ repairTail: true }));
+    if (!flags.all) records = records.filter((record) => !record.reclaimed);
     if (flags.last) {
       const n = positiveInteger(flags.last, '--last');
       records = records.slice(-n);
     }
     if (records.length === 0) {
-      console.log('log is empty');
-      return;
+      printLine('log is empty');
+      return [];
     }
-    console.log(records.map(render).join('\n\n'));
+    printLine(records.map(render).join('\n\n'));
+    return records.map(publicIntent);
+  },
+
+  reclaim(argv) {
+    const { positionals, flags } = parseArgs(argv, {
+      reason: '-r',
+      'older-than': 'single',
+      force: 'boolean',
+      'dry-run': 'boolean',
+    });
+    const reason = flags.reason && flags.reason.trim();
+    if (!reason) {
+      fail(
+        'usage: driftseal reclaim [id ...] --reason "<why>" [--older-than <days>] [--force] [--dry-run]'
+      );
+    }
+    let olderThanDays = 7;
+    if (flags['older-than'] !== undefined) {
+      olderThanDays = positiveInteger(flags['older-than'], '--older-than');
+    }
+
+    const records = fold(readEvents({ repairTail: true }));
+    let targets;
+    if (positionals.length > 0) {
+      const ids = [...new Set(positionals)];
+      targets = ids.map((id) => {
+        const record = records.find((candidate) => candidate.id === id);
+        if (!record) fail(`unknown intent id: ${id}`);
+        if (record.status === 'in_progress') {
+          fail(`cannot reclaim intent ${id} while it is in_progress`);
+        }
+        if (record.reclaimed) fail(`intent ${id} is already reclaimed`);
+        const routine = ['failed', 'abandoned'].includes(record.status) &&
+          record.decisions.length === 0;
+        if (!routine && !flags.force) {
+          fail(
+            `intent ${id} is ${record.status}` +
+              (record.decisions.length > 0 ? ' and linked to decisions' : '') +
+              '; re-run with --force to reclaim it anyway'
+          );
+        }
+        return record;
+      });
+    } else {
+      if (flags.force) fail('--force requires explicit intent ids');
+      const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
+      targets = records.filter(
+        (record) =>
+          record.status !== 'in_progress' &&
+          ['failed', 'abandoned'].includes(record.status) &&
+          record.decisions.length === 0 &&
+          !record.reclaimed &&
+          Date.parse(record.tsEnd) < cutoff
+      );
+      if (targets.length === 0) {
+        printLine('no reclaimable intents');
+        return [];
+      }
+    }
+
+    if (flags['dry-run']) {
+      printLine(targets.map((record) => `${record.id} ${record.status} — ${record.intent}`).join('\n'));
+      return targets.map(publicIntent);
+    }
+
+    let events = readEvents({ repairTail: true });
+    for (const record of targets) {
+      events.push(
+        appendEvent({
+          type: 'reclaim',
+          id: record.id,
+          ts: new Date().toISOString(),
+          reason,
+        })
+      );
+    }
+    const reclaimed = fold(events).filter((record) =>
+      targets.some((target) => target.id === record.id)
+    );
+    printLine(targets.map((record) => `${record.id} reclaimed`).join('\n'));
+    return reclaimed.map(publicIntent);
+  },
+
+  unreclaim(argv) {
+    const { positionals, flags } = parseArgs(argv, { reason: '-r' });
+    const reason = flags.reason && flags.reason.trim();
+    if (positionals.length !== 1 || !reason) {
+      fail('usage: driftseal unreclaim <id> --reason "<why>"');
+    }
+    const events = readEvents({ repairTail: true });
+    const record = fold(events).find((candidate) => candidate.id === positionals[0]);
+    if (!record) fail(`unknown intent id: ${positionals[0]}`);
+    if (!record.reclaimed) fail(`intent ${positionals[0]} is not reclaimed`);
+    events.push(
+      appendEvent({
+        type: 'unreclaim',
+        id: record.id,
+        ts: new Date().toISOString(),
+        reason,
+      })
+    );
+    const restored = fold(events).find((candidate) => candidate.id === record.id);
+    printLine(`${record.id} unreclaimed`);
+    return publicIntent(restored);
   },
 
   decision(argv) {
@@ -1392,8 +1624,9 @@ const commands = {
       });
       ensureDirectoryDurable(decisionDir());
       atomicCreateFile(path.join(decisionDir(), file), content);
-      console.log(path.join(decisionDir(), file));
-      return;
+      const decision = findDecision(String(id));
+      printLine(path.join(decisionDir(), file));
+      return publicDecision(decision, { includeContent: true });
     }
 
     if (subcommand === 'update') {
@@ -1431,8 +1664,9 @@ const commands = {
         fail('simulated interruption after decision write');
       }
       appendEvent(reconciliationEvent('decision_reconcile_commit', update));
-      console.log(`${decision.id} ${update.fromStatus} -> ${update.toStatus} (${intent.id})`);
-      return;
+      const reconciled = findDecision(decision.id);
+      printLine(`${decision.id} ${update.fromStatus} -> ${update.toStatus} (${intent.id})`);
+      return publicDecision(reconciled, { includeContent: true });
     }
 
     if (subcommand === 'list') {
@@ -1448,8 +1682,8 @@ const commands = {
       }
       const index = decisionIndex();
       if (flags.count && !status) {
-        console.log(index.length);
-        return;
+        printLine(index.length);
+        return { count: index.length };
       }
       let records = decisionCatalog(!status && last ? index.slice(-last) : index);
       if (status) {
@@ -1457,19 +1691,19 @@ const commands = {
       }
       if (status && last) records = records.slice(-last);
       if (flags.count) {
-        console.log(records.length);
-        return;
+        printLine(records.length);
+        return { count: records.length };
       }
       if (records.length === 0) {
-        console.log(status ? `no decision records with status ${status}` : 'decision log is empty');
-        return;
+        printLine(status ? `no decision records with status ${status}` : 'decision log is empty');
+        return [];
       }
-      console.log(
+      printLine(
         records
           .map((record) => `[${record.id}] ${titleCase(record.status)} — ${record.title}\n  ${record.file}`)
           .join('\n')
       );
-      return;
+      return records.map(publicDecision);
     }
 
     if (subcommand === 'show') {
@@ -1478,8 +1712,8 @@ const commands = {
         fail('usage: driftseal decision show <id>');
       }
       const decision = findDecision(positionals[0]);
-      process.stdout.write(decision.content);
-      return;
+      writeOutput(decision.content);
+      return publicDecision(decision, { includeContent: true });
     }
 
     fail('usage: driftseal decision add|update|list|show (run: driftseal help)');
@@ -1505,6 +1739,8 @@ const commands = {
         protocolEol(previousIntentProtocolBlock(2), eol),
         protocolEol(previousIntentProtocolBlock(3), eol),
         protocolEol(previousIntentProtocolBlock(4), eol),
+        protocolEol(previousIntentProtocolBlock(5), eol),
+        protocolEol(previousIntentProtocolBlock(6), eol),
       ],
       knownLegacyBlocks: [protocolEol(legacyIntentProtocolBlock(), eol)],
     });
@@ -1516,9 +1752,11 @@ const commands = {
       versionPattern: /^<!-- driftseal-decisions-version: (\d+) -->\r?$/m,
       replacement: decisionBlock,
       knownManagedBlocks: [
-        protocolEol(decisionProtocolBlock(2), eol),
-        protocolEol(decisionProtocolBlock(3), eol),
-        protocolEol(decisionProtocolBlock(4), eol),
+        protocolEol(previousDecisionProtocolBlock(2), eol),
+        protocolEol(previousDecisionProtocolBlock(3), eol),
+        protocolEol(previousDecisionProtocolBlock(4), eol),
+        protocolEol(previousDecisionProtocolBlock(5), eol),
+        protocolEol(previousDecisionProtocolBlock(6), eol),
       ],
       knownLegacyBlocks: [protocolEol(legacyDecisionProtocolBlock(), eol)],
     });
@@ -1539,15 +1777,16 @@ const commands = {
     }
 
     if (updated === current) {
-      console.log('AGENTS.md already contains the DriftSeal protocols; nothing to do');
-      return;
+      printLine('AGENTS.md already contains the DriftSeal protocols; nothing to do');
+      return { changed: false, target };
     }
     atomicWriteFile(target, updated);
-    console.log(`DriftSeal protocol ${existed ? 'updated in' : 'written to'} ${target}`);
+    printLine(`DriftSeal protocol ${existed ? 'updated in' : 'written to'} ${target}`);
+    return { changed: true, target };
   },
 
   help() {
-    console.log(`DriftSeal — Seal the intent. Stop the drift.
+    printLine(`DriftSeal — Seal the intent. Stop the drift.
 
 Intent-level write-ahead log for agent sessions.
 
@@ -1555,7 +1794,11 @@ usage:
   driftseal begin "<intent>" [--verify "<how to verify>"] [--decision <id>] [--force]
   driftseal end [id] [--status completed|partial|failed|abandoned] [--note "..."] [--verify-result "..."]
   driftseal status                     show the intent currently in progress (re-anchor after drift)
-  driftseal log [--last N]             show intent history
+  driftseal log [--last N] [--all]     show intent history (--all includes reclaimed records)
+  driftseal reclaim [id ...] --reason "<why>" [--older-than <days>] [--force] [--dry-run]
+                                 hide meaningless closed records without deleting them
+  driftseal unreclaim <id> --reason "<why>"
+                                 restore a reclaimed record to the visible log
   driftseal decision add "<title>" --context "..." --outcome "..." [options]
   driftseal decision update <id> [--status STATUS] --note "..."
                                  reconcile a linked decision in the open intent
@@ -1573,6 +1816,7 @@ decision add options:
 
 intent log: $DRIFTSEAL_HOME/events.jsonl, or .intent-log/events.jsonl
 decision log: $DRIFTSEAL_DECISION_HOME, or .decision-log/ in the current directory`);
+    return null;
   },
 };
 
@@ -1586,6 +1830,7 @@ function requestedEndStatus(argv) {
 
 function mutationResources(cmd, argv) {
   if (cmd === 'init') return [process.cwd()];
+  if (cmd === 'reclaim' || cmd === 'unreclaim') return [logDir()];
   if (cmd === 'begin' && !argv.some((arg) => arg === '--decision' || arg.startsWith('--decision='))) {
     return [logDir()];
   }
@@ -1595,24 +1840,168 @@ function mutationResources(cmd, argv) {
   return [logDir(), decisionDir()];
 }
 
-function main() {
-  const [cmd, ...rest] = process.argv.slice(2);
+function dispatch(argv) {
+  const [cmd, ...rest] = argv;
   if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
-    commands.help();
-    process.exit(cmd ? 0 : 1);
+    return { data: commands.help(), exitCode: cmd ? 0 : 1 };
   }
   const fn = commands[cmd];
   if (!fn) fail(`unknown command: ${cmd} (run: driftseal help)`);
   const mutates =
-    ['begin', 'end', 'init'].includes(cmd) ||
+    ['begin', 'end', 'init', 'reclaim', 'unreclaim'].includes(cmd) ||
     (cmd === 'decision' && ['add', 'update'].includes(rest[0]));
   const readsIntentLog = ['status', 'log'].includes(cmd);
   if (mutates || readsIntentLog) {
     const resources = readsIntentLog ? [logDir()] : mutationResources(cmd, rest);
-    withMutationLocks(resources, () => fn(rest));
-  } else {
-    fn(rest);
+    return { data: withMutationLocks(resources, () => fn(rest)), exitCode: 0 };
   }
+  return { data: fn(rest), exitCode: 0 };
 }
 
-main();
+function repositoryRoot(root) {
+  if (typeof root !== 'string' || root.trim().length === 0) {
+    fail('repository root must be a non-empty path');
+  }
+  const resolved = path.resolve(root);
+  let stat;
+  try {
+    stat = fs.statSync(resolved);
+  } catch {
+    fail(`repository root does not exist: ${resolved}`);
+  }
+  if (!stat.isDirectory()) fail(`repository root is not a directory: ${resolved}`);
+  return fs.realpathSync(resolved);
+}
+
+function runCommand(argv, { root = process.cwd(), isolateStorage = false, capture = true } = {}) {
+  if (!Array.isArray(argv) || argv.some((arg) => typeof arg !== 'string')) {
+    fail('command arguments must be an array of strings');
+  }
+  if (capture && activeOutput) fail('nested captured DriftSeal commands are not supported');
+
+  const fixedRoot = repositoryRoot(root);
+  const previousCwd = process.cwd();
+  const previousIntentHome = process.env.DRIFTSEAL_HOME;
+  const previousDecisionHome = process.env.DRIFTSEAL_DECISION_HOME;
+  const output = { stdout: '', stderr: '', data: null, exitCode: 0 };
+  const previousOutput = activeOutput;
+
+  try {
+    process.chdir(fixedRoot);
+    if (isolateStorage) {
+      delete process.env.DRIFTSEAL_HOME;
+      delete process.env.DRIFTSEAL_DECISION_HOME;
+    }
+    if (capture) activeOutput = output;
+    const result = dispatch(argv);
+    output.data = result.data;
+    output.exitCode = result.exitCode;
+    return output;
+  } catch (err) {
+    if (capture) {
+      err.stdout = output.stdout;
+      err.stderr = output.stderr;
+    }
+    throw err;
+  } finally {
+    activeOutput = previousOutput;
+    process.chdir(previousCwd);
+    if (previousIntentHome === undefined) delete process.env.DRIFTSEAL_HOME;
+    else process.env.DRIFTSEAL_HOME = previousIntentHome;
+    if (previousDecisionHome === undefined) delete process.env.DRIFTSEAL_DECISION_HOME;
+    else process.env.DRIFTSEAL_DECISION_HOME = previousDecisionHome;
+  }
+}
+
+function appendFlag(argv, flag, value) {
+  if (value !== undefined && value !== null && value !== '') argv.push(flag, String(value));
+}
+
+function createApi({ root = process.cwd(), isolateStorage = false } = {}) {
+  const fixedRoot = repositoryRoot(root);
+  const call = (argv) => runCommand(argv, { root: fixedRoot, isolateStorage, capture: true }).data;
+  return Object.freeze({
+    root: fixedRoot,
+    status() {
+      return call(['status']);
+    },
+    begin({ intent, verify, decisions = [], force = false }) {
+      const argv = ['begin', intent];
+      appendFlag(argv, '--verify', verify);
+      for (const decision of decisions) appendFlag(argv, '--decision', decision);
+      if (force) argv.push('--force');
+      return call(argv);
+    },
+    end({ id, status, note, verifyResult } = {}) {
+      const argv = ['end'];
+      if (id) argv.push(String(id));
+      appendFlag(argv, '--status', status);
+      appendFlag(argv, '--note', note);
+      appendFlag(argv, '--verify-result', verifyResult);
+      return call(argv);
+    },
+    log({ last, all = false } = {}) {
+      const argv = ['log'];
+      appendFlag(argv, '--last', last);
+      if (all) argv.push('--all');
+      return call(argv);
+    },
+    reclaim({ ids = [], reason, olderThan, force = false, dryRun = false }) {
+      const argv = ['reclaim', ...ids.map(String), '--reason', reason];
+      appendFlag(argv, '--older-than', olderThan);
+      if (force) argv.push('--force');
+      if (dryRun) argv.push('--dry-run');
+      return call(argv);
+    },
+    unreclaim({ id, reason }) {
+      return call(['unreclaim', String(id), '--reason', reason]);
+    },
+    decisionAdd({ title, context, outcome, status, drivers = [], options = [], consequences = [] }) {
+      const argv = ['decision', 'add', title, '--context', context, '--outcome', outcome];
+      appendFlag(argv, '--status', status);
+      for (const driver of drivers) appendFlag(argv, '--driver', driver);
+      for (const option of options) appendFlag(argv, '--option', option);
+      for (const consequence of consequences) appendFlag(argv, '--consequence', consequence);
+      return call(argv);
+    },
+    decisionUpdate({ id, status, note }) {
+      const argv = ['decision', 'update', String(id), '--note', note];
+      appendFlag(argv, '--status', status);
+      return call(argv);
+    },
+    decisionList({ status, last, count = false } = {}) {
+      const argv = ['decision', 'list'];
+      appendFlag(argv, '--status', status);
+      appendFlag(argv, '--last', last);
+      if (count) argv.push('--count');
+      return call(argv);
+    },
+    decisionShow({ id }) {
+      return call(['decision', 'show', String(id)]);
+    },
+    init() {
+      return call(['init']);
+    },
+  });
+}
+
+function main() {
+  try {
+    const result = dispatch(process.argv.slice(2));
+    process.exitCode = result.exitCode;
+  } catch (err) {
+    const message = err && err.message ? err.message : String(err);
+    console.error(`driftseal: error: ${message}`);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  DECISION_STATUSES,
+  END_STATUSES,
+  DriftSealError,
+  createApi,
+  runCommand,
+};
+
+if (require.main === module) main();