@quolu/lattice 0.58.4 → 0.59.1

package/bin/lattice.mjs

@@ -73,6 +73,26 @@ if (sensorRelaunchStatus !== null) {
   } catch (error) {
     process.exitCode = projectCliFailure(process.stderr, error);
   }
+} else if (args.length === 7 && args[0] === 'plan' && args[1] === 'scope-review'
+  && args[2] === '--plan-input' && args[4] === '--review' && args[6] === '--json') {
+  const { runPlanScopeReview } = await import('../src/plan-scope-review.mjs');
+  const { projectCliFailure } = await import('../src/project-cli.mjs');
+  try {
+    process.exitCode = await runPlanScopeReview({
+      cwd: process.cwd(), planInputRef: args[3], reviewRef: args[5], stdout: process.stdout,
+    });
+  } catch (error) {
+    process.exitCode = projectCliFailure(process.stderr, error);
+  }
+} else if (args.length === 4 && args[0] === 'plan' && args[1] === 'scope-review'
+  && args[2] === '--schema' && args[3] === '--json') {
+  const { runPlanScopeReviewSchema } = await import('../src/plan-scope-review.mjs');
+  const { projectCliFailure } = await import('../src/project-cli.mjs');
+  try {
+    process.exitCode = await runPlanScopeReviewSchema({ stdout: process.stdout });
+  } catch (error) {
+    process.exitCode = projectCliFailure(process.stderr, error);
+  }
 } else if (args.length === 2 && args[0] === 'factory-diagnostics' && args[1] === '--json') {
   const { buildFactoryDiagnostics } = await import('../src/factory-diagnostics.mjs');
   const diagnostics = await buildFactoryDiagnostics();

package/docs/schemas/lattice.executor_packet.v1.schema.json

@@ -39,9 +39,9 @@
     },
     "forbidden_operations": {
       "type": "array",
-      "minItems": 1,
       "maxItems": 256,
-      "items": { "type": "string" }
+      "items": { "type": "string" },
+      "description": "Compatibility field. Lattice-produced packets use an empty array; operation authority belongs to the host."
     },
     "context_content_digest": { "$ref": "#/$defs/digest" },
     "packet_digest": { "$ref": "#/$defs/digest" }

package/docs/schemas/lattice.plan_create_input.v4.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://github.com/kitepon-rgb/Lattice/blob/main/docs/schemas/lattice.plan_create_input.v4.schema.json",
   "title": "lattice.plan_create_input.v4",
-  "description": "Canonical initial authoring input for a phase-audited plan. Every task requires a design memo. あなたがこのToDoに対して、何も考えていないならば、設計メモに `NO_PLAN` と書いてください",
+  "description": "Canonical initial authoring input for a phase-audited plan. Every task requires a design memo. After the complete plan is written, run `lattice plan scope-review` and confirm that every task preserves an owner-supplied work specification without adding a product purpose. あなたがこのToDoに対して、何も考えていないならば、設計メモに `NO_PLAN` と書いてください",
   "$comment": "Runtime validation additionally enforces canonical JSON+LF bytes, sorted identifiers and edges, unique ids, combined task/phase acyclicity, byte bounds, non-empty design_memo, and input_digest.",
   "type": "object",
   "additionalProperties": false,

package/docs/schemas/lattice.plan_scope_review.v1.schema.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/kitepon-rgb/Lattice/blob/main/docs/schemas/lattice.plan_scope_review.v1.schema.json",
+  "title": "lattice.plan_scope_review.v1",
+  "description": "AI-authored review performed after the complete plan is written and before it is registered. Every planned task is judged against the owner-supplied work specifications; task splitting and parallelization are allowed, but a new product purpose is not.",
+  "$comment": "Lattice validates complete task coverage, known work-spec references, verdict consistency, and digest binding. The operating AI owns the semantic judgment.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema", "authoring_digest", "work_specs", "task_assessments", "verdict", "review_digest"
+  ],
+  "properties": {
+    "schema": { "const": "lattice.plan_scope_review.v1" },
+    "authoring_digest": { "$ref": "#/$defs/digest" },
+    "work_specs": {
+      "type": "array", "minItems": 1, "maxItems": 512,
+      "description": "The owner-supplied work specifications. Do not add inferred improvements as work specifications.",
+      "items": { "$ref": "#/$defs/workSpec" }
+    },
+    "task_assessments": {
+      "type": "array", "minItems": 1, "maxItems": 512,
+      "description": "Exactly one assessment for every task that will be registered. Use out_of_scope when the task creates a purpose not required by any work specification.",
+      "items": { "$ref": "#/$defs/taskAssessment" }
+    },
+    "verdict": { "enum": ["scope_preserved", "scope_mismatch"] },
+    "review_digest": { "$ref": "#/$defs/digest" }
+  },
+  "$defs": {
+    "identifier": { "type": "string", "pattern": "^[0-9A-Za-z](?:[0-9A-Za-z._-]{0,127})$" },
+    "digest": { "type": "string", "pattern": "^[0-9a-f]{64}$" },
+    "text": { "type": "string", "minLength": 1, "maxLength": 16384, "pattern": "\\S" },
+    "workSpec": {
+      "type": "object", "additionalProperties": false,
+      "required": ["work_spec_id", "requirement", "acceptance"],
+      "properties": {
+        "work_spec_id": { "$ref": "#/$defs/identifier" },
+        "requirement": { "$ref": "#/$defs/text" },
+        "acceptance": { "$ref": "#/$defs/text" }
+      }
+    },
+    "taskAssessment": {
+      "type": "object", "additionalProperties": false,
+      "required": ["task_id", "work_spec_ids", "judgment", "reason"],
+      "properties": {
+        "task_id": { "$ref": "#/$defs/identifier" },
+        "work_spec_ids": {
+          "type": "array", "maxItems": 512, "uniqueItems": true,
+          "items": { "$ref": "#/$defs/identifier" }
+        },
+        "judgment": { "enum": ["required", "out_of_scope"] },
+        "reason": { "$ref": "#/$defs/text" }
+      }
+    }
+  }
+}

package/docs/schemas/lattice.todo_extraction.v3.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://github.com/kitepon-rgb/Lattice/blob/main/docs/schemas/lattice.todo_extraction.v3.schema.json",
   "title": "lattice.todo_extraction.v3",
-  "description": "AI-authored ToDo migration artifact. Every task carries a non-blank Markdown design_memo. If no plan exists, write NO_PLAN explicitly.",
+  "description": "AI-authored ToDo migration artifact. Every task carries a non-blank Markdown design_memo. After the complete plan is written, run `lattice plan scope-review` and confirm that every registered task preserves an owner-supplied work specification without adding a product purpose. If no plan exists, write NO_PLAN explicitly.",
   "$comment": "あなたがこのToDoに対して、何も考えていないならば、設計メモに `NO_PLAN` と書いてください。Runtime validation also enforces UTF-8 byte bounds, exact keys, strict sort order, referential integrity, disposition consistency, and the canonical self-digest.",
   "type": "object",
   "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.58.4",
+  "version": "0.59.1",
   "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",
@@ -29,6 +29,7 @@
     "docs/schemas/lattice.plan_create_input.v2.schema.json",
     "docs/schemas/lattice.plan_create_input.v3.schema.json",
     "docs/schemas/lattice.plan_create_input.v4.schema.json",
+    "docs/schemas/lattice.plan_scope_review.v1.schema.json",
     "docs/schemas/lattice.todo_revision.v2.schema.json",
     "docs/schemas/lattice.todo_revision_set.v3.schema.json",
     "docs/schemas/lattice.phase_todo_revision.v3.schema.json",

package/src/cli-help.mjs

@@ -202,6 +202,7 @@ const SUBCOMMAND_USAGE = Object.freeze({
   'session-context': 'session-context --json',
   'plan create': 'plan create --input <file> [--serialization-reviewed] | --schema --json | --schema-version <1|2|3|4> --json',
   'plan show': 'plan show <plan_key> --json',
+  'plan scope-review': 'plan scope-review --plan-input <plan-create-or-extraction.json> --review <scope-review.json> --json | --schema --json',
   'plan compile': 'plan compile --request <request.json> | --schema --json',
   'plan verify': 'plan verify --request <request.json> --plan <plan.json>',
   'run start': 'run start --request <request.json> --executor <adapter>'
@@ -262,7 +263,7 @@ const SUBCOMMAND_USAGE = Object.freeze({
   'todo retract': 'todo retract --plan <key> --task <id> --reason <text>',
   'todo block': 'todo block --plan <key> --task <id> --reason <text>',
   'todo unblock': 'todo unblock --plan <key> --task <id>',
-  'todo done': 'todo done --plan <key> --task <id> --evidence <file>',
+  'todo done': 'todo done --plan <key> --task <id> --evidence <file> [--test-result <markdown-file>]',
   'todo reopen': 'todo reopen --plan <key> --task <id> --reason <text> [--override-reason <text>]',
   'todo evidence': 'todo evidence promote --plan <key> --task <id> --evidence <file>',
   'todo evidence promote': 'todo evidence promote --plan <key> --task <id> --evidence <file>',

package/src/plan-scope-review.mjs

@@ -0,0 +1,211 @@
+import { constants as fsConstants } from 'node:fs';
+import { lstat, open, realpath, readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { gitSync } from './git-process.mjs';
+import {
+  exactRecord,
+  isTodoDigest,
+  isTodoIdentifier,
+  isTodoRef,
+  todoSelfDigest,
+} from './todo-contracts.mjs';
+import { TodoStoreError } from './todo-store.mjs';
+
+const REVIEW_SCHEMA = 'lattice.plan_scope_review.v1';
+const RESULT_SCHEMA = 'lattice.plan_scope_review_result.v1';
+const PLAN_CREATE_SCHEMA = 'lattice.plan_create_input.v4';
+const TODO_EXTRACTION_SCHEMA = 'lattice.todo_extraction.v3';
+const MAX_INPUT_BYTES = 8_388_608;
+const JUDGMENTS = new Set(['required', 'out_of_scope']);
+
+function boundedText(value) {
+  return typeof value === 'string' && value.trim().length > 0
+    && Buffer.byteLength(value) <= 16_384;
+}
+
+function sortedStrictly(values, key = (value) => value) {
+  return values.every((value, index) => index === 0 || key(values[index - 1]) < key(value));
+}
+
+function within(root, candidate) {
+  return candidate.startsWith(`${root}${path.sep}`);
+}
+
+function resolveRepoRoot(cwd) {
+  try {
+    return path.resolve(gitSync(['rev-parse', '--show-toplevel'], {
+      cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    }).replace(/\r?\n$/u, ''));
+  } catch {
+    return null;
+  }
+}
+
+async function readJsonWithinRepo(repoRoot, inputRef) {
+  if (!isTodoRef(inputRef)) {
+    throw new TodoStoreError('INPUT_UNREADABLE', 'input_path_outside_repo', undefined,
+      { input_ref: inputRef });
+  }
+  const canonicalRoot = await realpath(repoRoot);
+  const absolute = path.resolve(canonicalRoot, inputRef);
+  if (!within(canonicalRoot, absolute)) {
+    throw new TodoStoreError('INPUT_UNREADABLE', 'input_path_outside_repo', undefined,
+      { input_ref: inputRef });
+  }
+  let stats;
+  try { stats = await lstat(absolute); } catch {
+    throw new TodoStoreError('INPUT_UNREADABLE', 'input_unreadable', undefined,
+      { input_ref: inputRef });
+  }
+  if (!stats.isFile() || stats.isSymbolicLink() || stats.size > MAX_INPUT_BYTES
+    || await realpath(absolute) !== absolute) {
+    throw new TodoStoreError('INPUT_UNREADABLE', 'input_path_unsafe', undefined,
+      { input_ref: inputRef });
+  }
+  let value;
+  try { value = JSON.parse(await readFile(absolute, 'utf8')); } catch {
+    throw new TodoStoreError('INPUT_INVALID', 'input_json_invalid', undefined,
+      { input_ref: inputRef });
+  }
+  return value;
+}
+
+function authoredPlan(value) {
+  const digestField = value?.schema === PLAN_CREATE_SCHEMA ? 'input_digest'
+    : value?.schema === TODO_EXTRACTION_SCHEMA ? 'extraction_digest' : null;
+  if (digestField === null) {
+    throw new TodoStoreError('PLAN_SCOPE_REVIEW_INVALID', 'authoring_schema_unsupported', undefined, {
+      pointer: '/schema', expected: [PLAN_CREATE_SCHEMA, TODO_EXTRACTION_SCHEMA],
+      actual: typeof value?.schema === 'string' ? value.schema : null,
+    });
+  }
+  if (!isTodoDigest(value[digestField])
+    || value[digestField] !== todoSelfDigest(value, digestField)) {
+    throw new TodoStoreError('PLAN_SCOPE_REVIEW_INVALID', 'authoring_digest_mismatch', undefined, {
+      pointer: `/${digestField}`,
+    });
+  }
+  const selected = value.schema === TODO_EXTRACTION_SCHEMA
+    ? value.tasks?.filter((task) => typeof task?.disposition === 'string'
+      && task.disposition.startsWith('register_'))
+    : value.tasks;
+  if (!Array.isArray(selected) || selected.length === 0
+    || selected.some((task) => !isTodoIdentifier(task?.task_id))) {
+    throw new TodoStoreError('PLAN_SCOPE_REVIEW_INVALID', 'authoring_tasks_invalid', undefined, {
+      pointer: '/tasks',
+    });
+  }
+  const taskIds = selected.map(({ task_id: taskId }) => taskId).sort();
+  if (new Set(taskIds).size !== taskIds.length) {
+    throw new TodoStoreError('PLAN_SCOPE_REVIEW_INVALID', 'authoring_task_ids_duplicate', undefined, {
+      pointer: '/tasks',
+    });
+  }
+  return { schema: value.schema, digest: value[digestField], taskIds };
+}
+
+function invalid(reason, pointer, detail = {}) {
+  throw new TodoStoreError('PLAN_SCOPE_REVIEW_INVALID', reason, undefined, { pointer, ...detail });
+}
+
+function validateReview(review, authored) {
+  if (!exactRecord(review, [
+    'schema', 'authoring_digest', 'work_specs', 'task_assessments', 'verdict', 'review_digest',
+  ]) || review.schema !== REVIEW_SCHEMA) invalid('review_schema_invalid', '/schema');
+  if (!isTodoDigest(review.authoring_digest) || review.authoring_digest !== authored.digest) {
+    invalid('review_authoring_digest_mismatch', '/authoring_digest', {
+      expected: authored.digest, actual: review.authoring_digest ?? null,
+    });
+  }
+  if (!isTodoDigest(review.review_digest)
+    || review.review_digest !== todoSelfDigest(review, 'review_digest')) {
+    invalid('review_digest_mismatch', '/review_digest');
+  }
+  if (!Array.isArray(review.work_specs) || review.work_specs.length === 0
+    || !review.work_specs.every((spec) => exactRecord(spec, [
+      'work_spec_id', 'requirement', 'acceptance',
+    ]) && isTodoIdentifier(spec.work_spec_id) && boundedText(spec.requirement)
+      && boundedText(spec.acceptance))
+    || !sortedStrictly(review.work_specs, ({ work_spec_id: id }) => id)) {
+    invalid('work_specs_invalid', '/work_specs');
+  }
+  const workSpecIds = new Set(review.work_specs.map(({ work_spec_id: id }) => id));
+  if (!Array.isArray(review.task_assessments)
+    || !review.task_assessments.every((assessment) => exactRecord(assessment, [
+      'task_id', 'work_spec_ids', 'judgment', 'reason',
+    ]) && isTodoIdentifier(assessment.task_id) && Array.isArray(assessment.work_spec_ids)
+      && assessment.work_spec_ids.every(isTodoIdentifier)
+      && sortedStrictly(assessment.work_spec_ids) && JUDGMENTS.has(assessment.judgment)
+      && boundedText(assessment.reason)
+      && (assessment.judgment === 'required'
+        ? assessment.work_spec_ids.length > 0 : assessment.work_spec_ids.length === 0)
+      && assessment.work_spec_ids.every((id) => workSpecIds.has(id)))
+    || !sortedStrictly(review.task_assessments, ({ task_id: id }) => id)) {
+    invalid('task_assessments_invalid', '/task_assessments');
+  }
+  const assessedTaskIds = review.task_assessments.map(({ task_id: id }) => id);
+  if (assessedTaskIds.length !== authored.taskIds.length
+    || assessedTaskIds.some((id, index) => id !== authored.taskIds[index])) {
+    invalid('task_assessments_incomplete', '/task_assessments', {
+      expected_task_ids: authored.taskIds, actual_task_ids: assessedTaskIds,
+    });
+  }
+  const outOfScopeTaskIds = review.task_assessments
+    .filter(({ judgment }) => judgment === 'out_of_scope')
+    .map(({ task_id: id }) => id);
+  const covered = new Set(review.task_assessments.flatMap(({ work_spec_ids: ids }) => ids));
+  const uncoveredWorkSpecIds = [...workSpecIds].filter((id) => !covered.has(id));
+  const expectedVerdict = outOfScopeTaskIds.length === 0 && uncoveredWorkSpecIds.length === 0
+    ? 'scope_preserved' : 'scope_mismatch';
+  if (review.verdict !== expectedVerdict) {
+    invalid('review_verdict_inconsistent', '/verdict', {
+      expected: expectedVerdict, actual: review.verdict ?? null,
+    });
+  }
+  return { outOfScopeTaskIds, uncoveredWorkSpecIds };
+}
+
+export function evaluatePlanScopeReview(planInput, review) {
+  const authored = authoredPlan(planInput);
+  const findings = validateReview(review, authored);
+  const result = {
+    schema: RESULT_SCHEMA,
+    authoring_schema: authored.schema,
+    authoring_digest: authored.digest,
+    work_spec_count: review.work_specs.length,
+    reviewed_task_count: review.task_assessments.length,
+    verdict: review.verdict,
+    accepted: review.verdict === 'scope_preserved',
+    out_of_scope_task_ids: findings.outOfScopeTaskIds,
+    uncovered_work_spec_ids: findings.uncoveredWorkSpecIds,
+    review_digest: review.review_digest,
+    result_digest: '',
+  };
+  result.result_digest = todoSelfDigest(result, 'result_digest');
+  return result;
+}
+
+export async function runPlanScopeReview({ cwd, planInputRef, reviewRef, stdout }) {
+  const repoRoot = resolveRepoRoot(cwd);
+  if (repoRoot === null) throw new TodoStoreError('REPO_UNRESOLVED', 'git_toplevel_unresolved');
+  const [planInput, review] = await Promise.all([
+    readJsonWithinRepo(repoRoot, planInputRef), readJsonWithinRepo(repoRoot, reviewRef),
+  ]);
+  const result = evaluatePlanScopeReview(planInput, review);
+  stdout.write(`${JSON.stringify(result)}\n`);
+  return result.accepted ? 0 : 1;
+}
+
+export async function runPlanScopeReviewSchema({ stdout }) {
+  const schemaUrl = new URL('../docs/schemas/lattice.plan_scope_review.v1.schema.json', import.meta.url);
+  const handle = await open(schemaUrl, fsConstants.O_RDONLY);
+  try {
+    const schema = JSON.parse(await handle.readFile('utf8'));
+    if (schema?.title !== REVIEW_SCHEMA) throw new TypeError('bundled plan scope review schema invalid');
+    stdout.write(`${JSON.stringify(schema)}\n`);
+    return 0;
+  } finally {
+    await handle.close();
+  }
+}

package/src/runtime-contracts.mjs

@@ -642,7 +642,7 @@ export function validateExecutorPacket(value) {
     && identifier(packet.plan_ref)
     && nonNegativeInteger(packet.plan_epoch)
     && boundedArray(packet.verifier_refs, (entry) => typeof entry === 'string')
-    && boundedArray(packet.forbidden_operations, (entry) => typeof entry === 'string', { min: 1 })
+    && boundedArray(packet.forbidden_operations, (entry) => typeof entry === 'string')
     && packet.context_content_digest === computeContextContentDigest(packet)
     && selfDigestValid(packet, 'packet_digest')
   ));

package/src/runtime-engine.mjs

@@ -32,18 +32,10 @@ import {
 
 const ENGINE_ACTOR = 'lattice-runtime';
 /**
- * workerへ配る禁止操作。
- *
- * `commit`は含めない。自分の隔離worktreeでdetached HEADへ進めるcommitは、canonical branchを
- * 動かさず外部へ効果を出さない一方で、進行中の成果を耐久化し、diff観測が生み出した木そのものを
- * 縛れるようにする（ADR 0139）。
- *
- * 禁止のままにするのは、HEADをbaseの子孫から外す操作と、外部へ効果を出す操作である。
- * 前者は観測の前提を壊し、後者は承認なしに行わないという公開契約に当たる。
+ * v1 packetの互換field。操作権限はhostへ委ね、Latticeからは禁止操作を配らない。
+ * worktree観測に必要な前提は、実際のHEADとdiffを観測して判定する（ADR 0178）。
  */
-const FORBIDDEN_OPERATIONS = Object.freeze([
-  'push', 'branch', 'merge', 'rebase', 'reset', 'stash',
-]);
+const FORBIDDEN_OPERATIONS = Object.freeze([]);
 
 function fail(reason) {
   throw new TypeError(`runtime engine契約違反: ${reason}`);

package/src/runtime-work-order-contracts.mjs

@@ -57,7 +57,7 @@ export function validateRunWorkOrder(value) {
     && GIT_SHA1.test(value.base_sha ?? '')
     && stringArray(value.scope_writes, { paths: true })
     && stringArray(value.verifier_refs)
-    && stringArray(value.forbidden_operations, { min: 1 })
+    && stringArray(value.forbidden_operations)
     && SHA256.test(value.packet_digest ?? '')
     && SHA256.test(value.order_digest ?? '')
     && selfDigest(value, 'order_digest') === value.order_digest;

package/src/todo-cli.mjs

@@ -10,6 +10,7 @@ import { parseTree } from 'jsonc-parser';
 import {
   TODO_COORDINATION_MODES,
   TODO_DESIGN_MEMO_PROMPT,
+  TODO_TEST_RESULT_CONTRACT_ID,
   canonicalizeTodoArtifact,
   digestTodoArtifact,
   exactRecord,
@@ -18,6 +19,7 @@ import {
   isTodoDesignMemo,
   isTodoIdentifier,
   isTodoRef,
+  isTodoTestResult,
   todoSelfDigest,
   validateEvidenceDescriptor,
 } from './todo-contracts.mjs';
@@ -333,6 +335,16 @@ async function readNoteTextInput(repoRoot, inputRef) {
   catch { throw new TodoStoreError('INPUT_UNREADABLE', 'note_input_invalid_utf8'); }
 }
 
+async function readTestResultInput(repoRoot, inputRef) {
+  const result = await readNoteTextInput(repoRoot, inputRef);
+  if (!isTodoTestResult(result)) {
+    throw new TodoStoreError('INVALID_TEST_RESULT', 'test_result_must_be_non_empty_markdown', undefined, {
+      contract_id: TODO_TEST_RESULT_CONTRACT_ID,
+    });
+  }
+  return result;
+}
+
 function taskRef(plan, taskId) {
   return { project_id: plan.project_id, plan_key: plan.plan_key, task_id: taskId };
 }
@@ -650,12 +662,15 @@ function terminalAuditDoneAdvisory(plan, phases) {
 
 async function mutate({
   repoRoot, env, planKey, taskId, kind, payload, evidenceRef, advisory = null,
-  noteContext = null, structureContext = null,
+  noteContext = null, structureContext = null, testResultRef = null,
 }) {
   const actor = mutationActor(env);
   const evidence = evidenceRef === null ? null : await readEvidenceInput(repoRoot, evidenceRef);
+  const testResult = testResultRef === null ? null : await readTestResultInput(repoRoot, testResultRef);
   let eventPayload = payload;
-  if (kind === 'done' && payload === 'authored') eventPayload = { evidence };
+  if (kind === 'done' && payload === 'authored') {
+    eventPayload = { evidence, ...(testResult === null ? {} : { test_result: testResult }) };
+  }
   if (kind === 'done' && payload === 'evidence_promotion') {
     eventPayload = { done_mode: 'evidence_promotion', imported: true, evidence };
   }
@@ -1672,7 +1687,7 @@ async function todoDetail({ repoRoot, planKey, taskId }) {
     repoRoot, store, planKey, taskId: task.task_id,
   });
   const result = {
-    schema: 'lattice.todo_detail_result.v2',
+    schema: 'lattice.todo_detail_result.v3',
     project_id: store.project_id,
     plan_key: planKey,
     plan_version: member.plan.plan_version,
@@ -3926,12 +3941,13 @@ export async function runTodoCli({ argv, cwd, stdout, stderr, env = process.env
     && argv[3] === '--task' && isTodoIdentifier(argv[4])) {
     action = (repoRoot) => mutate({ repoRoot, env, planKey: argv[2], taskId: argv[4],
       kind: 'unblock', payload: {}, evidenceRef: null });
-  } else if (argv.length === 7 && argv[0] === 'done'
+  } else if ((argv.length === 7 || argv.length === 9) && argv[0] === 'done'
     && argv[1] === '--plan' && isTodoIdentifier(argv[2])
     && argv[3] === '--task' && isTodoIdentifier(argv[4])
-    && argv[5] === '--evidence' && isTodoRef(argv[6])) {
+    && argv[5] === '--evidence' && isTodoRef(argv[6])
+    && (argv.length === 7 || (argv[7] === '--test-result' && isTodoRef(argv[8])))) {
     action = (repoRoot) => mutate({ repoRoot, env, planKey: argv[2], taskId: argv[4],
-      kind: 'done', payload: 'authored', evidenceRef: argv[6] });
+      kind: 'done', payload: 'authored', evidenceRef: argv[6], testResultRef: argv[8] ?? null });
   } else if (argv.length === 8 && argv[0] === 'evidence' && argv[1] === 'promote'
     && argv[2] === '--plan' && isTodoIdentifier(argv[3])
     && argv[4] === '--task' && isTodoIdentifier(argv[5])

package/src/todo-contracts.mjs

@@ -62,10 +62,14 @@ const CONTROL = /[\u0000-\u001f\u007f]/u;
 const NOTE_FORBIDDEN_CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
 
 export const TODO_DESIGN_MEMO_PROMPT = 'あなたがこのToDoに対して、何も考えていないならば、設計メモに `NO_PLAN` と書いてください';
+export const TODO_TEST_RESULT_CONTRACT_ID = 'lattice.todo_test_result.v1';
 
 export const isTodoDigest = (value) => typeof value === 'string' && DIGEST.test(value);
 export const isTodoIdentifier = (value) => typeof value === 'string' && IDENTIFIER.test(value);
 export const isNonNegativeSafeInteger = (value) => Number.isSafeInteger(value) && value >= 0;
+export const isTodoTestResult = (value) => typeof value === 'string' && value.trim().length > 0
+  && Buffer.byteLength(value, 'utf8') <= TODO_LIMITS.noteBodyBytes
+  && !NOTE_FORBIDDEN_CONTROL.test(value);
 
 export function isStrictTodoTimestamp(value) {
   return isCanonicalUtcTimestamp(value);
@@ -527,8 +531,10 @@ function validPayload(event) {
   if (event.kind === 'block') return exactRecord(payload, ['reason']) && nullableText(payload.reason) && payload.reason !== null;
   if (event.kind === 'unblock') return exactRecord(payload, []);
   if (event.kind === 'done' && payload?.done_mode === 'authored') {
-    return exactRecord(payload, ['done_mode', 'imported', 'evidence'])
-      && payload.imported === false && evidence(payload.evidence);
+    return (exactRecord(payload, ['done_mode', 'imported', 'evidence'])
+      || exactRecord(payload, ['done_mode', 'imported', 'evidence', 'test_result']))
+      && payload.imported === false && evidence(payload.evidence)
+      && (payload.test_result === undefined || isTodoTestResult(payload.test_result));
   }
   if (event.kind === 'done' && payload?.done_mode === 'historical_import') {
     return exactRecord(payload, ['done_mode', 'imported', 'status', 'completed_at', 'evidence'])
@@ -569,22 +575,29 @@ function validPayload(event) {
 }
 
 function validCarriedState(value) {
-  if (!exactRecord(value, [
+  const legacy = exactRecord(value, [
     'status', 'started_at', 'done_at', 'blocked_reason', 'evidence', 'imported',
-  ]) || !['pending', 'in-progress', 'blocked', 'done'].includes(value.status)
+  ]);
+  const resultAware = exactRecord(value, [
+    'status', 'started_at', 'done_at', 'blocked_reason', 'evidence', 'imported', 'test_result',
+  ]);
+  if ((!legacy && !resultAware) || !['pending', 'in-progress', 'blocked', 'done'].includes(value.status)
     || (value.started_at !== null && !isStrictTodoTimestamp(value.started_at))
     || (value.done_at !== null && !isStrictTodoTimestamp(value.done_at))
     || (value.blocked_reason !== null && !nullableText(value.blocked_reason))
     || typeof value.imported !== 'boolean') return false;
+  const testResult = resultAware ? value.test_result : null;
+  if (testResult !== null && !isTodoTestResult(testResult)) return false;
   if (value.status === 'pending') return value.started_at === null && value.done_at === null
-    && value.blocked_reason === null && value.evidence === null && value.imported === false;
+    && value.blocked_reason === null && value.evidence === null && value.imported === false
+    && testResult === null;
   const activeEvidenceValid = value.imported
     ? value.evidence === null || validateTodoImportSource(value.evidence)
     : value.evidence === null;
   if (value.status === 'in-progress') return value.done_at === null && value.blocked_reason === null
-    && activeEvidenceValid;
+    && activeEvidenceValid && testResult === null;
   if (value.status === 'blocked') return value.done_at === null && value.blocked_reason !== null
-    && activeEvidenceValid;
+    && activeEvidenceValid && testResult === null;
   return value.blocked_reason === null && value.evidence !== null
     && (value.imported ? validateTodoImportSource(value.evidence) : evidence(value.evidence));
 }
@@ -700,20 +713,35 @@ export function validateTodoSnapshot(value) {
       'schema', 'project_id', 'plan_key', 'plan_version', 'projection_version', 'through_sequence',
       'journal_head_digest', 'tasks', 'phases', 'snapshot_digest',
     ]);
-    return (v1 || v2) && isTodoIdentifier(value.project_id)
+    const v3 = value?.schema === 'lattice.todo_snapshot.v3' && exactRecord(value, [
+      'schema', 'project_id', 'plan_key', 'plan_version', 'projection_version', 'through_sequence',
+      'journal_head_digest', 'tasks', 'snapshot_digest',
+    ]);
+    const v4 = value?.schema === 'lattice.todo_snapshot.v4' && exactRecord(value, [
+      'schema', 'project_id', 'plan_key', 'plan_version', 'projection_version', 'through_sequence',
+      'journal_head_digest', 'tasks', 'phases', 'snapshot_digest',
+    ]);
+    const resultAware = v3 || v4;
+    const phaseAware = v2 || v4;
+    return (v1 || v2 || v3 || v4) && isTodoIdentifier(value.project_id)
       && isTodoIdentifier(value.plan_key) && isTodoIdentifier(value.plan_version)
-      && value.projection_version === (v1 ? 1 : 2) && isNonNegativeSafeInteger(value.through_sequence)
+      && value.projection_version === (v1 ? 1 : v2 ? 2 : v3 ? 3 : 4)
+      && isNonNegativeSafeInteger(value.through_sequence)
       && isTodoDigest(value.journal_head_digest) && Array.isArray(value.tasks)
       && value.tasks.length > 0 && value.tasks.length <= TODO_LIMITS.tasksPerPlan
       && value.tasks.every((entry) => exactRecord(entry, [
         'task_id', 'status', 'started_at', 'done_at', 'blocked_reason', 'evidence', 'evidence_unverified', 'imported',
+        ...(resultAware ? ['test_result'] : []),
       ]) && isTodoIdentifier(entry.task_id) && ['pending', 'in-progress', 'blocked', 'done'].includes(entry.status)
         && (entry.started_at === null || isStrictTodoTimestamp(entry.started_at))
         && (entry.done_at === null || isStrictTodoTimestamp(entry.done_at)) && nullableText(entry.blocked_reason)
         && (entry.evidence === null || evidence(entry.evidence) || validateTodoImportSource(entry.evidence))
-        && typeof entry.evidence_unverified === 'boolean' && typeof entry.imported === 'boolean')
+        && typeof entry.evidence_unverified === 'boolean' && typeof entry.imported === 'boolean'
+        && (!resultAware || (entry.status === 'done'
+          ? entry.test_result === null || isTodoTestResult(entry.test_result)
+          : entry.test_result === null)))
       && value.tasks.every((entry, index) => index === 0 || value.tasks[index - 1].task_id < entry.task_id)
-      && (!v2 || (Array.isArray(value.phases) && value.phases.length > 0
+      && (!phaseAware || (Array.isArray(value.phases) && value.phases.length > 0
         && value.phases.every((entry) => exactRecord(entry, [
           'phase_id', 'status', 'review_event_digest', 'decision_event_digest', 'decision_evidence',
         ]) && isTodoIdentifier(entry.phase_id)

package/src/todo-store.mjs

@@ -302,7 +302,7 @@ async function readPlanScopedJournal(repoRoot, journalRef) {
 
 function taskState(taskId) {
   return { task_id: taskId, status: 'pending', started_at: null, done_at: null, blocked_reason: null,
-    evidence: null, evidence_unverified: false, imported: false };
+    evidence: null, evidence_unverified: false, imported: false, test_result: null };
 }
 
 function emptyPhaseState(phaseId) {
@@ -685,6 +685,7 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
           plan_key: plan.plan_key, task_id: event.task_id,
         });
         state.status = 'done'; state.done_at = event.recorded_at; state.evidence = event.payload.evidence;
+        state.test_result = event.payload.test_result ?? null;
         state.imported = false;
         completion.set(event.task_id, { mode: 'authored', completed_at: event.recorded_at });
       } else if (event.payload.done_mode === 'historical_import') {
@@ -731,7 +732,7 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
       }
       const startedSuccessor = localSuccessors(plan, event.task_id).some((id) => states.get(id).status !== 'pending');
       if (startedSuccessor && event.payload.override_reason === null) fail('STORE_INCONSISTENT', 'reopen_has_started_successor');
-      state.status = 'in-progress'; state.done_at = null; state.evidence = null;
+      state.status = 'in-progress'; state.done_at = null; state.evidence = null; state.test_result = null;
       completion.delete(event.task_id);
     }
   }
@@ -774,11 +775,21 @@ function snapshotFor(plan, events, tasks) {
   // ——ADR 0147以降の暗黙terminal-audit Phaseの状態は、この関数の外(readTodoStore/
   // appendTodoEventが返す`phases`という導出ビュー)で供給する。
   const phasePlan = isPhaseTodoPlanSchema(plan.schema);
+  const resultAware = events.some((event) => event.kind === 'done'
+    && typeof event.payload?.test_result === 'string')
+    || events.some((event) => event.kind === 'plan_genesis'
+      && event.state_migration?.some(({ state }) => typeof state?.test_result === 'string'));
+  const snapshotTasks = resultAware ? tasks.map((task) => ({ ...task, test_result: task.test_result ?? null }))
+    : tasks.map(({ test_result: _testResult, ...task }) => task);
   const snapshot = {
-    schema: phasePlan ? 'lattice.todo_snapshot.v2' : 'lattice.todo_snapshot.v1',
+    schema: resultAware
+      ? (phasePlan ? 'lattice.todo_snapshot.v4' : 'lattice.todo_snapshot.v3')
+      : (phasePlan ? 'lattice.todo_snapshot.v2' : 'lattice.todo_snapshot.v1'),
     project_id: plan.project_id, plan_key: plan.plan_key,
-    plan_version: plan.plan_version, projection_version: phasePlan ? 2 : 1, through_sequence: head.sequence,
-    journal_head_digest: head.event_digest, tasks, snapshot_digest: '',
+    plan_version: plan.plan_version,
+    projection_version: resultAware ? (phasePlan ? 4 : 3) : (phasePlan ? 2 : 1),
+    through_sequence: head.sequence,
+    journal_head_digest: head.event_digest, tasks: snapshotTasks, snapshot_digest: '',
     ...(phasePlan ? { phases: projectPhaseStates(plan, events,
       new Map(tasks.map((task) => [task.task_id, task]))) } : {}),
   };
@@ -1515,9 +1526,14 @@ export async function rebuildTodoSnapshot(options = {}) {
 
 function nextEvent(input, storeMember) {
   const previous = storeMember.journal.events.at(-1);
-  const payload = input.kind === 'done' && exactRecord(input.payload, ['evidence'])
-    ? { done_mode: 'authored', imported: false, evidence: input.payload.evidence }
-    : input.payload;
+  let payload = input.payload;
+  if (input.kind === 'done' && (exactRecord(input.payload, ['evidence'])
+    || exactRecord(input.payload, ['evidence', 'test_result']))) {
+    payload = {
+      done_mode: 'authored', imported: false, evidence: input.payload.evidence,
+      ...(input.payload.test_result === undefined ? {} : { test_result: input.payload.test_result }),
+    };
+  }
   const phaseCapablePlan = isPhaseTodoPlanSchema(storeMember.plan.schema);
   const phaseKind = ['phase_review', 'phase_accept', 'phase_reject', 'phase_reopen', 'phase_close_unaudited']
     .includes(input.kind);
@@ -2613,6 +2629,7 @@ function stateMigrationFor(previous, revision) {
     return { ...migration, state: {
       status: state.status, started_at: state.started_at, done_at: state.done_at,
       blocked_reason: state.blocked_reason, evidence: state.evidence, imported: state.imported,
+      ...(typeof state.test_result === 'string' ? { test_result: state.test_result } : {}),
     } };
   });
 }