@quolu/lattice 0.12.34 → 0.14.0

package/src/todo-cli.mjs

@@ -36,9 +36,14 @@ import {
   applyTodoRevisionSet,
   createTodoStoreWriter,
   TodoStoreError,
+  readTodoIndependenceArtifact,
   readTodoStore,
+  readTodoWitnessSet,
+  todoWitnessRef,
+  writeTodoWitnessSet,
   readTodoStoreStable,
   rebuildTodoSnapshot,
+  writeTodoIndependenceArtifact,
   verifyEffectivePhaseTodoRevisionSources,
   verifyTodoRevisionSources,
 } from './todo-store.mjs';
@@ -46,7 +51,23 @@ import {
   appendTodoExtraction,
   validateTodoExtraction,
 } from './todo-migration.mjs';
-import { projectTodoBindings, projectTodoStatus } from './todo-status.mjs';
+import {
+  computeReadyFrontier,
+  projectTodoBindings,
+  projectTodoStatus,
+} from './todo-status.mjs';
+import {
+  TODO_INDEPENDENCE_PROJECTION_SCHEMA,
+  explainTodoWitnessSet,
+  validateTodoIndependenceProjection,
+} from './todo-independence-contracts.mjs';
+import {
+  collectWitnessSensorEvidence,
+  compileTodoIndependence,
+  migrateWitnessSetTaskIds,
+  projectIndependenceFrontier,
+} from './todo-independence.mjs';
+import { selectIndependenceGuidance } from './todo-independence-guidance.mjs';
 import {
   parseTodoSourceRef, todoLegacyReconciliationDigest, validatePhaseTodoRevision,
   validateTodoRevision, validateTodoRevisionSet,
@@ -227,6 +248,12 @@ async function readRevisionInput(repoRoot, inputRef, {
 }
 
 async function readEvidenceInput(repoRoot, inputRef) {
+  return readJsonInput(repoRoot, inputRef, {
+    validate: validateEvidenceDescriptor, invalidCode: 'INVALID_EVIDENCE',
+  });
+}
+
+async function readJsonInput(repoRoot, inputRef, { validate, invalidCode }) {
   if (!isTodoRef(inputRef)) {
     throw new TodoStoreError('INPUT_UNREADABLE', 'input_path_outside_repo', undefined, { input_ref: inputRef });
   }
@@ -270,12 +297,32 @@ async function readEvidenceInput(repoRoot, inputRef) {
   try { descriptor = JSON.parse(text); } catch {
     throw new TodoStoreError('INVALID_JSON', 'json_parse_failed');
   }
-  if (!validateEvidenceDescriptor(descriptor)) {
-    throw new TodoStoreError('INVALID_EVIDENCE', 'schema_invalid');
+  if (!validate(descriptor)) {
+    throw new TodoStoreError(invalidCode, 'schema_invalid');
   }
   return descriptor;
 }
 
+/** 安全読み取りとcanonical JSON規律を共有したまま、witness set契約で検証する。 */
+async function readWitnessSetInput(repoRoot, inputRef) {
+  let explained = null;
+  const witnessSet = await readJsonInput(repoRoot, inputRef, {
+    validate: (value) => {
+      explained = explainTodoWitnessSet(value);
+      return explained.valid;
+    },
+    invalidCode: 'INVALID_TODO_WITNESS_SET',
+  }).catch((error) => {
+    if (error?.code === 'INVALID_TODO_WITNESS_SET' && explained !== null) {
+      throw new TodoStoreError('INVALID_TODO_WITNESS_SET', explained.reason, undefined, {
+        input_ref: inputRef, path: explained.path,
+      });
+    }
+    throw error;
+  });
+  return witnessSet;
+}
+
 function mutationActor(env) {
   const entries = ACTOR_ENV_KEYS.map((key) => ({ key, value: env[key] }));
   const missingEnvironment = entries
@@ -295,7 +342,9 @@ function mutationActor(env) {
   return { host: entries[0].value, session: entries[1].value, agent: entries[2].value };
 }
 
-async function mutate({ repoRoot, env, planKey, taskId, kind, payload, evidenceRef }) {
+async function mutate({
+  repoRoot, env, planKey, taskId, kind, payload, evidenceRef, advisory = null,
+}) {
   const actor = mutationActor(env);
   const evidence = evidenceRef === null ? null : await readEvidenceInput(repoRoot, evidenceRef);
   let eventPayload = payload;
@@ -311,7 +360,7 @@ async function mutate({ repoRoot, env, planKey, taskId, kind, payload, evidenceR
   });
   const task = snapshot.tasks.find(({ task_id: current }) => current === event.task_id);
   const result = {
-    schema: 'lattice.todo_mutation_result.v1',
+    schema: 'lattice.todo_mutation_result.v2',
     project_id: event.project_id,
     plan_key: event.plan_key,
     plan_version: event.plan_version,
@@ -322,14 +371,86 @@ async function mutate({ repoRoot, env, planKey, taskId, kind, payload, evidenceR
     journal_head_digest: event.event_digest,
     snapshot_digest: snapshot.snapshot_digest,
     status: task.status,
+    advisory,
     result_digest: '',
   };
   result.result_digest = todoSelfDigest(result, 'result_digest');
   return result;
 }
 
+/**
+ * 着手しようとしているtaskについて、記録済みの独立性から助言を組む（ADR 0128 Decision 5）。
+ *
+ * 助言であって拒否ではない。ADR 0063のdispatch契約は変えない。ただし助言を計算できない
+ * 状況——git HEADが読めない等——はsilent degradeせず、呼び出し側でstart自体を止める。
+ */
+async function startAdvisory({ repoRoot, store, projection, planKey, taskId }) {
+  const artifact = await readTodoIndependenceArtifact({ repoRoot, store, planKey });
+  if (artifact === null) {
+    // 記録が無ければ鮮度を語る相手がいない。HEADを要求すると、commitがまだ無いrepoで
+    // 「判定できない」でなく「startできない」になってしまう。
+    return {
+      coverage: 'missing',
+      drift_intersecting: null,
+      conflicts_with_active: [],
+      uncovered_active_task_ids: projection.active_set
+        .filter((task) => task.plan_key === planKey).map(({ task_id: id }) => id),
+      self_unknowns: [{ kind: 'witness_missing', ref: 'no_independence_record' }],
+      guidance: selectIndependenceGuidance({
+        coverage: 'missing', taskDeclared: false, taskStale: false,
+      }),
+    };
+  }
+  // 記録があるなら鮮度の判定にHEADが要る。ここで読めないのは判定不能であり、
+  // 助言なしで通してよい状態ではない。
+  const currentBaseSha = currentHeadSha(repoRoot);
+  const changedPaths = artifact.base_sha !== currentBaseSha
+    ? changedPathsSince(repoRoot, artifact.base_sha) : null;
+  const member = store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
+  const projected = projectIndependenceFrontier({
+    artifact,
+    readyTaskIds: projection.next_ready
+      .filter((task) => task.plan_key === planKey).map(({ task_id: id }) => id),
+    activeTaskIds: projection.active_set
+      .filter((task) => task.plan_key === planKey).map(({ task_id: id }) => id),
+    plan: member?.plan ?? { plan_version: null, topology_digest: null },
+    currentBaseSha,
+    changedPaths,
+  });
+  const selfUnknowns = projected.frontier.unknown
+    .find((entry) => entry.task_id === taskId)?.unknowns ?? [];
+  const conflictsWithActive = projected.frontier.conflicts_with_active
+    .filter((entry) => entry.ready_task_id === taskId)
+    .map((entry) => ({
+      active_task_id: entry.active_task_id,
+      type: entry.type,
+      detail: entry.detail,
+      kind: entry.kind,
+      severability: entry.severability,
+    }));
+  const readyConflict = projected.frontier.serialize_pairs
+    .find((pair) => pair.task_ids.includes(taskId)) ?? null;
+  const declared = !selfUnknowns.some(({ kind }) => kind === 'witness_missing');
+  return {
+    coverage: projected.coverage,
+    drift_intersecting: projected.drift === null
+      ? null : projected.drift.intersecting_task_ids.includes(taskId),
+    conflicts_with_active: conflictsWithActive,
+    uncovered_active_task_ids: projected.uncovered_active_task_ids,
+    self_unknowns: selfUnknowns,
+    guidance: selectIndependenceGuidance({
+      coverage: projected.coverage,
+      taskDeclared: declared,
+      taskStale: selfUnknowns.some(({ kind }) => kind === 'record_stale'),
+      conflictWithActive: conflictsWithActive[0]?.severability ?? null,
+      conflictBetweenReady: readyConflict?.severability ?? null,
+    }),
+  };
+}
+
 async function startTask({ repoRoot, env, planKey, taskId, overrideReason, parallelFrontier }) {
-  const projection = projectTodoStatus(await readTodoStore({ repoRoot }));
+  const store = await readTodoStore({ repoRoot });
+  const projection = projectTodoStatus(store);
   const readyTask = projection.next_ready.find((task) => (
     task.plan_key === planKey && task.task_id.toLowerCase() === taskId.toLowerCase()
   ));
@@ -347,8 +468,13 @@ async function startTask({ repoRoot, env, planKey, taskId, overrideReason, paral
         serial_reason_flag: '--override-reason',
       });
   }
-  return mutate({ repoRoot, env, planKey, taskId: readyTask?.task_id ?? taskId, kind: 'start',
-    payload: { override_reason: overrideReason }, evidenceRef: null });
+  const resolvedTaskId = readyTask?.task_id ?? taskId;
+  // 助言はjournalへ書く前に確定させる。計算できないならstart自体を止める。
+  const advisory = await startAdvisory({
+    repoRoot, store, projection, planKey, taskId: resolvedTaskId,
+  });
+  return mutate({ repoRoot, env, planKey, taskId: resolvedTaskId, kind: 'start',
+    payload: { override_reason: overrideReason }, evidenceRef: null, advisory });
 }
 
 function validatePhaseDecisionInput(value, outcome) {
@@ -478,6 +604,229 @@ async function bindings({ repoRoot, requestedPlanKey }) {
   return projectTodoBindings(await readTodoStore({ repoRoot }), { requestedPlanKey });
 }
 
+function currentHeadSha(repoRoot) {
+  let head;
+  try {
+    head = execFileSync('git', ['rev-parse', 'HEAD'], {
+      cwd: repoRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    throw new TodoStoreError('INDEPENDENCE_BASE_UNRESOLVED', 'git_head_unresolved');
+  }
+  if (!/^[0-9a-f]{40}$/u.test(head)) {
+    throw new TodoStoreError('INDEPENDENCE_BASE_UNRESOLVED', 'git_head_invalid');
+  }
+  return head;
+}
+
+/**
+ * `base_sha..HEAD`で変わったrepo相対pathを返す。
+ *
+ * baseがgit historyから到達できない場合（rebase・shallow等）はnullを返す。
+ * 「変更なし」の空配列と「差分を確定できない」を同じ顔にしない——前者は記録の有効性を
+ * 支える事実だが、後者は支えない（ADR 0128 Decision 4）。
+ */
+function changedPathsSince(repoRoot, baseSha) {
+  try {
+    execFileSync('git', ['cat-file', '-e', `${baseSha}^{commit}`], {
+      cwd: repoRoot, stdio: ['ignore', 'ignore', 'ignore'],
+    });
+  } catch {
+    return null;
+  }
+  let output;
+  try {
+    output = execFileSync('git', ['diff', '--name-only', '--no-renames', `${baseSha}..HEAD`], {
+      cwd: repoRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    });
+  } catch {
+    return null;
+  }
+  return [...new Set(output.split('\n').map((line) => line.trim()).filter((line) => line.length > 0))]
+    .sort();
+}
+
+function requireCleanWorktree(repoRoot) {
+  let porcelain;
+  try {
+    porcelain = execFileSync('git', ['status', '--porcelain'], {
+      cwd: repoRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    });
+  } catch {
+    throw new TodoStoreError('INDEPENDENCE_BASE_UNRESOLVED', 'git_status_unresolved');
+  }
+  const dirty = porcelain.split('\n').filter((line) => line.trim().length > 0);
+  if (dirty.length > 0) {
+    // 未commitの観測を検証済み証拠として固定化しない（ADR 0127 Decision 3）。
+    throw new TodoStoreError('INDEPENDENCE_WORKTREE_DIRTY', 'worktree_not_clean', undefined, {
+      changed_entries: dirty.length,
+      next_action: 'commit_or_stash_then_retry',
+    });
+  }
+}
+
+async function independenceCompile({ repoRoot, planKey, inputRef }) {
+  const witnessSet = await readWitnessSetInput(repoRoot, inputRef);
+  requireCleanWorktree(repoRoot);
+  const baseSha = currentHeadSha(repoRoot);
+  const store = await readTodoStore({ repoRoot });
+  const member = store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
+  if (!member) throw new TodoStoreError('STORE_INCONSISTENT', 'plan_not_active', undefined, { plan_key: planKey });
+
+  const artifact = compileTodoIndependence({
+    witnessSet,
+    plan: member.plan,
+    baseSha,
+    compiledAt: new Date().toISOString(),
+    sensorEvidence: await collectWitnessSensorEvidence({ cwd: repoRoot, witnessSet }),
+  });
+  const { ref } = await writeTodoIndependenceArtifact({ repoRoot, artifact });
+
+  const result = {
+    schema: 'lattice.todo_independence_compile_result.v1',
+    project_id: artifact.project_id,
+    plan_key: artifact.plan_key,
+    plan_version: artifact.plan_version,
+    base_sha: artifact.base_sha,
+    artifact_ref: ref,
+    outcome: artifact.outcome,
+    task_count: artifact.task_ids.length,
+    conflict_count: artifact.conflicts.length,
+    unknown_count: artifact.unknowns.length,
+    result_digest: '',
+  };
+  result.result_digest = todoSelfDigest(result, 'result_digest');
+  return result;
+}
+
+/**
+ * revision後のwitness宣言をtask migrationで写す（ADR 0128 Decision 6）。
+ *
+ * compileしないので証拠を固定化せず、dirty worktreeを拒否しない。
+ * 想定運用は「移行 → commit → cleanな状態でcompile」である。
+ */
+async function independenceWitnessMigrate({ repoRoot, planKey }) {
+  const store = await readTodoStore({ repoRoot });
+  const member = store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
+  if (!member) {
+    throw new TodoStoreError('STORE_INCONSISTENT', 'plan_not_active', undefined, { plan_key: planKey });
+  }
+  const witnessSet = await readTodoWitnessSet({ repoRoot, planKey });
+  if (witnessSet === null) {
+    throw new TodoStoreError('WITNESS_MIGRATION_UNAVAILABLE', 'witness_set_absent', undefined, {
+      witness_ref: todoWitnessRef(planKey),
+    });
+  }
+  const revision = member.revision;
+  if (!revision || !Array.isArray(revision.task_migration)) {
+    // revisionを経ていないplanには写す先が無い。「移行済み」と装わない。
+    throw new TodoStoreError('WITNESS_MIGRATION_UNAVAILABLE', 'plan_has_no_revision', undefined, {
+      plan_key: planKey, plan_version: member.plan.plan_version,
+    });
+  }
+
+  const migration = migrateWitnessSetTaskIds({
+    witnessSet,
+    taskMigration: revision.task_migration,
+    planTaskIds: member.plan.tasks.map(({ task_id: taskId }) => taskId),
+  });
+  const { ref } = await writeTodoWitnessSet({ repoRoot, witnessSet: migration.witnessSet });
+
+  const result = {
+    schema: 'lattice.todo_witness_migrate_result.v1',
+    project_id: store.project_id,
+    plan_key: planKey,
+    plan_version: member.plan.plan_version,
+    witness_ref: ref,
+    migrated_count: migration.migrated_count,
+    removed_count: migration.removed_count,
+    unchanged_count: migration.unchanged_count,
+    witness_set_digest: migration.witnessSet.witness_set_digest,
+    result_digest: '',
+  };
+  result.result_digest = todoSelfDigest(result, 'result_digest');
+  return result;
+}
+
+async function independence({ repoRoot, requestedPlanKey }) {
+  const store = await readTodoStore({ repoRoot });
+  if (requestedPlanKey !== null
+    && !store.members.some(({ descriptor }) => descriptor.plan_key === requestedPlanKey)) {
+    throw new TodoStoreError('STORE_INCONSISTENT', 'plan_not_active', undefined, {
+      plan_key: requestedPlanKey,
+    });
+  }
+  const frontier = computeReadyFrontier(store);
+  const readyPlanKeys = [...new Set(frontier.map(({ plan_key: key }) => key))].sort();
+  // planを絞らない呼び出しではreadyがどのplanを指しているかで決める。readyが無い時は
+  // 全planが候補になる。どちらの場合も候補が複数なら、片方だけ見せて答えたことにしない。
+  // ここで黙ってnullへ倒すと、記録があるのにcoverage missingと報告してしまう。
+  const candidatePlanKeys = readyPlanKeys.length > 0
+    ? readyPlanKeys
+    : store.members.map(({ descriptor }) => descriptor.plan_key).sort();
+  if (requestedPlanKey === null && candidatePlanKeys.length > 1) {
+    throw new TodoStoreError('INDEPENDENCE_PLAN_AMBIGUOUS', 'plan_selection_ambiguous', undefined, {
+      plan_keys: candidatePlanKeys,
+      ready_plan_keys: readyPlanKeys,
+      next_action: 'rerun_with_plan_flag',
+    });
+  }
+  const planKey = requestedPlanKey ?? candidatePlanKeys[0] ?? null;
+
+  const currentBaseSha = currentHeadSha(repoRoot);
+  const ready = frontier.filter((task) => task.plan_key === planKey);
+  const member = planKey === null
+    ? undefined : store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
+  const artifact = member === undefined
+    ? null : await readTodoIndependenceArtifact({ repoRoot, store, planKey });
+  const active = projectTodoStatus(store).active_set
+    .filter((task) => task.plan_key === planKey);
+  // HEADが進んでいる時だけdiffを取る。一致していれば宣言境界を見るまでもない。
+  const changedPaths = artifact !== null && artifact.base_sha !== currentBaseSha
+    ? changedPathsSince(repoRoot, artifact.base_sha) : null;
+
+  const projected = projectIndependenceFrontier({
+    artifact,
+    readyTaskIds: ready.map(({ task_id: taskId }) => taskId),
+    activeTaskIds: active.map(({ task_id: taskId }) => taskId),
+    plan: member?.plan ?? { plan_version: null, topology_digest: null },
+    currentBaseSha,
+    changedPaths,
+  });
+
+  const result = {
+    schema: TODO_INDEPENDENCE_PROJECTION_SCHEMA,
+    project_id: store.project_id,
+    plan_key: planKey,
+    coverage: projected.coverage,
+    compiled_base_sha: artifact?.base_sha ?? null,
+    current_base_sha: currentBaseSha,
+    plan_version: artifact?.plan_version ?? null,
+    topology_digest: artifact?.topology_digest ?? null,
+    active_task_ids: projected.active_task_ids,
+    uncovered_active_task_ids: projected.uncovered_active_task_ids,
+    drift: projected.drift,
+    // planを読みに来た人にも、着手する人と同じ文言を返す（ADR 0130 Decision 1）。
+    guidance: selectIndependenceGuidance({
+      coverage: projected.coverage,
+      readyCount: ready.length,
+      taskDeclared: projected.frontier.unknown
+        .every(({ unknowns }) => !unknowns.some(({ kind }) => kind === 'witness_missing')),
+      taskStale: projected.frontier.unknown
+        .some(({ unknowns }) => unknowns.some(({ kind }) => kind === 'record_stale')),
+      conflictWithActive: projected.frontier.conflicts_with_active[0]?.severability ?? null,
+      conflictBetweenReady: projected.frontier.serialize_pairs[0]?.severability ?? null,
+    }),
+    frontier: projected.frontier,
+    result_digest: '',
+  };
+  result.result_digest = todoSelfDigest(result, 'result_digest');
+  if (!validateTodoIndependenceProjection(result)) {
+    throw new TodoStoreError('INDEPENDENCE_PROJECTION_INVALID', 'independence_projection_invalid');
+  }
+  return result;
+}
+
 async function readNarrative(repoRoot, ref) {
   const canonicalRoot = await realpath(repoRoot);
   const source = parseTodoSourceRef(ref);
@@ -644,6 +993,66 @@ function parseGanttDescriptor(bytes, descriptorRef) {
   return value;
 }
 
+/**
+ * 図が描く全planについて独立性を投影する（ADR 0129 Decision 4）。
+ *
+ * Ganttは複数planを同時に描くので、単一plan前提の`todo independence`の曖昧判定は持ち込まない。
+ * plan単位で記録を引き、記録が無いplanは投影を持たないまま通す——描けない事実を
+ * 図の側で作り出さない。
+ */
+/**
+ * live配信の更新検知に使うhead digest（ADR 0129 Decision 6）。
+ *
+ * manifest_digestだけでは、独立性の再compileもHEAD前進も検知できず画面が古いまま残る。
+ * 同じ値を描画側と検知側で別々に組み立てると、更新されない状態が静かに再発するため、
+ * 一つの関数だけが組む。
+ */
+export async function ganttLiveHeadDigest({ repoRoot, store }) {
+  const independence = await independenceForGantt({ repoRoot, store });
+  return digestTodoArtifact({
+    schema: 'lattice.todo_gantt_live_head.v1',
+    manifest_digest: store.manifest.manifest_digest,
+    independence: independence === null ? null : independence.map((entry) => ({
+      plan_key: entry.plan_key,
+      coverage: entry.coverage,
+      frontier_digest: digestTodoArtifact(entry.frontier),
+    })),
+  });
+}
+
+async function independenceForGantt({ repoRoot, store }) {
+  const frontier = computeReadyFrontier(store);
+  const status = projectTodoStatus(store);
+  let currentBaseSha = null;
+  const projections = [];
+  for (const member of store.members) {
+    const planKey = member.plan.plan_key;
+    const artifact = await readTodoIndependenceArtifact({ repoRoot, store, planKey });
+    if (artifact === null) continue;
+    // 記録があるplanが1つでもあれば鮮度の判定にHEADが要る。
+    if (currentBaseSha === null) currentBaseSha = currentHeadSha(repoRoot);
+    const changedPaths = artifact.base_sha !== currentBaseSha
+      ? changedPathsSince(repoRoot, artifact.base_sha) : null;
+    const projected = projectIndependenceFrontier({
+      artifact,
+      readyTaskIds: frontier.filter((task) => task.plan_key === planKey)
+        .map(({ task_id: taskId }) => taskId),
+      activeTaskIds: status.active_set.filter((task) => task.plan_key === planKey)
+        .map(({ task_id: taskId }) => taskId),
+      plan: member.plan,
+      currentBaseSha,
+      changedPaths,
+    });
+    projections.push({
+      project_id: member.plan.project_id,
+      plan_key: planKey,
+      coverage: projected.coverage,
+      frontier: projected.frontier,
+    });
+  }
+  return projections.length === 0 ? null : projections;
+}
+
 export async function renderTodoGanttForProject({
   repoRoot, stable = false, displayName = null, env = process.env, readModel = null,
   scope = DEFAULT_GANTT_SCOPE,
@@ -656,11 +1065,12 @@ export async function renderTodoGanttForProject({
   const presentation = await loadTodoGanttPresentation({ repoRoot, readModel: store });
   const topology = mergedTopology(store);
   const chain = projectTodoChainV1(topology);
-  const layout = layoutTodoGantt(store, chain, { scope });
+  const independence = await independenceForGantt({ repoRoot, store });
+  const layout = layoutTodoGantt(store, chain, { scope, independence });
   // When the diagram hides history, the page also carries the full diagram so
   // the reader can bring it back in place. Nothing is hidden under `all`.
   const expandedLayout = layout.scope.folded_task_count === 0
-    ? null : layoutTodoGantt(store, chain, { scope: 'all' });
+    ? null : layoutTodoGantt(store, chain, { scope: 'all', independence });
   const narrative = await loadNarratives(store, repoRoot);
   const anchorOutcomes = verifyNarrativeAnchors({
     readModel: store,
@@ -785,12 +1195,15 @@ async function serveGantt({ repoRoot, port, stdout, env, scope = DEFAULT_GANTT_S
     displayName: identity.displayName,
     port,
     render: async () => {
-      const { rendered, metadata } = await renderTodoGanttForProject({
-        repoRoot, stable: true, displayName: identity.displayName, scope,
+      const store = await readTodoStoreStable({ repoRoot });
+      const { rendered } = await renderTodoGanttForProject({
+        repoRoot, stable: true, displayName: identity.displayName, scope, readModel: store,
       });
-      return { html: rendered.html, head_digest: metadata.manifest_digest };
+      return { html: rendered.html, head_digest: await ganttLiveHeadDigest({ repoRoot, store }) };
     },
-    readHead: async () => (await readTodoStoreStable({ repoRoot })).manifest.manifest_digest,
+    readHead: async () => ganttLiveHeadDigest({
+      repoRoot, store: await readTodoStoreStable({ repoRoot }),
+    }),
   });
   const result = { schema: 'lattice.todo_gantt_live_result.v2', project_id: live.projectId,
     host: live.host, port: live.port, project_path: live.projectPath,
@@ -937,6 +1350,21 @@ export async function runTodoCli({ argv, cwd, stdout, stderr, env = process.env
     && argv[1] === '--plan' && isTodoIdentifier(argv[2])
     && (argv.length === 3 || argv[3] === '--json')) {
     action = (repoRoot) => bindings({ repoRoot, requestedPlanKey: argv[2] });
+  } else if (argv.length === 5 && argv[0] === 'independence' && argv[1] === 'witness'
+    && argv[2] === 'migrate' && argv[3] === '--plan' && isTodoIdentifier(argv[4])) {
+    action = (repoRoot) => independenceWitnessMigrate({ repoRoot, planKey: argv[4] });
+  } else if (argv.length === 6 && argv[0] === 'independence' && argv[1] === 'compile'
+    && argv[2] === '--plan' && isTodoIdentifier(argv[3]) && argv[4] === '--input') {
+    action = (repoRoot) => independenceCompile({
+      repoRoot, planKey: argv[3], inputRef: argv[5],
+    });
+  } else if ((argv.length === 1 && argv[0] === 'independence')
+    || (argv.length === 2 && argv[0] === 'independence' && argv[1] === '--json')) {
+    action = (repoRoot) => independence({ repoRoot, requestedPlanKey: null });
+  } else if ((argv.length === 3 || argv.length === 4) && argv[0] === 'independence'
+    && argv[1] === '--plan' && isTodoIdentifier(argv[2])
+    && (argv.length === 3 || argv[3] === '--json')) {
+    action = (repoRoot) => independence({ repoRoot, requestedPlanKey: argv[2] });
   } else if ((argv.length === 1 && argv[0] === 'verify')
     || (argv.length === 2 && argv[0] === 'verify' && argv[1] === '--json')) {
     action = (repoRoot) => verify({ repoRoot, requestedPlanKey: null });