@galda/cli 0.10.38 → 0.10.40

package/engine/server.mjs

@@ -13,7 +13,7 @@
 
 import { createServer } from 'node:http';
 import { spawn, execFile, spawnSync } from 'node:child_process';
-import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, statSync, readdirSync, unlinkSync } from 'node:fs';
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, statSync, readdirSync, unlinkSync, rmSync } from 'node:fs';
 import { emitEvent } from './analytics-client.mjs';
 import { randomBytes, createHash, randomUUID } from 'node:crypto';
 import { resolve, dirname, join, basename } from 'node:path';
@@ -21,7 +21,8 @@ import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { pathToFileURL } from 'node:url';
 import { needsProjectFolder, folderLabel, buildFolderQuestion, resolveFolderAnswer, classifyFolderTarget, buildFolderInitConfirm, isFolderInitConfirmed, needsReviewPreference, buildReviewPreferenceQuestion, resolveReviewPreferenceAnswer, routeQuestionAnswer, notUnderstoodNote, parseRelocalizedQuestion, classifyAuthProbe, authBannerText, makeSigninChallenge, parseClaimResponse } from './lib.mjs';
-import { parseStreamEvents, parsePlan, refinePlanTasks, findOverlappingGoal, canEditGoal, canDeleteGoal, shouldAskClarification, workerExitReason, isForcedStop, workerResultText, taskCountsAsComplete, resolveWantsPR, resolveGoalSource, buildGoalSummary, buildGoalProofMd, buildGoalPrBody, buildReviewSummaryPrompt, parseReviewSummary, buildReviewRuleSection, nextGoalStatus, isPrMerged, isPrApproved, reviewToDoneStatus, advanceReviewGoal, revertReviewGoal, approveGoal, dismissGoal, rejectGoal, reopenGoal, permissionModeFor, isPlanReview, nextAfterPlanApprove, GOAL_MODES, parseSkillFrontmatter, collectSkills, retestGoal, cancelRetestGoal, computeRetestOutcome, revertGoal, planRevertActions, archiveGoal, unarchiveGoal, undismissGoal, parseNumstat, truncateDiffText, sumUsage, resolveEntryUrl, parseGitLog, diffNewCommits, replayQueueLog, reconcileOrphanGoals, reorderQueue, sortQueueByPriority, TASK_PRIORITIES, validateWorkflowColumns, DEFAULT_WORKFLOW_COLUMNS, validateReviewDefinition, DEFAULT_REVIEW_DEFINITION, buildEphemeralSeedLog, buildEphemeralSeedProjects, trimTaskActivityForState, buildAskContext, WORKER_TOOLS, verifyCfAccessJwt, resolveIdentity, goalVisibleTo, clampParallelLimit, canStartMore, nextRunnableTasks, goalsConflict, detectConflicts, pickFoldTarget, isUiChange, shouldCaptureProof, shouldCaptureBaseline, hasTestRelevantChanges, parseFailingTestNames, classifyTestGate, classifyVerifyGate, buildExecutionPlan, buildContextHandoffSummary, buildFailurePostmortem, appendFailureMemory, latestFailurePolicy, classifyChangeRisk, checkRunBudget, usageBudgetTokens, isRateLimited, nextResumeDelay, checkFreeTierLimit, resolveEntitlement, resolveCachedEntitlement, FREE_TIER_LIMITS, QUEUED_GOAL_STATUSES, verifyLicenseToken, shouldEmitSetupCompleted, pickAnalyticsUid, shouldEmitFreeExhausted, detectRequestLanguage, isNothingVerifiable, classifyComposerIntentHeuristic, detectPauseIntent, buildIntentPrompt, parseIntentResponse, buildBoardSnapshot, validateBoardSnapshot, boardIsEmpty, decideBoardPull, resolveConnectedAgents, pickAvailableAgent, pickUtilityAgent, utilityModel, liveTakeoverDecision, shouldOpenBrowserOnBoot } from './lib.mjs';
+import { parseStreamEvents, parseCodexEvents, buildCodexArgs, parsePlan, refinePlanTasks, findOverlappingGoal, canEditGoal, canDeleteGoal, shouldAskClarification, workerExitReason, isForcedStop, workerResultText, taskCountsAsComplete, resolveWantsPR, resolveGoalSource, buildGoalSummary, buildGoalProofMd, buildGoalPrBody, buildReviewSummaryPrompt, parseReviewSummary, buildReviewRuleSection, nextGoalStatus, isPrMerged, isPrApproved, reviewToDoneStatus, advanceReviewGoal, revertReviewGoal, approveGoal, dismissGoal, rejectGoal, reopenGoal, permissionModeFor, isPlanReview, nextAfterPlanApprove, GOAL_MODES, parseSkillFrontmatter, collectSkills, retestGoal, cancelRetestGoal, computeRetestOutcome, revertGoal, planRevertActions, archiveGoal, unarchiveGoal, undismissGoal, parseNumstat, truncateDiffText, sumUsage, resolveEntryUrl, parseGitLog, diffNewCommits, replayQueueLog, reconcileOrphanGoals, reorderQueue, sortQueueByPriority, TASK_PRIORITIES, validateWorkflowColumns, DEFAULT_WORKFLOW_COLUMNS, validateReviewDefinition, DEFAULT_REVIEW_DEFINITION, buildEphemeralSeedLog, buildEphemeralSeedProjects, trimTaskActivityForState, buildAskContext, WORKER_TOOLS, workerPrompt, verifyCfAccessJwt, resolveIdentity, goalVisibleTo, clampParallelLimit, canStartMore, nextRunnableTasks, goalsConflict, detectConflicts, pickFoldTarget, hasTestRelevantChanges, parseFailingTestNames, classifyTestGate, classifyVerifyGate, buildExecutionPlan, buildContextHandoffSummary, buildFailurePostmortem, appendFailureMemory, latestFailurePolicy, classifyChangeRisk, checkRunBudget, usageBudgetTokens, isRateLimited, nextResumeDelay, checkFreeTierLimit, resolveEntitlement, resolveCachedEntitlement, FREE_TIER_LIMITS, QUEUED_GOAL_STATUSES, verifyLicenseToken, shouldEmitSetupCompleted, pickAnalyticsUid, shouldEmitFreeExhausted, detectRequestLanguage, isNothingVerifiable, classifyComposerIntentHeuristic, detectPauseIntent, buildIntentPrompt, parseIntentResponse, buildBoardSnapshot, validateBoardSnapshot, boardIsEmpty, decideBoardPull, resolveConnectedAgents, pickAvailableAgent, pickUtilityAgent, utilityModel, liveTakeoverDecision, shouldOpenBrowserOnBoot, goalTaskTitle, buildGoalTask, RUN_DECL_FILE, parseRunDeclaration, SHOT_DIR, collectShotNames } from './lib.mjs';
+import { createSerialQueue } from './lib.mjs';
 import { openPR } from './pr.mjs';
 import { runVerification, exerciseUi } from './verify.mjs';
 
@@ -63,6 +64,12 @@ function maybeEmitSetupCompleted(req) {
 // timeout→'interrupted' path is testable (a test sets a short value + a slow
 // fake worker instead of waiting 10 real minutes).
 const WORKER_TIMEOUT_MS = Number(process.env.MANAGER_WORKER_TIMEOUT_MS) || 15 * 60 * 1000;
+// The worker's own words ARE the deliverable for every request that doesn't
+// produce something runnable (research, summaries, answers to a question). The
+// old 4000-char cap silently ate the middle of exactly those answers, so the
+// review card showed a truncated report and called it evidence. Keep a cap —
+// this lands in persisted state — but one that fits a real answer.
+const RESULT_MAX = 20000;
 const MODELS = ['sonnet', 'opus', 'haiku'];
 const CODEX_MODELS = ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex-spark'];
 const WORKER_AGENTS = ['claude-code', 'codex'];
@@ -729,7 +736,33 @@ for (const fix of orphanFixes) {
   const g = goals.find((x) => x.id === fix.id);
   if (g) { console.log(`[manager] goal ${g.id}: reaped as orphaned (no live worker after restart) → interrupted`); saveGoal(g); }
 }
+// The implementation log (P1.5, Masa 2026-07-22).
+//
+// The tool-call stream — ⏺ Read / Edit / Bash and their results — existed only while the
+// worker ran: sendAct() kept it on the task, streamed it, and saveTask() then dropped it
+// on the floor. So the moment a task finished (or the page reloaded), there was no way to
+// see what the AI had actually done. Claude Code's own app keeps that history and Masa
+// reads it; we threw ours away.
+//
+// Frozen to a file rather than into the state log on purpose: 1000 lines × 500 chars is
+// up to ~500KB per task, and the state log is replayed in full on every boot. The file is
+// read on demand by GET /api/tasks/:id/activity — the same "only when asked" shape as
+// /preview. Nothing is summarised: what the worker did is what gets stored.
+const ACTIVITY_TERMINAL = new Set(['done', 'failed', 'interrupted', 'skipped']);
+const activityLogFile = (taskId) => join(logDir, `activity-${taskId}.log`);
+function freezeActivityLog(t) {
+  if (!ACTIVITY_TERMINAL.has(t.status) || !t.activity?.length) return false;
+  try { writeFileSync(activityLogFile(t.id), t.activity.join('\n')); return true; }
+  catch (e) { console.error(`[manager] activity log write failed for task ${t.id} (${e?.code || e})`); return false; }
+}
+function readActivityLog(taskId) {
+  try { return readFileSync(activityLogFile(taskId), 'utf8').split('\n').filter(Boolean); }
+  catch { return []; }
+}
 function saveTask(t) {
+  // freeze BEFORE the destructure strips `activity`, and mark the task so the UI knows a
+  // log exists without having to ask for one that was never written.
+  if (freezeActivityLog(t)) t.activityLog = true;
   const { activity, todos, ...persist } = t; // activity + todos are ephemeral (live only)
   logAppend(JSON.stringify({ ...persist, kind: 'task' }));
   const goal = goals.find((g) => g.id === t.goalId);
@@ -1047,54 +1080,49 @@ function runClaude({ prompt, cwd, tools, onEvent, onTodos, resume, model, effort
     });
   });
 }
-function parseCodexUsage(usage) {
-  if (!usage) return null;
-  return {
-    input_tokens: usage.input_tokens ?? usage.inputTokens ?? 0,
-    output_tokens: usage.output_tokens ?? usage.outputTokens ?? 0,
-    cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0,
-    cache_read_input_tokens: usage.cached_input_tokens ?? usage.cache_read_input_tokens ?? 0,
-  };
-}
-function runCodex({ prompt, cwd, onEvent, permissionMode = 'acceptEdits', model, effort, onChild }) {
+// The Codex half of the worker bridge. Same contract as runClaude, because
+// nothing downstream may care which agent ran: live activity, the agent's own
+// to-dos (the board), the thread id to talk to it again, usage, final message.
+function runCodex({ prompt, cwd, onEvent, onTodos, resume, permissionMode = 'acceptEdits', model, effort, onChild }) {
   return new Promise((done) => {
     const sandbox = permissionMode === 'plan' ? 'read-only' : 'workspace-write';
-    const args = ['exec', '--json', '-m', workerModel('codex', model), '-c', `model_reasoning_effort="${workerEffort('codex', effort)}"`, '--sandbox', sandbox, '--skip-git-repo-check', '--cd', cwd, '-'];
+    const args = buildCodexArgs({ model: workerModel('codex', model), effort: workerEffort('codex', effort), sandbox, cwd, resume });
     const child = spawn('codex', args, { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
     onChild?.(child);
     child.stdin.end(prompt);
-    let result = '', err = '', buf = '', usage = null, timedOut = false, lastAct = '';
+    let result = '', err = '', buf = '', sessionId = null, usage = null, timedOut = false, lastAct = '';
     const timer = setTimeout(() => { timedOut = true; child.kill('SIGTERM'); }, WORKER_TIMEOUT_MS);
     child.stdout.on('data', (d) => {
       buf += d;
       const lines = buf.split('\n'); buf = lines.pop();
       for (const line of lines) {
         if (!line.trim()) continue;
-        try {
-          const ev = JSON.parse(line);
-          if (ev.type === 'item.completed') {
-            const item = ev.item ?? {};
-            if (item.type === 'agent_message' && item.text) {
-              result = item.text;
-              onEvent?.(`✎ ${item.text.trim().replace(/\s+/g, ' ').slice(0, 500)}`);
-            } else if (item.type === 'error' && item.message) onEvent?.(`Error ${item.message}`);
-            else if (item.type === 'command_execution' && item.command) { lastAct = `Run ${item.command}`; onEvent?.(lastAct); }
-          } else if (ev.type === 'turn.completed') {
-            usage = parseCodexUsage(ev.usage);
-          } else if (ev.type === 'error' && ev.message) {
-            err += `${ev.message}\n`;
-            onEvent?.(`Error ${ev.message}`);
-          }
-        } catch {
-          if (line.trim()) lastAct = line.trim().slice(0, 240);
-          onEvent?.(line.trim().slice(0, 240));
+        const evs = parseCodexEvents(line);
+        // A line we cannot parse is still the worker talking — show it rather
+        // than swallow it (how this ran before the bridge existed).
+        if (!evs.length && !line.trim().startsWith('{')) {
+          lastAct = line.trim().slice(0, 240);
+          onEvent?.(lastAct);
+          continue;
+        }
+        for (const ev of evs) {
+          if (ev.kind === 'session') sessionId = ev.id;
+          else if (ev.kind === 'usage') usage = ev.usage;
+          else if (ev.kind === 'todos') onTodos?.(ev.todos);
+          else if (ev.kind === 'message') {
+            result = ev.text;
+            onEvent?.(`✎ ${ev.text.trim().replace(/\s+/g, ' ').slice(0, 500)}`);
+          } else if (ev.kind === 'error') {
+            err += `${ev.text}\n`;
+            onEvent?.(`Error ${ev.text}`);
+          } else { lastAct = ev.text; onEvent?.(ev.text); }
         }
       }
     });
     child.stderr.on('data', (d) => { err += d; });
     child.on('close', (code) => {
       clearTimeout(timer);
-      done({ code, timedOut, result: workerResultText({ result, err, code, timedOut, lastAct, timeoutMs: WORKER_TIMEOUT_MS }), sessionId: null, usage });
+      done({ code, timedOut, result: workerResultText({ result, err, code, timedOut, lastAct, timeoutMs: WORKER_TIMEOUT_MS }), sessionId, usage });
     });
   });
 }
@@ -1401,7 +1429,9 @@ async function planGoal(goal) {
     '- 複数タスクに分けるのは、依頼に「明確に別々の成果物・トピック」が含まれる時「だけ」（例:「音声入力を追加して、あとビジュアル作成も」→ 音声入力 / ビジュアル作成 の2つ）。工程での分割は絶対にしない。',
     '- 被っている・言い換えているだけの依頼は、自分で理解して1つにまとめる。',
     '- タスク数は最小に。既定1個、多くても distinct な依頼の数だけ（現実的に1〜3、最大4）。依存順に並べる。',
-    '- 各タスクの title は「ユーザーから見た成果（ユーザーの言葉のまま・短く）」にする。エンジニアリングの手順名（設計/実装/テスト等）にしない。detail には worker への完全な指示を書く：そのworkerが1人で実装・テスト・proofまで完結させる。工程ごとの兄弟タスクは来ない前提で書くこと。',
+    '- 各タスクの title は「ユーザーが頼んだこと」を、ユーザーの言葉・語彙をそのまま活かして短く書く。実装のやり方（「〜するように直した」「〜を計算する」等）や、完了報告の文（「〜した」「〜しました」）を title にしない。エンジニアリングの手順名（設計/実装/テスト等）にもしない。例: 依頼「一回たたむとsettingボタンがズレるバグ修正して」→ title「settingボタンがズレるバグの修正」（✕「アニメーションが終わってから歯車の位置を計算するように直した」）。',
+    '- バグ修正の依頼では、title に「どの問題を直すか」がわかるように書く（解決する問題＝ユーザーの言葉）。依頼に直し方の方針が書かれていればそれも短く添えてよいが、無ければ問題だけでよい。工程・実装詳細は detail に書く。',
+    '- detail には worker への完全な指示を書く：そのworkerが1人で実装・テスト・proofまで完結させる。工程ごとの兄弟タスクは来ない前提で書くこと。',
     '- passCondition はユーザーが依頼文で明示的に検証条件（「成功条件:」「〜したら〜になる」等）を書いた場合のみ設定する。見た目の調整・文言変更・スタイル変更のタスクには付けない（null）。検証は高価なので、明示された時だけ。',
     '- 検証対象のページがあれば entry に書く（プロジェクト相対のhtmlパス、または http URL。無ければ null）。依頼中に書かれていればそれを使い、無ければリポジトリを見て推測してよい。',
     '- 依頼が曖昧で重要な前提が1つ欠けている（例: 対象・範囲・形式が不明）か、既存の作業と矛盾する場合「のみ」、タスクではなく確認質問を返す: {"question":"確認したい1点（短く）","options":["選択肢A","選択肢B"]}。ただし基本は合理的な仮定で進めること。質問は本当に必要な時だけ、1問に絞る。',
@@ -1457,22 +1487,25 @@ async function planGoal(goal) {
   plan.tasks = refinePlanTasks(plan.tasks, { goalText: goal.text });
   goal.status = 'running';
   goal.entry = plan.entry;
-  goal.plan = plan.tasks.map((t) => t.title);
+  // Demoted planner (Masa 2026-07-21, P0b): the planner LLM still resolves the
+  // entry URL, asks for clarification, and warms the session — but it no longer
+  // DECOMPOSES the request into tasks the worker must follow. The request goes
+  // to the worker verbatim as ONE task; the worker (Claude Code / Codex) decides
+  // its own breakdown and emits it as its own TodoWrite, which the board shows.
+  // One card = one request. A user-written pass condition still rides along.
+  const title = goalTaskTitle(goal.text);
+  goal.plan = [title];
   saveGoal(goal);
   const base = tasks.filter((t) => t.projectId === goal.projectId).map((t) => t.num);
-  let num = (base.length ? Math.max(...base) : 0);
-  for (const p of plan.tasks) {
-    const task = {
-      id: nextId++, num: ++num, goalId: goal.id, projectId: goal.projectId,
-      title: p.title, detail: p.detail, passCondition: p.passCondition, model: goal.model, effort: goal.effort, agent: goal.agent,
-      mode: goal.mode ?? 'auto', skill: goal.skill ?? null,
-      status: 'queued', createdAt: new Date().toISOString(), priority: '中',
-      result: null, changedFiles: [], secs: null, activity: [], proof: null, usage: null,
-    };
-    tasks.push(task);
-    saveTask(task);
-    queues.get(goal.projectId).waiting.push(task);
-  }
+  const num = (base.length ? Math.max(...base) : 0) + 1;
+  const task = buildGoalTask(goal, {
+    id: nextId++, num,
+    passCondition: plan.tasks[0]?.passCondition ?? null,
+    createdAt: new Date().toISOString(),
+  });
+  tasks.push(task);
+  saveTask(task);
+  queues.get(goal.projectId).waiting.push(task);
   pump(goal.projectId);
 }
 
@@ -1838,44 +1871,8 @@ function testOutputExcerpt(text) {
   return chosen.join('\n').slice(-3000);
 }
 
-function workerPrompt(task, goal, lastFailure) {
-  // Optional skill the user attached to this goal. Empirically (scratch worker,
-  // haiku, custom fixture skill) the reliably-firing form is an explicit Skill-tool
-  // instruction as the FIRST line; a bare "/name" first line did not consistently
-  // trigger the skill in `claude -p`. See commit body for the run evidence.
-  const skill = task?.skill ?? goal?.skill;
-  const agentName = workerAgent(task?.agent ?? goal?.agent) === 'codex' ? 'Codex' : 'Claude Code';
-  // Report back to the human in the SAME language they wrote the goal in (Masa
-  // 2026-07-15: "撃った言語で返す"). JP characters → Japanese, otherwise English.
-  const replyLang = detectRequestLanguage(goal?.text || task?.title || '') === 'ja' ? '日本語' : 'English';
-  return [
-    skill ? `FIRST, use the /${skill} skill via the Skill tool (invoke Skill with the "${skill}" skill) before doing anything else. Then carry out the task below.` : '',
-    `You are a ${agentName} worker managed by "Manager for AI". Do ONLY the task below inside this project directory.`,
-    goal?.priorFailureMemory?.length ? `\nMANAGER FAILURE MEMORY:\n${latestFailurePolicy(goal.priorFailureMemory)?.text}\nApply this prevention before starting.` : '',
-    '',
-    `TASK ${task.num}: ${task.title}`,
-    task.detail ? `DETAIL: ${task.detail}` : '',
-    goal?.images?.length ? `ATTACHED IMAGES (absolute paths, use the Read tool to view them): ${goal.images.join(' ')}` : '',
-    task.passCondition ? `\nEXPLICIT PASS CONDITION (verified externally by a headless browser after you finish — NOT by you): ${task.passCondition}` : '',
-    lastFailure ? `\nPREVIOUS ATTEMPT FAILED EXTERNAL VERIFICATION: ${lastFailure}\nYour previous changes are on disk. Diagnose and fix.` : '',
-    goal ? `\n(全体ゴールの一部です: ${goal.text.slice(0, 500)})` : '',
-    '',
-    'RULES:',
-    '- Edit only files inside this directory. Keep changes minimal.',
-    '- Keep the work bounded: inspect only files needed for this task; avoid broad repository scans unless they are necessary.',
-    '- If the task is larger than one focused patch, make the smallest safe change and report the next step instead of expanding scope.',
-    "- You may use the user's installed skills (Skill tool, e.g. /galda-doc) when one clearly fits the task.",
-    // Token-frugality + the 10-min run cap: the worker used to run the WHOLE suite
-    // (npm test) repeatedly, which the Manager ALSO runs at close-out — double work
-    // that regularly overran the cap (→ a SIGTERM 'interrupted'). Write the test,
-    // run only the RELEVANT file once, and leave the full-suite + verification to
-    // the Manager. (Masa: worker が自前でテスト全回し→止まる、が最大の無駄。)',
-    '- 変更に対応するテストを書く。確認は該当テストファイル1つだけを1回実行する（例: node --test path/to/only-this.test.mjs）。プロジェクト全体の npm test を繰り返し回さない — 全体テストと最終検証は Manager 側が実行する。テストが適用できない変更は理由と手動確認手順を書く。',
-    '- 検証しすぎない: 自分の変更が動くと確認できたら、それ以上ログを漁ったり再検証を重ねたりせず、すぐに報告して終える（時間と token の無駄を避ける）。',
-    '- Do not commit (git is handled by the Manager).',
-    `- 最後に${replyLang}で2〜4行：何を変えたか・どのファイルか・テスト結果・人間が確認すべき点。`,
-  ].filter(Boolean).join('\n');
-}
+// workerPrompt moved to lib.mjs (pure + unit-tested). Caller resolves the
+// agent id via workerAgent(); lib keeps the presentation.
 
 // A fresh ephemeral instance starts with zero history, but some pass
 // conditions are about completion-time behavior (e.g. task 46: a goal
@@ -1963,148 +1960,121 @@ function entryUrlFor(goal, project) {
   return resolveEntryUrl({ entry: goal?.entry, projectDir: project.dir, managerRoot: ROOT, port: PORT, accessKey: ACCESS_KEY });
 }
 
-function canSnapshot(project) {
-  return existsSync(join(project.dir, 'engine', 'server.mjs')) && existsSync(join(project.dir, 'app', 'index.html'));
-}
+// ---- EVIDENCE: what the worker made, actually reachable ---------------------
+// Everything that used to live here (proofIntentFor / verifyManagerProofTarget /
+// captureSnapshotProof) staged a photograph: it booted an ephemeral copy of the
+// project and screenshotted the MANAGER'S OWN flagship board, picking WHICH
+// region to shoot by keyword-matching the request text. That produced pictures
+// unrelated to the change (#496) and, because canSnapshot() demanded
+// engine/server.mjs + app/index.html, it never ran at all outside this repo.
+//
+// The replacement asks the only AI in the pipeline — the worker that just did
+// the work — how a human can run and see the result, and then does exactly
+// that. This layer never guesses the command and never classifies the request.
 
-function proofIntentFor(goal, task) {
-  const text = `${goal?.text ?? ''}\n${goal?.plan?.join?.('\n') ?? ''}\n${task?.title ?? ''}\n${task?.detail ?? ''}`.toLowerCase();
-  if (/retry|resume|view log|archive|失敗|エラー|blocked|interrupted|attention|to do|todo/.test(text)) {
-    return 'attention-actions';
+// Consume the worker's run declaration from the worktree root. It is a message
+// to the Manager, not part of the deliverable, so it is deleted after reading:
+// it must not reach the diff or the PR.
+//
+// Silence is a valid answer. A request with nothing to run (research, a
+// summary, an answer to a question) leaves no declaration and gets no "run it"
+// button — there, the worker's own words are the whole deliverable.
+function readRunDeclaration(task, workDir) {
+  const file = join(workDir, RUN_DECL_FILE);
+  let raw = null;
+  try { raw = readFileSync(file, 'utf8'); } catch { return; }
+  try { unlinkSync(file); } catch { /* best effort — never fail a task over cleanup */ }
+  const run = parseRunDeclaration(raw);
+  if (!run) {
+    sendAct(task, `run declaration ignored — ${RUN_DECL_FILE} was not usable JSON`);
+    return;
   }
-  if (/review|approve|dismiss|proof|スクショ|画像|動画/.test(text)) return 'review';
-  return 'general';
+  task.run = { ...run, dir: workDir };
+  sendProcessAct(task, `Worker declared how to see the result: ${run.cmd ?? run.url}`);
 }
 
-async function verifyManagerProofTarget(page, ui, { goal = null, task = null } = {}) {
-  const intent = proofIntentFor(goal, task);
-  const root = await page.waitForSelector('#fsRoot', { timeout: 1500 }).catch(() => null);
-  if (!root) {
-    await exerciseUi(page, ui);
-    return { pass: true, detail: 'UI change capture (auto, unverified)' };
-  }
-  await page.evaluate(() => {
-    localStorage.setItem('layout', 'flagship');
-    if (window.state?.projects?.some((p) => p.id === 'default')) window.state.active = 'default';
-    window.render?.();
-  });
-  await ui.sleep(300);
-
-  if (intent === 'attention-actions') {
-    await page.waitForSelector('#fsTodoSec .drow.err .acts2', { timeout: 5000 });
-    await page.evaluate(() => document.querySelector('#fsTodoSec .drow.err')?.scrollIntoView({ block: 'center', inline: 'nearest' }));
-    await ui.sleep(250);
-    const metrics = await page.evaluate(() => {
-      const rect = (el) => {
-        const r = el?.getBoundingClientRect?.();
-        return r ? { x: r.x, y: r.y, width: r.width, height: r.height, top: r.top, bottom: r.bottom, right: r.right, left: r.left } : null;
-      };
-      const root = document.querySelector('#fsRoot');
-      const feed = document.querySelector('#fsFeedWrap') || document.querySelector('#fsFeed')?.parentElement;
-      const lane = document.querySelector('#fsLane');
-      const row = document.querySelector('#fsTodoSec .drow.err');
-      const msg = row?.querySelector('.errline .msg');
-      const acts = row?.querySelector('.acts2');
-      const buttonText = [...(acts?.querySelectorAll('button') ?? [])].map((b) => b.textContent.trim()).join(' ');
-      const rootR = rect(root), feedR = rect(feed), laneR = rect(lane), msgR = rect(msg), actsR = rect(acts);
-      return {
-        buttonText,
-        hasRetry: /Retry|Resume/.test(buttonText),
-        hasLog: /View log/.test(buttonText),
-        hasArchive: /Archive/.test(buttonText),
-        actionGap: msgR && actsR ? Math.round(actsR.top - msgR.bottom) : null,
-        laneWidth: Math.round(laneR?.width ?? 0),
-        feedWidth: Math.round(feedR?.width ?? 0),
-        rootWidth: Math.round(rootR?.width ?? 0),
-        laneVisible: Boolean(laneR && laneR.width >= 260 && laneR.right <= window.innerWidth + 2),
-      };
-    });
-    const actionClose = metrics.actionGap == null || metrics.actionGap <= 18;
-    const laneSane = metrics.laneVisible && metrics.feedWidth > 420 && metrics.laneWidth > 260;
-    return {
-      pass: Boolean(metrics.hasRetry && metrics.hasLog && actionClose && laneSane),
-      detail: `Manager UI proof target: failed-row actions visible (${metrics.buttonText || 'none'}), action gap ${metrics.actionGap ?? 'n/a'}px, lane ${metrics.laneWidth}px/feed ${metrics.feedWidth}px`,
-    };
+// Take whatever the worker photographed out of the worktree (SHOT_DIR) and put
+// it where the Manager already serves images from, so the pictures are reachable
+// at a URL instead of sitting in a temp checkout that gets deleted.
+//
+// Moved, not copied, and moved BEFORE the diff is computed: a screenshot is the
+// worker talking to us about the deliverable, not the deliverable, and it must
+// not turn up as a binary file in the pull request.
+//
+// This function does not know what a good picture is. It never shoots anything
+// itself, and an empty SHOT_DIR is a normal outcome — plenty of requests have
+// nothing to look at.
+function collectWorkerShots(task, workDir) {
+  const dir = join(workDir, SHOT_DIR);
+  let names = [];
+  try { names = collectShotNames(readdirSync(dir)); } catch { return; }
+  const outDir = join(logDir, 'uploads');
+  mkdirSync(outDir, { recursive: true });
+  const shots = [];
+  for (const name of names) {
+    const safe = name.replace(/[^\w.-]/g, '_').slice(-80);
+    const file = `${Date.now()}-shot-${task.id}-${safe}`;
+    try {
+      writeFileSync(join(outDir, file), readFileSync(join(dir, name)));
+      shots.push({ name, url: `/upload/${file}`, path: join(outDir, file) });
+    } catch { /* one unreadable shot must not cost the task its other shots */ }
   }
-
-  await exerciseUi(page, ui);
-  const metrics = await page.evaluate(() => {
-    const lane = document.querySelector('#fsLane')?.getBoundingClientRect();
-    const feed = (document.querySelector('#fsFeedWrap') || document.querySelector('#fsFeed')?.parentElement)?.getBoundingClientRect();
-    return { laneWidth: Math.round(lane?.width ?? 0), feedWidth: Math.round(feed?.width ?? 0) };
-  });
-  return { pass: true, detail: `Manager UI capture (${intent}); lane ${metrics.laneWidth}px/feed ${metrics.feedWidth}px` };
+  try { rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ }
+  if (!shots.length) return;
+  task.shots = [...(task.shots ?? []), ...shots];
+  sendProcessAct(task, `Worker attached ${shots.length} screenshot${shots.length === 1 ? '' : 's'} of the result.`);
 }
 
-// Zero-LLM screenshot + short clip of an ephemeral instance of the project's
-// current code, stored as the task's proof. Used automatically for UI tasks
-// without an explicit pass condition, and on demand via
-// POST /api/tasks/:id/snapshot to backfill old "No capture yet" reviews.
+// Live previews, started on demand by POST /api/tasks/:id/preview.
 //
-// The clip is no longer an idle page (a 0-second clip of nothing moving said
-// nothing a screenshot didn't) — exerciseUi() moves the cursor and scrolls
-// the live app during the capture, so the GIF/mp4 actually SHOW the change
-// instead of a static landing shot. The `detail` text is deliberately NOT
-// "snapshot"-worded: app/index.html's proofMediaHtml() keys its PNG-only /
-// no-video display off /snapshot|スナップショット/i in proof.detail (that
-// heuristic exists for the old idle capture) — this capture has real motion
-// worth showing, so it earns the same GIF+tap-to-play-mp4 treatment as a
-// verified run.
-//
-// opts.baselineDir: when given and it's a genuinely different checkout than
-// `project.dir` (see shouldCaptureBaseline — never fabricate a before/after
-// from the same directory), best-effort capture a BASELINE screenshot too
-// (single attempt, screenshot-only, never throws) so the review card can
-// show before/after. Reviewer UI already supports this via
-// proof.beforePng/beforeGif (beforeAfterMediaHtml in app/index.html).
-async function captureSnapshotProof(task, project, opts = {}) {
-  const eph = await startEphemeralApp(project.dir);
-  if (!eph) throw new Error('ephemeral instance failed to boot');
-  try {
-    const proofDir = join(logDir, `proof-${task.id}`);
-    mkdirSync(proofDir, { recursive: true });
-    const managerApp = canSnapshot(project);
-    const snap = await runVerification({
-      entryUrl: eph.url,
-      verify: async (page, ui) => managerApp
-        ? verifyManagerProofTarget(page, ui, { goal: opts.goal, task })
-        : (await exerciseUi(page, ui), { pass: true, detail: 'UI change capture (auto, unverified)' }),
-      outBase: join(proofDir, 'snapshot'),
-      viewport: managerApp ? { width: 1440, height: 900, deviceScaleFactor: 2 } : undefined,
-    });
-    task.proof = {
-      pass: snap.pass, detail: snap.detail || 'UI change capture (auto, unverified)',
-      gif: snap.gifPath?.split('/').pop() ?? null,
-      png: snap.shotPath?.split('/').pop() ?? null,
-      mp4: snap.videoPath?.split('/').pop() ?? null,
-    };
-    const baselineDir = opts.baselineDir;
-    if (shouldCaptureBaseline({ baselineDir, afterDir: project.dir, canCaptureBaseline: baselineDir ? canSnapshot({ dir: baselineDir }) : false })) {
-      let beph = null;
-      try {
-        beph = await startEphemeralApp(baselineDir);
-        if (beph) {
-          const bsnap = await runVerification({
-            entryUrl: beph.url,
-            verify: async (page, ui) => managerApp
-              ? verifyManagerProofTarget(page, ui, { goal: opts.goal, task })
-              : (await exerciseUi(page, ui), { pass: true, detail: 'baseline (before)' }),
-            outBase: join(proofDir, 'before'),
-            viewport: managerApp ? { width: 1440, height: 900, deviceScaleFactor: 2 } : undefined,
-            record: false, // comparison shot only — not worth a second video encode
-          });
-          task.proof.beforePng = bsnap.shotPath?.split('/').pop() ?? null;
-        }
-      } catch (e) {
-        // Before/after is a nice-to-have on top of the mandatory "after"
-        // capture above (already saved) — never let a flaky baseline boot
-        // fail the whole capture. Report it and move on.
-        sendAct(task, `proof: baseline (before) capture skipped — ${String(e.message ?? e).slice(0, 100)}`);
-      } finally { beph?.kill(); }
+// On demand rather than always-on: a preview costs a real process, and most
+// finished goals are never opened. Idle ones are reaped, so a reviewer who
+// opens twenty cards doesn't leave twenty servers behind.
+const previews = new Map(); // taskId -> { proc, url, expires }
+const PREVIEW_IDLE_MS = 10 * 60 * 1000;
+const PREVIEW_BOOT_TRIES = 60; // × 250ms = 15s
+
+function installPreviewReaper() {
+  if (installPreviewReaper.done) return;
+  installPreviewReaper.done = true;
+  setInterval(() => {
+    for (const [id, p] of previews) {
+      if (p.expires > Date.now()) continue;
+      try { p.proc.kill(); } catch { /* already gone */ }
+      previews.delete(id);
     }
-    saveTask(task);
-    return task;
-  } finally { eph.kill(); }
+  }, 60 * 1000).unref?.();
+  const killAll = () => { for (const p of previews.values()) { try { p.proc.kill(); } catch { /* already gone */ } } };
+  process.on('exit', killAll);
+}
+
+async function startPreview(task) {
+  installPreviewReaper();
+  const { cmd, url, dir } = task.run;
+  const live = previews.get(task.id);
+  if (live && live.proc.exitCode === null) {
+    live.expires = Date.now() + PREVIEW_IDLE_MS;
+    return { url: live.url, reused: true };
+  }
+  // Declared a URL but no command: the thing is already reachable (an app the
+  // worker left running, a hosted page). Nothing to start.
+  if (!cmd) return { url, reused: false, started: false };
+  const proc = spawn(cmd, { cwd: dir, shell: true, stdio: 'ignore' });
+  const entry = { proc, url: url ?? null, expires: Date.now() + PREVIEW_IDLE_MS };
+  previews.set(task.id, entry);
+  proc.on('close', () => { if (previews.get(task.id) === entry) previews.delete(task.id); });
+  // No URL to poll — we started it and say so; the note tells the human where
+  // to look.
+  if (!url) return { url: null, reused: false, started: true };
+  for (let i = 0; i < PREVIEW_BOOT_TRIES; i++) {
+    await new Promise((r) => setTimeout(r, 250));
+    if (proc.exitCode !== null) throw new Error(`run command exited with code ${proc.exitCode} before ${url} answered`);
+    // Any HTTP answer means it's up; a 404 on the root is still a live server.
+    try { await fetch(url); return { url, reused: false, started: true }; } catch { /* not up yet */ }
+  }
+  try { proc.kill(); } catch { /* already gone */ }
+  previews.delete(task.id);
+  throw new Error(`${url} did not answer within 15s of running: ${cmd}`);
 }
 
 async function runTask(task) {
@@ -2163,7 +2133,7 @@ async function runTask(task) {
     sendProcessAct(task, `Worker finished with exit code ${r.code}.`);
     task.secs = Math.round((Date.now() - t0) / 1000);
     task.status = r.code === 0 ? 'done' : 'failed';
-    task.result = r.result.slice(0, 4000);
+    task.result = r.result.slice(0, RESULT_MAX);
     task.usage = sumUsage([r.usage]);
     if (r.sessionId && goal) { goal.sessionId = r.sessionId; saveGoal(goal); }
     const afterR = await gitChanges(workDir);
@@ -2196,7 +2166,7 @@ async function runTask(task) {
     let callT0 = Date.now();
     const plan = goal?.executionPlan;
     const resumeSession = shouldFreshSessionForPlan(plan) ? undefined : (goal?.sessionId ?? undefined);
-    const prompt = [managerHandoffPrompt(goal, plan), workerPrompt(task, goal, lastFailure)].filter(Boolean).join('\n\n');
+    const prompt = [managerHandoffPrompt(goal, plan), workerPrompt(task, goal, lastFailure, workerAgent(task.agent ?? goal?.agent))].filter(Boolean).join('\n\n');
     sendProcessAct(task, `Starting ${workerAgent(task.agent ?? goal?.agent) === 'codex' ? 'Codex' : 'Claude Code'} worker (attempt ${attempt}/${maxAttempts}).`);
     let r = await runWorkerAgent({
       agent: task.agent ?? goal?.agent,
@@ -2225,7 +2195,7 @@ async function runTask(task) {
       sendProcessAct(task, 'Starting a fresh worker session because the warm session could not resume.');
       r = await runWorkerAgent({
         agent: task.agent ?? goal?.agent,
-        prompt: workerPrompt(task, goal, lastFailure), cwd: workDir, tools: WORKER_TOOLS,
+        prompt: workerPrompt(task, goal, lastFailure, workerAgent(task.agent ?? goal?.agent)), cwd: workDir, tools: WORKER_TOOLS,
         permissionMode,
         model: task.model ?? goal?.model, effort: task.effort ?? goal?.effort, onEvent: (line) => sendAct(task, line),
         onTodos: (todos) => sendTodos(task, todos),
@@ -2301,15 +2271,20 @@ async function runTask(task) {
     : forcedStop ? 'interrupted'
     : conclusive ? 'failed'
     : (code === 0 ? 'done' : 'failed');
+  // Freeze the worker's own final TodoWrite list (P0b): live `todos` are stripped
+  // on save, so snapshot them into `todosFinal` — persisted (blacklist saveTask /
+  // trimTaskActivityForState keep it) so the board/review can show what the AI
+  // actually did after it finishes, not just while it runs.
+  task.todosFinal = Array.isArray(task.todos) ? task.todos : [];
   // Never leave the reason as a bare "(no output)": if the worker produced no
   // report text, result already carries workerExitReason(); make doubly sure a
   // force-stopped task states WHY so the Attention card explains itself.
   if (forcedStop && (!result || result === '(no output)')) result = workerExitReason(code, timedOut, WORKER_TIMEOUT_MS);
-  task.result = result.slice(0, 4000);
+  task.result = result.slice(0, RESULT_MAX);
   task.usage = sumUsage(usages);
   if (verdict) {
     const label = verdict.pass ? 'PASS' : verdict.inconclusive ? 'INCONCLUSIVE (自動確認できず・要確認)' : 'FAIL';
-    task.result = `検証${label}: ${verdict.detail}\n\n${task.result}`.slice(0, 4000);
+    task.result = `検証${label}: ${verdict.detail}\n\n${task.result}`.slice(0, RESULT_MAX);
     // Only attach an authoritative proof for a conclusive verdict. An
     // inconclusive one must NOT leave a pass:false proof — that would trip
     // verifyGate's proofFailing and re-block the goal through the back door
@@ -2329,28 +2304,28 @@ async function runTask(task) {
       };
     }
   }
+  // Evidence = the thing the worker actually made, reachable by the human.
+  //
+  // What used to be here (after changedFiles): an auto "proof" snapshot. It
+  // booted an ephemeral app and screenshotted the MANAGER'S OWN flagship board
+  // — never the deliverable — and canSnapshot() required engine/server.mjs +
+  // app/index.html, so it only ever ran when the project was this repo. In
+  // every customer project it was dead code, and in ours it produced a picture
+  // unrelated to the change (#496: "3案見せて" → a screenshot of the board).
+  // Staging a photo ourselves is the one thing this layer must not do, so it is
+  // gone rather than fixed.
+  //
+  // What replaces it: whatever the worker itself declared as the way to see the
+  // result. No classification of the request, no per-project knowledge here.
+  //
+  // Runs BEFORE changedFiles is computed because it consumes (reads + removes)
+  // the declaration file — it's a message to the Manager, not part of the
+  // deliverable, and it must not show up in the diff or the PR.
+  readRunDeclaration(task, workDir);
+  collectWorkerShots(task, workDir);
   const after = await gitChanges(workDir);
   task.changedFiles = after.filter((l) => !before.includes(l)).map((l) => l.slice(3));
   sendProcessAct(task, `Detected ${task.changedFiles.length} changed file${task.changedFiles.length === 1 ? '' : 's'} from this task.`);
-
-  // A UI change with no explicit pass condition used to finish with no
-  // evidence at all ("UI変更のはずなのに写真が撮られてない"). Capture a cheap
-  // zero-LLM snapshot (screenshot + short clip) from an ephemeral instance
-  // of the edited app so the review card always has something to look at.
-  // baselineDir = the user's real project dir (unmodified, pre-goal code) —
-  // when it's genuinely different from wproject.dir (a real worktree, not
-  // the shared-dir fallback), also attempt a before/after pair.
-  if (!conclusive && task.status === 'done' && shouldCaptureProof({ changedFiles: task.changedFiles, hasProof: Boolean(task.proof), canCapture: canSnapshot(wproject) })) {
-    try {
-      sendAct(task, 'proof: capturing UI change (screenshot + clip) of the edited app…');
-      await captureSnapshotProof(task, wproject, { baselineDir: project.dir, goal });
-      sendProcessAct(task, `Proof capture finished: ${task.proof?.pass === false ? 'target check failed' : 'screenshot/clip attached'}.`);
-      if (task.proof && task.proof.pass === false) {
-        task.status = 'failed';
-        task.result = `proof FAIL: ${task.proof.detail}\n\n${task.result ?? ''}`.slice(0, 4000);
-      }
-    } catch (e) { sendAct(task, `proof: capture failed — ${String(e.message ?? e).slice(0, 100)}`); }
-  }
   task.finishedAt = new Date().toISOString();
   saveTask(task);
   sendProcessAct(task, `Task saved as ${task.status}.`);
@@ -2376,11 +2351,20 @@ async function runTask(task) {
   }
 }
 
+// Machine-wide lock around actually running `npm test` (see createSerialQueue
+// in lib.mjs): the suite spawns real headless Chrome + real servers, so two
+// goals verifying at once compete for the same finite CPU/ports/tmp-dirs and
+// throw a DIFFERENT flaky failure each time — which then never converges
+// under the baseline-diff gate (postmortem: goal #552/#487, 2026-07-21; both
+// goals' actual requested feature was already correct). Only the expensive
+// test-run itself is serialized — planning/working on other goals is
+// unaffected, they just queue for their verification turn.
+const testRunQueue = createSerialQueue();
 // Manager-run tests (never trust the worker's "all green" claim): run the
 // project's own `npm test` in the goal's worktree and parse node --test's
 // "ℹ pass N / ℹ fail N" (or TAP "# pass/# fail"). Returns {ran,passed,failed,ok}.
 function runTestsOnce(dir) {
-  return new Promise((res) => {
+  return testRunQueue.run(() => new Promise((res) => {
     execFile('npm', ['test'], { cwd: dir, timeout: 240000, env: { ...process.env }, maxBuffer: 8 * 1024 * 1024 }, (e, out = '', err = '') => {
       const text = `${out}\n${err}`;
       const n = (re) => { const m = text.match(re); return m ? Number(m[1]) : null; };
@@ -2399,7 +2383,7 @@ function runTestsOnce(dir) {
       // diff them against the base's failures and block only on NEW ones.
       res({ passed, failed, detail: testOutputExcerpt(text), failingNames: parseFailingTestNames(text) });
     });
-  });
+  }));
 }
 async function runProjectTests(dir) {
   let hasTest = false;
@@ -2839,28 +2823,22 @@ async function verifyGate(goal, prProject, siblings, baseProject, activityTask =
     goalAct('Writing the review summary from the worker report and diff.');
     goal.reviewSummary = await summarizeForReview(goal, siblings, wdir, reviewDefinition);
   }
-  const uiTasks = siblings.filter((t) => isUiChange(t.changedFiles));
-  // Only require/capture proof for projects we can actually boot & screenshot
-  // (Manager-shaped). A generic web repo that edits a stylesheet can't be
-  // captured — it must still reach Review as a report, not be trapped in
-  // 'blocked' forever (PRD §4A/§6#1: block only what a human can't judge, not
-  // what the tool can't photograph).
-  const canCapture = canSnapshot(prProject);
-  if (shouldCaptureProof({ changedFiles: uiTasks.flatMap((t) => t.changedFiles ?? []), hasProof: uiTasks.some((t) => t.proof), canCapture })) {
-    const t = uiTasks[uiTasks.length - 1];
-    goalAct('UI changed and no proof is attached yet, so Manager is capturing proof now.');
-    for (let i = 0; i < 3 && !t.proof; i++) {
-      try {
-        goalAct(`Proof capture attempt ${i + 1}/3.`);
-        await captureSnapshotProof(t, prProject, { baselineDir: baseProject?.dir, goal });
-      } catch (e) {
-        goalAct(`Proof capture attempt ${i + 1}/3 failed: ${String(e.message ?? e).slice(0, 140)}`);
-      }
-    }
-    saveTask(t);
-  }
-  const proofMissing = canCapture && uiTasks.length > 0 && !uiTasks.some((t) => t.proof);
-  const proofFailing = canCapture && uiTasks.some((t) => t.proof && t.proof.pass === false);
+  // The goal-level proof retry loop (3 attempts to screenshot the Manager's own
+  // board) is gone with the rest of the staged-photo machinery — see the note
+  // where the per-task capture used to be. Nothing here photographs anything
+  // now; the human gets the worker's run declaration and its own report.
+  //
+  // proofMissing is retired with it, and deliberately not replaced. It meant
+  // "a UI task carries no auto-snapshot" — with no auto-snapshot left, keeping
+  // it would block every UI goal forever, and blocking a goal because WE failed
+  // to take a picture is exactly the Failed-manufacturing this product decided
+  // against (検証は薄く任意・Failed を作らない).
+  const proofMissing = false;
+  // A genuinely FAILED verification still blocks: this only ever comes from an
+  // explicit passCondition run (task.proof.verified), which is the opt-in strong
+  // path we keep. No canSnapshot() gate — that gate silently limited this to
+  // Manager-shaped repos.
+  const proofFailing = siblings.some((t) => t.proof && t.proof.pass === false);
   let testsFailing = goal.testResult.ran && goal.testResult.failed > 0;
   // Baseline diff (Masa 2026-07-19): block ONLY on failures THIS change
   // introduced. A test already red on the base — e.g. persist-failure on clean
@@ -2903,9 +2881,10 @@ async function verifyGate(goal, prProject, siblings, baseProject, activityTask =
   const verifyFail = reviewDefinition.requireVerifyPass && !allVerified;
   // 段5 検証ゲート厳格化 (Masa 2026-07-15: "proof無しは完了と言わない"): passCondition
   // を約束したタスクなのに 0 ファイル変更で proof も無い＝約束した検証が実行されずに
-  // すり抜けたサイン（isUiChange は changedFiles が空だと絶対に一致しないため、既存の
-  // proofMissing(UIタスク限定)はこのケースを検知できない）。passCondition が無い調査
-  // 系ゴール（0ファイルが正当な完了）は対象外 — 人間が読んで判断すれば足りる。
+  // すり抜けたサイン。passCondition が無い調査系ゴール（0ファイルが正当な完了）は
+  // 対象外 — 人間が読んで判断すれば足りる。
+  // これは「約束した強検証が走らなかった」検知であって、写真の有無ではない
+  // （P1で自動撮影と proofMissing は撤去済み）。
   const nothingVerifiable = isNothingVerifiable({
     changedFiles,
     hasPassCondition: siblings.some((t) => t.passCondition),
@@ -3659,21 +3638,37 @@ const server = createServer(async (req, res) => {
     return json(res, 200, task);
   }
 
-  // backfill a snapshot proof for a finished task (old reviews predate
-  // automatic UI snapshots and show "No capture yet" otherwise)
-  const snapMatch = url.pathname.match(/^\/api\/tasks\/(\d+)\/snapshot$/);
-  if (snapMatch && req.method === 'POST') {
-    const task = tasks.find((t) => t.id === Number(snapMatch[1]));
+  // Start what the worker said to start, and hand back the URL to look at.
+  //
+  // This is the "動かして見られる状態" the review card offers. It replaces the
+  // old POST /api/tasks/:id/snapshot (backfill a staged screenshot), which is
+  // gone along with the rest of the photo-staging.
+  //
+  // On demand, not always-on: a goal's preview costs a process, and most goals
+  // are never opened. Started here, reaped when idle.
+  const previewMatch = url.pathname.match(/^\/api\/tasks\/(\d+)\/preview$/);
+  if (previewMatch && req.method === 'POST') {
+    const task = tasks.find((t) => t.id === Number(previewMatch[1]));
     if (!task) return json(res, 404, { error: 'task not found' });
     if (!requireTaskGoalOwnership(req, res, task)) return;
-    const project = projects.find((p) => p.id === task.projectId);
-    if (!project || !canSnapshot(project)) return json(res, 409, { error: 'project cannot be snapshotted' });
-    captureSnapshotProof(task, project)
-      .then(() => json(res, 200, task))
+    if (!task.run) return json(res, 409, { error: 'no run declaration for this task' });
+    startPreview(task)
+      .then((p) => json(res, 200, p))
       .catch((e) => json(res, 500, { error: String(e.message ?? e).slice(0, 200) }));
     return;
   }
 
+  // The implementation log for one task, read on demand (see freezeActivityLog above).
+  // A task still running answers from memory — the same lines the SSE stream is feeding
+  // the page — so opening a card mid-run shows the work in progress, not an empty box.
+  const activityMatch = url.pathname.match(/^\/api\/tasks\/(\d+)\/activity$/);
+  if (activityMatch && req.method === 'GET') {
+    const task = tasks.find((t) => t.id === Number(activityMatch[1]));
+    if (!task) return json(res, 404, { error: 'task not found' });
+    if (!requireTaskGoalOwnership(req, res, task)) return;
+    return json(res, 200, { lines: task.activity?.length ? task.activity : readActivityLog(task.id) });
+  }
+
   // close a stalled task without running it (failure-taxonomy: skipped)
   const skipMatch = url.pathname.match(/^\/api\/tasks\/(\d+)\/skip$/);
   if (skipMatch && req.method === 'POST') {