@quolu/lattice 0.36.1 → 0.38.0

package/src/todo-cli.mjs

@@ -104,6 +104,12 @@ import {
   parseTodoSourceRef, todoLegacyReconciliationDigest, validatePhaseTodoRevision,
   validateTodoRevision, validateTodoRevisionSet,
 } from './todo-revision.mjs';
+import {
+  appendTodoNote,
+  readTodoNoteContext,
+  readTodoNoteContextsForPlan,
+  readTodoNoteEvents,
+} from './todo-note-store.mjs';
 
 const CLI_ERROR_SCHEMA = 'lattice.cli_error.v2';
 const DEFAULT_GANTT_REF = '.lattice/generated/gantt.html';
@@ -111,6 +117,7 @@ const GANTT_DESCRIPTOR_SUFFIX = '.status.json';
 const MAX_GANTT_DESCRIPTOR_BYTES = 65_536;
 const DEFAULT_GANTT_SCOPE = 'live';
 const MAX_MIGRATION_INPUT_BYTES = 8_388_608;
+const MAX_NOTE_INPUT_BYTES = 16_384;
 const ACTOR_ENV_KEYS = Object.freeze([
   'LATTICE_TODO_ACTOR_HOST',
   'LATTICE_TODO_ACTOR_SESSION',
@@ -183,6 +190,43 @@ function selectMembers(store, requestedPlanKey) {
   return [member];
 }
 
+function selectNoteTask(member, requestedTaskId) {
+  const exact = member.plan.tasks.find(({ task_id: taskId }) => taskId === requestedTaskId);
+  if (exact !== undefined) return exact;
+  const folded = requestedTaskId.toLowerCase();
+  const matches = member.plan.tasks.filter(({ task_id: taskId }) => taskId.toLowerCase() === folded);
+  if (matches.length !== 1) {
+    throw new TodoStoreError('NOTE_TASK_NOT_FOUND', 'note_task_not_active', undefined, {
+      plan_key: member.plan.plan_key, task_id: requestedTaskId,
+    });
+  }
+  return matches[0];
+}
+
+async function readNoteTextInput(repoRoot, inputRef) {
+  if (!isTodoRef(inputRef)) throw new TodoStoreError('INPUT_UNREADABLE', 'input_path_outside_repo');
+  const canonicalRoot = await realpath(repoRoot);
+  const absolute = path.resolve(canonicalRoot, inputRef);
+  if (!within(canonicalRoot, absolute) || absolute === canonicalRoot) {
+    throw new TodoStoreError('INPUT_UNREADABLE', 'input_path_outside_repo');
+  }
+  let metadata;
+  try { metadata = await lstat(absolute); } catch {
+    throw new TodoStoreError('INPUT_UNREADABLE', 'input_missing');
+  }
+  if (metadata.isSymbolicLink() || !metadata.isFile() || metadata.size > MAX_NOTE_INPUT_BYTES) {
+    throw new TodoStoreError('INPUT_UNREADABLE', 'unsafe_or_oversized_note_input');
+  }
+  const resolved = await realpath(absolute);
+  if (resolved !== absolute || !within(canonicalRoot, resolved)) {
+    throw new TodoStoreError('INPUT_UNREADABLE', 'input_path_alias_or_escape');
+  }
+  const bytes = await readFile(resolved);
+  if (bytes.length > MAX_NOTE_INPUT_BYTES) throw new TodoStoreError('INPUT_TOO_LARGE', 'note_input_too_large');
+  try { return new TextDecoder('utf-8', { fatal: true }).decode(bytes); }
+  catch { throw new TodoStoreError('INPUT_UNREADABLE', 'note_input_invalid_utf8'); }
+}
+
 function taskRef(plan, taskId) {
   return { project_id: plan.project_id, plan_key: plan.plan_key, task_id: taskId };
 }
@@ -416,6 +460,26 @@ function mutationActor(env) {
   return { host: entries[0].value, session: entries[1].value, agent: entries[2].value };
 }
 
+/**
+ * gate_readyの札が出た理由と次の一歩をtypedに言う(ADR 0148裁定8)。
+ *
+ * 0.36.0で入れた終端監査gate(ADR 0147)は、これから終わる工程だけでなく過去に完了した
+ * 工程まで監査待ちにしてしまっていた——原因を言わないgateは、なぜ止まっているかを
+ * 説明しないのと同じなので、ここでその経緯を明示する。次の一歩は2択で書く:
+ * 今から監査する(review→accept)か、監査せず歴史として閉じる(close-unaudited、
+ * 複数plan一括ならbaseline)か。
+ */
+function auditGateGuidance(planKey, phaseId) {
+  return '全ToDoがdoneになり監査待ち(gate_ready)。0.36.0で入れた終端監査gateは、'
+    + 'これから終わる工程だけでなく過去に完了した工程まで監査待ちにしてしまっていた'
+    + '(ADR 0148で修正)。今から監査するなら: '
+    + `todo phase review --plan ${planKey} --phase ${phaseId} --reason <text> → `
+    + `todo phase accept --plan ${planKey} --phase ${phaseId} --input <file>。`
+    + '監査せず歴史として閉じるなら: '
+    + `todo phase close-unaudited --plan ${planKey} --phase ${phaseId} --reason <text>`
+    + '（複数planをまとめて畳むなら todo phase baseline --reason <text> [--except <plan_key>]...）。';
+}
+
 /**
  * phase無しplanで、この変異の結果terminal-audit Phaseがgate_ready(全task done・未監査)に
  * なっていれば助言を返す(ADR 0147)。doneの結果だけを見て機械的に判定するので、既にreview
@@ -429,14 +493,13 @@ function terminalAuditDoneAdvisory(plan, phases) {
   if (phase?.status !== 'gate_ready') return null;
   return {
     terminal_audit_required: true, phase_id: TERMINAL_AUDIT_PHASE_ID, status: phase.status,
-    guidance: '全taskがdoneになった。このplanはphaseを持たないため、終端の重監査'
-      + '(todo phase review --plan <key> --phase terminal-audit → todo phase accept)を'
-      + '経るまで「閉じた」ことにはならない。',
+    guidance: auditGateGuidance(plan.plan_key, TERMINAL_AUDIT_PHASE_ID),
   };
 }
 
 async function mutate({
   repoRoot, env, planKey, taskId, kind, payload, evidenceRef, advisory = null,
+  noteContext = null,
 }) {
   const actor = mutationActor(env);
   const evidence = evidenceRef === null ? null : await readEvidenceInput(repoRoot, evidenceRef);
@@ -457,8 +520,12 @@ async function mutate({
   // Phase状態はsnapshot(v1にはphasesキーが無い)でなく、appendTodoEventが別途返す
   // 導出ビュー`phases`から読む。
   const resolvedAdvisory = advisory ?? (kind === 'done' ? terminalAuditDoneAdvisory(plan, phases) : null);
+  const includesNoteContext = kind === 'start';
+  if (includesNoteContext && noteContext === null) {
+    throw new TypeError('start mutation requires note context');
+  }
   const result = {
-    schema: 'lattice.todo_mutation_result.v2',
+    schema: includesNoteContext ? 'lattice.todo_mutation_result.v3' : 'lattice.todo_mutation_result.v2',
     project_id: event.project_id,
     plan_key: event.plan_key,
     plan_version: event.plan_version,
@@ -470,6 +537,7 @@ async function mutate({
     snapshot_digest: snapshot.snapshot_digest,
     status: task.status,
     advisory: resolvedAdvisory,
+    ...(includesNoteContext ? { note_context: noteContext } : {}),
     result_digest: '',
   };
   result.result_digest = todoSelfDigest(result, 'result_digest');
@@ -637,13 +705,33 @@ async function startTask({
         });
     }
   }
-  const resolvedTaskId = readyTask?.task_id ?? taskId;
+  const member = store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
+  if (member === undefined) throw new TodoStoreError('STORE_INCONSISTENT', 'plan_not_active');
+  const taskMatches = member.plan.tasks.filter(({ task_id: candidate }) => (
+    candidate.toLowerCase() === taskId.toLowerCase()
+  ));
+  if (taskMatches.length === 0) {
+    throw new TodoStoreError('TASK_NOT_FOUND', 'task_not_found', undefined, {
+      requested_task_id: taskId,
+    });
+  }
+  if (taskMatches.length > 1) {
+    throw new TodoStoreError('TASK_ID_AMBIGUOUS', 'task_id_case_ambiguous', undefined, {
+      requested_task_id: taskId,
+      matching_task_ids: taskMatches.map(({ task_id: candidate }) => candidate).sort(),
+    });
+  }
+  const resolvedTaskId = readyTask?.task_id ?? taskMatches[0].task_id;
+  // noteはjournal appendより前に読む。読めなければstart自体を止め、部分進行を作らない。
+  const { context: noteContext } = await readTodoNoteContext({
+    repoRoot, store, planKey, taskId: resolvedTaskId,
+  });
   // 助言は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 });
+    payload: { override_reason: overrideReason }, evidenceRef: null, advisory, noteContext });
 }
 
 function validatePhaseDecisionInput(value, outcome) {
@@ -705,11 +793,110 @@ async function phaseStatus({ repoRoot, planKey }) {
   // 無いのでsnapshot.phasesは直接読まない)。ここでPHASE_UNAVAILABLEへ拒否せず、その暗黙Phase
   // をそのまま返す——`implicit`で機械可読に「宣言されたPhaseではない」ことを示す。
   const implicit = isPhaselessTodoPlanSchema(member.plan.schema);
+  // ADR 0148裁定8: gate_readyのPhaseには、なぜ監査待ちになったかと次の一歩をここでも言う
+  // (todo doneのadvisoryと同じ文言)。implicit(暗黙のterminal-audit Phase)に限らず、
+  // v4/v5の実Phaseがgate_readyになった場合も同じ理由で同じ案内が要る。
+  const phases = member.phases.map((phase) => ({
+    ...phase,
+    guidance: phase.status === 'gate_ready'
+      ? auditGateGuidance(member.plan.plan_key, phase.phase_id) : null,
+  }));
   const result = {
     schema: 'lattice.phase_status_result.v1', project_id: store.project_id,
     plan_key: member.plan.plan_key, plan_version: member.plan.plan_version,
     journal_head_digest: member.journal.events.at(-1).event_digest,
-    implicit, phases: member.phases, result_digest: '',
+    implicit, phases, result_digest: '',
+  };
+  result.result_digest = todoSelfDigest(result, 'result_digest');
+  return result;
+}
+
+/**
+ * `phase baseline --reason <text> [--except <plan_key>]...`の可変長`--except`を解析する。
+ * 他のargvはすべて固定位置(argv.length + 位置一致)で判定しているが、0回以上繰り返せる
+ * flagだけは固定位置で表現できないため、並び全体を見る専用ヘルパへ切り出す
+ * (bridge-cliの`parseOptions`と同じ発想)。不正な並びはnullを返し、呼び出し側の
+ * 分岐条件がそのままusageFailureへ落ちる。
+ */
+function parseBaselineExceptFlags(rest) {
+  if (rest.length % 2 !== 0) return null;
+  const planKeys = [];
+  for (let index = 0; index < rest.length; index += 2) {
+    if (rest[index] !== '--except' || !isTodoIdentifier(rest[index + 1])) return null;
+    planKeys.push(rest[index + 1]);
+  }
+  return planKeys;
+}
+
+/**
+ * `phase baseline`——現在gate_readyかつphase eventを1つも持たないPhaseを一括で
+ * closed_unauditedへ宣言する(ADR 0148裁定6)。「phase eventを1つも持たない」は
+ * derivedStatusだけでは判定できない——一度reviewしてからreopenしたPhaseは、構造的には
+ * また`gate_ready`に戻り得るが、既に監査に触れている以上は対象外である。journalの実event
+ * 履歴(phase_id別に`phase_`で始まるkindがあるか)を直接見て区別する。
+ *
+ * `--except`はplan単位の除外(ADR 0148裁定7)。ServerManagerの26 ToDoのような
+ * 「最近の作業でコードも生きている」campaignを基準線で流さないための口であり、
+ * Phase単位では絞れない(そのplanのPhaseは丸ごと対象外になる)。
+ */
+async function phaseBaseline({ repoRoot, env, reason, exceptPlanKeys }) {
+  const store = await readTodoStore({ repoRoot });
+  const knownPlanKeys = new Set(store.members.map(({ descriptor }) => descriptor.plan_key));
+  const unknownExcept = exceptPlanKeys.filter((planKey) => !knownPlanKeys.has(planKey));
+  if (unknownExcept.length > 0) {
+    throw new TodoStoreError('PHASE_BASELINE_INVALID', 'except_plan_key_unknown', undefined, {
+      unknown_plan_keys: unknownExcept,
+    });
+  }
+  const exceptSet = new Set(exceptPlanKeys);
+  const applied = [];
+  const excluded = [];
+  const notApplicable = [];
+  const failed = [];
+  for (const member of store.members) {
+    const planKey = member.descriptor.plan_key;
+    const touchedPhaseIds = new Set(member.journal.events
+      .filter((event) => event.kind.startsWith('phase_'))
+      .map((event) => event.phase_id));
+    for (const phase of member.phases) {
+      const entry = { plan_key: planKey, phase_id: phase.phase_id, status: phase.status };
+      // 「対象外だったもの(既にaccepted等)も区別して返す」——まだgate_readyに到達していない
+      // (locked/active)のと、既に監査の決着が付いている(accepted/rejected/closed_unaudited)のは
+      // 原因が違うので、causeを分けて機械可読にする。
+      if (['accepted', 'rejected', 'closed_unaudited'].includes(phase.status)) {
+        notApplicable.push({ ...entry, cause: `already_${phase.status}` });
+      } else if (phase.status !== 'gate_ready') {
+        notApplicable.push({ ...entry, cause: 'not_gate_ready' });
+      } else if (touchedPhaseIds.has(phase.phase_id)) {
+        notApplicable.push({ ...entry, cause: 'already_has_phase_event' });
+      } else if (exceptSet.has(planKey)) {
+        excluded.push({ ...entry, cause: 'excepted' });
+      } else {
+        // ADR 0148裁定6の非目標: journalはappend-onlyで、一度書いた宣言を後から取り消す
+        // 手段が無い。1件失敗しても既に書けた他件を無かったことにはできない以上、
+        // 全件一括のtransactionは新設せず、appendTodoEvent単位(1 event = 1排他書込み)の
+        // 独立実行を続ける。各書込みは呼ぶたびにstoreを読み直してgate_ready前提を
+        // 再検証するため、他項目の成否とは無関係に安全である——1件の失敗で残りを
+        // 止めず、続行して全件の結果をtypedで返す。
+        try {
+          const result = await phaseMutation({
+            repoRoot, env, planKey, phaseId: phase.phase_id,
+            kind: 'phase_close_unaudited', payload: { reason },
+          });
+          applied.push({ ...entry, event_digest: result.event_digest,
+            journal_head_digest: result.journal_head_digest });
+        } catch (error) {
+          failed.push({ ...entry, code: error?.code ?? 'INTERNAL_FAILURE',
+            message: typeof error?.message === 'string' ? error.message : null });
+        }
+      }
+    }
+  }
+  const result = {
+    schema: 'lattice.phase_baseline_result.v1',
+    reason, except_plan_keys: [...exceptSet].sort(),
+    applied, excluded, not_applicable: notApplicable, failed,
+    result_digest: '',
   };
   result.result_digest = todoSelfDigest(result, 'result_digest');
   return result;
@@ -811,6 +998,93 @@ async function status({ repoRoot }) {
   return projectTodoStatus(await readTodoStore({ repoRoot }));
 }
 
+async function todoDetail({ repoRoot, planKey, taskId }) {
+  const store = await readTodoStore({ repoRoot });
+  const [member] = selectMembers(store, planKey);
+  const task = selectNoteTask(member, taskId);
+  const state = member.tasks.find(({ task_id: current }) => current === task.task_id);
+  if (state === undefined) throw new TodoStoreError('STORE_INCONSISTENT', 'task_state_missing');
+  const { context } = await readTodoNoteContext({
+    repoRoot, store, planKey, taskId: task.task_id,
+  });
+  const result = {
+    schema: 'lattice.todo_detail_result.v1',
+    project_id: store.project_id,
+    plan_key: planKey,
+    plan_version: member.plan.plan_version,
+    task,
+    state,
+    note_context: context,
+    result_digest: '',
+  };
+  result.result_digest = todoSelfDigest(result, 'result_digest');
+  return result;
+}
+
+async function appendNote({ repoRoot, env, planKey, taskId, message, inputRef, supersedes }) {
+  const store = await readTodoStore({ repoRoot });
+  const [member] = selectMembers(store, planKey);
+  const task = selectNoteTask(member, taskId);
+  const body = inputRef === null ? message : await readNoteTextInput(repoRoot, inputRef);
+  const projectedBeforeAppend = await readTodoNoteContext({
+    repoRoot, store, planKey, taskId: task.task_id,
+  });
+  const event = await appendTodoNote({
+    repoRoot,
+    projectId: store.project_id,
+    planKey,
+    planVersion: member.plan.plan_version,
+    taskId: task.task_id,
+    actor: mutationActor(env),
+    recordedAt: new Date().toISOString(),
+    body,
+    supersedes,
+    eligibleSupersedes: projectedBeforeAppend.history.map(({ event_digest: digest }) => digest),
+  });
+  const { context } = await readTodoNoteContext({ repoRoot, store, planKey, taskId: task.task_id });
+  const result = {
+    schema: 'lattice.todo_note_append_result.v1',
+    project_id: store.project_id,
+    plan_key: planKey,
+    task_id: task.task_id,
+    event,
+    note_context: context,
+    result_digest: '',
+  };
+  result.result_digest = todoSelfDigest(result, 'result_digest');
+  return result;
+}
+
+async function listNotes({ repoRoot, planKey, taskId }) {
+  const store = await readTodoStore({ repoRoot });
+  const [member] = selectMembers(store, planKey);
+  const chain = await readTodoNoteEvents({ repoRoot, planKey });
+  let notes = chain.events;
+  let archived = [];
+  let resolvedTaskId = null;
+  if (taskId !== null) {
+    const task = selectNoteTask(member, taskId);
+    resolvedTaskId = task.task_id;
+    const projected = await readTodoNoteContext({
+      repoRoot, store, planKey, taskId: task.task_id,
+    });
+    notes = projected.history;
+    archived = projected.archived;
+  }
+  const result = {
+    schema: 'lattice.todo_note_list_result.v1',
+    project_id: store.project_id,
+    plan_key: planKey,
+    requested_task_id: resolvedTaskId,
+    notes,
+    archived,
+    note_head_digest: chain.head_digest,
+    result_digest: '',
+  };
+  result.result_digest = todoSelfDigest(result, 'result_digest');
+  return result;
+}
+
 async function bindings({ repoRoot, requestedPlanKey }) {
   return projectTodoBindings(await readTodoStore({ repoRoot }), { requestedPlanKey });
 }
@@ -1604,12 +1878,13 @@ function parseGanttDescriptor(bytes, descriptorRef) {
  * 一つの関数だけが組む。
  */
 export async function ganttLiveHeadDigest({ repoRoot, store }) {
-  const [independence, seamProposals] = await Promise.all([
+  const [independence, seamProposals, noteHeads] = await Promise.all([
     independenceForGantt({ repoRoot, store }),
     seamProposalsForGantt({ repoRoot, store }),
+    noteHeadsForGantt({ repoRoot, store }),
   ]);
   return digestTodoArtifact({
-    schema: 'lattice.todo_gantt_live_head.v1',
+    schema: 'lattice.todo_gantt_live_head.v2',
     manifest_digest: store.manifest.manifest_digest,
     independence: independence === null ? null : independence.map((entry) => ({
       plan_key: entry.plan_key,
@@ -1621,9 +1896,46 @@ export async function ganttLiveHeadDigest({ repoRoot, store }) {
       coverage: entry.coverage,
       projection_digest: digestTodoArtifact(entry),
     })),
+    note_heads: noteHeads,
   });
 }
 
+async function noteHeadsForGantt({ repoRoot, store }) {
+  const bindings = [];
+  for (const member of store.members) {
+    try {
+      const chain = await readTodoNoteEvents({ repoRoot, planKey: member.plan.plan_key });
+      bindings.push({ plan_key: member.plan.plan_key, note_head_digest: chain.head_digest, error: null });
+    } catch (error) {
+      if (typeof error?.code !== 'string' || !error.code.startsWith('NOTE_')) throw error;
+      bindings.push({ plan_key: member.plan.plan_key, note_head_digest: null, error: error.code });
+    }
+  }
+  return bindings;
+}
+
+async function notesForGantt({ repoRoot, store }) {
+  const contexts = [];
+  const warnings = [];
+  const headBindings = [];
+  for (const member of store.members) {
+    try {
+      const projected = await readTodoNoteContextsForPlan({
+        repoRoot, store, planKey: member.plan.plan_key,
+      });
+      contexts.push(...projected.contexts);
+      headBindings.push({
+        plan_key: member.plan.plan_key, note_head_digest: projected.note_head_digest,
+      });
+    } catch (error) {
+      if (typeof error?.code !== 'string' || !error.code.startsWith('NOTE_')) throw error;
+      warnings.push({ plan_key: member.plan.plan_key, code: error.code, message: error.message });
+      headBindings.push({ plan_key: member.plan.plan_key, note_head_digest: null });
+    }
+  }
+  return { contexts, warnings, headBindings };
+}
+
 async function independenceForGantt({ repoRoot, store }) {
   const frontier = computeReadyFrontier(store);
   const status = projectTodoStatus(store);
@@ -1712,7 +2024,7 @@ async function seamProposalsForGantt({ repoRoot, store }) {
 
 export async function renderTodoGanttForProject({
   repoRoot, stable = false, displayName = null, env = process.env, readModel = null,
-  scope = DEFAULT_GANTT_SCOPE,
+  scope = DEFAULT_GANTT_SCOPE, includeNotes = true,
 }) {
   const store = readModel
     ?? (stable ? await readTodoStoreStable({ repoRoot }) : await readTodoStore({ repoRoot }));
@@ -1722,9 +2034,11 @@ export async function renderTodoGanttForProject({
   const presentation = await loadTodoGanttPresentation({ repoRoot, readModel: store });
   const topology = mergedTopology(store);
   const chain = projectTodoChainV1(topology);
-  const [independence, seamProposals] = await Promise.all([
+  const [independence, seamProposals, notes] = await Promise.all([
     independenceForGantt({ repoRoot, store }),
     seamProposalsForGantt({ repoRoot, store }),
+    includeNotes ? notesForGantt({ repoRoot, store })
+      : { contexts: null, warnings: [], headBindings: [] },
   ]);
   const layout = layoutTodoGantt(store, chain, { scope, independence, seamProposals });
   // When the diagram hides history, the page also carries the full diagram so
@@ -1758,6 +2072,7 @@ export async function renderTodoGanttForProject({
     presentation_digest: presentation.presentation_digest,
     chain_digest: digestTodoArtifact(chain),
     layout_digest: digestTodoArtifact(layout),
+    note_bindings_digest: digestTodoArtifact(notes.headBindings),
     renderer_version: TODO_GANTT_RENDERER_VERSION,
     project_display_name: identity.displayName,
     folded_task_count: layout.scope.folded_task_count,
@@ -1770,10 +2085,17 @@ export async function renderTodoGanttForProject({
     anchorOutcomes,
     presentation,
     metadata,
+    noteContexts: notes.contexts,
+    noteWarnings: notes.warnings,
   });
   return { store, metadata, memberBindings, rendered };
 }
 
+/** 公開配信面は呼び出し側の既定値忘れに依存せず、常にnote本文を除外する。 */
+export async function renderPublicTodoGanttForProject(options = {}) {
+  return renderTodoGanttForProject({ ...options, includeNotes: false });
+}
+
 async function gantt({ repoRoot, outputRef, env, scope = DEFAULT_GANTT_SCOPE }) {
   const { store, metadata, memberBindings, rendered } = await renderTodoGanttForProject({
     repoRoot, env, scope,
@@ -1858,7 +2180,7 @@ async function serveGantt({ repoRoot, port, stdout, env, scope = DEFAULT_GANTT_S
     port,
     render: async () => {
       const store = await readTodoStoreStable({ repoRoot });
-      const { rendered } = await renderTodoGanttForProject({
+      const { rendered } = await renderPublicTodoGanttForProject({
         repoRoot, stable: true, displayName: identity.displayName, scope, readModel: store,
       });
       return { html: rendered.html, head_digest: await ganttLiveHeadDigest({ repoRoot, store }) };
@@ -1903,6 +2225,10 @@ async function ensureActiveProjectDashboard({ repoRoot, env }) {
 async function verify({ repoRoot, requestedPlanKey }) {
   const store = await readTodoStore({ repoRoot });
   const members = selectMembers(store, requestedPlanKey);
+  // note chainはlifecycle storeと独立だが、verifyは両方を検査する。破損を空扱いしない。
+  for (const member of members) {
+    await readTodoNoteEvents({ repoRoot, planKey: member.plan.plan_key });
+  }
   const verifiedSourceInventories = new Map();
   for (const member of members) {
     const unverified = member.tasks.find((task) => task.evidence_unverified);
@@ -2019,6 +2345,10 @@ export async function runTodoCli({ argv, cwd, stdout, stderr, env = process.env
   if ((argv.length === 1 && argv[0] === 'status')
     || (argv.length === 2 && argv[0] === 'status' && argv[1] === '--json')) {
     action = (repoRoot) => status({ repoRoot });
+  } else if (argv.length === 6 && argv[0] === 'show'
+    && argv[1] === '--plan' && isTodoIdentifier(argv[2])
+    && argv[3] === '--task' && isTodoIdentifier(argv[4]) && argv[5] === '--json') {
+    action = (repoRoot) => todoDetail({ repoRoot, planKey: argv[2], taskId: argv[4] });
   } else if ((argv.length === 1 && argv[0] === 'bindings')
     || (argv.length === 2 && argv[0] === 'bindings' && argv[1] === '--json')) {
     action = (repoRoot) => bindings({ repoRoot, requestedPlanKey: null });
@@ -2026,6 +2356,26 @@ 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 === 7 || argv.length === 9) && argv[0] === 'note'
+    && argv[1] === '--plan' && isTodoIdentifier(argv[2])
+    && argv[3] === '--task' && isTodoIdentifier(argv[4])
+    && ['--message', '--input'].includes(argv[5])
+    && ((argv[5] === '--message' && argv[6].length > 0)
+      || (argv[5] === '--input' && isTodoRef(argv[6])))
+    && (argv.length === 7 || (argv[7] === '--supersedes' && isTodoDigest(argv[8])))) {
+    action = (repoRoot) => appendNote({
+      repoRoot, env, planKey: argv[2], taskId: argv[4],
+      message: argv[5] === '--message' ? argv[6] : null,
+      inputRef: argv[5] === '--input' ? argv[6] : null,
+      supersedes: argv[8] ?? null,
+    });
+  } else if (argv.length === 5 && argv[0] === 'note' && argv[1] === 'list'
+    && argv[2] === '--plan' && isTodoIdentifier(argv[3]) && argv[4] === '--json') {
+    action = (repoRoot) => listNotes({ repoRoot, planKey: argv[3], taskId: null });
+  } else if (argv.length === 7 && argv[0] === 'note' && argv[1] === 'list'
+    && argv[2] === '--plan' && isTodoIdentifier(argv[3])
+    && argv[4] === '--task' && isTodoIdentifier(argv[5]) && argv[6] === '--json') {
+    action = (repoRoot) => listNotes({ repoRoot, planKey: argv[3], taskId: argv[5] });
   } 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] });
@@ -2148,6 +2498,17 @@ export async function runTodoCli({ argv, cwd, stdout, stderr, env = process.env
     && (argv.length === 8 || (argv[8] === '--override-reason' && argv[9].length > 0))) {
     action = (repoRoot) => phaseMutation({ repoRoot, env, planKey: argv[3], phaseId: argv[5],
       kind: 'phase_reopen', payload: { reason: argv[7], override_reason: argv[9] ?? null } });
+  } else if (argv.length === 8 && argv[0] === 'phase' && argv[1] === 'close-unaudited'
+    && argv[2] === '--plan' && isTodoIdentifier(argv[3])
+    && argv[4] === '--phase' && isTodoIdentifier(argv[5])
+    && argv[6] === '--reason' && argv[7].length > 0) {
+    action = (repoRoot) => phaseMutation({ repoRoot, env, planKey: argv[3], phaseId: argv[5],
+      kind: 'phase_close_unaudited', payload: { reason: argv[7] } });
+  } else if (argv.length >= 4 && argv[0] === 'phase' && argv[1] === 'baseline'
+    && argv[2] === '--reason' && argv[3].length > 0
+    && parseBaselineExceptFlags(argv.slice(4)) !== null) {
+    const exceptPlanKeys = parseBaselineExceptFlags(argv.slice(4));
+    action = (repoRoot) => phaseBaseline({ repoRoot, env, reason: argv[3], exceptPlanKeys });
   } else if ((argv.length === 5 || argv.length === 6 || argv.length === 7 || argv.length === 8)
     && argv[0] === 'start'
     && argv[1] === '--plan' && isTodoIdentifier(argv[2])