@galda/cli 0.10.40 → 0.10.42

package/engine/server.mjs

@@ -21,8 +21,9 @@ 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, 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 { parseStreamEvents, parseCodexEvents, buildCodexArgs, parsePlan, refinePlanTasks, canEditGoal, canDeleteGoal, shouldAskClarification, workerExitReason, isForcedStop, taskStatusAfterVerify, 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, isInconclusiveTestRun, 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, parseGoalAddress, REPLY_OUTCOMES, REPLY_INTENTS, buildReplyIntentPrompt, parseReplyIntent, buildGoalMessage, serializeGoalMessage, parseGoalMessages } from './lib.mjs';
 import { createSerialQueue } from './lib.mjs';
+import { collectProjectRules } from './lib.mjs';
 import { openPR } from './pr.mjs';
 import { runVerification, exerciseUi } from './verify.mjs';
 
@@ -759,10 +760,43 @@ function readActivityLog(taskId) {
   try { return readFileSync(activityLogFile(taskId), 'utf8').split('\n').filter(Boolean); }
   catch { return []; }
 }
+
+// ---- the conversation on a goal (docs/design/ONE-CONVERSATION.md §1.1) -----
+// Append-only JSONL per goal. Unlike the activity log (frozen once, at the end
+// of a task) a conversation grows over the whole life of the goal, so it is
+// appended as it happens. Never sent with /api/state — read on demand by
+// GET /api/goals/:id/messages, so 100 cards don't drag 100 threads along.
+// goal.messageCount is the only thing state carries: a number, not content, so
+// the UI knows a thread exists without asking for one that was never written.
+const goalMessagesFile = (goalId) => join(logDir, `messages-${goalId}.jsonl`);
+function addGoalMessage(goal, { from, via, text, at } = {}) {
+  if (!goal) return null;
+  const msg = buildGoalMessage({ from, via, text, at });
+  if (!msg) return null;
+  try { appendFileSync(goalMessagesFile(goal.id), `${serializeGoalMessage(msg)}\n`); }
+  catch (e) { console.error(`[manager] goal message write failed for goal ${goal.id} (${e?.code || e})`); return null; }
+  goal.messageCount = (goal.messageCount ?? 0) + 1;
+  saveGoal(goal);
+  return msg;
+}
+function readGoalMessages(goalId) {
+  try { return parseGoalMessages(readFileSync(goalMessagesFile(goalId), 'utf8')); }
+  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;
+  // The AI's side of the conversation (§1.1): what the worker reported back,
+  // verbatim. Once per task — saveTask runs on every status change, so the flag
+  // is set before the persist below and rides along in the log entry.
+  if (ACTIVITY_TERMINAL.has(t.status) && t.result && !t.messageLogged) {
+    t.messageLogged = true;
+    addGoalMessage(goals.find((g) => g.id === t.goalId), {
+      from: 'ai', via: t.reply ? 'thread' : 'composer', text: t.result,
+    });
+  }
   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);
@@ -1221,6 +1255,12 @@ function detectRepos(homeDir) {
 // if worktrees can't be created (e.g. not a git repo).
 const goalWorkDirs = new Map();
 function goalWorkDir(goal, project) {
+  // Masa 2026-07-22: the isolated copy is now a choice, the way the Claude app's
+  // `worktree` checkbox is. Off = the work happens in the folder the person is looking
+  // at, which is what they want when they mean to watch it happen. On (the default)
+  // keeps today's behaviour: a private copy per goal, so a run can never leave their
+  // checkout half-edited.
+  if (goal?.worktree === false) return project.dir;
   const cached = goalWorkDirs.get(goal.id);
   if (cached && existsSync(cached)) return cached;
   let repoRoot;
@@ -1432,13 +1472,21 @@ async function planGoal(goal) {
     '- 各タスクの title は「ユーザーが頼んだこと」を、ユーザーの言葉・語彙をそのまま活かして短く書く。実装のやり方（「〜するように直した」「〜を計算する」等）や、完了報告の文（「〜した」「〜しました」）を title にしない。エンジニアリングの手順名（設計/実装/テスト等）にもしない。例: 依頼「一回たたむとsettingボタンがズレるバグ修正して」→ title「settingボタンがズレるバグの修正」（✕「アニメーションが終わってから歯車の位置を計算するように直した」）。',
     '- バグ修正の依頼では、title に「どの問題を直すか」がわかるように書く（解決する問題＝ユーザーの言葉）。依頼に直し方の方針が書かれていればそれも短く添えてよいが、無ければ問題だけでよい。工程・実装詳細は detail に書く。',
     '- detail には worker への完全な指示を書く：そのworkerが1人で実装・テスト・proofまで完結させる。工程ごとの兄弟タスクは来ない前提で書くこと。',
-    '- passCondition はユーザーが依頼文で明示的に検証条件（「成功条件:」「〜したら〜になる」等）を書いた場合のみ設定する。見た目の調整・文言変更・スタイル変更のタスクには付けない（null）。検証は高価なので、明示された時だけ。',
+    // passCondition is gone from this prompt on purpose (Masa 2026-07-22). The
+    // rule used to be "only when the user wrote one" — a rule this layer asked
+    // for and could not hold: measured twice on the identical request with no
+    // condition in it, the intake AI invented one on the first run and not on
+    // the second. The run where it invented one then failed its own invented
+    // check and forced a full rework (>100k tokens) that pushed the work
+    // TOWARD the wrong target. What to look at is the working AI's to state
+    // (`check` in .manager-run.json, #235) — the intake AI only read the
+    // request, so it cannot know what "correct" is.
     '- 検証対象のページがあれば entry に書く（プロジェクト相対のhtmlパス、または http URL。無ければ null）。依頼中に書かれていればそれを使い、無ければリポジトリを見て推測してよい。',
     '- 依頼が曖昧で重要な前提が1つ欠けている（例: 対象・範囲・形式が不明）か、既存の作業と矛盾する場合「のみ」、タスクではなく確認質問を返す: {"question":"確認したい1点（短く）","options":["選択肢A","選択肢B"]}。ただし基本は合理的な仮定で進めること。質問は本当に必要な時だけ、1問に絞る。',
     // Once the user has answered a clarification, NEVER ask again — re-asking looped
     // the answered question back onto the board. Override the rule above for re-plans.
     goal.clarified ? '【最重要】ユーザーは既にこの依頼への確認質問に回答済み（依頼文末尾に [確認: … → …] として反映済み）。これ以上、確認質問(question)を返してはならない。回答を前提に、必ずタスクへ分解して返すこと。' : '',
-    '- 出力はJSONのみ（前後に文章を書かない）。通常: {"entry":"path|null","tasks":[{"title":"ユーザーから見た成果（依頼と同じ言語で短く）","detail":"workerへの完全な指示","passCondition":"検証条件|null"}]} ／ 確認が要る時だけ: {"question":"...(依頼と同じ言語)","options":["...","..."]}',
+    '- 出力はJSONのみ（前後に文章を書かない）。通常: {"entry":"path|null","tasks":[{"title":"ユーザーから見た成果（依頼と同じ言語で短く）","detail":"workerへの完全な指示"}]} ／ 確認が要る時だけ: {"question":"...(依頼と同じ言語)","options":["...","..."]}',
     '',
     goal.priorFailureMemory?.length ? [
       '過去の失敗メモリ（同じ失敗を避けること）:',
@@ -1492,7 +1540,11 @@ async function planGoal(goal) {
   // 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.
+  // One card = one request. The pass condition no longer rides along at all:
+  // it was the last place where an AI that had only READ the request decided
+  // what "correct" means for it, and it did so at random (see the prompt note
+  // above). Nothing here sets one, so `entry` now only survives as the page a
+  // future explicit, user-written condition would open.
   const title = goalTaskTitle(goal.text);
   goal.plan = [title];
   saveGoal(goal);
@@ -1500,7 +1552,6 @@ async function planGoal(goal) {
   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);
@@ -1825,7 +1876,11 @@ function resumeProject(projectId) {
 
 // Slack風スレッド返信タスクの生成(/api/goals/:id/reply と /api/goals/:id/dismiss で共有)。
 // runTask()のtask.reply分岐がgoal.sessionIdをresumeに渡して同じ会話を続ける。
-function queueReplyTask(goal, text) {
+function queueReplyTask(goal, text, { from = 'manager', via = 'composer' } = {}) {
+  // Every follow-up on a goal is part of its conversation (§1.1). Recorded here
+  // rather than at each call site so an internally-generated nudge (auto-retest
+  // dismissal, fold-in) is kept too — with `from` saying whose words they are.
+  addGoalMessage(goal, { from, via, text });
   const failurePolicy = latestFailurePolicy(goal);
   const promptText = failurePolicy ? `${failurePolicy.text}\n\n${text}` : text;
   goal.executionPlan = buildExecutionPlan({
@@ -1863,6 +1918,38 @@ function queueReplyTask(goal, text) {
   return task;
 }
 
+// split (docs/design/ONE-CONVERSATION.md §1.3): 「それは別件」と返された時の受け皿。
+// 元のゴールには触らない——新しいチケットを1枚起こし、そこに「どこから生まれたか」だけ
+// 片方向の印（bornFrom）を残す。
+//
+// なぜ片方向か（Masa確定 2026-07-22）: 必要なのは「なぜこのチケットが在るか」だけで、
+// 2つをまとめて管理したいわけではない。関係を双方向にすると「解除」の仕組みまで要り、
+// 作られないまま残る仕組みが1つ増える。片方向なら片方が消えても壊れない。
+//
+// 設定は親から引き継ぐ（プロジェクト・エージェント・モデル・effort）。別件とはいえ
+// 同じ場所で同じ人が続けている作業なので、ここで選び直させる理由が無い。
+function createSplitGoal(parent, text, identity) {
+  const goal = {
+    id: nextId++, projectId: parent.projectId, text: text.slice(0, 8000), status: 'planning',
+    wantsPR: resolveWantsPR('auto', text, getReviewDefinition(parent.projectId).defaultWantsPR),
+    model: parent.model, effort: parent.effort, agent: parent.agent, mode: 'auto',
+    skill: null, images: [], source: resolveGoalSource('app'), sourceRef: null,
+    executionPlan: buildExecutionPlan({ projectId: parent.projectId, text, previousSession: false }),
+    plan: null, pr: undefined, createdAt: new Date().toISOString(),
+    // 片方向の印。表示は app（新しいカード「#N の会話から生まれました」／元のカード
+    // 「→ #M を切り出しました」）。engine は数字を1つ持つだけ。
+    bornFrom: parent.id,
+    owner: identity,
+  };
+  goals.push(goal);
+  saveGoal(goal);
+  addGoalMessage(goal, { from: 'you', via: 'review', text: goal.text });
+  planGoal(goal).catch((e) => {
+    goal.status = 'failed'; goal.prError = String(e).slice(0, 300); saveGoal(goal);
+  });
+  return goal;
+}
+
 function testOutputExcerpt(text) {
   const lines = String(text ?? '').split('\n').map((l) => l.trimEnd()).filter(Boolean);
   const interesting = lines.filter((l) =>
@@ -1990,7 +2077,24 @@ function readRunDeclaration(task, workDir) {
     return;
   }
   task.run = { ...run, dir: workDir };
-  sendProcessAct(task, `Worker declared how to see the result: ${run.cmd ?? run.url}`);
+  const how = run.cmd ?? run.url;
+  if (how) sendProcessAct(task, `Worker declared how to see the result: ${how}`);
+  if (run.title) sendProcessAct(task, `Worker named the work: ${run.title}`);
+  if (run.compare) sendProcessAct(task, `Worker declared a before/after pair: ${run.compare.join(' → ')}`);
+}
+
+// A declared pair only survives if both pictures actually arrived. The card
+// draws a red box over whatever differs between the two, so a name matching no
+// collected shot would leave the reviewer half a comparison — show the plain
+// screenshots and say why instead. Runs after the shots are collected.
+function reconcileComparePair(task) {
+  const pair = task.run?.compare;
+  if (!pair) return;
+  const have = new Set((task.shots ?? []).map((s) => s.name));
+  const missing = pair.filter((n) => !have.has(n));
+  if (!missing.length) return;
+  task.run = { ...task.run, compare: null };
+  sendAct(task, `before/after pair ignored — no screenshot named ${missing.join(', ')}`);
 }
 
 // Take whatever the worker photographed out of the worktree (SHOT_DIR) and put
@@ -2161,12 +2265,14 @@ async function runTask(task) {
     return;
   }
 
-  let verify = null, verdict = null, lastFailure = null, code = 0, result = '', usages = [], timedOut = false;
+  // No `lastFailure` any more: it existed only to tell the next attempt why our
+  // check had rejected the last one, and there is no next attempt now.
+  let verify = null, verdict = null, code = 0, result = '', usages = [], timedOut = false;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     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, workerAgent(task.agent ?? goal?.agent))].filter(Boolean).join('\n\n');
+    const prompt = [managerHandoffPrompt(goal, plan), workerPrompt(task, goal, null, 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,
@@ -2195,7 +2301,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, workerAgent(task.agent ?? goal?.agent)), cwd: workDir, tools: WORKER_TOOLS,
+        prompt: workerPrompt(task, goal, null, 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),
@@ -2234,12 +2340,14 @@ async function runTask(task) {
         eph?.kill();
       }
       sendAct(task, `verify: ${verdict.pass ? 'PASS' : verdict.inconclusive ? 'INCONCLUSIVE (check could not run)' : 'FAIL'} — ${verdict.detail.slice(0, 120)}`);
-      // An inconclusive verdict = the check itself couldn't run (authored check
-      // referenced hooks the app doesn't expose — #487). Retrying will just
-      // throw again, so stop and let it route to human review rather than
-      // burning attempts and scoring the change as failed.
-      if (verdict.pass || verdict.inconclusive) break;
-      lastFailure = verdict.detail;
+      // Whatever the verdict, the worker is not sent back (Masa 2026-07-22).
+      // A rework used to be triggered by a FAIL — and the check that produced
+      // the FAIL is something this layer authored from the request, not from
+      // the work. When it was wrong, the rework spent more than the whole
+      // original run and taught the AI to chase the wrong target. The failing
+      // check is reported in review instead; a human decides whether to ask
+      // for another pass. (Inconclusive already stopped here, #487.)
+      break;
     } catch (e) {
       sendAct(task, `verify: could not run — ${String(e.message ?? e).slice(0, 120)}`);
       verdict = null;
@@ -2249,28 +2357,21 @@ async function runTask(task) {
 
   if (goal?.cancelled) return; // deleted during the verify loop → don't resurrect the task
   task.secs = Math.round((Date.now() - t0) / 1000);
-  // Status decision, most-authoritative first:
+  // Status decision, most-authoritative first (taskStatusAfterVerify in lib):
   //  1. an independent verify PASS = verified success — wins even if the worker
   //     was force-stopped afterwards (the change is proven good).
   //  2. a forced STOP (10-min timeout / SIGTERM, exit 143) = 'interrupted', NOT
-  //     'failed' — it's a retryable halt, not "the worker's code was wrong". A
-  //     FAIL verdict on a killed (incomplete) worker isn't authoritative either,
-  //     so the stop reason takes precedence. (Mirrors the budget-breach path.)
-  //  3. a verify that actually ran and FAILED = 'failed'.
-  //  4. an INCONCLUSIVE verify (the check threw / returned garbage — the
-  //     verifier is at fault, not necessarily the change, #487) is NOT
-  //     authoritative: fall through to the exit code so a cleanly-finished
-  //     worker still reaches review for a human, instead of a false 'failed'.
-  //  5. no verify = the exit code decides.
+  //     'failed' — it's a retryable halt, not "the worker's code was wrong".
+  //  3. otherwise the exit code decides. A check that ran and FAILED no longer
+  //     scores 'failed' (Masa 2026-07-22) — it is reported in review like an
+  //     inconclusive one. Our check can be wrong about the work; a cleanly
+  //     finished worker must not be marked failed by it.
   const forcedStop = isForcedStop(code, timedOut);
   // A verdict only counts as authoritative when the check actually judged the
   // change. An inconclusive verdict (check threw / returned garbage) is treated
-  // like "no verdict" everywhere below — status, proof, and snapshot capture.
+  // like "no verdict" for the proof below.
   const conclusive = verdict && !verdict.inconclusive;
-  task.status = verdict?.pass ? 'done'
-    : forcedStop ? 'interrupted'
-    : conclusive ? 'failed'
-    : (code === 0 ? 'done' : 'failed');
+  task.status = taskStatusAfterVerify({ verdict, code, timedOut });
   // 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
@@ -2323,6 +2424,7 @@ async function runTask(task) {
   // deliverable, and it must not show up in the diff or the PR.
   readRunDeclaration(task, workDir);
   collectWorkerShots(task, workDir);
+  reconcileComparePair(task);
   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.`);
@@ -2364,8 +2466,11 @@ const testRunQueue = createSerialQueue();
 // 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) {
+  // The timeout is env-overridable so tests can force the killed-run path fast;
+  // production keeps the 4-minute default.
+  const runTimeout = Number(process.env.MANAGER_TEST_TIMEOUT_MS) || 240000;
   return testRunQueue.run(() => new Promise((res) => {
-    execFile('npm', ['test'], { cwd: dir, timeout: 240000, env: { ...process.env }, maxBuffer: 8 * 1024 * 1024 }, (e, out = '', err = '') => {
+    execFile('npm', ['test'], { cwd: dir, timeout: runTimeout, 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; };
       const passed = n(/ℹ pass (\d+)/) ?? n(/# pass (\d+)/) ?? n(/(\d+) passing/) ?? 0;
@@ -2379,9 +2484,15 @@ function runTestsOnce(dir) {
       const timeoutFlakes = (text.match(/did not report ready in time/g) || []).length;
       const realAssertion = /AssertionError|Expected values to be|expected .+ (?:to |but )/i.test(text);
       const failed = realAssertion ? failedTotal : Math.max(0, failedTotal - timeoutFlakes);
+      // Was the run KILLED at the execFile timeout (machine too saturated to
+      // finish), rather than exiting on its own? execFile sets killed=true and
+      // signal='SIGTERM' on timeout. That is the inconclusive signal — a normal
+      // non-zero exit (a small suite that printed `not ok` and exited 1) is NOT
+      // killed and must still be treated as a real result (isInconclusiveTestRun).
+      const timedOut = Boolean(e && (e.killed || e.signal === 'SIGTERM' || e.code === 'ETIMEDOUT'));
       // Capture the failing test NAMES too (not just the count) so the gate can
       // diff them against the base's failures and block only on NEW ones.
-      res({ passed, failed, detail: testOutputExcerpt(text), failingNames: parseFailingTestNames(text) });
+      res({ passed, failed, timedOut, realAssertion, detail: testOutputExcerpt(text), failingNames: parseFailingTestNames(text) });
     });
   }));
 }
@@ -2400,11 +2511,16 @@ async function runProjectTests(dir) {
     r = {
       passed: Math.max(r.passed, r2.passed),
       failed: Math.min(r.failed, r2.failed),
+      // Only an ALL-killed pair is inconclusive: if EITHER attempt exited on its
+      // own (timedOut=false) the result is conclusive. realAssertion is OR-ed so
+      // a real red in either run still fails closed.
+      timedOut: Boolean(r.timedOut && r2.timedOut),
+      realAssertion: r.realAssertion || r2.realAssertion,
       detail: kept.detail || r.detail || r2.detail || '',
       failingNames: kept.failingNames ?? r.failingNames ?? [],
     };
   }
-  return { ran: true, passed: r.passed, failed: r.failed, ok: r.failed === 0, detail: r.detail ?? '', failingNames: r.failingNames ?? [] };
+  return { ran: true, passed: r.passed, failed: r.failed, ok: r.failed === 0, timedOut: !!r.timedOut, realAssertion: !!r.realAssertion, detail: r.detail ?? '', failingNames: r.failingNames ?? [] };
 }
 
 // Failing tests on the BASE (pre-change) checkout — the set the review gate
@@ -2588,11 +2704,15 @@ async function summarizeForReview(goal, siblings, dir, reviewDefinition) {
   const lang = reviewDefinition.language === 'auto' ? detectRequestLanguage(goal.text) : (reviewDefinition.language || 'ja');
   const changed = [...new Set(siblings.flatMap((t) => t.changedFiles ?? []))].slice(0, 20);
   const reports = siblings.filter((t) => !t.reply).map((t) => `- ${t.title}: ${(t.result ?? '').replace(/\s+/g, ' ').slice(0, 300)}`).join('\n');
-  // fallback = current behavior: title/changed derived from the goal's own text,
-  // so a goal with no summary (AI failed or nothing to summarize) still shows a
-  // meaningful title/changed and never a blank or mis-phrased "…の修正".
+  // The name of the work, from the agent that did it (task.run.title). It wins
+  // over both the summarizer and the request text: the summarizer only ever read
+  // the same request the user typed, and the request text is the sentence the
+  // title is supposed to be an answer to. Masa 2026-07-22.
+  const declaredTitle = siblings.map((t) => t.run?.title).find(Boolean) ?? null;
+  // fallback: the request text, still — but now only when nobody named the work
+  // at all (an old worker, or one that wrote no declaration).
   const fallback = {
-    title: (goal.text ?? '').replace(/\s+/g, ' ').slice(0, 60),
+    title: declaredTitle ?? (goal.text ?? '').replace(/\s+/g, ' ').slice(0, 60),
     check: '',
     changed: (goal.plan?.[0] ?? goal.text ?? '').replace(/\s+/g, ' ').slice(0, 80),
   };
@@ -2600,7 +2720,8 @@ async function summarizeForReview(goal, siblings, dir, reviewDefinition) {
   const prompt = buildReviewSummaryPrompt({ lang, goalText: goal.text, changed, reports });
   try {
     const r = await runUtility({ prompt, cwd: dir, tools: 'Read' });
-    return parseReviewSummary(r.result, fallback);
+    const summary = parseReviewSummary(r.result, fallback);
+    return declaredTitle ? { ...summary, title: declaredTitle } : summary;
   } catch { /* fall through */ }
   return fallback;
 }
@@ -2734,7 +2855,7 @@ async function finishGoalIfComplete(goal, project, activityTask = null) {
     // The target re-opens: it has new work to do, and createGoalPR's rework path
     // will push the result onto the PR branch it already owns.
     foldTarget.status = 'running';
-    queueReplyTask(foldTarget, goal.text.slice(0, 8000));
+    queueReplyTask(foldTarget, goal.text.slice(0, 8000), { from: 'you', via: 'composer' });
     saveGoal(foldTarget);
     // The folded goal keeps its row (PRD §3.5: a submission is never dropped) —
     // it becomes a pointer at the goal that now carries its work.
@@ -2840,6 +2961,16 @@ async function verifyGate(goal, prProject, siblings, baseProject, activityTask =
   // Manager-shaped repos.
   const proofFailing = siblings.some((t) => t.proof && t.proof.pass === false);
   let testsFailing = goal.testResult.ran && goal.testResult.failed > 0;
+  // Inconclusive run (2026-07-23): the suite was killed before it could finish
+  // (0 passed, no summary, no real assertion) — the machine was too saturated to
+  // run the tests, not the code failing. Blocking a finished goal (with a PR) on
+  // that stranded #602/#604. Treat it like the infra-flake discount above: don't
+  // block, note it, and let a human re-run when the machine is idle.
+  if (testsFailing && isInconclusiveTestRun(goal.testResult)) {
+    testsFailing = false;
+    goal.testResult.inconclusive = true;
+    goalAct('Project tests could not complete — the suite was killed before finishing (0 passed, no real assertion), which means the machine was too saturated to run them, not a code failure. Treating as inconclusive, not blocking. Re-run the tests when the machine is idle to confirm.');
+  }
   // 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
   // origin/main — is pre-existing noise and must not knock a proof-verified
@@ -3159,7 +3290,14 @@ const server = createServer(async (req, res) => {
       price: await getBillingPrice(),
       siteUrl: BILLING_API_URL || null,
     };
-    return json(res, 200, { projects, goals: visibleGoals, tasks: trimTaskActivityForState(visibleTasks), models: MODELS, agentModels: { 'claude-code': MODELS, codex: CODEX_MODELS }, agentEfforts: { 'claude-code': CLAUDE_EFFORTS, codex: CODEX_EFFORTS }, agents: AVAILABLE_AGENTS, connectCommand, queueOrder, externalActivity, workflowColumns: projectColumns, reviewDefinitions: projectReviewDefs, runningCounts, parallelLimits, uiVersion: uiVersion(), billing, auth: publicAuth() });
+    // The branch each project is on — the Context Bar prints it next to the folder, and
+    // it is read here rather than guessed (a branch nobody can see is not a branch).
+    const projectsWithBranch = projects.map((p) => {
+      let branch = null;
+      try { branch = gitSync(p.dir, ['rev-parse', '--abbrev-ref', 'HEAD']); } catch { /* not a repo → no branch, and the bar shows none */ }
+      return branch ? { ...p, branch } : p;
+    });
+    return json(res, 200, { projects: projectsWithBranch, goals: visibleGoals, tasks: trimTaskActivityForState(visibleTasks), models: MODELS, agentModels: { 'claude-code': MODELS, codex: CODEX_MODELS }, agentEfforts: { 'claude-code': CLAUDE_EFFORTS, codex: CODEX_EFFORTS }, agents: AVAILABLE_AGENTS, connectCommand, queueOrder, externalActivity, workflowColumns: projectColumns, reviewDefinitions: projectReviewDefs, runningCounts, parallelLimits, uiVersion: uiVersion(), billing, auth: publicAuth() });
   }
 
   // Billing (docs/BILLING-LAUNCH-PLAN.md): activate the license key a user
@@ -3287,6 +3425,32 @@ const server = createServer(async (req, res) => {
     return json(res, r.action === 'busy' ? 409 : 200, r);
   }
 
+  // The folders a person could actually point a project at: the git repos sitting
+  // directly under HOME. A browser cannot open an OS folder dialog that yields a real
+  // path (showDirectoryPicker hands back a handle, never a path), so a detected list
+  // plus typing a path IS the picker — and the detection already existed here, feeding
+  // the "which folder?" question card. This endpoint only exposes what it already
+  // finds; nothing new is scanned, invented, or ranked.
+  if (url.pathname === '/api/repos' && req.method === 'GET') {
+    return json(res, 200, { repos: detectRepos(HOME), home: HOME });
+  }
+
+  // The project's working rules (ONE-CONVERSATION §1.5a): the settings panel
+  // shows a read-only view of whichever of CLAUDE.md / AGENTS.md exist in the
+  // project dir — the instructions the connected AI actually reads. The browser
+  // can't touch the filesystem, so it reads them here. Filenames are fixed
+  // (collectProjectRules), so `project.dir` is the only path input and there is
+  // no traversal surface.
+  const rulesMatch = url.pathname.match(/^\/api\/projects\/([\w-]+)\/rules$/);
+  if (rulesMatch && req.method === 'GET') {
+    const project = projects.find((p) => p.id === rulesMatch[1]);
+    if (!project) return json(res, 404, { error: 'project not found' });
+    const files = collectProjectRules(project.dir, (dir, name) => {
+      try { return readFileSync(join(dir, name), 'utf8'); } catch { return null; }
+    });
+    return json(res, 200, { dir: project.dir, files });
+  }
+
   if (url.pathname === '/api/projects' && req.method === 'POST') {
     let body = '';
     req.on('data', (d) => { body += d; });
@@ -3337,6 +3501,21 @@ const server = createServer(async (req, res) => {
       try {
         const input = JSON.parse(body || '{}');
         if (typeof input.name === 'string' && input.name.trim()) project.name = input.name.trim().slice(0, 80);
+        // Moving a project to another folder. Refused loudly when the path is not
+        // somewhere work can happen: a folder that does not exist, or is HOME itself,
+        // or is not a git repository. Accepting it here would look like it worked and
+        // then fail silently on the next goal — the worst of the two failures, and the
+        // reason the "which folder?" card exists at all.
+        if (input.dir !== undefined) {
+          const dir = String(input.dir ?? '').trim();
+          if (!dir) return json(res, 400, { error: 'folder is required' });
+          const abs = dir.startsWith('~') ? join(HOME, dir.slice(1)) : resolve(dir);
+          if (!existsSync(abs)) return json(res, 400, { error: 'no such folder', dir: abs });
+          if (needsProjectFolder({ dir: abs, homeDir: HOME, isRepo: isGitRepo(abs) })) {
+            return json(res, 400, { error: 'not a git repository', dir: abs });
+          }
+          project.dir = abs;
+        }
         saveProjects();
         send({ ev: 'projects', projects });
         return json(res, 200, { project, projects });
@@ -3383,7 +3562,7 @@ const server = createServer(async (req, res) => {
     req.on('data', (d) => { body += d; });
     req.on('end', async () => {
       try {
-        const { projectId, text, pr, images, model, effort, source, pending, review, note, mode, skill, agent } = JSON.parse(body);
+        const { projectId, text, pr, images, model, effort, source, pending, review, note, mode, skill, agent, worktree } = JSON.parse(body);
         const project = projects.find((p) => p.id === projectId);
         if (!project || !text?.trim()) return json(res, 400, { error: 'projectId and text required' });
         // Chat-driven play/pause (Masa: "チャットで再生一時停止はおせる"). Deterministic
@@ -3401,6 +3580,32 @@ const server = createServer(async (req, res) => {
             return json(res, 200, { kind: 'chat', reply: `${project.name} を再開しました。止めた作業を続きから進めます。` });
           }
         }
+        // 宛先 (docs/design/ONE-CONVERSATION.md §1.2): 「#12 の件だけど…」と書けたら、
+        // その番号のチケット宛て。決定論——我々の層は何も推測しない。
+        //
+        // Checked BEFORE the chat/task classifier on purpose: writing a number is an
+        // explicit statement of where the words go, and a guess (however cheap) must
+        // not be able to overrule it. "#12 これで合ってる?" reads as chat to the
+        // heuristic; it is a follow-up on #12.
+        //
+        // Falls through silently when the number names nothing this person can act on
+        // (unknown id, another project, someone else's goal, already finished). The
+        // words then become a new ticket, which is what happens today anyway — a typo
+        // must never make a request disappear.
+        const identity = identityFor(req);
+        if (!pending && !review) {
+          const addr = parseGoalAddress(text);
+          const target = addr && goals.find((g) => g.id === addr.goalId
+            && g.projectId === projectId
+            && goalVisibleTo(g, identity, MANAGER_OWNER_EMAIL)
+            && !['done', 'reverted', 'skipped', 'rejected'].includes(g.status));
+          if (target) {
+            // A follow-up on a goal already awaiting review re-opens work on it.
+            if (target.status === 'review') { target.status = 'running'; saveGoal(target); }
+            const replyTask = queueReplyTask(target, text.trim().slice(0, 8000), { from: 'you', via: 'composer' });
+            return json(res, 200, { ...target, addressedTo: target.id, replyTaskId: replyTask.id });
+          }
+        }
         // Onboarding (docs/HANDOFF-ONBOARDING-conversational.md, SLICE 2): the
         // composer is conversation-first. A chat/help/settings message ("what can
         // you do?", "reply in English", a greeting) gets a conversational reply
@@ -3427,29 +3632,14 @@ const server = createServer(async (req, res) => {
             if (parsed.intent === 'chat') return json(res, 200, { kind: 'chat', reply: parsed.reply.slice(0, 2000), lang: intentLang });
           } catch { /* LLM unavailable → fall through to goal creation */ }
         }
-        // Dedupe (Masa: 被ったやつもまとめて): if this near-duplicates a goal
-        // already in flight (running/review with a live worker session), fold it
-        // in as a thread follow-up (context kept via session resume) instead of
-        // piling up a redundant parallel goal. Conservative — HIGH-confidence
-        // text overlap only, against session-bearing active goals — so a
-        // genuinely distinct ask always becomes its own goal, and the user's
-        // text is never dropped (it becomes a reply task either way). Skipped for
-        // pending (shelved) and review-only (human-only) items.
-        const identity = identityFor(req);
-        if (!pending && !review) {
-          // Stage 2: only fold into a goal this identity can actually see —
-          // otherwise a near-duplicate message from user B could silently
-          // attach as a reply task onto someone else's private goal (and
-          // leak that goal's text back to B in the response).
-          const candidates = goals.filter((g) => g.projectId === projectId && g.sessionId && ['running', 'review'].includes(g.status) && goalVisibleTo(g, identity, MANAGER_OWNER_EMAIL));
-          const overlap = findOverlappingGoal(text.trim(), candidates);
-          if (overlap) {
-            // A follow-up on a goal already awaiting review re-opens work on it.
-            if (overlap.goal.status === 'review') { overlap.goal.status = 'running'; saveGoal(overlap.goal); }
-            const replyTask = queueReplyTask(overlap.goal, text.trim().slice(0, 8000));
-            return json(res, 200, { ...overlap.goal, mergedInto: overlap.goal.id, replyTaskId: replyTask.id, overlapScore: overlap.score });
-          }
-        }
+        // (REMOVED 2026-07-22, ONE-CONVERSATION.md §1.2) The 0.72 auto-merge used to
+        // sit here: any new request whose WORDS looked ~72% like an in-flight goal was
+        // silently folded into it as a follow-up. That was our layer guessing "this is
+        // probably the same thing" — the exact move this product exists to stop doing.
+        // When it was right nobody noticed; when it was wrong the request vanished into
+        // someone else's ticket. Replaced by the address above: the person says which
+        // ticket, or it becomes its own.
+        //
         // Billing (docs/BILLING-LAUNCH-PLAN.md §2/§5): gate actual new-goal
         // creation on the free tier / paid entitlement. Placed after the
         // dedupe fold-in above on purpose — folding into an existing goal as
@@ -3502,6 +3692,11 @@ const server = createServer(async (req, res) => {
           mode: (!review && GOAL_MODES.includes(mode)) ? mode : 'auto',
           // SKILL: an optional user/project skill (or command) to invoke first.
           skill: (typeof skill === 'string' && skill.trim()) ? skill.trim().slice(0, 80) : null,
+          // WORKTREE (Masa 2026-07-22, the Claude app's own checkbox): true/undefined =
+          // a private copy per goal, which is what has always happened. Explicit false =
+          // work in the folder the person is looking at. Only an explicit false is
+          // stored, so every goal ever written keeps meaning what it meant.
+          worktree: worktree === false ? false : undefined,
           images: Array.isArray(images) ? images.slice(0, 6) : [],
           source: resolveGoalSource(source), sourceRef: null,
           executionPlan: buildExecutionPlan({
@@ -3517,6 +3712,10 @@ const server = createServer(async (req, res) => {
         };
         goals.push(goal);
         saveGoal(goal);
+        // The conversation starts with what the person actually asked for, so a
+        // thread opened later reads from the beginning instead of starting at
+        // the first follow-up (§1.1: 入口が違っても1本の列).
+        addGoalMessage(goal, { from: 'you', via: 'composer', text: goal.text, at: goal.createdAt });
         // pending = deliberately shelved (Phase 2 material): never planned,
         // never queued, until POST /api/goals/:id/activate. review-only items
         // are terminal-until-human too, so they also skip planGoal.
@@ -3669,6 +3868,17 @@ const server = createServer(async (req, res) => {
     return json(res, 200, { lines: task.activity?.length ? task.activity : readActivityLog(task.id) });
   }
 
+  // The conversation on one goal, read on demand (see addGoalMessage above).
+  // Deliberately NOT part of /api/state: every card would drag its whole thread
+  // along on every poll. Same "only when asked" shape as the implementation log.
+  const messagesMatch = url.pathname.match(/^\/api\/goals\/(\d+)\/messages$/);
+  if (messagesMatch && req.method === 'GET') {
+    const goal = goals.find((g) => g.id === Number(messagesMatch[1]));
+    if (!goal) return json(res, 404, { error: 'goal not found' });
+    if (!requireGoalOwnership(req, res, goal)) return;
+    return json(res, 200, { messages: readGoalMessages(goal.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') {
@@ -4008,7 +4218,7 @@ const server = createServer(async (req, res) => {
           goal.blocked = null;
           saveGoal(goal);
         }
-        json(res, 200, queueReplyTask(goal, text.trim()));
+        json(res, 200, queueReplyTask(goal, text.trim(), { from: 'you', via: 'thread' }));
       } catch { json(res, 400, { error: 'bad json' }); }
     });
     return;
@@ -4198,6 +4408,58 @@ const server = createServer(async (req, res) => {
     return json(res, 200, payload);
   }
 
+// 返事の行き先を AI 本人に決めてもらう (ONE-CONVERSATION.md §1.4)。
+//
+// 判定は1往復だけの軽い仕事なので、作業した本人ではなくユーティリティのモデルに
+// 聞く（答えを書く answer 本体は本人に聞く——あちらは中身を知っている必要がある）。
+// 呼べなかった時は 'unsure'。「たぶん continue」で走り出すより、人に1タップ選ばせる
+// ほうが安い。
+async function judgeReplyIntent(goal, reply) {
+  let parsed;
+  try {
+    const r = await runUtility({ prompt: buildReplyIntentPrompt({ goalText: goal.text, reply }), cwd: ROOT, tools: 'Read' });
+    parsed = parseReplyIntent(r.result);
+  } catch { parsed = { outcome: 'unsure', read: false }; }
+  // Could not ask at all → do what a reply has always done (continue). Blocking the
+  // reply on four choices would leave a machine with no reachable agent unable to
+  // send anything back, and an answer could not have been written there anyway.
+  return parsed.read ? parsed.outcome : 'continue';
+}
+
+// 「聞いてるだけ」への返事 (ONE-CONVERSATION.md §1.3 answer)。
+//
+// 答えるのは**作業した AI 本人**＝ goal.sessionId を resume する。状況一覧しか
+// 知らない別AIでは「なぜそうしたか」に答えられない（Masa確定 2026-07-22）。
+// コードは1文字も変わらない: ツールは Read だけ、permissionMode は 'plan'
+// （Codex 側は read-only サンドボックスに落ちる）。タスクも作らないので看板も
+// 動かない——answer は「何も動かさない」が仕様。
+// 失敗しても人が待ちぼうけにならないよう、理由を manager の発言として会話に残す。
+async function answerGoalQuestion(goal, question) {
+  const project = projects.find((p) => p.id === goal.projectId);
+  const cwd = project?.dir && existsSync(project.dir) ? project.dir : ROOT;
+  const prompt = [
+    'あなたが担当した作業について、依頼者から質問が来ています。',
+    'コードは変更せず（読み取りしかできません）、質問にだけ簡潔に答えてください。',
+    'これは作り直しの指示ではありません。答えだけを書いてください。',
+    '',
+    `依頼: ${String(goal.text ?? '').slice(0, 800)}`,
+    `質問: ${question.slice(0, 1000)}`,
+  ].join('\n');
+  try {
+    const r = await runWorkerAgent({
+      agent: goal.agent, model: goal.model, prompt, cwd,
+      tools: 'Read', permissionMode: 'plan',
+      resume: goal.sessionId ?? undefined,
+      onChild: (c) => trackGoalWorker(goal.id, c),
+    });
+    const answer = String(r?.result ?? '').trim();
+    if (answer) addGoalMessage(goal, { from: 'ai', via: 'review', text: answer });
+    else addGoalMessage(goal, { from: 'manager', via: 'review', text: '答えが空でした。もう一度聞いてみてください。' });
+  } catch (e) {
+    addGoalMessage(goal, { from: 'manager', via: 'review', text: `答えられませんでした: ${String(e?.message ?? e).slice(0, 200)}` });
+  }
+}
+
   // レビュー詳細パネルのDismissボタン: 修正指示(空でも「差し戻し」扱い)をgoalのスレッド
   // 返信としてworkerに渡し、goalをrunning(doing相当)へ戻す。
   const dismissMatch = url.pathname.match(/^\/api\/goals\/(\d+)\/dismiss$/);
@@ -4213,17 +4475,74 @@ const server = createServer(async (req, res) => {
       saveGoal(goal);
       return json(res, 200, { goal });
     }
-    const result = dismissGoal({ goalStatus: goal.status });
-    if (!result.ok) return json(res, 409, { error: result.error });
+    if (goal.status !== 'review') return json(res, 409, { error: dismissGoal({ goalStatus: goal.status }).error });
     let body = '';
     req.on('data', (d) => { body += d; });
-    req.on('end', () => {
-      let text = '';
-      try { text = String(JSON.parse(body || '{}').text ?? '').trim(); } catch {}
+    req.on('end', async () => {
+      let text = '', outcome = 'continue', auto = false;
+      try {
+        const parsed = JSON.parse(body || '{}');
+        text = String(parsed.text ?? '').trim();
+        if (REPLY_OUTCOMES.includes(parsed.outcome)) outcome = parsed.outcome;
+        auto = parsed.outcome === 'auto';
+      } catch {}
+
+      // outcome:'auto' = 決めるのは AI 本人 (§1.4)。人の言葉を1回だけ渡して、返って
+      // きた行き先のとおりに配線する。我々はキーワードも類似度も見ない。
+      // 迷ったと言われたら**ゴールに触らずに**選択肢を返す——ここで勝手に continue に
+      // 倒すと、質問しただけの人のコードが動き出す（それが直したかった壊れ方）。
+      if (auto) {
+        if (!text) return json(res, 400, { error: 'text required' });
+        const judged = await judgeReplyIntent(goal, text);
+        if (judged === 'unsure') return json(res, 200, { goal, outcome: 'unsure', choices: REPLY_OUTCOMES });
+        outcome = judged;
+      }
+      // 返事の行き先4種 (ONE-CONVERSATION.md §1.3). 既定は今までどおり continue なので、
+      // outcome を送ってこない今の UI の挙動は1ミリも変わらない。
+      const result = dismissGoal({ goalStatus: goal.status, outcome });
+      if (!result.ok) return json(res, 409, { error: result.error });
+
+      // split: 元のゴールには触らない。新しいチケットが1枚生まれるだけ。
+      if (result.splits) {
+        if (!text) return json(res, 400, { error: 'text required to split' });
+        // 新しいゴールが1枚増える＝無料枠の対象。continue/rescope は増えないので通らない。
+        const gate = await requireEntitlementGate(identityFor(req));
+        if (!gate.allowed) return json(res, 402, { error: 'free-tier limit reached', blocked: gate.blocked });
+        addGoalMessage(goal, { from: 'you', via: 'review', text });
+        const born = createSplitGoal(goal, text, identityFor(req));
+        return json(res, 200, { goal, outcome, splitInto: born.id, born });
+      }
+
+      // answer: 聞かれただけ。ゴールは review のまま、ワーカーも起こさない（§1.3）。
+      // 答えるのは**その作業をやった AI 本人**（goal.sessionId を resume）なので
+      // 「なぜそうしたか」に答えられる。HTTP は待たせない——答えは会話に1発言
+      // 積まれ、SSE の goal イベント（messageCount）で画面に出る。
+      if (result.answers) {
+        if (!text) return json(res, 400, { error: 'text required to answer' });
+        addGoalMessage(goal, { from: 'you', via: 'review', text });
+        json(res, 200, { goal, outcome, answering: true });
+        answerGoalQuestion(goal, text);
+        return;
+      }
+
+      // rescope: チケットの文章が書き換わるのはここだけ。人が「そうじゃなくて、こう」と
+      // 言い直した以上、古い依頼文を掲げたままにするのは嘘になる。元の言葉は会話に残る
+      // （§1.1）ので失われない。
+      // 断る判定はゴールに触る前に済ませる——400 を返しながら状態だけ動いていた、が
+      // 一番たちの悪い壊れ方。
+      if (result.rewritesText) {
+        if (!text) return json(res, 400, { error: 'text required to rescope' });
+        addGoalMessage(goal, { from: 'you', via: 'review', text });
+        goal.text = text.slice(0, 8000);
+      }
       goal.status = result.status;
       saveGoal(goal);
-      const task = queueReplyTask(goal, text || '差し戻し。修正してください。');
-      json(res, 200, { goal, task });
+      // rescope はワーカーを起こさない——「いったん止めて考え直す」なので、走り出したら
+      // 意味が無い。To Do の下で Start を待つ。
+      if (!result.spawnsWorker) return json(res, 200, { goal, outcome });
+
+      const task = queueReplyTask(goal, text || '差し戻し。修正してください。', { from: text ? 'you' : 'manager', via: 'review' });
+      json(res, 200, { goal, outcome, task });
     });
     return;
   }