driftseal 2.1.0 → 3.1.0

package/bin/driftseal.js

@@ -20,7 +20,8 @@
  *
  * Seal root: $DRIFTSEAL_HOME, or .seal in cwd.
  * Outcome log: <seal-root>/outcomes/events.jsonl.
- * In a Git worktree, an open outcome is parked in Git metadata until end.
+ * In a default Git-repository seal, an open outcome is parked beside the WAL until end.
+ * Custom $DRIFTSEAL_HOME seals write open outcomes directly to the WAL.
  * MADR records: <seal-root>/madr/.
  */
 
@@ -32,6 +33,15 @@ const { isDeepStrictEqual } = require('util');
 const { StringDecoder } = require('string_decoder');
 const { execFileSync, spawnSync } = require('child_process');
 const { version: PACKAGE_VERSION } = require('../package.json');
+const { createOutcomeFold } = require('../lib/outcome-fold.js');
+const {
+  OutcomeIndexError,
+  SqliteUnavailableError,
+  openOutcomeIndex,
+  removeIndexFiles,
+  temporaryIndexPath,
+} = require('../lib/outcome-index-sqlite.js');
+const { assertSupportedNode } = require('../lib/sqlite-runtime.js');
 
 const END_STATUSES = ['completed', 'partial', 'failed', 'abandoned'];
 const DECISION_STATUSES = [
@@ -50,12 +60,22 @@ const PROTOCOL_VERSION = '2.1';
 const DEFAULT_LOG_LANGUAGE = 'en';
 const DEFAULT_LANE = 'main';
 const LANE_NAME_RE = /^[a-z][a-z0-9-]{0,62}$/;
-const IN_PROGRESS_GIT_PATH = 'driftseal-v2-in-progress.jsonl';
-const CURRENT_LANE_GIT_PATH = 'driftseal-v2-current-lane';
-const LANE_INDEX_GIT_PATH = 'driftseal-v2-lane-index.json';
-const LANE_INDEX_VERSION = 1;
-const LANE_INDEX_PREFIX_BYTES = 8192;
-const LANE_INDEX_TAIL_BYTES = 64 * 1024;
+const IN_PROGRESS_SIDECAR = '.in-progress.jsonl';
+const WORKSPACE_SIDECAR_IGNORE_NAMES = Object.freeze([
+  '.current-lane',
+  '.lane-index.json',
+  '.in-progress.jsonl',
+  '.driftseal-local-outcome.json',
+  '.outcome-index.sqlite',
+  '.outcome-index.sqlite-journal',
+  '.outcome-index.sqlite-wal',
+  '.outcome-index.sqlite-shm',
+  '..outcome-index.sqlite.*.tmp',
+  '..outcome-index.sqlite.*.tmp-*',
+  '..current-lane.*.tmp',
+  '..in-progress.jsonl.*.tmp',
+  '..driftseal-local-outcome.json.*.tmp',
+]);
 const LOCK_STALE_MS = 30 * 60 * 1000;
 const LOCK_INIT_STALE_MS = 5 * 1000;
 const READ_ONLY_NOTICE = '(read-only: another mutation holds the lock; tail repair skipped)';
@@ -65,6 +85,12 @@ const VERIFICATION_OUTPUT_CHUNK_BYTES = 64 * 1024;
 const CAPTURE_OUTPUT_EDGE_CHARACTERS = 32 * 1024;
 const CAPTURE_OUTPUT_OMISSION = '\n... [driftseal captured output truncated] ...\n';
 const LOCAL_OUTCOME_PROVENANCE_FILE = '.driftseal-local-outcome.json';
+const outcomeFoldEngine = createOutcomeFold({
+  fail,
+  contentHash,
+  logVersion: LOG_VERSION,
+  defaultLane: DEFAULT_LANE,
+});
 
 class DriftSealError extends Error {
   constructor(message) {
@@ -561,13 +587,6 @@ function gitWorktreeRoot(cwd = process.cwd()) {
   return gitCapture(['rev-parse', '--show-toplevel'], cwd);
 }
 
-function worktreeInProgressFile(cwd = process.cwd()) {
-  if (!isGitWorkTree(cwd)) return null;
-  const gitPath = gitCapture(['rev-parse', '--git-path', IN_PROGRESS_GIT_PATH], cwd);
-  if (!gitPath) return null;
-  return path.resolve(cwd, gitPath);
-}
-
 function isParkableOutcomeLog() {
   if (process.env.DRIFTSEAL_HOME) return false;
   const root = gitWorktreeRoot();
@@ -575,40 +594,63 @@ function isParkableOutcomeLog() {
   return path.resolve(logFile()) === path.resolve(root, '.seal', 'outcomes', 'events.jsonl');
 }
 
+function inProgressFileForLog(file) {
+  return path.join(path.dirname(file), IN_PROGRESS_SIDECAR);
+}
+
 function inProgressFile() {
   if (!isParkableOutcomeLog()) return null;
-  return worktreeInProgressFile();
+  return inProgressFileForLog(logFile());
 }
 
-function worktreeMetadataFile(gitPath, cwd = process.cwd()) {
-  if (!isGitWorkTree(cwd)) return null;
-  const resolved = gitCapture(['rev-parse', '--git-path', gitPath], cwd);
-  if (!resolved) return null;
-  return path.resolve(cwd, resolved);
+function existingInProgressFileForLog(file) {
+  return inProgressFileForLog(file);
+}
+
+function existingInProgressFile() {
+  if (!isParkableOutcomeLog()) return null;
+  return existingInProgressFileForLog(logFile());
+}
+
+function adoptInProgressFile() {
+  const current = inProgressFile();
+  if (!current) return null;
+  ensureDerivedLaneSidecarIgnore();
+  ensureDirectoryDurable(path.dirname(current));
+  return current;
 }
 
 function currentLaneFile() {
-  if (isParkableOutcomeLog()) return worktreeMetadataFile(CURRENT_LANE_GIT_PATH);
+  // Keep the worktree-local pointer beside the WAL so agent sandboxes that
+  // deny .git writes can still switch lanes.
   return path.join(logDir(), '.current-lane');
 }
 
 function laneIndexFile() {
-  if (isParkableOutcomeLog()) return worktreeMetadataFile(LANE_INDEX_GIT_PATH);
+  // Keep the disposable index beside the WAL so agent sandboxes that deny
+  // .git writes can still rebuild it inside the workspace.
+  return path.join(logDir(), '.outcome-index.sqlite');
+}
+
+function legacyLaneIndexFile() {
   return path.join(logDir(), '.lane-index.json');
 }
 
 function emptyLaneCatalog() {
-  return new Map([[DEFAULT_LANE, { name: DEFAULT_LANE, description: null, addedAt: null, head: null }]]);
+  return outcomeFoldEngine.emptyLaneCatalog();
 }
 
-function readCurrentLaneName() {
-  const file = currentLaneFile();
-  if (!file || !fs.existsSync(file)) return DEFAULT_LANE;
+function readLaneNameFromFile(file) {
+  if (!file || !fs.existsSync(file)) return null;
   const name = fs.readFileSync(file, 'utf8').trim();
-  if (!name) return DEFAULT_LANE;
+  if (!name) return null;
   return normalizeLaneName(name);
 }
 
+function readCurrentLaneName() {
+  return readLaneNameFromFile(currentLaneFile()) || DEFAULT_LANE;
+}
+
 function writeCurrentLaneName(name, { readOnly = false } = {}) {
   if (readOnly) return;
   const file = currentLaneFile();
@@ -618,371 +660,138 @@ function writeCurrentLaneName(name, { readOnly = false } = {}) {
   atomicWriteFile(file, `${name}\n`, 0o600);
 }
 
+function existingAncestor(dir) {
+  let current = path.resolve(dir);
+  while (!fs.existsSync(current)) {
+    const parent = path.dirname(current);
+    if (parent === current) return current;
+    current = parent;
+  }
+  return current;
+}
+
+function listedIgnoreNames(content) {
+  return new Set(
+    content
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0)
+  );
+}
+
+function workspaceSidecarIgnoreFile() {
+  return path.join(logDir(), '.gitignore');
+}
+
+function gitContainedOutcomeLog() {
+  return isGitWorkTree(existingAncestor(logDir()));
+}
+
+function workspaceSidecarIgnoreComplete() {
+  const ignoreFile = workspaceSidecarIgnoreFile();
+  if (!fs.existsSync(ignoreFile)) return false;
+  const listed = listedIgnoreNames(fs.readFileSync(ignoreFile, 'utf8'));
+  return WORKSPACE_SIDECAR_IGNORE_NAMES.every((name) => listed.has(name));
+}
+
+function canPersistDerivedOutcomeIndex() {
+  return !gitContainedOutcomeLog() || workspaceSidecarIgnoreComplete();
+}
+
 function ensureDerivedLaneSidecarIgnore() {
-  if (isParkableOutcomeLog()) return;
-  if (!isGitWorkTree(logDir())) return;
-  const ignoreFile = path.join(logDir(), '.gitignore');
+  if (!gitContainedOutcomeLog()) return { changed: false, target: null };
+  const ignoreFile = workspaceSidecarIgnoreFile();
   let current = fs.existsSync(ignoreFile) ? fs.readFileSync(ignoreFile, 'utf8') : '';
+  const listed = listedIgnoreNames(current);
   let next = current;
-  for (const name of ['.current-lane', '.lane-index.json']) {
-    const present = next.split(/\r?\n/).some((line) => line.trim() === name);
-    if (present) continue;
+  for (const name of WORKSPACE_SIDECAR_IGNORE_NAMES) {
+    if (listed.has(name)) continue;
     if (next && !next.endsWith('\n')) next += '\n';
     next += `${name}\n`;
   }
-  if (next === current) return;
+  if (next === current) return { changed: false, target: ignoreFile };
   ensureDirectoryDurable(logDir());
   atomicWriteFile(ignoreFile, next, 0o644);
+  return { changed: true, target: ignoreFile };
 }
 
-function defaultLaneCatalogObject() {
-  return { [DEFAULT_LANE]: { name: DEFAULT_LANE, description: null, addedAt: null, head: null } };
-}
-
-function emptyLaneIndexState() {
-  return {
-    indexVersion: LANE_INDEX_VERSION,
-    source: {
-      indexedThrough: 0,
-      indexedLines: 0,
-      prefixHash: contentHash(''),
-      tailHash: contentHash(''),
-    },
-    lastBuild: 'full',
-    lanes: emptyLaneCatalog(),
-    order: [],
-    records: new Map(),
-    ranges: new Map(),
-    reconciliations: new Map(),
-  };
-}
-
-function hashFileRange(file, start, length) {
-  if (length <= 0) return contentHash('');
+function hashFilePrefix(file, length) {
+  const hash = crypto.createHash('sha256');
+  if (length <= 0) return hash.digest('hex');
   const fd = fs.openSync(file, 'r');
   try {
-    const buf = Buffer.alloc(length);
-    const read = fs.readSync(fd, buf, 0, length, start);
-    return crypto.createHash('sha256').update(buf.subarray(0, read)).digest('hex');
+    const buffer = Buffer.alloc(Math.min(1024 * 1024, length));
+    let position = 0;
+    while (position < length) {
+      const requested = Math.min(buffer.length, length - position);
+      const read = fs.readSync(fd, buffer, 0, requested, position);
+      if (read === 0) break;
+      hash.update(buffer.subarray(0, read));
+      position += read;
+    }
+    if (position !== length) return null;
+    return hash.digest('hex');
   } finally {
     fs.closeSync(fd);
   }
 }
 
 function laneIndexSourceIdentity(file, indexedThrough, indexedLines = 0) {
-  if (!fs.existsSync(file) || indexedThrough <= 0) {
+  if (!fs.existsSync(file)) {
     return {
       indexedThrough: 0,
       indexedLines: 0,
-      prefixHash: contentHash(''),
-      tailHash: contentHash(''),
+      walHash: contentHash(''),
+      device: null,
+      inode: null,
+      mtimeMs: null,
+      ctimeMs: null,
     };
   }
-  const prefix = Math.min(LANE_INDEX_PREFIX_BYTES, indexedThrough);
-  const tail = Math.min(LANE_INDEX_TAIL_BYTES, indexedThrough);
+  const stat = fs.statSync(file);
   return {
     indexedThrough,
     indexedLines,
-    prefixHash: hashFileRange(file, 0, prefix),
-    tailHash: hashFileRange(file, indexedThrough - tail, tail),
-  };
-}
-
-function laneIndexMatchesFile(index, file) {
-  if (!index || index.indexVersion !== LANE_INDEX_VERSION) return false;
-  if (!Number.isSafeInteger(index.source?.indexedLines) || index.source.indexedLines < 0) return false;
-  if (!fs.existsSync(file)) return index.source.indexedThrough === 0;
-  const size = fs.statSync(file).size;
-  if (size < index.source.indexedThrough) return false;
-  const identity = laneIndexSourceIdentity(file, index.source.indexedThrough);
-  return (
-    identity.prefixHash === index.source.prefixHash &&
-    identity.tailHash === index.source.tailHash
-  );
-}
-
-function serializeLaneIndex(state) {
-  return {
-    indexVersion: state.indexVersion,
-    source: state.source,
-    lastBuild: state.lastBuild,
-    lanes: Object.fromEntries(
-      [...state.lanes.entries()].map(([name, lane]) => [
-        name,
-        { name, description: lane.description || null, addedAt: lane.addedAt || null, head: lane.head || null, inferred: lane.inferred === true },
-      ])
-    ),
-    order: [...state.order],
-    records: Object.fromEntries(state.records),
-    ranges: Object.fromEntries(state.ranges),
-    reconciliations: Object.fromEntries(state.reconciliations),
-  };
-}
-
-function deserializeLaneIndex(raw) {
-  if (!raw || raw.indexVersion !== LANE_INDEX_VERSION || !raw.source || !raw.records) return null;
-  const lanes = new Map();
-  for (const [name, lane] of Object.entries(raw.lanes || defaultLaneCatalogObject())) {
-    lanes.set(name, {
-      name,
-      description: lane.description || null,
-      addedAt: lane.addedAt || null,
-      head: lane.head || null,
-      inferred: lane.inferred === true,
-    });
-  }
-  if (!lanes.has(DEFAULT_LANE)) {
-    lanes.set(DEFAULT_LANE, { name: DEFAULT_LANE, description: null, addedAt: null, head: null });
-  }
-  return {
-    indexVersion: LANE_INDEX_VERSION,
-    source: raw.source,
-    lastBuild: raw.lastBuild || 'full',
-    lanes,
-    order: Array.isArray(raw.order) ? [...raw.order] : [],
-    records: new Map(Object.entries(raw.records)),
-    ranges: new Map(Object.entries(raw.ranges || {})),
-    reconciliations: new Map(Object.entries(raw.reconciliations || {})),
+    walHash: hashFilePrefix(file, indexedThrough),
+    device: Number(stat.dev),
+    inode: Number(stat.ino),
+    mtimeMs: stat.mtimeMs,
+    ctimeMs: stat.ctimeMs,
   };
 }
 
-function cloneLaneIndexState(state) {
-  return deserializeLaneIndex(serializeLaneIndex(state));
-}
-
-function linkLaneIndex(state) {
-  const heads = new Map();
-  for (const id of state.order) {
-    const rec = state.records.get(id);
-    rec.previous = heads.get(rec.lane) || null;
-    heads.set(rec.lane, id);
+function laneIndexMatchesFile(source, file, { exact = false } = {}) {
+  if (
+    !source ||
+    typeof source.walHash !== 'string' ||
+    !Number.isSafeInteger(source.indexedLines) ||
+    source.indexedLines < 0
+  ) {
+    return false;
   }
-  for (const [name, lane] of state.lanes) {
-    lane.head = heads.get(name) || null;
+  if (!fs.existsSync(file)) return source.indexedThrough === 0;
+  const stat = fs.statSync(file);
+  const size = stat.size;
+  if (size < source.indexedThrough || (exact && size !== source.indexedThrough)) return false;
+  if (
+    source.device !== null &&
+    source.inode !== null &&
+    (Number(stat.dev) !== source.device || Number(stat.ino) !== source.inode)
+  ) {
+    return false;
   }
-}
-
-function applyIndexedEvent(state, ev, startByte, endByte) {
-  if (ev.type === 'begin' || ev.type === 'import') {
-    state.ranges.set(ev.id, { firstByte: startByte, lastByte: endByte });
-  } else if (state.records.has(ev.id) || state.ranges.has(ev.id)) {
-    const range = state.ranges.get(ev.id) || { firstByte: startByte, lastByte: endByte };
-    range.lastByte = endByte;
-    state.ranges.set(ev.id, range);
+  if (
+    size === source.indexedThrough &&
+    stat.mtimeMs === source.mtimeMs &&
+    stat.ctimeMs === source.ctimeMs
+  ) {
+    return true;
   }
-  applyFoldEvent(state, ev);
+  return hashFilePrefix(file, source.indexedThrough) === source.walHash;
 }
 
 function applyFoldEvent(state, ev) {
-  const { records, reconciliations, order, lanes } = state;
-  const ensureLane = (name) => {
-    if (lanes.has(name)) return;
-    lanes.set(name, { name, description: null, addedAt: null, head: null, inferred: true });
-  };
-  if (ev.type === 'begin') {
-    if (records.has(ev.id)) fail(`duplicate begin event for outcome id: ${ev.id}`);
-    const record = newOutcomeRecord(ev);
-    ensureLane(record.lane);
-    records.set(ev.id, record);
-    order.push(ev.id);
-    return;
-  }
-  if (ev.type === 'import') {
-    if (records.has(ev.id)) fail(`duplicate imported outcome id: ${ev.id}`);
-    const record = newOutcomeRecord({
-      ...ev,
-      ts: ev.beganAt,
-      acceptance: [],
-      verify: null,
-    });
-    ensureLane(record.lane);
-    record.status = ev.status;
-    record.tsEnd = ev.endedAt;
-    record.note = ev.summary || null;
-    record.reclaimed = ev.reclaimed === true;
-    record.reclaimReason = ev.reclaimReason || null;
-    record.reclaimedAt = ev.reclaimedAt || null;
-    record.imported = {
-      sourceIds: ev.sources.map((source) => source.id),
-      sourceFingerprint: ev.sourceFingerprint,
-      sources: ev.sources,
-    };
-    records.set(ev.id, record);
-    order.push(ev.id);
-    return;
-  }
-  if (ev.type === 'migration') return;
-  if (ev.type === 'lane_add') {
-    const existing = lanes.get(ev.lane);
-    if (existing && !existing.inferred) {
-      if (ev.description) existing.description = ev.description;
-      return;
-    }
-    lanes.set(ev.lane, {
-      name: ev.lane,
-      description: ev.description || null,
-      addedAt: ev.ts,
-      head: existing ? existing.head : null,
-      inferred: false,
-    });
-    return;
-  }
-  if (ev.type === 'lane_assign') {
-    const rec = records.get(ev.id);
-    if (!rec) fail(`lane assign references unknown outcome id: ${ev.id}`);
-    if (rec.status === 'in_progress') fail(`cannot assign lane of in_progress outcome ${ev.id}`);
-    ensureLane(ev.lane);
-    rec.lane = ev.lane;
-    return;
-  }
-  if (ev.type === 'extend') {
-    const rec = records.get(ev.id);
-    if (!rec) fail(`extension references unknown outcome id: ${ev.id}`);
-    if (rec.status !== 'in_progress') fail(`extension occurred after outcome ${ev.id} was closed`);
-    rec.extensions.push({
-      extension: ev.extension,
-      acceptance: ev.acceptance,
-      verify: ev.verify,
-      decisions: ev.decisions,
-      extendedAt: ev.ts,
-      head: ev.head || null,
-    });
-    rec.acceptance = [...new Set([...rec.acceptance, ...ev.acceptance])];
-    if (ev.verify) rec.verify = ev.verify;
-    rec.decisions = [...new Set([...rec.decisions, ...ev.decisions])];
-    rec.contractHash = outcomeContractHash(rec);
-    rec.verification = null;
-    rec.decisionUpdates = [];
-    return;
-  }
-  if (ev.type === 'verify') {
-    const rec = records.get(ev.id);
-    if (!rec) fail(`verification event references unknown outcome id: ${ev.id}`);
-    if (rec.status !== 'in_progress') fail(`verification occurred after outcome ${ev.id} was closed`);
-    if (rec.acceptance.length === 0 || !rec.verify) {
-      fail(`verification event references outcome ${ev.id} without acceptance criteria`);
-    }
-    if (ev.command !== rec.verify) fail(`verification command does not match outcome ${ev.id}`);
-    if (rec.logVersion === LOG_VERSION && ev.contractHash !== rec.contractHash) {
-      fail(`verification contract does not match outcome ${ev.id}`);
-    }
-    rec.verificationAttempts.push(ev);
-    rec.verification = ev;
-    return;
-  }
-  if (ev.type === 'reclaim' || ev.type === 'unreclaim') {
-    const rec = records.get(ev.id);
-    if (!rec) fail(`${ev.type} event references unknown outcome id: ${ev.id}`);
-    if (ev.type === 'reclaim') {
-      if (rec.status === 'in_progress') fail(`cannot reclaim outcome ${ev.id} while it is in_progress`);
-      if (rec.reclaimed) fail(`duplicate reclaim event for outcome id: ${ev.id}`);
-      rec.reclaimed = true;
-      rec.reclaimReason = ev.reason;
-      rec.reclaimedAt = ev.ts;
-    } else {
-      if (!rec.reclaimed) fail(`unreclaim event for outcome id that is not reclaimed: ${ev.id}`);
-      rec.reclaimed = false;
-      rec.reclaimReason = null;
-      rec.reclaimedAt = null;
-    }
-    return;
-  }
-  if (ev.type === 'end') {
-    const rec = records.get(ev.id);
-    if (!rec) fail(`end event references unknown outcome id: ${ev.id}`);
-    if (rec.status !== 'in_progress') fail(`duplicate end event for outcome id: ${ev.id}`);
-    const conflictingCancellation = rec.decisionTerminals.find(
-      (terminal) => terminal.type === 'decision_reconcile_cancel' && terminal.outcomeStatus !== ev.status
-    );
-    if (conflictingCancellation) {
-      fail(`outcome ${ev.id} was closed as ${ev.status} after reconciliation recovery was cancelled for ${conflictingCancellation.outcomeStatus}`);
-    }
-    if (
-      ['completed', 'partial'].includes(ev.status) &&
-      rec.decisions.length > 0 &&
-      ((rec.logVersion === 1 && rec.schemaVersion >= 2 && (ev.schemaVersion || 1) < 2) ||
-        rec.decisions.some((decisionId) => qualifyingDecisionUpdates(rec, decisionId).length === 0))
-    ) {
-      fail(`linked outcome ${ev.id} was closed without reconciling every declared decision`);
-    }
-    if (ev.status === 'completed' && rec.acceptance.length > 0) {
-      if (!rec.verification || !rec.verification.passed) {
-        fail(`acceptance-bound outcome ${ev.id} was completed without successful machine verification`);
-      }
-      if (
-        (rec.logVersion === 1 && (ev.schemaVersion || 1) < 4) ||
-        ev.verificationId !== rec.verification.verificationId ||
-        (ev.workspace ?? null) !== rec.verification.workspace ||
-        (rec.logVersion === LOG_VERSION &&
-          (ev.contractHash !== rec.contractHash || rec.verification.contractHash !== rec.contractHash))
-      ) {
-        fail(`acceptance-bound outcome ${ev.id} was completed with stale machine verification`);
-      }
-    }
-    rec.status = ev.status;
-    rec.tsEnd = ev.ts;
-    rec.note = ev.note || null;
-    rec.verifyResult = ev.verifyResult || null;
-    rec.endHead = ev.head || null;
-    return;
-  }
-  if (ev.type === 'decision_reconcile_prepare') {
-    const rec = records.get(ev.id);
-    if (!rec) fail(`decision reconciliation references unknown outcome id: ${ev.id}`);
-    if (rec.status !== 'in_progress') fail(`decision reconciliation occurred after outcome ${ev.id} was closed`);
-    if (!rec.decisions.includes(ev.decisionId)) fail(`decision reconciliation references unlinked decision ${ev.decisionId}`);
-    if (reconciliations.has(ev.reconciliationId)) fail(`duplicate reconciliation id: ${ev.reconciliationId}`);
-    rec.decisionPrepares.push(ev);
-    reconciliations.set(ev.reconciliationId, {
-      prepare: ev,
-      terminal: null,
-      contractHash: rec.contractHash,
-    });
-    return;
-  }
-  if (ev.type === 'decision_reconcile') {
-    const rec = records.get(ev.id);
-    if (!rec) fail(`decision reconciliation references unknown outcome id: ${ev.id}`);
-    if (rec.status !== 'in_progress') fail(`decision reconciliation occurred after outcome ${ev.id} was closed`);
-    if (rec.logVersion === 1 && rec.schemaVersion >= 2) {
-      fail(`linked legacy schema-v2 outcome ${rec.id} contains a legacy decision reconciliation`);
-    }
-    rec.decisionUpdates.push(ev);
-    return;
-  }
-  if (
-    ev.type === 'decision_reconcile_commit' ||
-    ev.type === 'decision_reconcile_abort' ||
-    ev.type === 'decision_reconcile_cancel'
-  ) {
-    const rec = records.get(ev.id);
-    const reconciliation = reconciliations.get(ev.reconciliationId);
-    if (rec && rec.status !== 'in_progress') fail(`decision reconciliation occurred after outcome ${ev.id} was closed`);
-    if (!rec || !reconciliation || reconciliation.prepare.id !== ev.id || reconciliation.prepare.decisionId !== ev.decisionId) {
-      fail(`decision reconciliation terminal has no matching prepare: ${ev.reconciliationId}`);
-    }
-    if (reconciliation.terminal) fail(`decision reconciliation already has a terminal event: ${ev.reconciliationId}`);
-    const priorCancellation = rec.decisionTerminals.find((terminal) => terminal.type === 'decision_reconcile_cancel');
-    if (ev.type === 'decision_reconcile_cancel' && priorCancellation && priorCancellation.outcomeStatus !== ev.outcomeStatus) {
-      fail(`outcome ${ev.id} has conflicting reconciliation cancellation statuses`);
-    }
-    if (
-      ev.type === 'decision_reconcile_commit' &&
-      (reconciliation.prepare.newHash !== ev.fileHash ||
-        reconciliation.prepare.fromStatus !== ev.fromStatus ||
-        reconciliation.prepare.toStatus !== ev.toStatus)
-    ) {
-      fail(`decision reconciliation commit does not match prepare: ${ev.reconciliationId}`);
-    }
-    reconciliation.terminal = ev;
-    rec.decisionTerminals.push(ev);
-    if (
-      ev.type === 'decision_reconcile_commit' &&
-      reconciliation.contractHash === rec.contractHash
-    ) {
-      rec.decisionUpdates.push(ev);
-    }
-  }
+  return outcomeFoldEngine.applyFoldEvent(state, ev);
 }
 
 function consumeLogSlice(file, startByte, onEvent, { repairTail = false, readOnly = false, startLine = 0 } = {}) {
@@ -1039,111 +848,225 @@ function consumeLogSlice(file, startByte, onEvent, { repairTail = false, readOnl
       }
       onEvent(event, start, pos);
     } catch (err) {
-      if (err instanceof DriftSealError) throw err;
+      if (err instanceof DriftSealError || err instanceof OutcomeIndexError) throw err;
       fail(`corrupt log line ${lineNumber} in ${file}`);
     }
   }
   return { endByte: pos, endLine: lineNumber };
 }
 
-function persistLaneIndex(state, { readOnly = false } = {}) {
-  if (readOnly) return;
-  const file = laneIndexFile();
-  if (!file) return;
-  ensureDirectoryDurable(path.dirname(file));
-  ensureDerivedLaneSidecarIgnore();
-  atomicWriteFile(file, `${JSON.stringify(serializeLaneIndex(state))}\n`, 0o600);
+function replaceOutcomeIndexFile(temporary, target) {
+  try {
+    fs.renameSync(temporary, target);
+  } catch (error) {
+    if (!['EEXIST', 'EPERM'].includes(error && error.code)) throw error;
+    removeIndexFiles(target);
+    fs.renameSync(temporary, target);
+  }
+  fs.chmodSync(target, 0o600);
+  for (const suffix of ['-journal', '-wal', '-shm']) {
+    fs.rmSync(`${target}${suffix}`, { force: true });
+  }
+  fsyncDirectory(path.dirname(target));
 }
 
-function loadPersistedLaneIndex() {
-  const file = laneIndexFile();
-  if (!file || !fs.existsSync(file)) return null;
+function removeLegacyLaneIndex() {
+  fs.rmSync(legacyLaneIndexFile(), { force: true });
+}
+
+function rebuildCommittedOutcomeIndex({ repairTail = false } = {}) {
+  const wal = logFile();
+  const target = laneIndexFile();
+  if (!target) return null;
+  if (!canPersistDerivedOutcomeIndex()) return null;
+  ensureDirectoryDurable(path.dirname(target));
+  const temporary = temporaryIndexPath(target);
+  removeIndexFiles(temporary);
+  let index;
   try {
-    return deserializeLaneIndex(JSON.parse(fs.readFileSync(file, 'utf8')));
-  } catch {
-    return null;
+    index = openOutcomeIndex(temporary);
+    let slice;
+    index.transaction(() => {
+      const indexedEvents = [];
+      slice = consumeLogSlice(
+        wal,
+        0,
+        (event, startByte, endByte) =>
+          indexedEvents.push({ event, startByte, endByte }),
+        { repairTail }
+      );
+      index.replaceFromFoldState(
+        outcomeFoldEngine.foldState(indexedEvents.map((item) => item.event)),
+        indexedEvents
+      );
+      index.setSource(
+        laneIndexSourceIdentity(wal, slice.endByte, slice.endLine),
+        'full'
+      );
+      index.acceptProjection();
+    });
+    if (!index.integrityCheck()) fail('rebuilt SQLite outcome index failed integrity check');
+    index.close();
+    index = null;
+    replaceOutcomeIndexFile(temporary, target);
+    removeLegacyLaneIndex();
+    const reopened = openOutcomeIndex(target);
+    reopened.build = 'full';
+    return reopened;
+  } catch (error) {
+    if (index) index.close();
+    removeIndexFiles(temporary);
+    throw error;
   }
 }
 
-function syncCommittedLaneIndex({ repairTail = false, readOnly = false } = {}) {
-  const file = logFile();
-  let state = loadPersistedLaneIndex();
-  const canIncrement = state && laneIndexMatchesFile(state, file);
-  let indexedThrough = 0;
-  let indexedLines = 0;
-  if (!canIncrement) {
-    state = emptyLaneIndexState();
-    const slice = consumeLogSlice(file, 0, (event, start, end) => applyIndexedEvent(state, event, start, end), {
-      repairTail,
-      readOnly,
-    });
-    indexedThrough = slice.endByte;
-    indexedLines = slice.endLine;
-    state.lastBuild = 'full';
-  } else {
-    const size = fs.existsSync(file) ? fs.statSync(file).size : 0;
-    if (size > state.source.indexedThrough) {
-      const slice = consumeLogSlice(
-        file,
-        state.source.indexedThrough,
-        (event, start, end) => applyIndexedEvent(state, event, start, end),
-        { repairTail, readOnly, startLine: state.source.indexedLines || 0 }
+function syncCommittedLaneIndex({ repairTail = false, readOnly = false, forceFull = false } = {}) {
+  if (process.env._DRIFTSEAL_TEST_DISABLE_OUTCOME_INDEX === '1') return null;
+  const wal = logFile();
+  const target = laneIndexFile();
+  if (!target) return null;
+  if (!readOnly && !canPersistDerivedOutcomeIndex()) return null;
+  if (readOnly) {
+    if (!fs.existsSync(target)) return null;
+    try {
+      const index = openOutcomeIndex(target, { readOnly: true });
+      if (
+        !index.projectionTrusted() ||
+        !laneIndexMatchesFile(index.source(), wal, { exact: true })
+      ) {
+        index.close();
+        return null;
+      }
+      index.build = 'hot';
+      return index;
+    } catch {
+      return null;
+    }
+  }
+  if (forceFull || !fs.existsSync(target)) {
+    try {
+      return rebuildCommittedOutcomeIndex({ repairTail });
+    } catch (error) {
+      if (error instanceof SqliteUnavailableError) return null;
+      throw error;
+    }
+  }
+  let index;
+  try {
+    index = openOutcomeIndex(target);
+    const source = index.source();
+    if (!index.projectionTrusted() || !laneIndexMatchesFile(source, wal)) {
+      index.close();
+      return rebuildCommittedOutcomeIndex({ repairTail });
+    }
+    const size = fs.existsSync(wal) ? fs.statSync(wal).size : 0;
+    if (size === source.indexedThrough) {
+      index.build = 'hot';
+      removeLegacyLaneIndex();
+      return index;
+    }
+    let slice;
+    index.transaction(() => {
+      slice = consumeLogSlice(
+        wal,
+        source.indexedThrough,
+        (event, start, end) =>
+          index.applyEvent(event, start, end, { applyFoldEvent, defaultLane: DEFAULT_LANE }),
+        {
+          repairTail,
+          startLine: source.indexedLines || 0,
+        }
       );
-      indexedThrough = slice.endByte;
-      indexedLines = slice.endLine;
-      state.lastBuild = 'incremental';
-    } else {
-      indexedThrough = size;
-      indexedLines = state.source.indexedLines || 0;
-      state.lastBuild = 'hot';
+      index.setSource(
+        laneIndexSourceIdentity(wal, slice.endByte, slice.endLine),
+        'incremental'
+      );
+      index.acceptProjection();
+    });
+    index.build = 'incremental';
+    removeLegacyLaneIndex();
+    return index;
+  } catch (error) {
+    if (index) index.close();
+    if (error instanceof DriftSealError) throw error;
+    if (error instanceof SqliteUnavailableError) return null;
+    return rebuildCommittedOutcomeIndex({ repairTail });
+  }
+}
+
+function attachIndexedOverlay(index, committed, plan, { readOnly = false } = {}) {
+  const lanes = index.laneCatalog();
+  if (!plan || plan.alreadyCommitted || plan.records.length === 0) {
+    committed.lanes = lanes;
+    return committed;
+  }
+  if (!readOnly && plan.mappings.length > 0) writeJsonl(plan.park, plan.records);
+  const overlay = fold(plan.records.map((record) => record.event));
+  for (const record of overlay) {
+    let lane = lanes.get(record.lane);
+    if (!lane) {
+      const foldedLane = overlay.lanes.get(record.lane);
+      lane = {
+        name: record.lane,
+        description: foldedLane ? foldedLane.description : null,
+        addedAt: foldedLane ? foldedLane.addedAt : null,
+        inferred: foldedLane ? foldedLane.inferred === true : true,
+        head: null,
+        count: 0,
+        visible: 0,
+      };
+      lanes.set(record.lane, lane);
     }
+    lane.count = (lane.count || 0) + 1;
+    if (!record.reclaimed) lane.visible = (lane.visible || 0) + 1;
   }
-  state.source = laneIndexSourceIdentity(file, indexedThrough, indexedLines);
-  linkLaneIndex(state);
-  if (state.lastBuild !== 'hot') persistLaneIndex(state, { readOnly });
-  return state;
+  const records = [...committed, ...overlay];
+  records.lanes = lanes;
+  return records;
 }
 
-function applyOverlayToLaneIndex(state, overlayEvents) {
-  if (!overlayEvents || overlayEvents.length === 0) return state;
-  const next = cloneLaneIndexState(state);
-  for (const event of overlayEvents) applyFoldEvent(next, event);
-  linkLaneIndex(next);
-  return next;
+function queryOutcomeView(index, park, { repairTail = false, readOnly = false } = {}) {
+  const committed = index.queryAll();
+  if (!park || !fs.existsSync(park)) {
+    committed.lanes = index.laneCatalog();
+    return { index: null, records: committed };
+  }
+  const plan = planIndexedInProgressOverlay(index, park, { repairTail, readOnly });
+  if (plan && plan.alreadyCommitted && !readOnly) discardInProgressLog(park);
+  return {
+    index: null,
+    records: attachIndexedOverlay(index, committed, plan, { readOnly }),
+  };
 }
 
-function foldedRecordsFromLaneIndex(state) {
-  const records = state.order.map((id) => state.records.get(id)).filter(Boolean);
-  records.lanes = state.lanes;
-  return records;
+function recoverableOutcomeIndexError(error) {
+  return (
+    error instanceof OutcomeIndexError ||
+    /^SQLITE_|^ERR_SQLITE_/.test(String(error && error.code))
+  );
 }
 
 function loadOutcomeView({ repairTail = false, readOnly = false } = {}) {
-  const committed = syncCommittedLaneIndex({ repairTail, readOnly });
-  const park = inProgressFile();
-  if (!park || !fs.existsSync(park)) {
-    return { state: committed, records: foldedRecordsFromLaneIndex(committed) };
+  const park = existingInProgressFile();
+  let index = syncCommittedLaneIndex({ repairTail, readOnly });
+  if (!index) {
+    const records = fold(readEvents({ repairTail, readOnly }));
+    return { index: null, records };
   }
   try {
-    const committedEvents = readJsonlRecordsFromFile(logFile(), { repairTail, readOnly }).map(
-      (record) => record.event
-    );
-    const overlay = planInProgressOverlay(committedEvents, park, { repairTail, readOnly });
-    if (!overlay || overlay.alreadyCommitted) {
-      if (overlay && overlay.alreadyCommitted && !readOnly) discardInProgressLog(park);
-      return { state: committed, records: foldedRecordsFromLaneIndex(committed) };
-    }
-    if (!readOnly && overlay.mappings.length > 0) writeJsonl(park, overlay.records);
-    const state = applyOverlayToLaneIndex(
-      committed,
-      overlay.records.map((record) => record.event)
-    );
-    return { state, records: foldedRecordsFromLaneIndex(state) };
-  } catch (err) {
-    if (readOnly && err && err.code === 'ENOENT') {
-      return { state: committed, records: foldedRecordsFromLaneIndex(committed) };
-    }
-    throw err;
+    return queryOutcomeView(index, park, { repairTail, readOnly });
+  } catch (error) {
+    index.close();
+    index = null;
+    if (readOnly && (error.code === 'ENOENT' || recoverableOutcomeIndexError(error))) {
+      return { index: null, records: fold(readEvents({ repairTail, readOnly })) };
+    }
+    if (!recoverableOutcomeIndexError(error)) throw error;
+    index = syncCommittedLaneIndex({ repairTail, forceFull: true });
+    if (!index) return { index: null, records: fold(readEvents({ repairTail })) };
+    return queryOutcomeView(index, park, { repairTail });
+  } finally {
+    if (index) index.close();
   }
 }
 
@@ -1213,6 +1136,53 @@ function selectLastLogRecords(records, current, n) {
   return [...clipped, ...extras].sort((left, right) => order.get(left.id) - order.get(right.id));
 }
 
+function indexedLaneSummary(state, name) {
+  const lane = state.lanes.get(name);
+  return {
+    name,
+    description: lane ? lane.description : null,
+    addedAt: lane ? lane.addedAt : null,
+    inferred: Boolean(lane && lane.inferred),
+    visible: lane ? lane.visible : 0,
+    count: lane ? lane.count : 0,
+  };
+}
+
+function tryLoadRecentOutcomeView(n, { includeReclaimed = false, repairTail = false, readOnly = false } = {}) {
+  const park = existingInProgressFile();
+  let index = syncCommittedLaneIndex({ repairTail, readOnly });
+  if (!index) return null;
+  const query = () => {
+    const plan =
+      park && fs.existsSync(park)
+        ? planIndexedInProgressOverlay(index, park, { repairTail, readOnly })
+        : null;
+    if (plan && plan.alreadyCommitted && !readOnly) discardInProgressLog(park);
+    const overlayView = attachIndexedOverlay(index, [], plan, { readOnly });
+    const state = { lanes: overlayView.lanes };
+    const { current, missing } = resolveCurrentLane(state);
+    const committed = index.queryRecent(current, n, { includeReclaimed });
+    const records = selectLastLogRecords(
+      [...committed, ...overlayView],
+      current,
+      n
+    );
+    return { state, records, current, missing };
+  };
+  try {
+    return query();
+  } catch (error) {
+    if (readOnly && error && error.code === 'ENOENT') return null;
+    index.close();
+    index = null;
+    if (readOnly) return null;
+    index = syncCommittedLaneIndex({ repairTail, forceFull: true });
+    return query();
+  } finally {
+    if (index) index.close();
+  }
+}
+
 function liveWorktreeOutcomeLog() {
   const root = gitWorktreeRoot();
   if (!root) return null;
@@ -1234,7 +1204,7 @@ function readJsonlRecordsFromFile(file, { repairTail = false, readOnly = false }
   if (
     readOnly &&
     process.env._DRIFTSEAL_TEST_UNLINK_PARK_BEFORE_READ === '1' &&
-    path.basename(file) === IN_PROGRESS_GIT_PATH
+    path.basename(file) === IN_PROGRESS_SIDECAR
   ) {
     // Simulate a writer flushing and unlinking the park between the existence
     // check and the read; the next attempt sees the park as absent.
@@ -1294,14 +1264,35 @@ function planInProgressOverlay(committedEvents, park, { repairTail = false, read
   return { park, records: remapped.records, mappings: remapped.mappings, alreadyCommitted: false };
 }
 
+function planIndexedInProgressOverlay(index, park, { repairTail = false, readOnly = false } = {}) {
+  if (!park || !fs.existsSync(park)) return null;
+  const overlayRecords = readJsonlRecordsFromFile(park, { repairTail, readOnly });
+  const overlayEvents = overlayRecords.map((record) => record.event);
+  if (overlayEvents.length === 0 || index.containsEventSequence(overlayEvents)) {
+    return { park, records: [], mappings: [], alreadyCommitted: true };
+  }
+  const remapped = remapTheirsRecords(
+    overlayRecords,
+    index.outcomeStartEvents(),
+    new Map(),
+    new Map()
+  );
+  return {
+    park,
+    records: remapped.records,
+    mappings: remapped.mappings,
+    alreadyCommitted: false,
+  };
+}
+
 function discardInProgressLog(park) {
-  fs.unlinkSync(park);
+  fs.rmSync(park, { force: true });
   fsyncDirectory(path.dirname(park));
 }
 
 function reconcileInProgressRecords(
   committedEvents,
-  { repairTail = false, readOnly = false, park = inProgressFile() } = {}
+  { repairTail = false, readOnly = false, park = existingInProgressFile() } = {}
 ) {
   const plan = planInProgressOverlay(committedEvents, park, { repairTail, readOnly });
   if (!plan) return [];
@@ -1323,7 +1314,7 @@ function readEventsSnapshot(file, { repairTail = false, readOnly = false } = {})
     reconcileInProgressRecords(events, {
       repairTail,
       readOnly,
-      park: worktreeInProgressFile(),
+      park: existingInProgressFileForLog(file),
     }).map((record) => record.event)
   );
 }
@@ -1452,7 +1443,7 @@ function appendEventTo(file, event) {
  * Returns the outcome ids it had to remap.
  */
 function flushInProgressLog() {
-  const park = inProgressFile();
+  const park = adoptInProgressFile();
   if (!park || !fs.existsSync(park)) return new Map();
   const committedRecords = readJsonlRecordsFromFile(logFile());
   const plan = planInProgressOverlay(
@@ -1482,7 +1473,8 @@ function parkedOpenOutcome(park) {
 }
 
 function appendEvent(event) {
-  const park = inProgressFile();
+  ensureDerivedLaneSidecarIgnore();
+  const park = adoptInProgressFile();
   if (!park) {
     const stored = appendEventTo(logFile(), event);
     if (event.type === 'begin') writeLocalOutcomeProvenance(stored);
@@ -1497,7 +1489,7 @@ function appendEvent(event) {
   if (event.type === 'begin') return appendEventTo(park, event);
   if (!open || open.id !== event.id) return appendEventTo(logFile(), event);
   if (event.type !== 'end') return appendEventTo(park, event);
-  // Close in the tracked log, never in Git metadata: the parked records move first, so the
+  // Close in the tracked log, never only in the park: the parked records move first, so the
   // closing record cannot end up somewhere a clone or a removed worktree would drop it.
   const remapped = flushInProgressLog();
   if (process.env._DRIFTSEAL_TEST_CRASH_AFTER_IN_PROGRESS_FLUSH === '1') {
@@ -1511,11 +1503,7 @@ function contentHash(content) {
 }
 
 function localOutcomeProvenanceFile() {
-  const root = gitWorktreeRoot();
-  const key = contentHash(path.resolve(logFile())).slice(0, 16);
-  if (!root) return path.join(logDir(), LOCAL_OUTCOME_PROVENANCE_FILE);
-  const gitPath = gitCapture(['rev-parse', '--git-path', `driftseal-local-outcome-${key}.json`]);
-  return gitPath ? path.resolve(process.cwd(), gitPath) : null;
+  return path.join(logDir(), LOCAL_OUTCOME_PROVENANCE_FILE);
 }
 
 function localOutcomeLogIdentity() {
@@ -1534,6 +1522,7 @@ function localOutcomeProvenanceFingerprint({ id, ts, verify }) {
 function writeLocalOutcomeProvenance(event) {
   const file = localOutcomeProvenanceFile();
   if (!file) return;
+  ensureDerivedLaneSidecarIgnore();
   ensureDirectoryDurable(path.dirname(file));
   atomicWriteFile(
     file,
@@ -1547,8 +1536,7 @@ function writeLocalOutcomeProvenance(event) {
   );
 }
 
-function readLocalOutcomeProvenance() {
-  const file = localOutcomeProvenanceFile();
+function parseLocalOutcomeProvenance(file) {
   if (!file || !fs.existsSync(file)) return null;
   try {
     const provenance = JSON.parse(fs.readFileSync(file, 'utf8'));
@@ -1566,6 +1554,10 @@ function readLocalOutcomeProvenance() {
   }
 }
 
+function readLocalOutcomeProvenance() {
+  return parseLocalOutcomeProvenance(localOutcomeProvenanceFile());
+}
+
 function hasMatchingLocalOutcomeProvenance(outcome) {
   const provenance = readLocalOutcomeProvenance();
   return (
@@ -1582,11 +1574,13 @@ function hasMatchingLocalOutcomeProvenance(outcome) {
 }
 
 function clearLocalOutcomeProvenance(id) {
-  const file = localOutcomeProvenanceFile();
   const provenance = readLocalOutcomeProvenance();
-  if (!file || !provenance || provenance.id !== id) return;
-  fs.unlinkSync(file);
-  fsyncDirectory(path.dirname(file));
+  if (!provenance || provenance.id !== id) return;
+  const file = localOutcomeProvenanceFile();
+  if (file && fs.existsSync(file)) {
+    fs.unlinkSync(file);
+    fsyncDirectory(path.dirname(file));
+  }
 }
 
 function atomicWriteFile(target, content, createMode = 0o644) {
@@ -1867,77 +1861,20 @@ function withMutationLocks(resources, action, { tryWaitMs } = {}) {
 }
 
 function outcomeContractHash(record) {
-  return contentHash(JSON.stringify({
-    outcome: record.outcome,
-    extensions: record.extensions.map(({ extension, acceptance, verify, decisions }) => ({
-      extension,
-      acceptance,
-      verify,
-      decisions,
-    })),
-    acceptance: record.acceptance,
-    verify: record.verify,
-    decisions: record.decisions,
-  }));
+  return outcomeFoldEngine.outcomeContractHash(record);
 }
 
 function newOutcomeRecord(ev) {
-  const record = {
-    id: ev.id,
-    tsBegin: ev.ts,
-    outcome: ev.outcome,
-    extensions: [],
-    acceptance: Array.isArray(ev.acceptance) ? ev.acceptance : [],
-    verify: ev.verify || null,
-    beginHead: ev.head || null,
-    decisions: Array.isArray(ev.decisions) ? ev.decisions : [],
-    logVersion: ev.logVersion || 1,
-    schemaVersion: ev.schemaVersion || 1,
-    lane: ev.lane || DEFAULT_LANE,
-    decisionPrepares: [],
-    decisionTerminals: [],
-    decisionUpdates: [],
-    verificationAttempts: [],
-    verification: null,
-    status: 'in_progress',
-    tsEnd: null,
-    note: null,
-    verifyResult: null,
-    endHead: null,
-    reclaimed: false,
-    reclaimReason: null,
-    reclaimedAt: null,
-    imported: null,
-    contractHash: null,
-  };
-  record.contractHash = outcomeContractHash(record);
-  return record;
+  return outcomeFoldEngine.newOutcomeRecord(ev);
 }
 
 /** Fold the event stream into one record per outcome. Legacy v1 events are accepted for migration. */
 function fold(events) {
-  const state = {
-    records: new Map(),
-    reconciliations: new Map(),
-    order: [],
-    lanes: emptyLaneCatalog(),
-  };
-  for (const ev of events) applyFoldEvent(state, ev);
-  const folded = state.order.map((id) => state.records.get(id));
-  folded.lanes = state.lanes;
-  return folded;
+  return outcomeFoldEngine.fold(events);
 }
 
 function qualifyingDecisionUpdates(record, decisionId) {
-  return record.decisionUpdates.filter((update) => {
-    if (update.decisionId !== decisionId) return false;
-    if (record.logVersion === 1 && record.schemaVersion < 2) return true;
-    return (
-      update.type === 'decision_reconcile_commit' &&
-      (update.logVersion === LOG_VERSION || (update.schemaVersion || 1) >= 2) &&
-      typeof update.fileHash === 'string'
-    );
-  });
+  return outcomeFoldEngine.qualifyingDecisionUpdates(record, decisionId);
 }
 
 function openOutcome(records) {
@@ -3482,6 +3419,8 @@ const SKILL_RELEASE_DIGESTS = new Set([
   '42a0549dff21483c0508ea4a79658e7bf05cd98f8af4238c95dbd23cdcde7ee6', // 2.0.0 outcome workflow
   '38e89060ff37ecdd663eae73a3e0c646d6bb220fc8232a5762356375d84ba69b', // 2.1.0 outcome lanes
   'b4b2cc27ea71c5777b5eb9b67d861fbe1da43f31ab5d422d6a877e0cad592493', // 2.1.0 lane re-anchor recovery
+  '6c49523c2f4a36ea1cd9d0b4e793ea3cdbd9d299174cf1f9a0a54f3d9a7cd331', // workspace park sidecar wording
+  '678cbaa8380f75f7a45d634010b500e51a59b06ea759eaf23cff2980142662f0', // default-seal parking help wording
 ]);
 
 function skillInstallUsage() {
@@ -3903,11 +3842,9 @@ function hookLogFile() {
   const root = gitWorktreeRoot(current);
   while (true) {
     const candidate = path.join(current, '.seal', 'outcomes', 'events.jsonl');
-    if (fs.existsSync(candidate)) return candidate;
-    if (root && path.resolve(root) === current) {
-      const park = worktreeInProgressFile(current);
-      if (park && fs.existsSync(park)) return candidate;
-    }
+    const workspacePark = path.join(current, '.seal', 'outcomes', IN_PROGRESS_SIDECAR);
+    if (fs.existsSync(candidate) || fs.existsSync(workspacePark)) return candidate;
+    if (root && path.resolve(root) === current) return null;
     const parent = path.dirname(current);
     if (parent === current) return null;
     current = parent;
@@ -4740,8 +4677,12 @@ function finishAbsorb({
   allowConflict = false,
   followupMessage = null,
 }) {
-  // An outcome parked in Git metadata is part of our side even though the log never saw it.
-  const park = shouldAttachInProgress(outputFile) ? inProgressFile() : null;
+  // A parked outcome is local even though the tracked log never saw it.
+  const park = shouldAttachInProgress(outputFile)
+    ? dryRun
+      ? existingInProgressFileForLog(outputFile)
+      : adoptInProgressFile() || existingInProgressFileForLog(outputFile)
+    : null;
   const plan = planInProgressOverlay(result.map((record) => record.event), park, {
     repairTail: true,
   });
@@ -5112,7 +5053,7 @@ function runMachineVerification({ allowTrackedCommand = false } = {}) {
       fail(`outcome ${outcome.id} has no acceptance criteria; declare them with driftseal begin --accept`);
     }
     if (!outcome.verify) fail(`outcome ${outcome.id} has no verification command`);
-    const park = inProgressFile();
+    const park = existingInProgressFile();
     const parked = park ? parkedOpenOutcome(park) : null;
     const locallyProvenanced = hasMatchingLocalOutcomeProvenance(outcome);
     return {
@@ -6294,16 +6235,47 @@ const commands = {
       'all-lanes': 'boolean',
     }, 'log');
     if (positionals.length > 0) fail(usageFor('log'));
+    const n = flags.last === undefined ? null : positiveInteger(flags.last, '--last');
+    const allLanes = flags['all-lanes'] === true;
+    const parkedV1 = legacyParkedIntent();
+    if (
+      n !== null &&
+      !allLanes &&
+      !parkedV1 &&
+      process.env._DRIFTSEAL_TEST_DISABLE_RECENT_INDEX !== '1'
+    ) {
+      const recent = tryLoadRecentOutcomeView(n, {
+        includeReclaimed: flags.all === true,
+        repairTail: true,
+        readOnly,
+      });
+      if (recent) {
+        const { state, records, current, missing } = recent;
+        warnMissingCurrentLane(missing);
+        const customLanes = state.lanes.size > 1;
+        if (customLanes || current !== DEFAULT_LANE || missing) {
+          const summary = indexedLaneSummary(state, current);
+          printLine(`lane: ${current} (${summary.visible} visible / ${summary.count} in lane)`);
+        }
+        if (records.length === 0) {
+          printLine('log is empty');
+          return [];
+        }
+        printLine(records.map((record) => render(record, { currentLane: current })).join('\n\n'));
+        return records.map(publicOutcome);
+      }
+    }
+    if (process.env._DRIFTSEAL_TEST_REQUIRE_RECENT_INDEX === '1' && n !== null && !allLanes) {
+      fail('recent lane index fast path was not used');
+    }
     const view = loadOutcomeView({ repairTail: true, readOnly });
     let records = view.records;
-    const parkedV1 = legacyParkedIntent();
     if (parkedV1 && !records.some((record) => record.id === parkedV1.id && record.status === 'in_progress')) {
       records = Object.assign([...records, parkedV1], { lanes: records.lanes });
     }
     const catalog = records.lanes || emptyLaneCatalog();
     const { current, missing } = resolveCurrentLane(view.records);
     warnMissingCurrentLane(missing);
-    const allLanes = flags['all-lanes'] === true;
     if (!allLanes) {
       records = Object.assign(selectLaneLogRecords(records, current), { lanes: catalog });
     }
@@ -6313,8 +6285,7 @@ const commands = {
       printLine(renderLaneLine(view.records, current));
     }
     let shown = visible;
-    if (flags.last) {
-      const n = positiveInteger(flags.last, '--last');
+    if (n !== null) {
       shown = selectLastLogRecords(visible, current, n);
     }
     if (shown.length === 0) {
@@ -6781,10 +6752,11 @@ const commands = {
     } catch (err) {
       printLine(`warning: could not configure git merge driver: ${err && err.message ? err.message : err}`);
     }
+    const indexIgnore = ensureDerivedLaneSidecarIgnore();
 
     if (localLog) warnIfDefaultLogsTracked();
 
-    if (updated === current && !attributes.changed && !driver.changed) {
+    if (updated === current && !attributes.changed && !driver.changed && !indexIgnore.changed) {
       printLine('AGENTS.md already contains the DriftSeal protocols; nothing to do');
       return { changed: false, target };
     }
@@ -6798,6 +6770,9 @@ const commands = {
     if (driver.changed) {
       printLine('Configured local git merge driver for DriftSeal outcome logs');
     }
+    if (indexIgnore.changed) {
+      printLine(`Configured derived outcome-index ignore: ${indexIgnore.target}`);
+    }
     return { changed: true, target };
   },
 
@@ -6875,7 +6850,7 @@ seal root: $DRIFTSEAL_HOME, or .seal in the current directory
 outcome log: <seal-root>/outcomes/events.jsonl
 MADR records: <seal-root>/madr/
 $DRIFTSEAL_DECISION_HOME is a v1-only default for migration source detection; v2 runtime ignores it.
-In a Git worktree, begin parks an open outcome in Git metadata until end, so merge does not need a log-only commit.`);
+In a default Git-repository seal, begin parks an open outcome beside the WAL until end, so merge does not need a log-only commit. Custom $DRIFTSEAL_HOME seals write that open outcome directly to events.jsonl.`);
     return null;
   },
 
@@ -7035,9 +7010,52 @@ function repositoryOutcomeLogFiles() {
   return files;
 }
 
+function indexedMigrationEvent(file) {
+  if (
+    canonicalPath(file) !== canonicalPath(logFile()) ||
+    !laneIndexFile() ||
+    !fs.existsSync(laneIndexFile())
+  ) {
+    return { usable: false, migration: null };
+  }
+  let index;
+  try {
+    index = openOutcomeIndex(laneIndexFile(), { readOnly: true });
+    const source = index.source();
+    if (!laneIndexMatchesFile(source, file)) {
+      return { usable: false, migration: null };
+    }
+    let migration = index.migrationEvent();
+    const size = fs.existsSync(file) ? fs.statSync(file).size : 0;
+    if (size > source.indexedThrough) {
+      consumeLogSlice(
+        file,
+        source.indexedThrough,
+        (event) => {
+          if (event.type === 'migration' && event.id === 'v1-to-v2') migration = event;
+        },
+        {
+          readOnly: true,
+          startLine: source.indexedLines || 0,
+        }
+      );
+    }
+    return { usable: true, migration };
+  } catch {
+    return { usable: false, migration: null };
+  } finally {
+    if (index) index.close();
+  }
+}
+
 function repositoryMigrationEvent() {
   for (const file of repositoryOutcomeLogFiles()) {
     try {
+      const indexed = indexedMigrationEvent(file);
+      if (indexed.usable) {
+        if (indexed.migration) return indexed.migration;
+        continue;
+      }
       const migration = findMigrationEvent(file);
       if (migration) return migration;
     } catch {
@@ -7244,7 +7262,7 @@ function dispatch(argv) {
         if (cmd === 'hook') {
           // Hooks read the nearest ancestor log, not the cwd-relative one: lock
           // the directory of the file the hook will actually read (the park a
-          // writer flushes under that same lock lives in the repo's Git metadata).
+          // writer flushes under that same lock lives beside the WAL).
           // With no ancestor log the hook prints nothing, so skip locking — this
           // also avoids creating a spurious <cwd>/.intent-log.
           const hookFile = hookLogFile();
@@ -7252,6 +7270,14 @@ function dispatch(argv) {
           resources = [path.dirname(hookFile)];
         } else if (legacyParkedIntent()) {
           resources = [path.dirname(legacyIntentLogFile())];
+        } else if (!fs.existsSync(logDir())) {
+          // Do not mkdir a cwd-relative seal just to lock a read: status/log
+          // from a subdirectory would otherwise plant packages/**/.seal.
+          const data = fn(rest, { readOnly: true });
+          return {
+            data,
+            exitCode: data && Number.isInteger(data.exitCode) ? data.exitCode : 0,
+          };
         } else {
           resources = [logDir()];
         }
@@ -7305,6 +7331,7 @@ function repositoryRoot(root) {
 }
 
 function runCommand(argv, { root = process.cwd(), isolateStorage = false, capture = true } = {}) {
+  assertSupportedNode();
   if (!Array.isArray(argv) || argv.some((arg) => typeof arg !== 'string')) {
     fail('command arguments must be an array of strings');
   }
@@ -7365,6 +7392,7 @@ function appendFlag(argv, flag, value) {
 }
 
 function createApi({ root = process.cwd(), isolateStorage = false } = {}) {
+  assertSupportedNode();
   const fixedRoot = repositoryRoot(root);
   let lastReadOnly = false;
   const call = (argv) => {
@@ -7501,6 +7529,7 @@ function createApi({ root = process.cwd(), isolateStorage = false } = {}) {
 
 function main() {
   try {
+    assertSupportedNode();
     const result = dispatch(process.argv.slice(2));
     process.exitCode = result.exitCode;
   } catch (err) {