@quolu/lattice 0.60.8 → 0.61.2

package/README.ja.md

@@ -218,39 +218,25 @@ cross-plan topologyを同時に切り替える場合は
 Phase付きv5 planでは、通常ToDoの開始順はToDo DAGだけで決まり、Phase前後関係は重監査の順序だけを
 制御します。特定ToDoがPhase受理を本当に必要とする場合だけ`phase_accept_dependencies`で明示します。
 `lattice todo status --json`の`dispatch_frontier`はready全件を同時dispatchする既定を示します。
-readyが複数なら最初のstartに`--parallel-frontier`を付けます。subsetだけを直列着手する場合は
-`--override-reason <reason>`で理由を残しますが、**その申告は一度突き返されます**。
+readyが複数でも、最初の`todo start`はflagなしで通ります。並列で始めるなら
+`--parallel-frontier`を付けられます。subsetだけを直列着手する場合は
+`--override-reason <reason>`で理由を残せます。どちらも門ではなく記録です。
 
 ```bash
+lattice todo start --plan <key> --task <id>
 lattice todo start --plan <key> --task <id> --parallel-frontier
-lattice todo start --plan <key> --task <id> --override-reason <reason> --serial-confirmed
+lattice todo start --plan <key> --task <id> --override-reason <reason>
 ```
 
-直列の申告に対して`PARALLEL_DISPATCH_RECONSIDER`を返し、並列の再検討を促してから、
-同じ理由に`--serial-confirmed`を付けた再実行だけを通します。規則を文書へ書くだけでは
-読み飛ばされるため、再考をコマンドの往復で強制する設計です。**足止めは一度だけで、
-再実行すれば直列で進みます。**
+`--serial-confirmed`と`--serialization-reviewed`は古い手順の互換として受理しますが、
+再実行の条件ではありません。直列理由の文言を審査して拒否することもありません。
 
-ただし理由が**実際の干渉を述べていない**場合——「単一セッションだから」「逐次実行するので」
-のようにworker数・セッション構成・作業者の都合を述べただけの場合——は
-`PARALLEL_DISPATCH_INVALID`で拒否し、`--serial-confirmed`を付けても通しません。
-実行主体が1つしか無いことは並列にできない理由ではない（必要ならworkerを増やす）ためです。
-「両taskが同一fileへ書き込む」のような干渉を書けば、再確認を経て通ります。
-
-**同じ検査を計画時点にも掛けます。** 着手時だけを締めても、planそのものが直列に組まれていれば
-並列は生まれません。`lattice plan create`と`lattice todo migrate`は依存グラフから
+`lattice plan create`と`lattice todo migrate`は依存グラフから
 `dispatch_shape`（`task_count`／`critical_path_length`／`max_frontier_width`／
-`serialization_ratio`）を計算して結果へ載せ、直列度が閾値を超えるplanを一度突き返します。
-再考した上でなお直列でよいなら`--serialization-reviewed`を付けて再実行します
-（6 task未満のplanは対象外）。判定はstore書込みの前に行うので、拒否された時にstoreへは
-何も書かれません。
-
-```bash
-lattice todo migrate --input <extraction.json> --serialization-reviewed
-```
+`serialization_ratio`）を計算して結果へ載せます。直列度が閾値を超えても作成は通ります。
 
-`--parallel-frontier`はhostへ並列dispatch方針を宣言する開始gateです。Lattice自身がAI hostのagentを
-起動するものではなく、実際のdispatchはhostが行います。宣言後もready全件が着手されたかは
+`--parallel-frontier`はhostへ並列dispatch方針を伝える記録です。Lattice自身がAI hostのagentを
+起動するものではなく、実際のdispatchはhostが行います。ready全件が着手されたかは
 `active_set`と`next_ready`で観測できます。
 ToDo完了は軽量確認までで、所属ToDoが全てdoneになったPhaseは`gate_ready`となり、`todo phase review`後に
 required evidenceを束縛した`todo phase accept`で重監査の判断を記録します。監査回数やPhase数を自動追加する

package/README.md

@@ -189,6 +189,15 @@ lattice todo seam-proposal apply   --plan <key>               # isolated worktre
 lattice todo seam-proposal land    --plan <key> --names names.json
 ```
 
+`lattice todo status --json` exposes `dispatch_frontier`: every ready task is the default
+parallel set. Starting one of them does not require `--parallel-frontier` or
+`--override-reason`. Those flags record intent; they are not gates.
+`--serial-confirmed` and `--serialization-reviewed` are accepted only for compatibility.
+
+```bash
+lattice todo start --plan <key> --task <id>
+```
+
 Full CLI surface: `lattice --help`, then
 `lattice <plan|run|event|todo|sensor|factory-diagnostics|runtime-errors|bridge|hooks> --help`.
 

package/bin/lattice.mjs

@@ -37,7 +37,6 @@ if (help !== null) {
   try {
     process.exitCode = await runPlanCreate({
       cwd: process.cwd(), inputRef: args[3], stdout: process.stdout,
-      serializationReviewed: args.length === 5,
     });
   } catch (error) {
     process.exitCode = projectCliFailure(process.stderr, error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.60.8",
+  "version": "0.61.2",
   "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

@@ -25,8 +25,7 @@ const NAMESPACE_HELP = Object.freeze({
 
 Commands:
   create --input <file> [--serialization-reviewed]
-      # 依存グラフがほぼ一直線（serialization_ratioが閾値超）なら一度突き返す。
-      # 再考した上でなお直列でよいなら --serialization-reviewed を付けて再実行する
+      # 結果へdispatch_shapeを載せる。--serialization-reviewedは互換のため受理するだけで門ではない
   create --schema --json             # 既定は最新版（v4）のJSON Schemaを返す
   create --schema-version <1|2|3|4> --json
   show <plan_key> --json             # task・依存・phase・状態をplan本体から1コマンドで投影する
@@ -94,9 +93,10 @@ Write commands:
   migrate --input <extraction.json> [--serialization-reviewed] [--json]
   migrate --input <extraction.json> --dry-run --json [--serialization-reviewed]
       # 既存storeへplanを追加する（plan createは空store初期化専用）。
-      # 依存グラフがほぼ一直線なら一度突き返し、再考後の --serialization-reviewed で通す
+      # 結果へdispatch_shapeを載せる。--serialization-reviewedは互換のため受理するだけで門ではない
   start --plan <key> --task <id> [--parallel-frontier|--override-reason <text> [--serial-confirmed]]
-        # 既定は全ready同時dispatch。直列にするには理由の申告後、再考を経て --serial-confirmed が要る
+        # readyならflagなしで着手する。--parallel-frontierと--override-reasonは方針・理由の記録。
+        # --serial-confirmedは互換のため受理する。いずれも門ではない
   block --plan <key> --task <id> --reason <text>
   unblock --plan <key> --task <id>
   done --plan <key> --task <id> --evidence <file>  # 構造対象taskはfresh realizationを要求する
@@ -152,6 +152,7 @@ ${TODO_INDEPENDENCE_WORKFLOW.join('\n')}
 
 判定していない工程は「競合が無い」ではなく「未検査」として扱われ、
 todo startのadvisoryとtodo independenceの投影が、その状況と次の一歩を返す。
+並列既定はstatusのdispatch_frontierとnext_actionが案内する。着手・作成を拒まない。
 `,
   sensor: `Usage: lattice sensor <init|sync> [path] --json
        lattice sensor diff <rootA> <rootB> [options] --json

package/src/project-cli.mjs

@@ -37,7 +37,6 @@ import {
   TodoStoreError,
 } from './todo-store.mjs';
 import {
-  assertTodoDispatchShapeReviewed,
   computeTodoDispatchShapeForPlan,
 } from './todo-dispatch-shape.mjs';
 
@@ -485,7 +484,7 @@ function validateCreateInput(value) {
   } catch { return false; }
 }
 
-export async function runPlanCreate({ cwd, inputRef, stdout, serializationReviewed = false }) {
+export async function runPlanCreate({ cwd, inputRef, stdout }) {
   const repoRoot = resolveRepoRoot(cwd);
   if (repoRoot === null) throw new TodoStoreError('REPO_UNRESOLVED', 'git_toplevel_unresolved');
   const input = await readCanonicalInput(repoRoot, inputRef);
@@ -526,8 +525,7 @@ export async function runPlanCreate({ cwd, inputRef, stdout, serializationReview
       next_action: 'correct_the_reported_pointer_then_rerun_plan_create',
     });
   }
-  // dispatch_shapeのgateはstore初期化より前に判定する（拒否時にstoreへ何も書かないため、
-  // 再考後の再実行がplan_key_already_existsで詰まらない）。
+  // dispatch_shapeは結果へ載せる観測であり、直列度では初期化を拒まない（ADR 0180）。
   const dispatchShape = computeTodoDispatchShapeForPlan({
     projectId: input.project_id,
     planKey: input.plan_key,
@@ -535,7 +533,6 @@ export async function runPlanCreate({ cwd, inputRef, stdout, serializationReview
     hardDependencies: input.hard_dependencies,
     joins: input.joins,
   });
-  assertTodoDispatchShapeReviewed({ shape: dispatchShape, reviewed: serializationReviewed });
   const store = await initializeAuthoredTodoStore({
     repoRoot, writer: createTodoStoreWriter({ caller: 'g5-authoring' }),
     projectId: input.project_id, repositories: [{ repo_id: 'self', path: '.' }],

package/src/runtime-pull-intake.mjs

@@ -13,6 +13,7 @@ import { classifyObservedDiff } from './runtime-decision-verifier.mjs';
 import { captureWorktreeDiff, detectCheckpointFindings } from './runtime-diff-observer.mjs';
 import { acquireRuntimeLifecycleLock } from './runtime-lifecycle-lock.mjs';
 import { observeManagedProcessStartIdentity } from './runtime-managed-supervisor.mjs';
+import { deliverWorkerSignal, observeWindowsWorkerProcess } from './runtime-windows-process.mjs';
 import { ensureScriptedWorktree } from './runtime-scripted-worktree.mjs';
 import {
   BOUNDARY_MANIFEST_SCHEMA, selfDigest, validateRuntimeBoundaryManifest, validateRuntimePlan,
@@ -890,6 +891,36 @@ export async function releasePullTask({ runDir, taskId, environment = process.en
 
 async function observeProcessBinding(pid) {
   if (!Number.isSafeInteger(pid) || pid < 1) fail('INVALID_WORKER_PID', 'pidが正整数でない');
+  if (process.platform === 'win32') {
+    let observed;
+    try {
+      observed = await observeWindowsWorkerProcess(pid);
+    } catch (error) {
+      fail('WORKER_IDENTITY_MISMATCH', `Windows worker process identityを完全観測できない: ${error.message}`);
+    }
+    const processStartIdentity = {
+      schema: 'lattice.process_start_identity.v1',
+      platform: 'win32',
+      pid: observed.pid,
+      started_identity: observed.started_identity,
+      identity_digest: '',
+    };
+    processStartIdentity.identity_digest = selfDigest(processStartIdentity, 'identity_digest');
+    const expected = {
+      pid: observed.pid,
+      process_group_id: observed.process_group_id,
+      process_start_identity: processStartIdentity,
+    };
+    if (!validateExpectedWorkerProcess(expected) || observed.argv.length === 0) {
+      fail('WORKER_IDENTITY_MISMATCH', 'worker process identityを完全観測できない');
+    }
+    return {
+      pid: observed.pid,
+      process_group_id: observed.process_group_id,
+      process_start_identity: processStartIdentity,
+      argv_digest: createHash('sha256').update(observed.argv, 'utf8').digest('hex'),
+    };
+  }
   const processStartIdentity = await observeManagedProcessStartIdentity(pid);
   const { stdout: pgidOut } = await execFileAsync('/bin/ps', ['-o', 'pgid=', '-p', String(pid)], { encoding: 'utf8' });
   const { stdout: argvOut } = await execFileAsync('/bin/ps', ['-o', 'command=', '-p', String(pid)], { encoding: 'utf8' });
@@ -917,7 +948,7 @@ async function signalAttachedWorker(intake, signal) {
     || observed.process_group_id !== intake.worker.process_group_id) {
     fail('WORKER_IDENTITY_MISMATCH', 'signal前のlstart/argv/pgidがattach bindingと一致しない');
   }
-  try { process.kill(intake.worker.pid, signal); }
+  try { deliverWorkerSignal(intake.worker.pid, signal); }
   catch { fail('WORKER_SIGNAL_FAILED', `workerへ${signal}を送れない`); }
   return true;
 }

package/src/runtime-windows-process.mjs

@@ -0,0 +1,54 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export function parseWindowsCreationDate(value) {
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) throw new Error('Windows CreationDateを解釈できない');
+    return value.toISOString();
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) throw new Error('Windows CreationDateを解釈できない');
+    return parsed.toISOString();
+  }
+  const text = String(value ?? '').trim();
+  const microsoft = /^\/Date\((-?\d+)(?:[+-]\d+)?\)\/$/u.exec(text);
+  if (microsoft) return new Date(Number(microsoft[1])).toISOString();
+  const parsed = new Date(text);
+  if (Number.isNaN(parsed.getTime())) throw new Error(`Windows CreationDateを解釈できない: ${text}`);
+  return parsed.toISOString();
+}
+
+export function deliverWorkerSignal(pid, signal) {
+  if (!Number.isSafeInteger(pid) || pid < 1) throw new Error('pidが正整数でない');
+  const jobControl = signal === 'SIGSTOP' || signal === 'SIGCONT';
+  if (process.platform === 'win32' && jobControl) {
+    return { delivered: false, recorded: true };
+  }
+  process.kill(pid, signal);
+  return { delivered: true, recorded: true };
+}
+
+export async function observeWindowsWorkerProcess(pid) {
+  if (!Number.isSafeInteger(pid) || pid < 1) {
+    throw new Error('pidが正整数でない');
+  }
+  const filter = JSON.stringify(`ProcessId=${pid}`);
+  const script = `Get-CimInstance Win32_Process -Filter ${filter} | Select-Object ProcessId,CommandLine,CreationDate | ConvertTo-Json -Compress`;
+  const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-Command', script], {
+    encoding: 'utf8',
+  });
+  const row = JSON.parse(stdout.trim() || 'null');
+  if (!row || Number(row.ProcessId) !== pid) throw new Error(`Win32_Processを観測できない: ${pid}`);
+  const argv = String(row.CommandLine || '').trim();
+  const startedIdentity = parseWindowsCreationDate(row.CreationDate);
+  if (!argv || !startedIdentity) throw new Error('Windows worker process identityを完全観測できない');
+  return {
+    pid,
+    process_group_id: pid,
+    started_identity: startedIdentity,
+    argv,
+  };
+}

package/src/todo-cli.mjs

@@ -104,7 +104,6 @@ import {
   validateTodoExtraction,
 } from './todo-migration.mjs';
 import {
-  assertTodoDispatchShapeReviewed,
   computeTodoDispatchShapeForPlan,
 } from './todo-dispatch-shape.mjs';
 import {
@@ -842,31 +841,8 @@ async function startAdvisory({ repoRoot, store, projection, planKey, taskId }) {
   };
 }
 
-// 直列化の理由として認めない定型句。
-// worker数・セッション構成・作業者の都合は「並列にできない根拠」ではない。
-// 根拠になるのは実際の干渉だけ（同一fileへの書込衝突・外部資源の排他・順序依存）。
-// 単一プロセスのagentが「自分は1人だから」と直列へ逃げる事例が実運用で出たため、
-// frontierの既定（all_ready_parallel_by_default）を宣言だけでなく機構で守る。
-const SERIAL_NON_REASONS = [
-  /単一(?:の)?(?:セッション|エージェント|worker|ワーカー|プロセス|スレッド)/u,
-  /(?:逐次|順次|直列|シリアル)(?:実行|処理|化|に|で)/u,
-  /(?:一人|1人|ひとり|1名|単独)(?:で|の|しか)/u,
-  /(?:サブ)?エージェント(?:が|は)?(?:居ない|いない|使わない|使えない)/u,
-  /single[-\s]?(?:session|agent|worker|process|thread)/iu,
-  /\b(?:sequential|serial)(?:ly)?\s*(?:execution|processing|run|dispatch)?\b/iu,
-  /one[-\s]at[-\s]a[-\s]time|\bsolo\b|\bby myself\b/iu,
-];
-
-/**
- * 直列化理由が「実際の干渉」を述べているかを検査する。
- * worker数・セッション構成を述べただけの理由は根拠にならないので拒否する。
- */
-function serialReasonNonInterference(reason) {
-  return SERIAL_NON_REASONS.find((pattern) => pattern.test(reason)) ?? null;
-}
-
 async function startTask({
-  repoRoot, env, planKey, taskId, overrideReason, parallelFrontier, serialConfirmed = false,
+  repoRoot, env, planKey, taskId, overrideReason, parallelFrontier,
 }) {
   const store = await readTodoStore({ repoRoot });
   // startはready判定にしかprojectionを使わず、resultを出力しない。
@@ -875,63 +851,11 @@ async function startTask({
     task.plan_key === planKey && task.task_id.toLowerCase() === taskId.toLowerCase()
   ));
   const targetReady = readyTask !== undefined;
+  // `--parallel-frontier`は方針の記録口で、対象がreadyでないときにだけ用法誤り。
+  // 複数readyのplain startや直列理由の文言審査で着手を止めない（ADR 0180）。
   if (parallelFrontier && !targetReady) {
     throw new TodoStoreError('PARALLEL_DISPATCH_INVALID', 'parallel_frontier_not_applicable');
   }
-  const frontierContested = targetReady && projection.active_set.length === 0
-    && projection.next_ready.length > 1;
-  if (frontierContested && overrideReason === null && !parallelFrontier) {
-    throw new TodoStoreError('PARALLEL_DISPATCH_REQUIRED', 'parallel_frontier_requires_declaration',
-      undefined, {
-        ready_count: projection.next_ready.length,
-        ready_task_ids: projection.next_ready.map((task) => task.task_id),
-        frontier_digest: projection.dispatch_frontier.frontier_digest,
-        parallel_start_flag: projection.dispatch_frontier.parallel_start_flag,
-        serial_reason_flag: '--override-reason',
-        default_policy: projection.dispatch_frontier.policy,
-        guidance: '既定は全ready分の同時dispatch。並列で始めるなら --parallel-frontier を使う。'
-          + '--override-reason は「なぜ並列にできないか」を書く欄であり、'
-          + 'worker数・セッション構成・作業者の都合は根拠にならない'
-          + '（同一fileへの書込衝突・外部資源の排他・順序依存だけが根拠になる）。',
-      });
-  }
-  if (frontierContested && overrideReason !== null) {
-    if (serialReasonNonInterference(overrideReason) !== null) {
-      throw new TodoStoreError('PARALLEL_DISPATCH_INVALID', 'serial_reason_is_not_an_interference',
-        undefined, {
-          ready_count: projection.next_ready.length,
-          ready_task_ids: projection.next_ready.map((task) => task.task_id),
-          rejected_reason: overrideReason,
-          default_policy: projection.dispatch_frontier.policy,
-          parallel_start_flag: projection.dispatch_frontier.parallel_start_flag,
-          guidance: 'worker数・セッション構成・作業者の都合は直列化の根拠にならない。'
-            + 'readyが複数あるなら既定は同時dispatchであり、実行主体が1つしか無いことは'
-            + '並列にできない理由ではない（必要ならworkerを増やす）。'
-            + '直列にするなら、並列で走らせたときに実際に起きる干渉'
-            + '（同一fileへの書込衝突・外部資源の排他・順序依存）を書く。',
-        });
-    }
-    // 直列の申告は一度突き返して並列を再検討させる。
-    // 規則を書くだけでは読み飛ばされるため、再考をコマンドの往復で強制する。
-    if (!serialConfirmed) {
-      throw new TodoStoreError('PARALLEL_DISPATCH_RECONSIDER', 'consider_parallel_before_serial',
-        undefined, {
-          ready_count: projection.next_ready.length,
-          ready_task_ids: projection.next_ready.map((task) => task.task_id),
-          declared_reason: overrideReason,
-          default_policy: projection.dispatch_frontier.policy,
-          parallel_start_flag: projection.dispatch_frontier.parallel_start_flag,
-          serial_confirm_flag: '--serial-confirmed',
-          guidance: `並列を検討しなさい。ready ${projection.next_ready.length} 件は同時に着手できる`
-            + '前提で並んでおり、既定は全件同時dispatchである。'
-            + `まず ${projection.dispatch_frontier.parallel_start_flag} で全readyを起こし、`
-            + 'それぞれ別のworkerへ渡すことを検討する'
-            + '（実行主体が足りないなら増やす。増やせないことは並列にできない理由ではない）。'
-            + '検討した上でなお直列にするなら、同じ --override-reason に'
-            + ' --serial-confirmed を付けて再実行する。',
-        });
-    }
-  }
   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 }) => (
@@ -1244,13 +1168,11 @@ async function phaseBaseline({ repoRoot, env, reason, exceptPlanKeys }) {
   return result;
 }
 
-async function migrate({ repoRoot, inputRef, serializationReviewed = false }) {
+async function migrate({ repoRoot, inputRef }) {
   const extraction = await readMigrationInput(repoRoot, inputRef);
-  // dispatch_shapeのgateはappendTodoExtraction（store書込み）より前に判定する必要がある
-  // （拒否時にstoreへ何も書かないため、再考後の再実行がplan_key_already_existsで
-  // 詰まらない）。unresolved/空集合の2つの早期gateは、compileTodoExtraction内部の
-  // 同名gateをここでも先に通しておくことで、既存のエラー優先順位
-  // （unresolved・空集合を直列度より先に報告する）を変えない。
+  // unresolved/空集合の早期gateは、compileTodoExtraction内部の同名gateをここでも
+  // 先に通しておくことで、既存のエラー優先順位を変えない。
+  // dispatch_shapeは結果へ載せる観測であり、直列度では書込みを拒まない（ADR 0180）。
   const unresolvedTaskIds = extraction.tasks
     .filter(({ disposition }) => disposition === 'unknown_requires_evidence')
     .map(({ task_id: taskId }) => taskId);
@@ -1272,9 +1194,6 @@ async function migrate({ repoRoot, inputRef, serializationReviewed = false }) {
     hardDependencies: extraction.hard_dependencies,
     joins: extraction.joins,
   });
-  if (dispatchShape !== null) {
-    assertTodoDispatchShapeReviewed({ shape: dispatchShape, reviewed: serializationReviewed });
-  }
 
   const imported = await appendTodoExtraction({ repoRoot, extraction });
   let companion = null;
@@ -1448,7 +1367,7 @@ function extractionAuthoringViolations(extraction, now = new Date()) {
   return violations;
 }
 
-async function migrateDryRun({ repoRoot, inputRef, serializationReviewed = false }) {
+async function migrateDryRun({ repoRoot, inputRef }) {
   const extraction = await readMigrationInput(repoRoot, inputRef, { requireValid: false });
   const violations = [];
   const tasks = Array.isArray(extraction?.tasks) ? extraction.tasks : [];
@@ -1521,13 +1440,6 @@ async function migrateDryRun({ repoRoot, inputRef, serializationReviewed = false
           taskIds: registered.map(({ task_id: taskId }) => taskId),
           hardDependencies: extraction.hard_dependencies, joins: extraction.joins,
         });
-        try {
-          assertTodoDispatchShapeReviewed({ shape: dispatchShape, reviewed: serializationReviewed });
-        } catch (error) {
-          violations.push({ code: error?.detail?.reason ?? 'plan_shape_too_serial', path: '/hard_dependencies',
-            task_ids: error?.detail?.critical_path_task_ids ?? [],
-            next_action: 'reconsider_parallel_seams_or_pass_serialization_reviewed' });
-        }
       }
     } catch (error) {
       plannedPlan = null;
@@ -1586,7 +1498,7 @@ async function migrateDryRun({ repoRoot, inputRef, serializationReviewed = false
       },
     },
     next_action: bounded.length === 0
-      ? `lattice todo migrate --input ${inputRef}${serializationReviewed ? ' --serialization-reviewed' : ''}`
+      ? `lattice todo migrate --input ${inputRef}`
       : 'correct_all_reported_violations_and_rerun_dry_run',
     result_digest: '',
   };
@@ -3916,17 +3828,13 @@ export async function runTodoCli({ argv, cwd, stdout, stderr, env = process.env
     && argv[1] === '--input' && isTodoRef(argv[2])
     && argv[3] === '--dry-run' && argv[4] === '--json'
     && (argv.length === 5 || argv[5] === '--serialization-reviewed')) {
-    action = (repoRoot) => migrateDryRun({
-      repoRoot, inputRef: argv[2], serializationReviewed: argv.length === 6,
-    });
+    action = (repoRoot) => migrateDryRun({ repoRoot, inputRef: argv[2] });
   } else if ((argv.length === 3 || argv.length === 4 || argv.length === 5)
     && argv[0] === 'migrate' && argv[1] === '--input' && isTodoRef(argv[2])
     && (argv.length === 3
       || (argv.length === 4 && ['--json', '--serialization-reviewed'].includes(argv[3]))
       || (argv.length === 5 && argv[3] === '--serialization-reviewed' && argv[4] === '--json'))) {
-    action = (repoRoot) => migrate({
-      repoRoot, inputRef: argv[2], serializationReviewed: argv[3] === '--serialization-reviewed',
-    });
+    action = (repoRoot) => migrate({ repoRoot, inputRef: argv[2] });
   } else if (argv.length === 5 && argv[0] === 'revise'
     && argv[1] === '--plan' && isTodoIdentifier(argv[2])
     && argv[3] === '--input' && isTodoRef(argv[4])) {
@@ -3986,8 +3894,7 @@ export async function runTodoCli({ argv, cwd, stdout, stderr, env = process.env
         && (argv.length === 7 || argv[7] === '--serial-confirmed')))) {
     const overrideReason = argv.length >= 7 ? argv[6] : null;
     action = (repoRoot) => startTask({ repoRoot, env, planKey: argv[2], taskId: argv[4],
-      overrideReason, parallelFrontier: argv.length === 6,
-      serialConfirmed: argv.length === 8 });
+      overrideReason, parallelFrontier: argv.length === 6 });
   } else if (argv.length === 7 && argv[0] === 'retract'
     && argv[1] === '--plan' && isTodoIdentifier(argv[2])
     && argv[3] === '--task' && isTodoIdentifier(argv[4])

package/src/todo-dispatch-shape.mjs

@@ -1,26 +1,24 @@
 import { TodoStoreError } from './todo-store.mjs';
 
 /**
- * 依存グラフの「直列度」を判定する既定閾値。
+ * 依存グラフの「直列度」を分類する既定閾値。
  *
  * `serialization_ratio = critical_path_length / task_count` がこれを超えると、
  * 依存連鎖が全task数の半分を超えて連なっている＝大半のtaskが並列候補ではなく
- * 一本の鎖に押し込まれていることを意味する。`todo start`側が既に持つ
- * `all_ready_parallel_by_default`方針をplan作成時点まで前倒しする出発点として
- * 0.5を採る。実測（parent-child-repair: task 26, critical path約20,
- * ratio≈0.77）を確実に超える一方、緩やかな分岐を持つ通常のplanまでは拾わない
- * 水準として選んだ。
+ * 一本の鎖に押し込まれていることを意味する。結果の`dispatch_shape`がこの事実を
+ * 載せる。拒否には使わない（ADR 0180）。
+ * 実測（parent-child-repair: task 26, critical path約20, ratio≈0.77）を確実に
+ * 超える一方、緩やかな分岐を持つ通常のplanまでは拾わない水準として選んだ。
  */
 export const DISPATCH_SHAPE_SERIALIZATION_THRESHOLD = 0.5;
 
 /**
- * 閾値判定の対象にする最小task数。
- * 3〜5 task程度の一直線planを毎回突き返しても再考の余地がなく
- * （並列化する意味のある規模でない）機構がノイズになるだけなので、
- * 6 task未満は常に素通りさせる。
+ * 直列度分類の対象にする最小task数。
+ * 3〜5 task程度の一直線は並列化する意味のある規模でないので、excessiveとはしない。
  */
 export const DISPATCH_SHAPE_MIN_TASK_COUNT_FOR_GATE = 6;
 
+/** 互換のため受理するだけのflag名。門には使わない（ADR 0180）。 */
 export const DISPATCH_SHAPE_SERIALIZATION_REVIEWED_FLAG = '--serialization-reviewed';
 
 function compareText(left, right) {
@@ -128,40 +126,12 @@ export function computeTodoDispatchShape({ taskIds, edges }) {
   };
 }
 
-/** dispatch_shapeが、再考なしで直列のまま通してよい規模・度合いかを判定する。 */
+/** dispatch_shapeが、観測上「直列に寄っている」規模・度合いかを分類する。拒否には使わない。 */
 export function isTodoDispatchShapeSerializationExcessive(shape) {
   return shape.task_count >= DISPATCH_SHAPE_MIN_TASK_COUNT_FOR_GATE
     && Number(shape.serialization_ratio) > DISPATCH_SHAPE_SERIALIZATION_THRESHOLD;
 }
 
-/**
- * dispatch_shapeが直列に寄りすぎているplanを、再考なしでは通さない。
- *
- * `todo start`の`PARALLEL_DISPATCH_RECONSIDER`と同じ二段階（一度突き返し、
- * 再考を経たflagが無ければ通さない）をplan作成時点へ前倒しする。ここで
- * 拒否する場合、呼び出し側はまだstoreへ何も書いていないこと（初期化／追加を
- * この呼び出しより後で行うこと）。
- */
-export function assertTodoDispatchShapeReviewed({ shape, reviewed }) {
-  if (!isTodoDispatchShapeSerializationExcessive(shape) || reviewed) return;
-  throw new TodoStoreError('PARALLEL_DISPATCH_RECONSIDER', 'plan_shape_too_serial', undefined, {
-    task_count: shape.task_count,
-    critical_path_length: shape.critical_path_length,
-    max_frontier_width: shape.max_frontier_width,
-    serialization_ratio: shape.serialization_ratio,
-    critical_path_task_ids: shape.critical_path_task_ids,
-    default_policy: 'all_ready_parallel_by_default',
-    serialization_reviewed_flag: DISPATCH_SHAPE_SERIALIZATION_REVIEWED_FLAG,
-    guidance: `並列を検討しなさい。task ${shape.task_count}件のうちcritical pathが`
-      + `${shape.critical_path_length}段（serialization_ratio ${shape.serialization_ratio}）で、`
-      + '大半のtaskが並列候補ではなく一本の依存鎖に押し込まれている。'
-      + 'critical_path_task_idsに沿った依存のうち、実際には干渉しない組を'
-      + 'hard_dependencies/joinsから外せないか見直す'
-      + '（実行主体が足りないなら増やす。増やせないことは直列化の理由にならない）。'
-      + `検討した上でなお直列でよいなら ${DISPATCH_SHAPE_SERIALIZATION_REVIEWED_FLAG} を付けて再実行する。`,
-  });
-}
-
 /**
  * plan/extractionの`tasks`・`hard_dependencies`・`joins`（nodeRef形式）から、
  * 「このproject_id/plan_keyの内側だけ」に絞ったdispatch形状を計算する高レベル入口。