@quolu/lattice 0.37.0 → 0.38.0

package/README.ja.md

@@ -43,6 +43,21 @@ planを再コンパイルします。共有面が共有でなくなるので、
 
 人が手で切ったのではありません。**工程を並列化するために製品が切りました。**
 
+### 作業記憶はToDoと一緒に渡る
+
+AIは、次の担当が作業を続けるために必要な方針、棄却案、調査結果、注意、未解決事項をToDoへ追記できます。
+通常の`lattice todo show`と、成功するすべての`lattice todo start`は、元version／元task、訂正状態、
+note chain head、overflow、全履歴コマンドを含む最新のbounded `note_context`を自動で返します。
+次のAIが別のnote読取コマンドを知っている必要はありません。
+
+```bash
+lattice todo note --plan <key> --task <id> --message "既存parserを使い、fallbackは追加しない"
+lattice todo show --plan <key> --task <id> --json
+```
+
+ローカルGanttでは、選択したToDoの右ペインへ同じ作業記録を表示します。公開Gantt／dashboardは契約として
+note本文を含めません。
+
 ### 変換の受入五条件
 
 **5つすべて**を満たしたときだけ採用します。1つでも欠ければ棄却です。

package/README.md

@@ -58,6 +58,22 @@ the same parallel group.
 
 Nobody hand-refactored that file. The product cut it so the work could parallelize.
 
+### Task memory travels with the task
+
+An agent can append the decisions, rejected approaches, findings, cautions, and open questions needed
+to continue a ToDo. A normal `lattice todo show` and every successful `lattice todo start` return the
+latest bounded `note_context` automatically, including origin, correction state, chain head, overflow,
+and the full-history command. The next agent does not need to discover or remember a separate note
+lookup command.
+
+```bash
+lattice todo note --plan <key> --task <id> --message "Use the existing parser; do not add a fallback"
+lattice todo show --plan <key> --task <id> --json
+```
+
+The same context appears in the selected ToDo's detail pane in a local Gantt. Public Gantt and
+dashboard rendering exclude note bodies by contract.
+
 ### The five acceptance conditions
 
 A transform is adopted only when **all five** hold. One missing condition rejects it:

package/bin/lattice-dashboard.mjs

@@ -5,7 +5,7 @@ import path from 'node:path';
 
 import { readTodoStoreStable } from '../src/todo-store.mjs';
 import { projectTodoStatus } from '../src/todo-status.mjs';
-import { ganttLiveHeadDigest, renderTodoGanttForProject } from '../src/todo-cli.mjs';
+import { ganttLiveHeadDigest, renderPublicTodoGanttForProject } from '../src/todo-cli.mjs';
 import {
   readVisibleTodoDashboardProjects,
   writeTodoDashboardDaemonDescriptor,
@@ -87,7 +87,7 @@ async function synchronize() {
       displayName: entry.display_name,
       render: async ({ displayName }) => {
         const store = await readCachedStore(entry.repo_root);
-        const result = await renderTodoGanttForProject({ repoRoot: entry.repo_root,
+        const result = await renderPublicTodoGanttForProject({ repoRoot: entry.repo_root,
           stable: true, displayName, readModel: store });
         return {
           html: result.rendered.html,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "description": "Schedulability compiler for multi-agent development: observe real code boundaries, refactor the conflicting seam, recompile the plan for parallel execution",
   "author": {
     "name": "Quo / クオ at kitepon.dev",

package/src/cli-help.mjs

@@ -61,6 +61,8 @@ Commands:
 
 Read commands:
   status [--json]
+  show --plan <key> --task <id> --json  # 個別ToDoと最新bounded note contextを追加操作なしで返す
+  note list --plan <key> [--task <id>] --json  # note全履歴の診断面（通常read/startでは不要）
   bindings [--plan <key>] [--json]   # compile_binding付きTaskをTODO identityつきで投影する
   independence [--plan <key>] [--json]  # readyを検証済み並列・要直列・未検査へ分けて投影する
   seam-profile --plan <key> --file <path> [--json]  # 係争fileの切断コスト内訳を投影する（read-only）
@@ -73,6 +75,8 @@ Read commands:
   phase status --plan <key>
 
 Write commands:
+  note --plan <key> --task <id> (--message <text>|--input <file>)
+      # ToDoへ作業継続に必要な方針・調査結果・注意をappend-onlyで追記する
   migrate --input <extraction.json> [--serialization-reviewed]
       # 既存storeへplanを追加する（plan createは空store初期化専用）。
       # 依存グラフがほぼ一直線なら一度突き返し、再考後の --serialization-reviewed で通す
@@ -168,6 +172,9 @@ const SUBCOMMAND_USAGE = Object.freeze({
   'run seam resolve': 'run seam resolve --run .lattice/runs/<id> --finding <digest> --input <seam-request.json>',
   'event verify': 'event verify --run .lattice/runs/<id>',
   'todo status': 'todo status [--json]',
+  'todo show': 'todo show --plan <key> --task <id> --json',
+  'todo note': 'todo note --plan <key> --task <id> (--message <text>|--input <file>) | list --plan <key> [--task <id>] --json',
+  'todo note list': 'todo note list --plan <key> [--task <id>] --json',
   'todo bindings': 'todo bindings [--plan <key>] [--json]',
   'todo independence': 'todo independence [--plan <key>] [--json] | compile --plan <key> --input <file> | witness migrate --plan <key>',
   'todo seam-profile': 'todo seam-profile --plan <key> --file <path> [--json]',

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 };
 }
@@ -455,6 +499,7 @@ function terminalAuditDoneAdvisory(plan, phases) {
 
 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);
@@ -475,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,
@@ -488,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');
@@ -655,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) {
@@ -928,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 });
 }
@@ -1721,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,
@@ -1738,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);
@@ -1829,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 }));
@@ -1839,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
@@ -1875,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,
@@ -1887,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,
@@ -1975,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 }) };
@@ -2020,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);
@@ -2136,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 });
@@ -2143,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] });

package/src/todo-contracts.mjs

@@ -9,6 +9,8 @@ export const TODO_EVENT_KINDS = Object.freeze([
   // 新しいevent schema版は作らない。
   'phase_close_unaudited',
 ]);
+export const TODO_NOTE_EVENT_SCHEMA = 'lattice.todo_note_event.v1';
+export const TODO_NOTE_CONTEXT_SCHEMA = 'lattice.todo_note_context.v1';
 export const TODO_LIMITS = Object.freeze({
   tasksPerPlan: 512,
   edgesPerPlan: 2_048,
@@ -16,11 +18,14 @@ export const TODO_LIMITS = Object.freeze({
   journalSegmentBytes: 1_048_576,
   snapshotBytes: 8_388_608,
   narrativeSectionBytes: 262_144,
+  noteBodyBytes: 16_384,
+  noteContextBytes: 65_536,
 });
 
 const DIGEST = /^[0-9a-f]{64}$/;
 const IDENTIFIER = /^[0-9A-Za-z](?:[0-9A-Za-z._-]{0,127})$/;
 const CONTROL = /[\u0000-\u001f\u007f]/u;
+const NOTE_FORBIDDEN_CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
 
 export const isTodoDigest = (value) => typeof value === 'string' && DIGEST.test(value);
 export const isTodoIdentifier = (value) => typeof value === 'string' && IDENTIFIER.test(value);
@@ -89,6 +94,67 @@ export function todoSelfDigest(value, field) {
   return digestTodoArtifact(projection);
 }
 
+const noteBody = (value) => typeof value === 'string' && value.length > 0
+  && Buffer.byteLength(value, 'utf8') <= TODO_LIMITS.noteBodyBytes
+  && !NOTE_FORBIDDEN_CONTROL.test(value);
+
+/** lifecycle journalとは独立したtask note event v1を検証する。 */
+export function validateTodoNoteEvent(value) {
+  try {
+    return exactRecord(value, [
+      'schema', 'project_id', 'plan_key', 'task_id', 'plan_version', 'sequence',
+      'previous_digest', 'actor', 'recorded_at', 'body', 'supersedes', 'event_digest',
+    ]) && value.schema === TODO_NOTE_EVENT_SCHEMA
+      && isTodoIdentifier(value.project_id) && isTodoIdentifier(value.plan_key)
+      && isTodoIdentifier(value.task_id) && isTodoIdentifier(value.plan_version)
+      && Number.isSafeInteger(value.sequence) && value.sequence >= 1
+      && (value.sequence === 1 ? value.previous_digest === null : isTodoDigest(value.previous_digest))
+      && actor(value.actor) && isStrictTodoTimestamp(value.recorded_at) && noteBody(value.body)
+      && (value.supersedes === null || isTodoDigest(value.supersedes))
+      && isTodoDigest(value.event_digest) && value.supersedes !== value.event_digest
+      && value.event_digest === todoSelfDigest(value, 'event_digest');
+  } catch {
+    return false;
+  }
+}
+
+function noteContextEntry(value) {
+  return exactRecord(value, [
+    'event_digest', 'origin_plan_version', 'origin_task_id', 'actor', 'recorded_at',
+    'body', 'supersedes', 'superseded_by', 'correction_state',
+  ]) && isTodoDigest(value.event_digest) && isTodoIdentifier(value.origin_plan_version)
+    && isTodoIdentifier(value.origin_task_id) && actor(value.actor)
+    && isStrictTodoTimestamp(value.recorded_at) && noteBody(value.body)
+    && (value.supersedes === null || isTodoDigest(value.supersedes))
+    && (value.superseded_by === null || isTodoDigest(value.superseded_by))
+    && ['current', 'superseded'].includes(value.correction_state)
+    && ((value.correction_state === 'current' && value.superseded_by === null)
+      || (value.correction_state === 'superseded' && isTodoDigest(value.superseded_by)));
+}
+
+/** 個別ToDo詳細とstart結果へ必ず同梱するbounded note contextを検証する。 */
+export function validateTodoNoteContext(value) {
+  try {
+    if (!exactRecord(value, [
+      'schema', 'project_id', 'plan_key', 'task_id', 'notes', 'note_head_digest',
+      'overflow_count', 'full_history_command', 'context_digest',
+    ]) || value.schema !== TODO_NOTE_CONTEXT_SCHEMA
+      || !isTodoIdentifier(value.project_id) || !isTodoIdentifier(value.plan_key)
+      || !isTodoIdentifier(value.task_id) || !Array.isArray(value.notes)
+      || value.notes.length > TODO_LIMITS.tasksPerPlan || !value.notes.every(noteContextEntry)
+      || !(value.note_head_digest === null || isTodoDigest(value.note_head_digest))
+      || !isNonNegativeSafeInteger(value.overflow_count)
+      || value.full_history_command !== `lattice todo note list --plan ${value.plan_key} --task ${value.task_id} --json`
+      || !isTodoDigest(value.context_digest)
+      || value.context_digest !== todoSelfDigest(value, 'context_digest')) return false;
+    if ((value.notes.length === 0) !== (value.note_head_digest === null)) return false;
+    return value.notes.reduce((bytes, note) => bytes + Buffer.byteLength(note.body, 'utf8'), 0)
+      <= TODO_LIMITS.noteContextBytes;
+  } catch {
+    return false;
+  }
+}
+
 const nullableDigest = (value) => value === null || isTodoDigest(value);
 const nullableText = (value) => value === null || (typeof value === 'string' && value.length > 0 && Buffer.byteLength(value) <= 16_384);
 const actor = (value) => exactRecord(value, ['host', 'session', 'agent'])

package/src/todo-gantt-html-independence.mjs

@@ -1,4 +1,25 @@
 import { DOCUMENT_STATUS, SEVERABILITY_LABEL, escapeHtmlAttribute, escapeHtmlText, foldIndex, planActivity, presentationLookup, refKey, renderPhaseProgress, renderRelationList, renderSeamProposalOverview, renderTaskIndex, statusMarkup, taskReference } from './todo-gantt-html-shared.mjs';
+import { renderTodoMarkdown } from './todo-markdown-renderer.mjs';
+
+function renderNoteContext(context) {
+  if (context === null) {
+    return '<section class="work-log"><h2>作業記録</h2><p class="note-warning">作業記録を読み取れません。概要の読取警告を確認してください。</p></section>';
+  }
+  if (context.notes.length === 0) {
+    return '<section class="work-log"><h2>作業記録</h2><p>記録はありません。</p></section>';
+  }
+  const entries = context.notes.map((note) => {
+    const rendered = renderTodoMarkdown(note.body);
+    const filtering = rendered.discarded.length === 0 ? ''
+      : '<p class="note-warning">安全上表示できない要素を除外しました。</p>';
+    const correction = note.correction_state === 'superseded'
+      ? `訂正済み（後継 ${note.superseded_by.slice(0, 12)}…）` : '現行';
+    return `<article class="work-log-entry"><header><span>${escapeHtmlText(note.recorded_at)}</span><span>${escapeHtmlText(correction)}</span></header><div class="work-log-body">${rendered.html}</div>${filtering}<p class="work-log-origin">来歴: ${escapeHtmlText(note.origin_plan_version)}/${escapeHtmlText(note.origin_task_id)}・記録者 ${escapeHtmlText(`${note.actor.host}/${note.actor.agent}`)}</p></article>`;
+  }).join('');
+  const overflow = context.overflow_count === 0 ? ''
+    : `<p class="note-warning">ほか ${context.overflow_count}件は上限のため省略。全履歴: <code>${escapeHtmlText(context.full_history_command)}</code></p>`;
+  return `<section class="work-log"><h2>作業記録</h2>${entries}${overflow}<p class="work-log-head">note head: <code>${escapeHtmlText(context.note_head_digest ?? 'none')}</code></p></section>`;
+}
 
 /**
  * 図の外が語るための独立性要約を、plan単位の投影から引ける形へ畳む（ADR 0129 Decision 3）。
@@ -63,7 +84,9 @@ export function renderIndependenceNote(ref, node, summary) {
   return `<p class="readiness-note"><strong>並列可否:</strong> 要直列です。</p><ul class="independence-conflicts">${items}</ul>`;
 }
 
-export function renderRightPane(sections, layout, presentation, readModel) {
+export function renderRightPane(
+  sections, layout, presentation, readModel, notesEnabled = false, noteWarnings = [],
+) {
   const lookup = presentationLookup(presentation);
   const sectionByKey = new Map(sections.map((section) => [refKey(section.ref), section]));
   const nodeByKey = new Map(layout.nodes.map((node) => [refKey(node.ref), node]));
@@ -104,7 +127,9 @@ export function renderRightPane(sections, layout, presentation, readModel) {
   const dispatchSummary = `${readyHeadline}${independenceNote}`;
   const activeLinks = active.length === 0 ? '<p>作業中の工程はありません。</p>'
     : `<ul class="active-list">${active.map((section) => `<li><button type="button" data-select-node-key="${escapeHtmlAttribute(refKey(section.ref))}">${escapeHtmlText(taskReference(section, lookup))} — ${escapeHtmlText(section.task.title)}</button></li>`).join('')}</ul>`;
-  const overview = `<section class="right-overview" data-right-panel="overview"><h1>工程を選択してください</h1><p>左の依存工程図から工程を選ぶと、題名・状態・前提・後続を表示します。</p><div class="status-summary"><span>☐ 未着手 ${counts.pending}</span><span>▶ 作業中 ${counts['in-progress']}</span><span>✅ 完了 ${counts.done}</span><span>⛔ ブロック中 ${counts.blocked}</span></div>${dispatchSummary}${renderSeamProposalOverview(layout)}${renderPhaseProgress(readModel)}<h2>作業中</h2>${activeLinks}</section>`;
+  const noteWarningMarkup = noteWarnings.length === 0 ? ''
+    : `<section class="gantt-warning"><h2>作業記録の読取警告</h2><ul>${noteWarnings.map((warning) => `<li><code>${escapeHtmlText(warning.plan_key)}</code>: <strong>${escapeHtmlText(warning.code)}</strong> — ${escapeHtmlText(warning.message)}</li>`).join('')}</ul></section>`;
+  const overview = `<section class="right-overview" data-right-panel="overview"><h1>工程を選択してください</h1><p>左の依存工程図から工程を選ぶと、題名・状態・前提・後続を表示します。</p><div class="status-summary"><span>☐ 未着手 ${counts.pending}</span><span>▶ 作業中 ${counts['in-progress']}</span><span>✅ 完了 ${counts.done}</span><span>⛔ ブロック中 ${counts.blocked}</span></div>${noteWarningMarkup}${dispatchSummary}${renderSeamProposalOverview(layout)}${renderPhaseProgress(readModel)}<h2>作業中</h2>${activeLinks}</section>`;
   const details = sections.map((section) => {
     const key = refKey(section.ref);
     const node = nodeByKey.get(key);
@@ -126,7 +151,8 @@ export function renderRightPane(sections, layout, presentation, readModel) {
     // Say it plainly when the reader will not find this ToDo on the diagram.
     const foldedNote = !folds.has(key) ? ''
       : '<p class="fold-note">完走済みのため図には描いていません。図に出すには <code>lattice todo gantt --scope all</code> を実行してください。</p>';
-    return `<article class="task-detail" data-detail-key="${escapeHtmlAttribute(key)}" hidden><header><span class="detail-status status-${escapeHtmlAttribute(section.state.status)}">${escapeHtmlText(status.mark)} ${escapeHtmlText(status.label)}</span><span class="detail-reference">${escapeHtmlText(taskReference(section, lookup))}</span></header><h1>${escapeHtmlText(section.task.title)}</h1><p class="detail-category"><strong>カテゴリ:</strong> ${escapeHtmlText(category)}</p>${categoryDescription}<p><strong>正規ID:</strong> <code>${escapeHtmlText(`${section.ref.plan_key}/${section.task.task_id}`)}</code></p>${blockedReason}${readiness}${independenceNote}${foldedNote}<section><h2>前提工程</h2>${renderRelationList(incoming.get(key), sectionByKey, lookup, '登録済みの前提工程はありません。', folds)}</section><section><h2>後続工程</h2>${renderRelationList(outgoing.get(key), sectionByKey, lookup, '登録済みの後続工程はありません。', folds)}</section><p class="anchor-status">${escapeHtmlText(anchorText)}</p><details class="task-diagnostics"><summary>開発者向け診断</summary><dl><dt>canonical ref</dt><dd><code>${escapeHtmlText(`${section.ref.project_id}/${section.ref.plan_key}/${section.task.task_id}`)}</code></dd><dt>anchor</dt><dd>${escapeHtmlText(section.anchorOutcome.anchored ? 'verified' : section.anchorOutcome.reason)}</dd></dl></details></article>`;
+    const workLog = notesEnabled ? renderNoteContext(section.noteContext) : '';
+    return `<article class="task-detail" data-detail-key="${escapeHtmlAttribute(key)}" hidden><header><span class="detail-status status-${escapeHtmlAttribute(section.state.status)}">${escapeHtmlText(status.mark)} ${escapeHtmlText(status.label)}</span><span class="detail-reference">${escapeHtmlText(taskReference(section, lookup))}</span></header><h1>${escapeHtmlText(section.task.title)}</h1><p class="detail-category"><strong>カテゴリ:</strong> ${escapeHtmlText(category)}</p>${categoryDescription}<p><strong>正規ID:</strong> <code>${escapeHtmlText(`${section.ref.plan_key}/${section.task.task_id}`)}</code></p>${blockedReason}${readiness}${independenceNote}${foldedNote}<section><h2>前提工程</h2>${renderRelationList(incoming.get(key), sectionByKey, lookup, '登録済みの前提工程はありません。', folds)}</section><section><h2>後続工程</h2>${renderRelationList(outgoing.get(key), sectionByKey, lookup, '登録済みの後続工程はありません。', folds)}</section>${workLog}<p class="anchor-status">${escapeHtmlText(anchorText)}</p><details class="task-diagnostics"><summary>開発者向け診断</summary><dl><dt>canonical ref</dt><dd><code>${escapeHtmlText(`${section.ref.project_id}/${section.ref.plan_key}/${section.task.task_id}`)}</code></dd><dt>anchor</dt><dd>${escapeHtmlText(section.anchorOutcome.anchored ? 'verified' : section.anchorOutcome.reason)}</dd></dl></details></article>`;
   }).join('');
   const taskIndex = renderTaskIndex(sections, lookup, folds, planActivity(readModel));
   return `<div class="right-toolbar"><button type="button" data-show-overview>概要</button><button type="button" data-show-selected hidden>選択工程へ戻る</button><button type="button" data-show-task-index>全工程一覧</button></div><div class="right-content">${overview}<div data-right-panel="details" hidden>${details}</div><section class="task-index" data-right-panel="task-index" hidden><h1>全工程</h1><p>Latticeに登録された全工程を現在の状態とともに表示しています。planは動いているものを最終活動の新しい順で上に、完走したものを古い順で下にまとめ、plan内は登録順です。</p>${taskIndex}</section></div>`;

package/src/todo-gantt-html-style.mjs

@@ -56,6 +56,12 @@ body{display:grid;grid-template-rows:minmax(0,1fr);height:100vh;margin:0;backgro
 .active-list,.relation-list{margin:0;padding:0;list-style:none}.active-list li+li,.relation-list li+li{margin-top:8px}
 .active-list button{width:100%}.anchor-status,.readiness-note,.category-description,.relation-empty{color:var(--text-secondary)}
 .task-detail>header{display:flex;flex-wrap:wrap;align-items:center;gap:8px;margin-bottom:8px}.detail-status,.detail-reference{font-size:12px;font-weight:600}.detail-reference{color:var(--text-secondary)}
+.work-log{margin-top:24px;padding-top:1px;border-top:1px solid var(--border)}
+.work-log-entry{margin-top:10px;padding:12px;border:1px solid var(--border);border-left:4px solid var(--accent);background:var(--surface-2)}
+.work-log-entry>header{display:flex;flex-wrap:wrap;justify-content:space-between;gap:6px 12px;color:var(--text-secondary);font-size:12px;font-weight:600}
+.work-log-body{overflow-wrap:anywhere}.work-log-body pre{max-width:100%;overflow:auto;padding:8px;background:var(--surface-1)}.work-log-body code{overflow-wrap:anywhere}
+.work-log-origin,.work-log-head,.note-warning{color:var(--text-secondary);font-size:12px;overflow-wrap:anywhere}.note-warning{color:var(--critical)}
+.gantt-warning{margin:16px 0;padding:12px;border:1px solid var(--critical);background:var(--surface-2)}.gantt-warning h2{margin:0 0 8px}.gantt-warning ul{margin:0;padding-left:20px}
 .relation-list button{display:flex;width:100%;flex-direction:column}.relation-list button span{font-weight:400}.relation-kind{display:block;margin-top:4px;color:var(--text-secondary);font-size:12px}
 .task-diagnostics{margin:16px 0;color:var(--text-secondary);font-size:12px}.task-diagnostics summary{cursor:pointer;color:var(--text-primary);font-weight:600}.task-diagnostics dl{display:grid;grid-template-columns:auto 1fr;gap:4px 12px}.task-diagnostics dd{margin:0;overflow-wrap:anywhere}
 .task-index>h1{margin:0 0 8px;font-size:19px;font-weight:650;line-height:1.45}.task-index>p{margin:0 0 24px;color:var(--text-secondary)}

package/src/todo-gantt-html.mjs

@@ -6,7 +6,7 @@ import { renderDiagramLegend, renderRightPane } from './todo-gantt-html-independ
 import { escapeHtmlAttribute, escapeHtmlText, refKey } from './todo-gantt-html-shared.mjs';
 import { CSS } from './todo-gantt-html-style.mjs';
 
-export const TODO_GANTT_RENDERER_VERSION = 'lattice.todo_gantt_renderer.v17';
+export const TODO_GANTT_RENDERER_VERSION = 'lattice.todo_gantt_renderer.v18';
 export const TODO_GANTT_PROSE_MAX_BYTES = 8 * 1024 * 1024;
 export const TODO_GANTT_HTML_MAX_BYTES = 24 * 1024 * 1024;
 
@@ -40,9 +40,12 @@ function digest(value) {
  * still read, because anchor verification needs them, and their size is still
  * bounded — but they are not rendered into the page.
  */
-function normalizeSections(readModel, narratives, anchorOutcomes) {
+function normalizeSections(readModel, narratives, anchorOutcomes, noteContexts) {
   const supplied = new Map(narratives.map((entry) => [refKey(entry.ref), entry]));
   const outcomes = new Map(anchorOutcomes.map((entry) => [refKey(entry.ref), entry]));
+  const notes = noteContexts === null ? null : new Map(noteContexts.map((entry) => [
+    refKey({ project_id: entry.project_id, plan_key: entry.plan_key, task_id: entry.task_id }), entry,
+  ]));
   const result = [];
   const counted = new Set();
   let proseBytes = 0;
@@ -69,7 +72,20 @@ function normalizeSections(readModel, narratives, anchorOutcomes) {
         ref, narrative_ref: narrativeRef, anchored: false, reason: 'anchor_missing',
         origin_line: task.narrative_anchor?.origin_line ?? null,
       };
-      result.push({ ref, task, state: states.get(task.task_id), narrativeRef, anchorOutcome });
+      const noteContext = notes?.get(refKey(ref)) ?? null;
+      if (noteContext !== null) {
+        proseBytes += noteContext.notes.reduce((bytes, note) => (
+          bytes + Buffer.byteLength(note.body, 'utf8')
+        ), 0);
+        if (proseBytes > TODO_GANTT_PROSE_MAX_BYTES) {
+          throw new TodoGanttRenderError('TODO_SCALE_EXCEEDED', 'todo gantt embedded prose limit exceeded', {
+            prose_bytes: proseBytes, prose_limit: TODO_GANTT_PROSE_MAX_BYTES,
+          });
+        }
+      }
+      result.push({
+        ref, task, state: states.get(task.task_id), narrativeRef, anchorOutcome, noteContext,
+      });
     }
   }
   return { sections: result, proseBytes };
@@ -132,19 +148,23 @@ const CONTROLLER = `
 
 export function renderTodoGanttHtml({
   readModel, layout, narratives = [], anchorOutcomes = [], presentation = null, metadata = {},
-  expandedLayout = null,
+  expandedLayout = null, noteContexts = null, noteWarnings = [],
 }) {
   if (readModel?.schema !== 'lattice.todo_store_read.v1' || !Array.isArray(readModel.members)) {
     throw new TypeError('readModel must be lattice.todo_store_read.v1');
   }
   if (!Array.isArray(narratives)) throw new TypeError('narratives must be an array');
   if (!Array.isArray(anchorOutcomes)) throw new TypeError('anchorOutcomes must be an array');
+  if (!(noteContexts === null || Array.isArray(noteContexts))) {
+    throw new TypeError('noteContexts must be null or an array');
+  }
+  if (!Array.isArray(noteWarnings)) throw new TypeError('noteWarnings must be an array');
   if (presentation !== null
     && (presentation?.schema !== 'lattice.todo_gantt_presentation_model.v1'
       || presentation.project_id !== readModel.project_id)) {
     throw new TypeError('presentation must be lattice.todo_gantt_presentation_model.v1');
   }
-  const normalized = normalizeSections(readModel, narratives, anchorOutcomes);
+  const normalized = normalizeSections(readModel, narratives, anchorOutcomes, noteContexts);
   const displayName = projectDisplayName(readModel, metadata);
   const svg = renderTodoGanttSvg(layout, { presentation });
   // The expanded diagram travels with the page so the badge can bring the
@@ -153,7 +173,9 @@ export function renderTodoGanttHtml({
   const diagrams = expandedSvg === ''
     ? `<div data-diagram="live">${svg}</div>`
     : `<div data-diagram="live">${svg}</div><div data-diagram="expanded" hidden>${expandedSvg}</div>`;
-  const rightPane = renderRightPane(normalized.sections, layout, presentation, readModel);
+  const rightPane = renderRightPane(
+    normalized.sections, layout, presentation, readModel, noteContexts !== null, noteWarnings,
+  );
   const staticData = serializeJsonForScript({
     renderer_version: TODO_GANTT_RENDERER_VERSION,
     metadata,

package/src/todo-note-store.mjs

@@ -0,0 +1,492 @@
+import { createHash, randomBytes } from 'node:crypto';
+import {
+  mkdir, open, readFile, readdir, rename, rm, stat,
+} from 'node:fs/promises';
+import path from 'node:path';
+
+import {
+  TODO_LIMITS,
+  TODO_NOTE_CONTEXT_SCHEMA,
+  TODO_NOTE_EVENT_SCHEMA,
+  canonicalizeTodoArtifact,
+  exactRecord,
+  isTodoDigest,
+  isTodoIdentifier,
+  todoSelfDigest,
+  validateTodoPlan,
+  validateTodoNoteContext,
+  validateTodoNoteEvent,
+} from './todo-contracts.mjs';
+import { validatePhaseTodoRevision, validateTodoRevision } from './todo-revision.mjs';
+
+const NOTE_ROOT_REF = '.lattice/todo/notes';
+const SEALED_NAME = /^(\d{12})-(\d{12})-([0-9a-f]{64})-([0-9a-f]{64})\.jsonl$/u;
+const ZERO_DIGEST = '0'.repeat(64);
+const MAX_SEGMENTS = 4_096;
+
+export class TodoNoteStoreError extends Error {
+  constructor(code, reason, detail = {}) {
+    super(reason);
+    this.name = 'TodoNoteStoreError';
+    this.code = code;
+    this.detail = { reason, ...detail };
+  }
+}
+
+function fail(code, reason, detail) {
+  throw new TodoNoteStoreError(code, reason, detail);
+}
+
+function sha256(bytes) {
+  return createHash('sha256').update(bytes).digest('hex');
+}
+
+function canonicalLine(value) {
+  return Buffer.from(`${canonicalizeTodoArtifact(value)}\n`, 'utf8');
+}
+
+function notePaths(repoRoot, planKey) {
+  if (!isTodoIdentifier(planKey)) throw new TypeError('planKey must be a todo identifier');
+  const root = path.resolve(repoRoot, NOTE_ROOT_REF, planKey);
+  return { root, active: path.join(root, 'active.jsonl'), sealed: path.join(root, 'sealed') };
+}
+
+async function readOptionalBounded(ref, { missing = false } = {}) {
+  try {
+    const metadata = await stat(ref);
+    if (!metadata.isFile() || metadata.size > TODO_LIMITS.journalSegmentBytes) {
+      fail('NOTE_LOG_CORRUPT', 'note_segment_invalid', { ref });
+    }
+    return await readFile(ref);
+  } catch (error) {
+    if (error instanceof TodoNoteStoreError) throw error;
+    if (missing && error?.code === 'ENOENT') return null;
+    fail('NOTE_LOG_CORRUPT', 'note_segment_unreadable', { ref });
+  }
+}
+
+function parseCanonicalSegment(bytes, ref) {
+  if (bytes.length === 0 || bytes.at(-1) !== 0x0a) {
+    fail('NOTE_LOG_CORRUPT', 'note_segment_not_canonical', { ref });
+  }
+  const lines = bytes.toString('utf8').slice(0, -1).split('\n');
+  const events = [];
+  for (const line of lines) {
+    let event;
+    try { event = JSON.parse(line); } catch { fail('NOTE_LOG_CORRUPT', 'note_json_invalid', { ref }); }
+    if (!validateTodoNoteEvent(event) || canonicalLine(event).toString('utf8') !== `${line}\n`) {
+      fail('NOTE_LOG_CORRUPT', 'note_event_invalid', { ref });
+    }
+    events.push(event);
+  }
+  return events;
+}
+
+async function sealedFiles(ref) {
+  try {
+    const names = await readdir(ref);
+    if (names.length > MAX_SEGMENTS || names.some((name) => !SEALED_NAME.test(name))) {
+      fail('NOTE_LOG_CORRUPT', 'note_sealed_inventory_invalid', { ref });
+    }
+    return names.sort();
+  } catch (error) {
+    if (error instanceof TodoNoteStoreError) throw error;
+    if (error?.code === 'ENOENT') return [];
+    fail('NOTE_LOG_CORRUPT', 'note_sealed_inventory_unreadable', { ref });
+  }
+}
+
+function validateEventChain(events, { projectId, planKey }) {
+  for (let index = 0; index < events.length; index += 1) {
+    const event = events[index];
+    const previous = events[index - 1] ?? null;
+    if (event.project_id !== projectId || event.plan_key !== planKey
+      || event.sequence !== index + 1
+      || event.previous_digest !== (previous?.event_digest ?? null)) {
+      fail('NOTE_LOG_CORRUPT', 'note_digest_chain_invalid', {
+        plan_key: planKey, sequence: event.sequence,
+      });
+    }
+  }
+}
+
+/** planに属する独立note chainをbyte-levelで検証して読む。missingだけは空chainである。 */
+export async function readTodoNoteEvents(options = {}) {
+  const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
+  const { active, sealed } = notePaths(repoRoot, options.planKey);
+  const names = await sealedFiles(sealed);
+  const events = [];
+  let previousSegmentDigest = ZERO_DIGEST;
+  for (const name of names) {
+    const match = name.match(SEALED_NAME);
+    const bytes = await readOptionalBounded(path.join(sealed, name));
+    const segmentDigest = sha256(bytes);
+    const segmentEvents = parseCanonicalSegment(bytes, path.join(sealed, name));
+    if (Number(match[1]) !== segmentEvents[0]?.sequence
+      || Number(match[2]) !== segmentEvents.at(-1)?.sequence
+      || match[3] !== previousSegmentDigest || match[4] !== segmentDigest) {
+      fail('NOTE_LOG_CORRUPT', 'note_seal_invalid', { ref: path.join(sealed, name) });
+    }
+    events.push(...segmentEvents);
+    previousSegmentDigest = segmentDigest;
+  }
+  const activeBytes = await readOptionalBounded(active, { missing: true });
+  if (activeBytes !== null) events.push(...parseCanonicalSegment(activeBytes, active));
+  if (events.length > 0) {
+    validateEventChain(events, { projectId: events[0].project_id, planKey: options.planKey });
+  }
+  return {
+    events,
+    head_digest: events.at(-1)?.event_digest ?? null,
+    active_bytes: activeBytes ?? Buffer.alloc(0),
+    previous_segment_digest: previousSegmentDigest,
+  };
+}
+
+async function atomicWrite(ref, bytes) {
+  await mkdir(path.dirname(ref), { recursive: true });
+  const temporary = path.join(path.dirname(ref),
+    `.${path.basename(ref)}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`);
+  let handle;
+  try {
+    handle = await open(temporary, 'wx', 0o600);
+    await handle.writeFile(bytes);
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    await rename(temporary, ref);
+    const directory = await open(path.dirname(ref), 'r');
+    try { await directory.sync(); } finally { await directory.close(); }
+  } finally {
+    if (handle) await handle.close();
+    await rm(temporary, { force: true });
+  }
+}
+
+async function withNoteLock(repoRoot, callback) {
+  const root = path.resolve(repoRoot, NOTE_ROOT_REF);
+  await mkdir(root, { recursive: true });
+  const lockRef = path.join(root, '.write.lock');
+  let handle;
+  try { handle = await open(lockRef, 'wx', 0o600); }
+  catch (error) {
+    if (error?.code === 'EEXIST') fail('NOTE_WRITE_CONFLICT', 'note_store_locked');
+    throw error;
+  }
+  try { return await callback(); }
+  finally { await handle.close(); await rm(lockRef, { force: true }); }
+}
+
+/** lifecycle artifactsへ触れず、独立note chainだけへ1 eventを追記する。 */
+export async function appendTodoNote(options = {}) {
+  const keys = [
+    'repoRoot', 'projectId', 'planKey', 'planVersion', 'taskId', 'actor',
+    'recordedAt', 'body', 'supersedes', 'eligibleSupersedes',
+  ];
+  if (!exactRecord(options, keys)
+    || !Array.isArray(options.eligibleSupersedes)
+    || !options.eligibleSupersedes.every(isTodoDigest)
+    || ![options.projectId, options.planKey, options.planVersion, options.taskId]
+    .every(isTodoIdentifier)) throw new TypeError('todo note append options invalid');
+  const repoRoot = path.resolve(options.repoRoot);
+  return withNoteLock(repoRoot, async () => {
+    const chain = await readTodoNoteEvents({ repoRoot, planKey: options.planKey });
+    if (options.supersedes !== null) {
+      const target = chain.events.find(({ event_digest: digest }) => digest === options.supersedes);
+      if (target === undefined || !options.eligibleSupersedes.includes(options.supersedes)) {
+        fail('NOTE_SUPERSEDES_INVALID', 'superseded_note_not_in_same_task', {
+          plan_key: options.planKey, task_id: options.taskId,
+        });
+      }
+    }
+    const previous = chain.events.at(-1) ?? null;
+    const event = {
+      schema: TODO_NOTE_EVENT_SCHEMA,
+      project_id: options.projectId,
+      plan_key: options.planKey,
+      task_id: options.taskId,
+      plan_version: options.planVersion,
+      sequence: (previous?.sequence ?? 0) + 1,
+      previous_digest: previous?.event_digest ?? null,
+      actor: options.actor,
+      recorded_at: options.recordedAt,
+      body: options.body,
+      supersedes: options.supersedes,
+      event_digest: '',
+    };
+    event.event_digest = todoSelfDigest(event, 'event_digest');
+    if (!validateTodoNoteEvent(event)) throw new TypeError('todo note event input invalid');
+
+    const paths = notePaths(repoRoot, options.planKey);
+    const eventBytes = canonicalLine(event);
+    if (chain.active_bytes.length > 0
+      && chain.active_bytes.length + eventBytes.length > TODO_LIMITS.journalSegmentBytes) {
+      const activeEvents = parseCanonicalSegment(chain.active_bytes, paths.active);
+      const segmentDigest = sha256(chain.active_bytes);
+      const name = `${String(activeEvents[0].sequence).padStart(12, '0')}`
+        + `-${String(activeEvents.at(-1).sequence).padStart(12, '0')}`
+        + `-${chain.previous_segment_digest}-${segmentDigest}.jsonl`;
+      await atomicWrite(path.join(paths.sealed, name), chain.active_bytes);
+      await atomicWrite(paths.active, eventBytes);
+    } else {
+      await atomicWrite(paths.active, Buffer.concat([chain.active_bytes, eventBytes]));
+    }
+    return event;
+  });
+}
+
+function noteProjectionEntry(event, supersededBy) {
+  return {
+    event_digest: event.event_digest,
+    origin_plan_version: event.plan_version,
+    origin_task_id: event.task_id,
+    actor: event.actor,
+    recorded_at: event.recorded_at,
+    body: event.body,
+    supersedes: event.supersedes,
+    superseded_by: supersededBy ?? null,
+    correction_state: supersededBy === undefined ? 'current' : 'superseded',
+  };
+}
+
+function migrationIndex(migrations) {
+  if (!Array.isArray(migrations)) throw new TypeError('todo note migrations must be an array');
+  const index = new Map();
+  for (const migration of migrations) {
+    if (!exactRecord(migration, ['from_plan_version', 'to_plan_version', 'task_migration'])
+      || !isTodoIdentifier(migration.from_plan_version)
+      || !isTodoIdentifier(migration.to_plan_version)
+      || migration.from_plan_version === migration.to_plan_version
+      || !Array.isArray(migration.task_migration)
+      || index.has(migration.from_plan_version)) {
+      fail('NOTE_PROJECTION_INVALID', 'note_migration_history_invalid');
+    }
+    const taskMap = new Map();
+    for (const entry of migration.task_migration) {
+      if (!exactRecord(entry, ['from_task_id', 'to_task_id'])
+        || !isTodoIdentifier(entry.from_task_id)
+        || !(entry.to_task_id === null || isTodoIdentifier(entry.to_task_id))
+        || taskMap.has(entry.from_task_id)) {
+        fail('NOTE_PROJECTION_INVALID', 'note_task_migration_invalid');
+      }
+      taskMap.set(entry.from_task_id, entry.to_task_id === 'removed' ? null : entry.to_task_id);
+    }
+    index.set(migration.from_plan_version, {
+      toPlanVersion: migration.to_plan_version, taskMap,
+    });
+  }
+  return index;
+}
+
+function resolveNoteTarget(event, { currentPlanVersion, currentTaskIds, migrations }) {
+  let version = event.plan_version;
+  let taskId = event.task_id;
+  const seen = new Set();
+  while (version !== currentPlanVersion) {
+    if (seen.has(version)) fail('NOTE_PROJECTION_INVALID', 'note_migration_cycle');
+    seen.add(version);
+    const step = migrations.get(version);
+    if (step === undefined) return { kind: 'archived' };
+    const nextTaskId = step.taskMap.get(taskId);
+    if (nextTaskId === undefined || nextTaskId === null) return { kind: 'archived' };
+    version = step.toPlanVersion;
+    taskId = nextTaskId;
+  }
+  return currentTaskIds.has(taskId) ? { kind: 'active', taskId } : { kind: 'archived' };
+}
+
+/**
+ * 既存task_migrationを合成し、現行taskへ渡すbounded contextとremoved taskのarchived束を作る。
+ * note listはこの全履歴を使えるが、通常詳細/startはcontextを自動同梱する。
+ */
+export function projectTodoNoteContext(options = {}) {
+  if (!exactRecord(options, [
+    'projectId', 'planKey', 'currentPlanVersion', 'currentTaskId',
+    'currentTaskIds', 'events', 'migrations',
+  ]) || ![options.projectId, options.planKey, options.currentPlanVersion, options.currentTaskId]
+    .every(isTodoIdentifier) || !Array.isArray(options.currentTaskIds)
+    || !options.currentTaskIds.every(isTodoIdentifier)
+    || !options.currentTaskIds.includes(options.currentTaskId)
+    || !Array.isArray(options.events) || !options.events.every(validateTodoNoteEvent)) {
+    throw new TypeError('todo note projection options invalid');
+  }
+  const currentTaskIds = new Set(options.currentTaskIds);
+  const migrations = migrationIndex(options.migrations);
+  const supersededBy = new Map();
+  for (const event of options.events) {
+    if (event.project_id !== options.projectId || event.plan_key !== options.planKey) {
+      fail('NOTE_LOG_CORRUPT', 'note_identity_mismatch');
+    }
+    if (event.supersedes !== null) supersededBy.set(event.supersedes, event.event_digest);
+  }
+
+  const current = [];
+  const archived = [];
+  const sequenceByDigest = new Map(options.events.map((event) => [event.event_digest, event.sequence]));
+  for (const event of options.events) {
+    const target = resolveNoteTarget(event, {
+      currentPlanVersion: options.currentPlanVersion, currentTaskIds, migrations,
+    });
+    const entry = noteProjectionEntry(event, supersededBy.get(event.event_digest));
+    if (target.kind === 'archived') archived.push(entry);
+    else if (target.taskId === options.currentTaskId) current.push(entry);
+  }
+  current.sort((left, right) => sequenceByDigest.get(right.event_digest)
+    - sequenceByDigest.get(left.event_digest));
+  archived.reverse();
+
+  const notes = [];
+  let usedBytes = 0;
+  for (const entry of current) {
+    const bytes = Buffer.byteLength(entry.body, 'utf8');
+    if (usedBytes + bytes > TODO_LIMITS.noteContextBytes) continue;
+    notes.push(entry);
+    usedBytes += bytes;
+  }
+  const context = {
+    schema: TODO_NOTE_CONTEXT_SCHEMA,
+    project_id: options.projectId,
+    plan_key: options.planKey,
+    task_id: options.currentTaskId,
+    notes,
+    note_head_digest: current[0]?.event_digest ?? null,
+    overflow_count: current.length - notes.length,
+    full_history_command: `lattice todo note list --plan ${options.planKey}`
+      + ` --task ${options.currentTaskId} --json`,
+    context_digest: '',
+  };
+  context.context_digest = todoSelfDigest(context, 'context_digest');
+  if (!validateTodoNoteContext(context)) {
+    fail('NOTE_PROJECTION_INVALID', 'note_context_invalid');
+  }
+  return { context, archived, history: current };
+}
+
+async function readCanonicalJson(ref, { missing = false } = {}) {
+  let bytes;
+  try {
+    const metadata = await stat(ref);
+    if (!metadata.isFile() || metadata.size > TODO_LIMITS.snapshotBytes) {
+      fail('NOTE_PROJECTION_INVALID', 'note_projection_artifact_invalid', { ref });
+    }
+    bytes = await readFile(ref);
+  } catch (error) {
+    if (error instanceof TodoNoteStoreError) throw error;
+    if (missing && error?.code === 'ENOENT') return null;
+    fail('NOTE_PROJECTION_INVALID', 'note_projection_artifact_unreadable', { ref });
+  }
+  let value;
+  try { value = JSON.parse(bytes.toString('utf8')); }
+  catch { fail('NOTE_PROJECTION_INVALID', 'note_projection_json_invalid', { ref }); }
+  if (!bytes.equals(canonicalLine(value))) {
+    fail('NOTE_PROJECTION_INVALID', 'note_projection_artifact_not_canonical', { ref });
+  }
+  return value;
+}
+
+async function readNoteMigrations(repoRoot, planKey, eventVersions) {
+  const base = path.resolve(repoRoot, '.lattice/todo/plans', planKey);
+  let entries;
+  try { entries = await readdir(base, { withFileTypes: true }); }
+  catch (error) {
+    if (error?.code === 'ENOENT' && eventVersions.size === 0) return [];
+    fail('NOTE_PROJECTION_INVALID', 'note_plan_history_unreadable', { plan_key: planKey });
+  }
+  const versions = new Set();
+  const migrations = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !isTodoIdentifier(entry.name)) {
+      fail('NOTE_PROJECTION_INVALID', 'note_plan_history_inventory_invalid', { plan_key: planKey });
+    }
+    const versionRoot = path.join(base, entry.name);
+    const plan = await readCanonicalJson(path.join(versionRoot, 'plan.json'));
+    if (!validateTodoPlan(plan) || plan.plan_key !== planKey || plan.plan_version !== entry.name) {
+      fail('NOTE_PROJECTION_INVALID', 'note_historical_plan_invalid', { plan_version: entry.name });
+    }
+    versions.add(entry.name);
+    const revision = await readCanonicalJson(path.join(versionRoot, 'revision.json'), { missing: true });
+    if (revision === null) continue;
+    if (!(validateTodoRevision(revision) || validatePhaseTodoRevision(revision))
+      || revision.plan_key !== planKey || revision.predecessor?.plan_version === undefined
+      || !Array.isArray(revision.task_migration)) {
+      fail('NOTE_PROJECTION_INVALID', 'note_historical_revision_invalid', { plan_version: entry.name });
+    }
+    migrations.push({
+      from_plan_version: revision.predecessor.plan_version,
+      to_plan_version: entry.name,
+      task_migration: revision.task_migration.map(({ from_task_id: fromTaskId, to_task_id: toTaskId }) => ({
+        from_task_id: fromTaskId, to_task_id: toTaskId,
+      })),
+    });
+  }
+  if ([...eventVersions].some((version) => !versions.has(version))) {
+    fail('NOTE_PROJECTION_INVALID', 'note_origin_plan_version_unknown');
+  }
+  return migrations;
+}
+
+/** active store memberと歴史revisionから、通常供給用contextを一回で読む。 */
+export async function readTodoNoteContext(options = {}) {
+  if (!exactRecord(options, ['repoRoot', 'store', 'planKey', 'taskId'])
+    || !isTodoIdentifier(options.planKey) || !isTodoIdentifier(options.taskId)
+    || options.store === null || typeof options.store !== 'object') {
+    throw new TypeError('todo note context read options invalid');
+  }
+  const repoRoot = path.resolve(options.repoRoot);
+  const member = options.store.members?.find(({ descriptor }) => (
+    descriptor.plan_key === options.planKey
+  ));
+  if (member === undefined) fail('NOTE_TASK_NOT_FOUND', 'note_plan_not_active', {
+    plan_key: options.planKey,
+  });
+  const task = member.plan.tasks.find(({ task_id: taskId }) => taskId === options.taskId);
+  if (task === undefined) fail('NOTE_TASK_NOT_FOUND', 'note_task_not_active', {
+    plan_key: options.planKey, task_id: options.taskId,
+  });
+  const chain = await readTodoNoteEvents({ repoRoot, planKey: options.planKey });
+  const migrations = await readNoteMigrations(repoRoot, options.planKey,
+    new Set(chain.events.map(({ plan_version: version }) => version)));
+  return projectTodoNoteContext({
+    projectId: member.plan.project_id,
+    planKey: options.planKey,
+    currentPlanVersion: member.plan.plan_version,
+    currentTaskId: task.task_id,
+    currentTaskIds: member.plan.tasks.map(({ task_id: taskId }) => taskId),
+    events: chain.events,
+    migrations,
+  });
+}
+
+/** Gantt用に1 planのchain/historyを一度だけ読み、全task contextへ投影する。 */
+export async function readTodoNoteContextsForPlan(options = {}) {
+  if (!exactRecord(options, ['repoRoot', 'store', 'planKey'])
+    || !isTodoIdentifier(options.planKey)
+    || options.store === null || typeof options.store !== 'object') {
+    throw new TypeError('todo note contexts read options invalid');
+  }
+  const repoRoot = path.resolve(options.repoRoot);
+  const member = options.store.members?.find(({ descriptor }) => (
+    descriptor.plan_key === options.planKey
+  ));
+  if (member === undefined) fail('NOTE_TASK_NOT_FOUND', 'note_plan_not_active', {
+    plan_key: options.planKey,
+  });
+  const chain = await readTodoNoteEvents({ repoRoot, planKey: options.planKey });
+  const migrations = await readNoteMigrations(repoRoot, options.planKey,
+    new Set(chain.events.map(({ plan_version: version }) => version)));
+  const currentTaskIds = member.plan.tasks.map(({ task_id: taskId }) => taskId);
+  const projected = member.plan.tasks.map((task) => projectTodoNoteContext({
+    projectId: member.plan.project_id,
+    planKey: options.planKey,
+    currentPlanVersion: member.plan.plan_version,
+    currentTaskId: task.task_id,
+    currentTaskIds,
+    events: chain.events,
+    migrations,
+  }));
+  return {
+    contexts: projected.map(({ context }) => context),
+    archived: projected[0]?.archived ?? [],
+    note_head_digest: chain.head_digest,
+  };
+}