@galda/cli 0.10.95 → 0.10.97

package/app/index.html

@@ -1920,6 +1920,11 @@
     box-shadow:inset 0 0 0 1px rgba(var(--green-rgb),.30);font:600 12px/1 var(--ui);cursor:pointer;display:inline-flex;align-items:center;gap:7px}
   .sa-app:hover{box-shadow:inset 0 0 0 1px var(--green);background:rgba(var(--green-rgb),.12)}
   .sa-app svg{width:12px;height:12px;fill:none;stroke:currentColor;stroke-width:2.4;stroke-linecap:round;stroke-linejoin:round}
+  .sa-approve-wrap{display:flex;flex-direction:column;align-items:flex-start;gap:5px;flex:0 0 auto}
+  .sa-approve-wrap + .sa-dis{align-self:flex-start}
+  .sa-delivery{font:500 9.5px/1.15 var(--mono);color:var(--ink3);text-decoration:none;white-space:nowrap}
+  a.sa-delivery{color:var(--green)}
+  a.sa-delivery:hover{text-decoration:underline}
   .sa-dis{height:32px;padding:0 13px;border:0;border-radius:9px;background:color-mix(in srgb,var(--danger) 8%,var(--panel));
     color:color-mix(in srgb,var(--danger) 70%,var(--ink));box-shadow:inset 0 0 0 1px rgba(var(--danger-rgb),.25);font:500 12px/1 var(--ui);cursor:pointer}
   .sa-dis:hover{box-shadow:inset 0 0 0 1px var(--danger);background:color-mix(in srgb,var(--danger) 8%,var(--panel))}
@@ -2208,6 +2213,30 @@
   .redesign .reqbody .lg-splitnote .hd{font:600 8.5px/1 var(--mono);letter-spacing:.08em;text-transform:uppercase;color:var(--ink3);margin-bottom:7px}
   .redesign .reqbody .lg-splitnote ul{margin:0;padding:0;list-style:none;font-size:12px;line-height:1.8;color:var(--ink3)}
   .redesign .reqbody .lg-splitnote li.cur{color:var(--ink)} .redesign .reqbody .lg-splitnote li.cur b{color:var(--green);font-weight:600}
+  /* Request stack (2026-07-29, Masa: "This reviewをやめてRequestに2発目・3発目として
+     積み上げる"): every ask on this goal as a numbered list, most recent emphasised.
+     Replaces the single Request paragraph + separate "This review" section. */
+  .redesign .rqlist{display:flex;flex-direction:column;gap:12px;margin-top:2px}
+  .redesign .rqit{display:flex;gap:10px;align-items:baseline}
+  .redesign .rqit .rqn{flex:0 0 16px;font:600 12px/1.5 var(--mono);color:var(--ink3);font-variant-numeric:tabular-nums}
+  .redesign .rqit .rqbody{flex:1;min-width:0}
+  /* §2 forces .rask to full-contrast ink !important everywhere else in the card (it's
+     the user's own words, never faded) — the Request stack is the one place that rule
+     is deliberately overridden: only the LATEST ask reads at full weight. */
+  .redesign .rqit .rqbody .rbody.rask{color:var(--ink2) !important}
+  .redesign .rqit.latest .rqn{color:var(--blue,#7C9EFF)}
+  .redesign .rqit.latest .rqbody .rbody.rask{color:var(--ink) !important;font-weight:600}
+  /* Changed/Tests aligns with the request TEXT, not the number/chevron — same 18px
+     the fold body below uses, so both sit under the same column (Masa 2026-07-29). */
+  .redesign .rqit .rqev{font-size:12px;color:var(--ink3);margin:5px 0 0;padding-left:18px}
+  /* A long ask folds with the SAME .lacc pulldown Activity/Conversation use — chevron on
+     the peek line, body is the genuine rest (no duplicate, no trailing "…": Masa
+     2026-07-29 flagged both the vertical anchor line and the "…" as unnecessary — the
+     chevron plus the aligned indent already say "there's more" on their own). */
+  .redesign .rqit .rqfold{margin-top:0}
+  .redesign .rqit .rqfold>summary{gap:9px}
+  .redesign .rqit .rqfold .lbody{margin-top:4px;padding-left:18px}
+  .redesign .rqit.latest .rqfold .lbody .rbody.rask{color:var(--ink) !important}
   /* workflow (spec §8) — vertical ✓ green / → green / □ dim */
   .redesign .rwf{display:flex;flex-direction:column;gap:2px;margin:10px 0 0 !important;font-family:var(--ui);font-size:12px;letter-spacing:-.004em;color:var(--ink3)}
   .redesign .rwf .wf-s{display:flex;align-items:center;gap:9px}
@@ -9772,6 +9801,30 @@ function saWorkflowHtml(it){
   const steps = [['Implemented', atImplemented ? 'now' : 'ok'], ['Tested', ran ? 'ok' : 'todo'], ['In review', atImplemented ? 'todo' : 'now'], ['Merge', 'todo']];
   return '<div class="rwf">' + steps.map(([s, st]) => `<div class="wf-s ${st}"><span class="mk">${st === 'ok' ? '✓' : st === 'now' ? '→' : '□'}</span>${s}</div>`).join('') + '</div>';
 }
+// Request stack rows (2026-07-29): shared by saItemHtml's first paint and
+// saLoadMessages's patch once the conversation fetch lands (see its call site) —
+// one function so the fold/no-duplicate rule stays identical in both places.
+function saReqStackRows(it, attemptEvidence){
+  const gk = it.goalId;
+  const reqMsgs = SA.msgs[gk];
+  const reqAsks = Array.isArray(reqMsgs) ? reqMsgs.filter((m) => m?.from === 'you' && String(m.text || '').trim()) : [];
+  const reqItems = reqAsks.length ? reqAsks : (it.goalText ? [{ text: it.goalText }] : []);
+  return reqItems.map((m, idx) => {
+    const text = String(m.text || '').trim();
+    const isLatest = idx === reqItems.length - 1;
+    const evLine = isLatest && attemptEvidence ? `<p class="rqev">${esc(attemptEvidence)}</p>` : '';
+    const body = shouldFoldRequestText(text)
+      ? (() => {
+          const peek = text.slice(0, REQUEST_PEEK_CHARS).trimEnd();
+          const rest = text.slice(peek.length).trimStart();
+          const key = `${gk}:req${idx}`;
+          const open = SA.detOpen.has(key);
+          return `<details class="lacc rqfold" data-detkey="${key}"${open ? ' open' : ''}><summary><i class="ltog">›</i><p class="rbody rask">${esc(peek)}</p></summary><div class="lbody"><p class="rbody rask">${esc(rest)}</p></div></details>`;
+        })()
+      : `<p class="rbody rask">${esc(text)}</p>`;
+    return `<div class="rqit${isLatest ? ' latest' : ''}"><span class="rqn">${idx + 1}</span><div class="rqbody">${body}${evLine}</div></div>`;
+  }).join('');
+}
 function saItemHtml(it, i){
   // st===3 is NOT a terminal row (REVIEW-FEEDBACK-FLOW 決定3): a reply is not a dismissal.
   // The old sa-done "feedback returned to To Do" line is gone; st===3 now renders the full
@@ -9860,22 +9913,11 @@ function saItemHtml(it, i){
   // no left rule) — not a bespoke widget (Masa 2026-07-27: "他の›と同じルールじゃなくない?").
   // §4 assumed Request was always short, which a mispaste can break; this reuses the one
   // pulldown shape the card already has rather than inventing a second one. ──
-  const reqFold = it.goalText && shouldFoldRequestText(it.goalText);
-  const reqOpen = reqFold && SA.detOpen.has(`${gk}:req`);
-  const reqPeek = reqFold ? `${it.goalText.slice(0, REQUEST_PEEK_CHARS).trimEnd()}…` : '';
-  const reqSec = !it.goalText ? '' : reqFold
-    ? `<section class="rsec rreq"><div class="rsec-h">Request</div><details class="lacc" data-detkey="${gk}:req"${reqOpen ? ' open' : ''}><summary><i class="ltog">›</i><p class="rbody rask lfirst">${esc(reqPeek)}</p></summary><div class="lbody"><p class="rbody rask">${esc(it.goalText)}</p></div></details></section>`
-    : `<section class="rsec rreq"><div class="rsec-h">Request</div><p class="rbody rask">${esc(it.goalText)}</p></section>`;
   // The active attempt is intentionally a compact fact row, not a second
   // interpretation of the request. It makes the latest reply, files and
   // verification visible together while prior attempts stay in Conversation.
   const attempt = it.attempt;
-  const activeText = String(attempt?.activeRequirement?.text || '').replace(/\s+/g, ' ').trim();
   const requestText = String(it.goalText || '').replace(/\s+/g, ' ').trim();
-  // A single requirement is commonly recorded verbatim from the Request. Do
-  // not make the review read it back as a second section; keep this section for
-  // a narrowed retry requirement or concrete run evidence instead.
-  const reviewText = activeText && activeText !== requestText ? activeText : '';
   const attemptFiles = Array.isArray(attempt?.changedFiles) ? attempt.changedFiles.filter(Boolean) : [];
   const attemptTests = attempt?.verification?.tests;
   const attemptProof = attempt?.verification?.proof;
@@ -9884,8 +9926,23 @@ function saItemHtml(it, i){
     attemptTests?.ran ? `Tests: ${attemptTests.passed ?? 0} passed${attemptTests.failed ? ` / ${attemptTests.failed} failed` : ''}` : '',
     attemptProof?.pass === true ? 'Proof recorded' : '',
   ].filter(Boolean).join(' · ');
-  const attemptSec = reviewText || attemptEvidence
-    ? `<section class="rsec"><div class="rsec-h">This review</div>${reviewText ? `<p class="rbody rask">${esc(reviewText)}</p>` : ''}${attemptEvidence ? `<p class="rbody v">${esc(attemptEvidence)}</p>` : ''}</section>`
+  // Request (redesigned 2026-07-29, Masa: "This reviewをやめてRequestに2発目・3発目
+  // として積み上げる"): every ask on this goal, numbered, latest emphasised — not just
+  // the original text plus a separate "This review" summary of only the newest one.
+  // Reuses the same Conversation messages (SA.msgs) that section already fetches;
+  // fetched proactively at render time (see the saLoadMessages call in the render-patch
+  // loop) so the stack has more than #1 without waiting for the reviewer to open
+  // Conversation first. it.goalText alone is the honest fallback while that fetch is
+  // still in flight or the goal has no replies yet. A long ask folds using the SAME
+  // `.lacc` pulldown as Activity/Conversation (spec §3: chevron on the first line, the
+  // body is the genuine REST of the text — not the peek repeated in full below it, which
+  // is what the pre-2026-07-29 version did and Masa flagged as confusing: "点々のあとに
+  // そのまま文から続くのって、ちょっとわかりにくい"). No trailing "…" either — the
+  // chevron alone says there's more. Row logic lives in saReqStackRows so the first
+  // paint here and the async patch in saLoadMessages stay identical.
+  const reqStackRows = saReqStackRows(it, attemptEvidence);
+  const reqSec = reqStackRows
+    ? `<section class="rsec rreq" data-reqmsgs="${gk}"><div class="rsec-h">Request</div><div class="rqlist">${reqStackRows}</div></section>`
     : '';
   const reqVerify = it.requirementVerification;
   const reqVerifyParts = [
@@ -10135,20 +10192,23 @@ function saItemHtml(it, i){
     : attn
     ? `<span class="rst ${attnInt ? 'int' : 'err'}"><span class="rdot"></span>${attnLabel}</span>`
     : '<span class="rst"><span class="rdot"></span>In review</span>';
+  const prNumber = (it.pr?.match(/\/pull\/(\d+)/) ?? [, ''])[1];
+  const delivery = it.pr
+    ? `<a class="sa-delivery" href="${esc(it.pr)}" target="_blank" rel="noopener">PR #${esc(prNumber)} ↗</a>`
+    : '<span class="sa-delivery">No pull request</span>';
   return `<div class="sa-item lg redesign${it.goalId === SA.cur ? ' cur' : ''}${working ? ' working' : ''}" data-gid="${it.goalId}">
     <div class="rhead"><span class="rtag">${it.no != null ? `#${it.no}` : ''}</span>${rst}</div>
     <h2 class="rtitle">${esc(it.title)}</h2>
     ${meta}
     ${reqSec}
-    ${attemptSec}
+    ${S('Open it', openBody + infraBody)}
+    ${S('What to check', checkBody)}
     ${coverageSec}
     ${evidenceSec}
     ${reqVerifySec}
-    ${S('Open it', openBody + infraBody)}
     ${S('Run state', interruptedBody)}
     ${S('PR', prRepairBody)}
     ${S('Also carries', carriesBody)}
-    ${S('What to check', checkBody)}
     ${S('Result', reportBody)}
     ${S('Screenshots', shotsBody)}
     ${S('Steps', stepsBody)}
@@ -10159,7 +10219,7 @@ function saItemHtml(it, i){
     ${conversationSec}
     ${activitySec}
     ${S('Workflow', saWorkflowHtml(it))}
-    <div class="sa-act">${attn ? '' : `<button class="sa-app" data-saact="app:${i}">${SA_SVG.ok}Approve</button><button class="sa-dis" data-saact="dis:${i}">Dismiss</button>`}<div class="sa-replybox"><div class="sa-replyattach${SA.attachments[it.goalId]?.length ? ' has' : ''}" data-saattach="${it.goalId}">${saReplyAttachmentsHtml(it.goalId)}</div><div class="sa-chatwrap"><input class="sa-chat" data-i="${i}" data-goal="${it.goalId}" placeholder="Reply, ask, or paste an image…"><button class="sa-send" data-saact="send:${i}" title="Send"><svg viewBox="0 0 24 24"><path d="M12 19V5M5 12l7-7 7 7"/></svg></button></div></div><button class="sa-ic" title="Archive" data-saact="arch:${i}">${SA_SVG.arch}</button><button class="sa-ic" title="Revert" data-saact="rev:${i}">${SA_SVG.trash}</button></div>
+    <div class="sa-act">${attn ? '' : `<div class="sa-approve-wrap"><button class="sa-app" data-saact="app:${i}">${SA_SVG.ok}Approve</button>${delivery}</div><button class="sa-dis" data-saact="dis:${i}">Dismiss</button>`}<div class="sa-replybox"><div class="sa-replyattach${SA.attachments[it.goalId]?.length ? ' has' : ''}" data-saattach="${it.goalId}">${saReplyAttachmentsHtml(it.goalId)}</div><div class="sa-chatwrap"><input class="sa-chat" data-i="${i}" data-goal="${it.goalId}" placeholder="Reply, ask, or paste an image…"><button class="sa-send" data-saact="send:${i}" title="Send"><svg viewBox="0 0 24 24"><path d="M12 19V5M5 12l7-7 7 7"/></svg></button></div></div><button class="sa-ic" title="Archive" data-saact="arch:${i}">${SA_SVG.arch}</button><button class="sa-ic" title="Revert" data-saact="rev:${i}">${SA_SVG.trash}</button></div>
   </div>`;
 }
 // Scroll the See-all body so a card's top edge (.rhead) sits at the top of the visible
@@ -10203,10 +10263,36 @@ async function saLoadMessages(goalId){
   } catch { msgs = []; }
   SA.msgs[goalId] = msgs;
   const body = document.querySelector(`#seeall [data-msgbody="${goalId}"]`);
-  if (!body) return;
-  body.innerHTML = msgs.length
-    ? saMsgRowsHtml(msgs, SA.convOpen.has(goalId))
-    : '<div class="txr res"><span class="w"></span><span class="m">Nothing was said on this one.</span></div>';
+  if (body) {
+    body.innerHTML = msgs.length
+      ? saMsgRowsHtml(msgs, SA.convOpen.has(goalId))
+      : '<div class="txr res"><span class="w"></span><span class="m">Nothing was said on this one.</span></div>';
+  }
+  // The Request stack (2026-07-29) reads the same fetch — patch it too, in place, so
+  // #2/#3 appear without the card re-rendering (which would close every open pulldown).
+  const reqList = document.querySelector(`#seeall [data-reqmsgs="${goalId}"] .rqlist`);
+  if (reqList) {
+    const it = SA.items.find((x) => x.goalId === goalId);
+    if (it) {
+      const attempt = it.attempt;
+      const attemptFiles = Array.isArray(attempt?.changedFiles) ? attempt.changedFiles.filter(Boolean) : [];
+      const attemptTests = attempt?.verification?.tests;
+      const attemptProof = attempt?.verification?.proof;
+      const attemptEvidence = [
+        attemptFiles.length ? `Changed: ${attemptFiles.join(' · ')}` : '',
+        attemptTests?.ran ? `Tests: ${attemptTests.passed ?? 0} passed${attemptTests.failed ? ` / ${attemptTests.failed} failed` : ''}` : '',
+        attemptProof?.pass === true ? 'Proof recorded' : '',
+      ].filter(Boolean).join(' · ');
+      reqList.innerHTML = saReqStackRows(it, attemptEvidence);
+      // Newly patched nodes miss the [data-detkey] wiring the main render loop applies —
+      // re-attach it for just this list (no actlog/msgs on a request fold, so nothing else needed).
+      for (const det of reqList.querySelectorAll('[data-detkey]')) {
+        det.addEventListener('toggle', () => {
+          if (det.open) SA.detOpen.add(det.dataset.detkey); else SA.detOpen.delete(det.dataset.detkey);
+        });
+      }
+    }
+  }
 }
 // After first paint, compute the red box for any card showing a before/after pair and
 // patch that card's node directly — a full re-render here would close every open
@@ -10282,6 +10368,12 @@ function saRender(){
     if (det.open && det.dataset.actlog) saLoadActivityLog(Number(det.dataset.actlog));
     if (det.open && det.dataset.msgs) saLoadMessages(Number(det.dataset.msgs));
   }
+  // The Request stack (2026-07-29) needs the same conversation messages Conversation
+  // fetches, but the reviewer must not have to open Conversation first just to see
+  // "#2, #3…" — so this one fetch is unconditional, not gated on an accordion being
+  // open. saLoadMessages is already idempotent per goal (SA.msgs cache), so a card
+  // whose Conversation is also open only asks the server once.
+  for (const rq of S.querySelectorAll('[data-reqmsgs]')) saLoadMessages(Number(rq.dataset.reqmsgs));
   // "ないものは載せない" (Masa): a Proof <img> whose file is missing/broken must never
   // show a broken-image placeholder. proofImg is only a stored filename, so a file that
   // isn't on disk (or fails to load) can only be caught at load time — drop the whole

package/engine/chrome-safety.mjs

@@ -1,27 +1,93 @@
 import { execFileSync } from 'node:child_process';
+import { homedir } from 'node:os';
 
 const MAC_CHROME = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
 
+// The human's Chrome session — the only one that can put a "quit unexpectedly"
+// dialog on their screen — always runs out of this profile. Every automated
+// launch (ours, or puppeteer's own default) passes an explicit --user-data-dir
+// somewhere else. Measured 2026-07-29: on a headless launch the browser process
+// AND all twelve helpers carry that flag, so one line is enough to tell whose
+// Chrome it is.
+const defaultProfileDir = () => `${homedir()}/Library/Application Support/Google/Chrome`;
+
+const readVersion = () => execFileSync('/usr/libexec/PlistBuddy', [
+  '-c', 'Print:CFBundleShortVersionString',
+  '/Applications/Google Chrome.app/Contents/Info.plist',
+], { encoding: 'utf8' }).trim();
+
+const readPs = () => execFileSync('/bin/ps', ['-axo', 'command='], { encoding: 'utf8' });
+
 // Chrome updates its app bundle while an older copy can remain open. Launching
 // the newly installed executable during that window aborts inside Chrome and
 // macOS shows a scary "quit unexpectedly" dialog.
+//
+// Only the human's own session counts. A leaked headless Chrome from a test run
+// twenty hours ago is a stale version too, and when it was allowed to vote it
+// silenced every browser check on the machine for as long as it lived — the
+// screenshot the worker was asked for became "no Chrome on this machine", and
+// the worker went off and wrote a static HTML file instead (goals #871 #835
+// #877). A background process we started cannot show anyone a dialog, so it has
+// no business deferring anyone's verification.
 export function chromeUpdatePending(chromePath, {
   platform = process.platform,
-  readCurrentVersion = () => execFileSync('/usr/libexec/PlistBuddy', [
-    '-c', 'Print:CFBundleShortVersionString',
-    '/Applications/Google Chrome.app/Contents/Info.plist',
-  ], { encoding: 'utf8' }).trim(),
-  readProcesses = () => execFileSync('/bin/ps', ['-axo', 'command='], { encoding: 'utf8' }),
+  readCurrentVersion = readVersion,
+  readProcesses = readPs,
+  humanProfileDir = defaultProfileDir,
 } = {}) {
-  if (platform !== 'darwin' || chromePath !== MAC_CHROME) return false;
+  return pendingVersions(chromePath, { platform, readCurrentVersion, readProcesses, humanProfileDir }).length > 0;
+}
+
+function pendingVersions(chromePath, { platform, readCurrentVersion, readProcesses, humanProfileDir }) {
+  if (platform !== 'darwin' || chromePath !== MAC_CHROME) return [];
   try {
     const current = readCurrentVersion();
-    const running = [...readProcesses().matchAll(/Google Chrome Framework\.framework\/Versions\/([^/\s]+)/g)]
-      .map((match) => match[1]);
-    return running.some((version) => version !== current);
+    const profile = humanProfileDir();
+    const stale = new Set();
+    for (const line of readProcesses().split('\n')) {
+      const version = line.match(/Google Chrome Framework\.framework\/Versions\/([^/\s]+)/)?.[1];
+      if (!version || version === current) continue;
+      // An explicit profile that is not the human's = something automated.
+      // Matched by substring because the real path contains a space, which the
+      // `ps` output gives us no way to delimit.
+      if (line.includes('--user-data-dir=') && !line.includes(profile)) continue;
+      stale.add(version);
+    }
+    return [...stale];
   } catch {
-    return false;
+    return [];
+  }
+}
+
+// Why a browser is or is not available, in the caller's words.
+//
+// "Chrome is missing" and "Chrome is here but we are standing down for a
+// moment" are different facts with different fixes, and collapsing them into a
+// single null taught everything downstream to say the wrong one. Callers that
+// only need a path still get `path`; callers that report to a human get
+// `reason` and a sentence that names the actual remedy.
+export function chromeStatus(chromePath, options = {}) {
+  if (!chromePath) {
+    return {
+      path: null,
+      reason: 'missing',
+      detail: 'Chrome is not installed here — install Google Chrome or set CHROME_PATH to the binary.',
+    };
+  }
+  const stale = pendingVersions(chromePath, {
+    platform: options.platform ?? process.platform,
+    readCurrentVersion: options.readCurrentVersion ?? readVersion,
+    readProcesses: options.readProcesses ?? readPs,
+    humanProfileDir: options.humanProfileDir ?? defaultProfileDir,
+  });
+  if (stale.length) {
+    return {
+      path: null,
+      reason: 'update-pending',
+      detail: `Chrome updated while it was open (still running ${stale.join(', ')}). Quit and reopen Chrome, then retry — Chrome IS installed on this machine.`,
+    };
   }
+  return { path: chromePath, reason: 'ok', detail: '' };
 }
 
 // Browser tests use this instead of launching the first installed binary
@@ -29,6 +95,5 @@ export function chromeUpdatePending(chromePath, {
 // behavior, so a Chrome update never becomes a product failure or a macOS
 // crash dialog.
 export function safeChromePath(chromePath, options) {
-  if (!chromePath) return null;
-  return chromeUpdatePending(chromePath, options) ? null : chromePath;
+  return chromeStatus(chromePath, options).path;
 }

package/engine/completion-contract.mjs

@@ -40,8 +40,50 @@ export const COMPLETION_CONTRACT_PROMPT = [
   '- The latest explicit user instruction can revise an older product decision or code comment. Treat old comments as context, not proof that the requested change is impossible. If the change has consequences, explain them and implement the latest request; only a real safety, permission, legal, or external-system constraint is a blocker.',
   '- A test must assert the observable outcome the user requested. Never replace the request with a tooltip, explanation, or a test that permanently preserves the opposite behavior.',
   '- Do not report a change request as complete with “cannot fix”, “直せません”, or equivalent. If a real external blocker remains, state the concrete blocker and leave the work explicitly unfinished instead of presenting it for Review as completed.',
+  '- Git commit, push, and PR creation belong to Galda close-out, not the worker. Never call that division of responsibility a permission blocker and never ask the user to run gh or git for you.',
+  '- Never infer that a commit bypassed Pull Requests from its subject, parent count, or the absence of “Merge pull request” in a narrow git log. Squash/rebase/merge strategies produce different commit shapes. Claim “no PR” only after verifying commit-to-PR association through GitHub; otherwise say PR provenance is unknown.',
+  '- If the requested change is already present in origin/main and there is no branch diff to put in a PR, that is not blocked. Verify the exact commit/result and append: MANAGER_OUTCOME: {"outcome":"already-satisfied","summary":"what is already present and where"}. A PR cannot be retroactively wrapped around a commit already on main; report the verification honestly and finish normally.',
+  '- You own the routing decision. When the run needs routing, append exactly one single-line receipt: MANAGER_OUTCOME: {"outcome":"needs-input|blocked|rebind-workspace|already-satisfied","summary":"short reason","question":"question for the user when needed","options":["optional choice"],"workingDirectory":"absolute path for rebind-workspace"}. Do not emit this receipt for an ordinary completed change. Galda transports this declaration verbatim; it does not reinterpret your prose.',
 ].join('\n');
 
+const MANAGER_OUTCOMES = new Set(['needs-input', 'blocked', 'rebind-workspace', 'already-satisfied']);
+
+// A transport receipt written by the worker, not a Manager inference. Keep the
+// schema deliberately tiny: the agent decides what happened; Galda only checks
+// that the envelope is safe to route.
+export function parseManagerOutcome(raw) {
+  const m = String(raw ?? '').match(/MANAGER_OUTCOME:\s*(\{[^\n]+\})/);
+  if (!m) return null;
+  let value;
+  try { value = JSON.parse(m[1]); } catch { return null; }
+  if (!MANAGER_OUTCOMES.has(value?.outcome)) return null;
+  const summary = typeof value.summary === 'string' ? value.summary.trim().slice(0, 500) : '';
+  const question = typeof value.question === 'string' ? value.question.trim().slice(0, 300) : '';
+  const options = Array.isArray(value.options)
+    ? value.options.map((x) => typeof x === 'string' ? x.trim().slice(0, 60) : '').filter(Boolean).slice(0, 4)
+    : [];
+  const workingDirectory = typeof value.workingDirectory === 'string' ? value.workingDirectory.trim().slice(0, 1000) : '';
+  if (value.outcome === 'needs-input' && !question) return null;
+  if (value.outcome === 'blocked' && !summary) return null;
+  if (value.outcome === 'already-satisfied' && !summary) return null;
+  if (value.outcome === 'rebind-workspace' && !workingDirectory.startsWith('/')) return null;
+  return { outcome: value.outcome, summary, question, options, workingDirectory };
+}
+
+// Existing requirement evidence is also an explicit worker declaration. A
+// worker cannot say `partial`/`not-addressed` and simultaneously be routed to
+// Review as complete. This is schema consistency, not semantic judgment.
+export function incompleteEvidenceOutcome(evidence) {
+  const incomplete = (evidence?.requirements ?? []).filter((r) => ['partial', 'not-addressed'].includes(r?.status));
+  if (!incomplete.length) return null;
+  return {
+    outcome: 'blocked',
+    summary: incomplete.map((r) => r.evidence || `${r.id}: ${r.status}`).filter(Boolean).join('; ').slice(0, 500)
+      || 'The worker declared one or more requirements incomplete.',
+    question: '', options: [], workingDirectory: '',
+  };
+}
+
 export function completionContractIssue({ request = '', followUp = '', result = '', status = '', changedFiles = [] } = {}) {
   if (status !== 'done') return null;
   const requested = `${request}\n${followUp}`;

package/engine/lib.mjs

@@ -2480,12 +2480,13 @@ export function dismissGoal({ goalStatus, outcome = 'continue' } = {}) {
   return { ok: true, outcome: 'continue', status: 'running', spawnsWorker: true };
 }
 
-// `outcome:auto` is the contract used by every review reply box in the app.
-// Keep the routing decision in one place: the reply either asks a question,
-// requests a change, rescopes the ticket, starts separate work, or explicitly
-// remains unsure.  Returning unsure is safe because the UI already presents
-// these exact choices without moving the goal.
-export const REPLY_INTENTS = [...REPLY_OUTCOMES, 'unsure'];
+// REPLY_INTENTS lived here — REPLY_OUTCOMES plus 'unsure', the vocabulary the
+// router answered in. #518 removed the router but left this constant exported,
+// and nothing imported it except one test's own skip guard
+// (`/REPLY_INTENTS/.test(lib.mjs)`), which therefore kept believing the router
+// was present and ran five tests for deleted behaviour. `main` was red from
+// that merge onward. A dead export is not free when something reads the source
+// to decide whether a feature exists.
 // buildReplyIntentPrompt / parseReplyIntent lived here: the prompt and parser for a
 // utility LLM that decided what a Review reply MEANT before the goal's own agent saw
 // it. They are gone with their caller. Its "answer" bucket — "a question about the
@@ -3254,7 +3255,7 @@ export function workerPrompt(task, goal, lastFailure, agentName = 'claude-code',
     runContext ? (typeof runContext === 'string' ? runContext : buildWorkerContextBlock(runContext)) : '',
     '',
     `TASK ${task.num}: ${task.title}`,
-    `REQUIREMENT ID FOR THIS RUN: task-${task.id ?? task.num}.`,
+    `REQUIREMENT IDS FOR THIS RUN: ${(task?.activeRequirementIds?.length ? task.activeRequirementIds : [`task-${task.id ?? task.num}`]).join(', ')}.`,
     task.detail ? `DETAIL: ${task.detail}` : '',
     `WORKSPACE MODE: ${workspaceMode}.`,
     goal?.images?.length ? `ATTACHED IMAGES (absolute paths, use the Read tool to view them): ${goal.images.join(' ')}` : '',
@@ -3276,7 +3277,7 @@ export function workerPrompt(task, goal, lastFailure, agentName = 'claude-code',
     // instead of expanding scope"): the request, not our fear of scope, sets
     // the size of the work.
     '- Deliver what the request actually asks for. If it asks for multiple options, N variations, a visual, an artifact, or a full exploration, produce ALL of them — do not reduce it to one, and do not cut it short to finish faster.',
-    '- At the end of your final report, add exactly one line: MANAGER_REQUIREMENT_EVIDENCE: {"requirements":[{"id":"task-<this run id>","status":"addressed|partial|not-addressed","evidence":"file, test, or Open it evidence","files":["changed/path"]}]}. This labels evidence for Review; it is not self-approval. Report partial or not-addressed honestly.',
+    `- Before your final report, Write ${REQUIREMENT_EVIDENCE_FILE} in the project root as one complete JSON document: {"schemaVersion":1,"requirements":[{"id":"<one of REQUIREMENT IDS FOR THIS RUN>","status":"addressed|partial|not-addressed","evidence":"file, test, or Open it evidence","files":["changed/path"]}]}. Include one row for every requirement ID listed above. This is a worker claim for Review, not self-approval. Report partial or not-addressed honestly. Always overwrite the whole file with Write; do not append it to prose and do not partially Edit it.`,
     '- For a review follow-up, implement and report against CURRENT USER FOLLOW-UP above. Do not claim the first attempt as this attempt\'s result. Do not change shared theme tokens, seed/demo data, or unrelated indicators merely to make a manual check easier unless the user explicitly requested those changes; put test fixtures in test files only.',
     '- Requirement history is context, not a Manager priority decision. Keep prior items visible; if an item remains unaddressed, say so plainly rather than omitting it.',
     '- デザイン案・UI案・レイアウト案を求められた場合は、文章だけで完了にしない。画像を使わない案でも、比較して確認できるHTML等のartifactをプロジェクト内に作り、実際に開ける .manager-run.json を残す。',
@@ -3377,15 +3378,13 @@ export function workerPrompt(task, goal, lastFailure, agentName = 'claude-code',
 // Anything we cannot validate is dropped: no "run it" button is honest, a
 // button that opens the wrong thing is the fabricated-proof bug all over again.
 export const RUN_DECL_FILE = '.manager-run.json';
+export const REQUIREMENT_EVIDENCE_FILE = '.manager-requirement-evidence.json';
+export const REQUIREMENT_EVIDENCE_SCHEMA_VERSION = 1;
 
 // Structured evidence is a transport record, not a Manager verdict. A worker
 // may append it to its normal final report so each requirement remains visible
 // with the attempt that addressed it.
-export function parseRequirementEvidence(raw) {
-  const m = String(raw ?? '').match(/MANAGER_REQUIREMENT_EVIDENCE:\s*(\{[^\n]+\})/);
-  if (!m) return null;
-  let value;
-  try { value = JSON.parse(m[1]); } catch { return null; }
+function normalizeRequirementClaims(value) {
   if (!Array.isArray(value?.requirements)) return null;
   const requirements = value.requirements.slice(0, 20).map((entry) => {
     const id = typeof entry?.id === 'string' ? entry.id.trim().slice(0, 120) : '';
@@ -3399,11 +3398,68 @@ export function parseRequirementEvidence(raw) {
   return requirements.length ? { requirements } : null;
 }
 
+// Primary, versioned transport. This parses one complete dedicated document
+// and returns explicit failure states so malformed evidence cannot disappear.
+export function parseRequirementEvidenceDocument(raw) {
+  let value;
+  try { value = JSON.parse(String(raw ?? '')); }
+  catch { return { ok: false, error: 'invalid-json', message: 'Requirement evidence was not valid JSON.' }; }
+  if (value?.schemaVersion !== REQUIREMENT_EVIDENCE_SCHEMA_VERSION) {
+    return { ok: false, error: 'unsupported-version', message: `Requirement evidence schemaVersion must be ${REQUIREMENT_EVIDENCE_SCHEMA_VERSION}.` };
+  }
+  const normalized = normalizeRequirementClaims(value);
+  if (!normalized) return { ok: false, error: 'invalid-requirements', message: 'Requirement evidence must contain at least one valid requirement claim.' };
+  return {
+    ok: true,
+    value: {
+      schemaVersion: REQUIREMENT_EVIDENCE_SCHEMA_VERSION,
+      source: 'artifact',
+      state: 'valid',
+      requirements: normalized.requirements,
+    },
+  };
+}
+
+// Migration-only fallback for workers launched with an older prompt.
+export function parseRequirementEvidence(raw) {
+  const m = String(raw ?? '').match(/MANAGER_REQUIREMENT_EVIDENCE:\s*(\{[^\n]+\})/);
+  if (!m) return null;
+  let value;
+  try { value = JSON.parse(m[1]); } catch { return null; }
+  return normalizeRequirementClaims(value);
+}
+
 export function unmappedChangedFiles(changedFiles = [], evidence = null) {
   const claimed = new Set((evidence?.requirements ?? []).flatMap((r) => r.files ?? []));
   return [...new Set((changedFiles ?? []).filter(Boolean))].filter((file) => !claimed.has(file));
 }
 
+// "Open it" opened a page the agent wrote about the work, while the work itself
+// was somewhere else.
+//
+// Goal #871: the worker really did change `app/index.html`, and declared
+// `docs/design/proposals/review-card-declutter-implemented.html` — a page whose
+// content was the implementation report — as the thing to open. The declaration
+// is served from the same /upload URL as any other artifact, so on the Review
+// card it is indistinguishable from the product. The operator pressed Open it,
+// got a write-up, and asked again for something they could actually look at.
+//
+// Declaring a static file is usually right: 15 tasks did it on the operator's
+// instance 2026-07-25..29 and 14 were comparison pages and reports with nothing
+// else to show. Only #871 declared one while ALSO changing something else. So
+// this does not block, score, or guess at intent — Galda deciding what a worker
+// "really meant" is the mistake #518 was written to undo. It reports one fact
+// the card cannot currently express: the file being opened is not the only thing
+// this run touched, and here is what else it touched.
+//
+// Returns null when there is nothing to say — no static declaration, or the
+// declared file is the whole change.
+export function previewOpensSomethingElse({ runFile = null, changedFiles = [] } = {}) {
+  if (!runFile) return null;
+  const others = [...new Set((changedFiles ?? []).filter(Boolean))].filter((f) => f !== runFile);
+  return others.length ? { opens: runFile, alsoChanged: others } : null;
+}
+
 // A declaration that parsed as JSON but breaks a rule (bad url scheme, an
 // unsafe `file` path) is NOT the same failure as unparseable JSON — the first
 // is a worker mistake with a specific, sayable reason; the second is a broken

package/engine/requirement-verification.mjs

@@ -0,0 +1,68 @@
+const COVERAGE = new Set(['unverified', 'verified', 'failed', 'not-applicable']);
+
+function cleanList(value) {
+  return [...new Set((Array.isArray(value) ? value : []).filter((item) => typeof item === 'string' && item))];
+}
+
+function normalizedCheck(check) {
+  if (!check || typeof check !== 'object') return null;
+  const kind = typeof check.kind === 'string' ? check.kind.trim() : '';
+  const status = typeof check.status === 'string' ? check.status.trim() : '';
+  if (!kind || !status) return null;
+  return {
+    authority: 'manager',
+    kind,
+    status,
+    requirementIds: cleanList(check.requirementIds),
+    detail: typeof check.detail === 'string' ? check.detail.trim().slice(0, 1000) : '',
+    ...(typeof check.url === 'string' && check.url ? { url: check.url } : {}),
+    files: cleanList(check.files),
+  };
+}
+
+function coverageFromChecks(requirementId, checks) {
+  const scoped = checks.filter((check) => check.requirementIds.includes(requirementId));
+  if (scoped.some((check) => check.status === 'failed')) return 'failed';
+  if (scoped.some((check) => check.status === 'verified')) return 'verified';
+  if (scoped.length && scoped.every((check) => check.status === 'not-applicable')) return 'not-applicable';
+  return 'unverified';
+}
+
+/**
+ * Join worker claims and Manager-observed checks by explicit IDs.
+ * Unscoped passing checks are retained as facts but never promote coverage.
+ */
+export function buildRequirementVerificationEvidence({
+  requirementIds = [], attemptId, taskId = null, workerEvidence = null, checks = [], changedFiles = [],
+} = {}) {
+  if (!attemptId) return [];
+  const ids = cleanList(requirementIds);
+  const normalizedChecks = checks.map(normalizedCheck).filter(Boolean);
+  const claims = new Map((workerEvidence?.requirements ?? []).map((claim) => [claim.id, claim]));
+  const observedFiles = cleanList(changedFiles);
+
+  return ids.map((requirementId) => {
+    const claim = claims.get(requirementId);
+    const coverage = coverageFromChecks(requirementId, normalizedChecks);
+    return {
+      requirementId,
+      attemptId,
+      taskId,
+      claim: claim?.status ?? null,
+      coverage: COVERAGE.has(coverage) ? coverage : 'unverified',
+      workerEvidence: claim?.evidence ?? '',
+      workerFiles: cleanList(claim?.files),
+      observedFiles,
+      checks: normalizedChecks,
+    };
+  });
+}
+
+export function mergeRequirementVerificationEvidence(existing = [], incoming = []) {
+  const rows = new Map();
+  for (const row of [...existing, ...incoming]) {
+    if (!row?.requirementId || !row?.attemptId) continue;
+    rows.set(`${row.requirementId}\u0000${row.attemptId}\u0000${row.taskId ?? ''}`, row);
+  }
+  return [...rows.values()];
+}

package/engine/server.mjs

@@ -21,12 +21,13 @@ import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { pathToFileURL } from 'node:url';
 import { needsProjectFolder, folderLabel, chooseFolderScript, parseChosenFolder, buildFolderQuestion, resolveFolderAnswer, classifyFolderTarget, buildFolderInitConfirm, isFolderInitConfirmed, needsReviewPreference, buildReviewPreferenceQuestion, resolveReviewPreferenceAnswer, routeQuestionAnswer, notUnderstoodNote, parseRelocalizedQuestion, classifyAuthProbe, authBannerText, makeSigninChallenge, parseClaimResponse, isCommandOnPath, parseRequestedWorkspaceDir } from './lib.mjs';
-import { parseStreamEvents, parseCodexEvents, buildCodexArgs, parsePlan, refinePlanTasks, canEditGoal, canDeleteGoal, shouldAskClarification, workerExitReason, classifyWorkerFailure, isForcedStop, taskStatusAfterVerify, workerResultText, taskCountsAsComplete, resolveWantsPR, resolveGoalSource, buildGoalSummary, buildReviewAttemptLedger, latestGoalOutcomeTask, buildDirtyWorkspacePrBlock, 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, rebasePreviewUrl, shouldCreateGoalPR, normalizePullRequestUrl, parseGitLog, diffNewCommits, replayQueueLog, reconcileOrphanGoals, reorderQueue, sortQueueByPriority, TASK_PRIORITIES, validateWorkflowColumns, DEFAULT_WORKFLOW_COLUMNS, validateReviewDefinition, DEFAULT_REVIEW_DEFINITION, resolveTestGate, buildEphemeralSeedLog, buildEphemeralSeedProjects, trimTaskActivityForState, buildAskContext, WORKER_TOOLS, workerPrompt, verifyCfAccessJwt, resolveIdentity, goalVisibleTo, clampParallelLimit, canStartMore, nextRunnableTasks, goalsConflict, detectConflicts, pickFoldTarget, autoFoldReviewsEnabled, parseGitUnifiedDiffLocations, hasTestRelevantChanges, parseFailingTestNames, classifyTestGate, classifyPrSafety, isInconclusiveTestRun, countInfraFlakes, classifyRunFailures, classifyVerifyGate, buildVerificationInfraError, verificationInfraErrorFrom, buildExecutionPlan, buildContextHandoffSummary, buildFailurePostmortem, appendFailureMemory, latestFailurePolicy, classifyChangeRisk, checkRunBudget, usageBudgetTokens, isRateLimited, nextResumeDelay, checkFreeTierLimit, resolveEntitlement, resolveCachedEntitlement, FREE_TIER_LIMITS, QUEUED_GOAL_STATUSES, verifyLicenseToken, licenseTokenPayload, shouldRefreshLicense, shouldEmitSetupCompleted, pickAnalyticsUid, shouldEmitFreeExhausted, detectRequestLanguage, testFailureReason, manualTestRetryPrompt, isNothingVerifiable, isNothingVerifiableForPR, isSuspiciouslyIncompleteDone, classifyComposerIntentHeuristic, detectPauseIntent, buildIntentPrompt, parseIntentResponse, buildBoardSnapshot, validateBoardSnapshot, boardIsEmpty, decideBoardPull, resolveConnectedAgents, pickAvailableAgent, pickUtilityAgent, utilityModel, liveTakeoverDecision, shouldOpenBrowserOnBoot, goalTaskTitle, buildGoalTask, shouldUsePlannerForGoal, RUN_DECL_FILE, parseRunDeclaration, SHOT_DIR, collectShotNames, parseGoalAddress, REPLY_OUTCOMES, buildGoalMessage, serializeGoalMessage, parseGoalMessages, computeInternalQualityMetrics, classifyInternalQualityTaskError, resolveWorkspaceMode, goalSessionFor, setGoalAgentSession, switchGoalAgentSession, parseApprovalRequest } from './lib.mjs';
+import { parseStreamEvents, parseCodexEvents, buildCodexArgs, parsePlan, refinePlanTasks, canEditGoal, canDeleteGoal, shouldAskClarification, workerExitReason, classifyWorkerFailure, isForcedStop, taskStatusAfterVerify, workerResultText, taskCountsAsComplete, resolveWantsPR, resolveGoalSource, buildGoalSummary, buildReviewAttemptLedger, latestGoalOutcomeTask, buildDirtyWorkspacePrBlock, 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, rebasePreviewUrl, shouldCreateGoalPR, normalizePullRequestUrl, parseGitLog, diffNewCommits, replayQueueLog, reconcileOrphanGoals, reorderQueue, sortQueueByPriority, TASK_PRIORITIES, validateWorkflowColumns, DEFAULT_WORKFLOW_COLUMNS, validateReviewDefinition, DEFAULT_REVIEW_DEFINITION, resolveTestGate, buildEphemeralSeedLog, buildEphemeralSeedProjects, trimTaskActivityForState, buildAskContext, WORKER_TOOLS, workerPrompt, verifyCfAccessJwt, resolveIdentity, goalVisibleTo, clampParallelLimit, canStartMore, nextRunnableTasks, goalsConflict, detectConflicts, pickFoldTarget, autoFoldReviewsEnabled, parseGitUnifiedDiffLocations, hasTestRelevantChanges, parseFailingTestNames, classifyTestGate, classifyPrSafety, isInconclusiveTestRun, countInfraFlakes, classifyRunFailures, classifyVerifyGate, buildVerificationInfraError, verificationInfraErrorFrom, buildExecutionPlan, buildContextHandoffSummary, buildFailurePostmortem, appendFailureMemory, latestFailurePolicy, classifyChangeRisk, checkRunBudget, usageBudgetTokens, isRateLimited, nextResumeDelay, checkFreeTierLimit, resolveEntitlement, resolveCachedEntitlement, FREE_TIER_LIMITS, QUEUED_GOAL_STATUSES, verifyLicenseToken, licenseTokenPayload, shouldRefreshLicense, shouldEmitSetupCompleted, pickAnalyticsUid, shouldEmitFreeExhausted, detectRequestLanguage, testFailureReason, manualTestRetryPrompt, isNothingVerifiable, isNothingVerifiableForPR, isSuspiciouslyIncompleteDone, classifyComposerIntentHeuristic, detectPauseIntent, buildIntentPrompt, parseIntentResponse, buildBoardSnapshot, validateBoardSnapshot, boardIsEmpty, decideBoardPull, resolveConnectedAgents, pickAvailableAgent, pickUtilityAgent, utilityModel, liveTakeoverDecision, shouldOpenBrowserOnBoot, goalTaskTitle, buildGoalTask, shouldUsePlannerForGoal, RUN_DECL_FILE, REQUIREMENT_EVIDENCE_FILE, parseRequirementEvidenceDocument, parseRunDeclaration, SHOT_DIR, collectShotNames, parseGoalAddress, REPLY_OUTCOMES, buildGoalMessage, serializeGoalMessage, parseGoalMessages, computeInternalQualityMetrics, classifyInternalQualityTaskError, resolveWorkspaceMode, goalSessionFor, setGoalAgentSession, switchGoalAgentSession, parseApprovalRequest } from './lib.mjs';
+import { migrateRequirementModel, validateRequirementModel } from './requirement-model.mjs';
 import { createSerialQueue } from './lib.mjs';
-import { parseRequirementEvidence, unmappedChangedFiles } from './lib.mjs';
+import { parseRequirementEvidence, unmappedChangedFiles, previewOpensSomethingElse } from './lib.mjs';
 import { isPrClosed } from './lib.mjs';
 import { collectProjectRules } from './lib.mjs';
-import { COMPLETION_CONTRACT_PROMPT, completionContractIssue } from './completion-contract.mjs';
+import { COMPLETION_CONTRACT_PROMPT, completionContractIssue, parseManagerOutcome, incompleteEvidenceOutcome } from './completion-contract.mjs';
 import { FALLBACK_CODEX_MODELS, loadCodexModels } from './codex-models.mjs';
 import { CLAUDE_MODELS } from './claude-models.mjs';
 import { classifyWorkerPreflight, shouldProbeClaudeAuth, workerCanStart } from './worker-availability.mjs';
@@ -749,6 +750,45 @@ let tasks = replayed.tasks;
 let nextId = replayed.nextId;
 let prioCounter = replayed.prioCounter;
 
+// Canonical requirement model: read legacy goal/task records without rewriting
+// the append-only log at boot. The next real save persists the normalized
+// shape, so rollout is non-destructive and old binaries can still replay the
+// untouched legacy fields during rollback.
+function refreshRequirementModel(goalId) {
+  const goal = goals.find((item) => item.id === goalId);
+  if (!goal) return { goal: null, changed: false };
+  const goalTasks = tasks.filter((item) => item.goalId === goalId);
+  const before = JSON.stringify({
+    version: goal.requirementModelVersion,
+    requirements: goal.requirements,
+    attempts: goal.attempts,
+    evidence: goal.requirementEvidence,
+    legacyMap: goal.legacyRequirementMap,
+    taskRefs: goalTasks.map((item) => [item.id, item.activeRequirementIds]),
+    error: goal.requirementModelError,
+  });
+  const migrated = migrateRequirementModel(goal, goalTasks);
+  Object.assign(goal, migrated.goal);
+  for (const normalized of migrated.tasks) {
+    const task = tasks.find((item) => item.id === normalized.id);
+    if (task) task.activeRequirementIds = normalized.activeRequirementIds;
+  }
+  const validation = validateRequirementModel(goal, goalTasks);
+  if (validation.ok) delete goal.requirementModelError;
+  else goal.requirementModelError = { kind: 'invalid-requirement-model', errors: validation.errors };
+  const after = JSON.stringify({
+    version: goal.requirementModelVersion,
+    requirements: goal.requirements,
+    attempts: goal.attempts,
+    evidence: goal.requirementEvidence,
+    legacyMap: goal.legacyRequirementMap,
+    taskRefs: goalTasks.map((item) => [item.id, item.activeRequirementIds]),
+    error: goal.requirementModelError,
+  });
+  return { goal, changed: before !== after };
+}
+for (const goal of goals) refreshRequirementModel(goal.id);
+
 // Cross-device sync (P3): before anything downstream (orphan reconcile, the
 // queues Map, workers) is built from this state, adopt a newer board from the
 // account if one exists — this is where a second device inherits the work on
@@ -859,6 +899,7 @@ function logAppend(line) {
   catch (e) { console.error(`[manager] log write failed (${e?.code || e}) — state not persisted this write, UI still updated`); return false; }
 }
 function saveGoal(g) {
+  refreshRequirementModel(g.id);
   emitGoalQualityEvents(g);
   logAppend(JSON.stringify({ ...g, kind: 'goal' }));
   sendGoalEvent({ ev: 'goal', goal: g }, g);
@@ -933,6 +974,12 @@ function saveTask(t) {
       from: 'ai', via: t.reply ? 'thread' : 'composer', text: t.result,
     });
   }
+  const canonical = refreshRequirementModel(t.goalId);
+  // Persist the canonical goal on first write (or when a new attempt/evidence
+  // changes it), not merely in memory. Avoid saveGoal() here: terminal task
+  // saves already add conversation messages, and recursively emitting another
+  // goal lifecycle event would duplicate analytics/SSE side effects.
+  if (canonical.changed && canonical.goal) logAppend(JSON.stringify({ ...canonical.goal, kind: 'goal' }));
   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);
@@ -1023,6 +1070,7 @@ function hydrateFromBoard(snap) {
     catch (e) { console.log(`[sync] hydrate: log write failed (${e?.code || e})`); }
     const r = replayQueueLog(snap.tasksLog || '', reviewDefinitions);
     goals = r.goals; tasks = r.tasks; nextId = r.nextId; prioCounter = r.prioCounter;
+    for (const goal of goals) refreshRequirementModel(goal.id);
     // A pulled 'running' goal has no live worker on this device — reconcile it
     // exactly as a restart would (same rule replayQueueLog callers use at boot).
     for (const fix of reconcileOrphanGoals(goals, tasks)) {
@@ -2310,6 +2358,79 @@ function pauseGoalForApproval(goal, task, request) {
   return true;
 }
 
+// The worker decides where its result belongs. Galda does not classify prose;
+// it only validates and transports the explicit receipt (or the worker's
+// existing partial/not-addressed evidence) into the corresponding board state.
+function routeWorkerOutcome(goal, task, project) {
+  if (!goal || !task || task.status !== 'done') return false;
+  const outcome = parseManagerOutcome(task.result) || incompleteEvidenceOutcome(task.requirementEvidence);
+  if (!outcome) return false; // backwards-compatible completed run
+  task.managerOutcome = outcome;
+  task.finishedAt = new Date().toISOString();
+
+  // An audit can find that the requested code is already on origin/main. With
+  // no branch diff GitHub cannot create a new PR, but nothing is blocked.
+  // Preserve the verified explanation and continue through normal Review
+  // close-out instead of asking the customer to run git/gh manually.
+  if (outcome.outcome === 'already-satisfied') {
+    goal.prNote = outcome.summary;
+    goal.blocked = null;
+    saveTask(task);
+    saveGoal(goal);
+    sendProcessAct(task, `Already satisfied on the base branch: ${outcome.summary}`);
+    return false;
+  }
+
+  if (outcome.outcome === 'rebind-workspace') {
+    const rebound = rebindGoalWorkspace(goal, project, outcome.workingDirectory);
+    if (rebound.ok) {
+      task.status = 'skipped';
+      task.result = `${task.result}\n\n[Galda: continuing in ${rebound.dir} with a fresh session]`.slice(0, RESULT_MAX);
+      saveTask(task);
+      goal.status = 'running';
+      goal.startedAt = null;
+      goal.question = null;
+      goal.blocked = null;
+      saveGoal(goal);
+      const continuation = queueReplyTask(goal, [
+        `Continue the same request in the newly bound working directory: ${rebound.dir}`,
+        outcome.summary,
+        'Inspect the files already present there and complete the original request. Do not repeat the old sandbox diagnosis.',
+      ].filter(Boolean).join('\n'), { from: 'manager', via: 'system' });
+      continuation.workspaceRebindContinuation = true;
+      saveTask(continuation);
+      sendProcessAct(task, `Worker requested a workspace rebind; continuing in ${rebound.dir} with a fresh session.`);
+      return true;
+    }
+    // An unsafe/unavailable path is not silently retried in the old sandbox.
+    outcome.outcome = 'needs-input';
+    outcome.question = rebound.error;
+    outcome.options = [];
+    outcome.summary = rebound.error;
+  }
+
+  // This turn ended successfully as a routing hand-off, not as a failed unit
+  // of implementation. Keeping it `interrupted` would poison the eventual
+  // closeout even after the user answers and the continuation completes.
+  task.status = 'skipped';
+  saveTask(task);
+  goal.startedAt = null;
+  if (outcome.outcome === 'needs-input') {
+    goal.status = 'needsInput';
+    goal.blocked = null;
+    goal.question = { kind: 'worker', text: outcome.question, options: outcome.options };
+    sendProcessAct(task, `Worker asked for input: ${outcome.question}`);
+  } else {
+    goal.status = 'blocked';
+    goal.question = null;
+    goal.blocked = { kind: 'worker-outcome', reason: outcome.summary };
+    sendProcessAct(task, `Worker declared the work blocked: ${outcome.summary}`);
+  }
+  saveGoal(goal);
+  startNextStacked(goal.projectId);
+  return true;
+}
+
 // split (docs/design/ONE-CONVERSATION.md §1.3): 「それは別件」と返された時の受け皿。
 // 元のゴールには触らない——新しいチケットを1枚起こし、そこに「どこから生まれたか」だけ
 // 片方向の印（bornFrom）を残す。
@@ -2556,6 +2677,22 @@ function collectRunDeclFileArtifact(task, workDir) {
   sendProcessAct(task, `Worker attached a file to open: ${rel}`);
 }
 
+// Runs from the caller that computes changedFiles, not from readRunDeclaration:
+// the declaration is consumed BEFORE the diff is taken (it is a message to the
+// Manager and must not appear in the PR), so at declaration time there is
+// nothing yet to compare against.
+//
+// This states a fact and stops. It does not withhold the link, mark the task, or
+// decide the worker showed the wrong thing — a report page beside a code change
+// is a perfectly good answer to "explain what you did". It just makes the card
+// able to say which one you are about to open.
+function notePreviewScope(task) {
+  const scope = previewOpensSomethingElse({ runFile: task.run?.file, changedFiles: task.changedFiles });
+  if (!scope) return;
+  task.run = { ...task.run, alsoChanged: scope.alsoChanged };
+  sendProcessAct(task, `Open it points at ${scope.opens}; this run also changed ${scope.alsoChanged.join(', ').slice(0, 300)}.`);
+}
+
 // A direct/shared workspace can still contain a declaration left by an older
 // run (for example when that run was interrupted before readRunDeclaration).
 // Remove it before this task starts so only a file created by THIS worker can
@@ -2571,6 +2708,53 @@ function clearStaleRunDeclaration(task, workDir) {
   }
 }
 
+function clearStaleRequirementEvidence(task, workDir) {
+  const file = join(workDir, REQUIREMENT_EVIDENCE_FILE);
+  if (!existsSync(file)) return;
+  try {
+    unlinkSync(file);
+    sendProcessAct(task, `Removed stale ${REQUIREMENT_EVIDENCE_FILE} before starting this attempt.`);
+  } catch (err) {
+    sendProcessAct(task, `Could not remove stale ${REQUIREMENT_EVIDENCE_FILE}: ${String(err?.code ?? err).slice(0, 80)}`);
+  }
+}
+
+// Read the dedicated versioned artifact first. Only an ABSENT artifact falls
+// back to the legacy prose marker; an artifact that exists but is malformed is
+// an explicit parse-error and must not be hidden by older report text.
+function readRequirementEvidence(task, workDir) {
+  const file = join(workDir, REQUIREMENT_EVIDENCE_FILE);
+  let raw;
+  try { raw = readFileSync(file, 'utf8'); }
+  catch {
+    const legacy = parseRequirementEvidence(task.result);
+    task.requirementEvidence = legacy
+      ? { schemaVersion: 0, source: 'legacy-report', state: 'valid', requirements: legacy.requirements }
+      : null;
+    task.requirementEvidenceStatus = legacy
+      ? { state: 'valid', source: 'legacy-report', schemaVersion: 0 }
+      : { state: 'missing', source: 'artifact' };
+    return;
+  }
+  try { unlinkSync(file); } catch { /* best effort: transport file is not a deliverable */ }
+  const parsed = parseRequirementEvidenceDocument(raw);
+  if (parsed.ok) {
+    task.requirementEvidence = parsed.value;
+    task.requirementEvidenceStatus = { state: 'valid', source: 'artifact', schemaVersion: parsed.value.schemaVersion };
+    sendProcessAct(task, `Loaded structured requirement evidence schema v${parsed.value.schemaVersion}.`);
+    return;
+  }
+  task.requirementEvidence = null;
+  task.requirementEvidenceStatus = {
+    state: 'parse-error',
+    source: 'artifact',
+    error: parsed.error,
+    message: parsed.message,
+    snippet: String(raw).slice(0, 200),
+  };
+  sendAct(task, `requirement evidence ignored — ${parsed.message}`);
+}
+
 function inheritPreviousRunDeclaration(task, goalId) {
   if (task.run || !goalId) return;
   const prev = [...tasks].reverse().find((t) => t.goalId === goalId && t.id !== task.id && t.run && (t.run.cmd || t.run.url));
@@ -2738,6 +2922,7 @@ async function runTask(task) {
     : `Prepared isolated worktree: ${workDir}`);
   if (goal?.workspaceWarning) sendProcessAct(task, goal.workspaceWarning);
   clearStaleRunDeclaration(task, workDir);
+  clearStaleRequirementEvidence(task, workDir);
   const before = await gitChanges(workDir);
   task.attemptId = task.attemptId || newAttemptId(goal, task);
   if (goal) {
@@ -2804,7 +2989,7 @@ async function runTask(task) {
     task.secs = Math.round((Date.now() - t0) / 1000);
     task.status = r.code === 0 ? 'done' : 'failed';
     task.result = r.result.slice(0, RESULT_MAX);
-    task.requirementEvidence = parseRequirementEvidence(task.result);
+    readRequirementEvidence(task, workDir);
     task.usage = sumUsage([r.usage]);
     if (r.sessionId && goal) { setGoalAgentSession(goal, runAgent, r.sessionId); saveGoal(goal); }
     const approval = parseApprovalRequest(r.result);
@@ -2819,8 +3004,12 @@ async function runTask(task) {
     const afterR = await gitChanges(workDir);
     task.changedFiles = afterR.filter((l) => !before.includes(l)).map((l) => l.slice(3));
     task.unmappedChangedFiles = unmappedChangedFiles(task.changedFiles, task.requirementEvidence);
+    notePreviewScope(task);
     task.requirementVerification = { proof: task.proof ?? null, run: task.run ?? null, changedFiles: task.changedFiles };
     sendProcessAct(task, `Detected ${task.changedFiles.length} changed file${task.changedFiles.length === 1 ? '' : 's'} from this follow-up.`);
+    // An explicit worker receipt takes precedence over Galda's legacy prose
+    // guard. The agent owns this decision; Manager only transports it.
+    if (routeWorkerOutcome(goal, task, project)) return;
     const completionIssue = completionContractIssue({
       request: goal?.text,
       followUp: task.detail,
@@ -2994,7 +3183,7 @@ async function runTask(task) {
   // 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, RESULT_MAX);
-  task.requirementEvidence = parseRequirementEvidence(task.result);
+  readRequirementEvidence(task, workDir);
   task.usage = sumUsage(usages);
   if (verdict) {
     const label = verdict.pass ? 'PASS' : verdict.inconclusive ? 'INCONCLUSIVE (自動確認できず・要確認)' : 'FAIL';
@@ -3041,8 +3230,12 @@ async function runTask(task) {
   const after = await gitChanges(workDir);
   task.changedFiles = after.filter((l) => !before.includes(l)).map((l) => l.slice(3));
   task.unmappedChangedFiles = unmappedChangedFiles(task.changedFiles, task.requirementEvidence);
+  notePreviewScope(task);
   task.requirementVerification = { proof: task.proof ?? null, run: task.run ?? null, changedFiles: task.changedFiles };
   sendProcessAct(task, `Detected ${task.changedFiles.length} changed file${task.changedFiles.length === 1 ? '' : 's'} from this task.`);
+  // An explicit worker receipt takes precedence over Galda's legacy prose
+  // guard. The agent owns this decision; Manager only transports it.
+  if (routeWorkerOutcome(goal, task, project)) return;
   // task 450: taskStatusAfterVerify decided 'done' from `code` alone, before
   // changedFiles existed to check against. Don't trust a clean exit code by
   // itself — a worker that changed nothing and left a cut-off-looking result
@@ -5143,6 +5336,18 @@ const server = createServer(async (req, res) => {
       let answer = '';
       try { answer = String(JSON.parse(body || '{}').answer ?? '').trim(); } catch {}
       if (!answer) return json(res, 400, { error: 'answer required' });
+      // A worker-authored question is a transport pause, not a new planning
+      // cycle. Preserve the worker session and pass the user's answer straight
+      // back to it; Galda must not reinterpret or rewrite the answer.
+      if (goal.question?.kind === 'worker') {
+        goal.question = null;
+        goal.blocked = null;
+        goal.status = 'running';
+        goal.startedAt = null;
+        saveGoal(goal);
+        const replyTask = queueReplyTask(goal, answer, { from: 'you', via: 'question' });
+        return json(res, 200, { ...goal, replyTaskId: replyTask.id });
+      }
       // Bind this goal to a project rooted at `dir` and start planning. Shared by
       // the "picked a repo" and "git-init'd a new folder" paths below.
       const bindAndPlan = (dir) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galda/cli",
-  "version": "0.10.95",
+  "version": "0.10.97",
   "type": "module",
   "description": "Galda - hand off work to Claude Code or Codex, get proof back. Runs on your existing subscription, no extra API cost.",
   "scripts": {