@galda/cli 0.10.69 → 0.10.71

package/engine/lib.mjs

@@ -89,6 +89,36 @@ export function resolveEntryUrl({ entry, projectDir, managerRoot, port, accessKe
   return pathToFileURL(abs).href;
 }
 
+// Preserve the worker-declared artifact below an ephemeral Manager origin.
+export function rebasePreviewUrl(declaredUrl, serverUrl) {
+  if (!serverUrl) return declaredUrl ?? null;
+  if (!declaredUrl) return serverUrl;
+  try {
+    const declared = new URL(declaredUrl);
+    const server = new URL(serverUrl);
+    const params = new URLSearchParams(declared.search);
+    for (const [key, value] of server.searchParams) {
+      if (!params.has(key)) params.set(key, value);
+    }
+    server.pathname = declared.pathname || '/';
+    server.search = params.toString();
+    server.hash = declared.hash;
+    return server.toString();
+  } catch {
+    return serverUrl;
+  }
+}
+
+export function shouldCreateGoalPR(goal, files = []) {
+  return goal?.wantsPR === true && files.length > 0;
+}
+
+export function normalizePullRequestUrl(value) {
+  const text = typeof value === 'string' ? value.trim() : '';
+  if (!/^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+\/?$/i.test(text)) return null;
+  return text.replace(/\/$/, '');
+}
+
 // Extract token/cost usage from a parsed `type:'result'` stream-json event
 // (the final event of a `claude -p --output-format stream-json` run).
 // Returns null for any other event type.
@@ -157,6 +187,215 @@ export function sumUsageForToday(tasks, nowMs) {
   return sumUsage(usages);
 }
 
+// Internal quality metrics -------------------------------------------------------
+// These definitions intentionally describe sanitized state transitions only.
+// Prompt/request bodies, worker reports, file contents, names, and emails do not
+// belong in the metric payload; server.mjs writes only ids, status/category and
+// timestamps to the internal event log.
+export const INTERNAL_QUALITY_EVENT_DEFINITIONS = Object.freeze([
+  { type: 'goal_created', description: '依頼が goal として受け付けられた。prompt 本文は含めない。' },
+  { type: 'goal_doing_started', description: 'goal が Doing として実作業を開始した。' },
+  { type: 'goal_review_reached', description: 'goal が Review に到達した。' },
+  { type: 'goal_failed', description: 'goal が failed / blocked / interrupted / partial のいずれかに入った。' },
+  { type: 'goal_folded', description: 'goal が既存 Review goal に統合された。' },
+  { type: 'goal_fold_unfolded', description: '統合済み goal が人間操作で戻された。誤統合補正として数える。' },
+  { type: 'goal_reverted', description: 'goal が revert された。' },
+  { type: 'task_created', description: 'worker task が作られた。title/detail/prompt は含めない。' },
+  { type: 'task_doing_started', description: 'worker task が実行開始した。' },
+  { type: 'task_finished', description: 'worker task が terminal status になった。status と error category だけを含める。' },
+  { type: 'task_retry_requested', description: '人間または内部処理が task の再試行を要求した。' },
+  { type: 'task_skipped', description: 'task が skip された。理由本文は含めない。' },
+]);
+
+const INTERNAL_TERMINAL_TASK_STATUSES = new Set(['done', 'failed', 'interrupted', 'skipped']);
+const INTERNAL_FAILURE_GOAL_STATUSES = new Set(['failed', 'blocked', 'interrupted', 'partial']);
+const INTERNAL_OPEN_GOAL_STATUSES = new Set(['stacked', 'planning', 'running', 'needsInput', 'blocked', 'partial', 'retesting']);
+
+function timeMs(value) {
+  if (!value) return null;
+  const n = Date.parse(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function firstTime(current, value) {
+  const n = timeMs(value);
+  if (n == null) return current ?? null;
+  return current == null ? n : Math.min(current, n);
+}
+
+function summarizeMs(values) {
+  const list = values.filter((n) => Number.isFinite(n) && n >= 0).sort((a, b) => a - b);
+  if (!list.length) return { count: 0, avg: null, p50: null, p90: null, min: null, max: null };
+  const pick = (q) => list[Math.min(list.length - 1, Math.floor((list.length - 1) * q))];
+  return {
+    count: list.length,
+    avg: Math.round(list.reduce((a, b) => a + b, 0) / list.length),
+    p50: pick(0.5),
+    p90: pick(0.9),
+    min: list[0],
+    max: list[list.length - 1],
+  };
+}
+
+function rate(count, total) {
+  return { count, total, rate: total > 0 ? count / total : null };
+}
+
+export function classifyInternalQualityTaskError(task = {}) {
+  if (!['failed', 'interrupted'].includes(task.status)) return null;
+  const haystack = [
+    task.result,
+    task.error,
+    task.prError,
+    task.testResult?.detail,
+    ...(Array.isArray(task.testResult?.failingNames) ? task.testResult.failingNames : []),
+  ].filter(Boolean).join('\n');
+  if (task.testResult?.infraOnly || /server exited|server did not report ready|TimeoutError|Target closed|ECONNREFUSED|ENOSPC|EACCES|EROFS|net::|Navigation timeout|Waiting failed|timed out waiting/i.test(haystack)) {
+    return 'infra';
+  }
+  if (/claude|codex|worker|agent|auth|credential|logged out|bad credentials|not connected|command not found|spawn|rate limit|quota|usage limit|session unavailable|warm session|exit code|run limit|SIGTERM|SIGKILL/i.test(haystack)) {
+    return 'agent';
+  }
+  return null;
+}
+
+export function computeInternalQualityMetrics({ goals = [], tasks = [], events = [], nowMs = Date.now(), staleAfterMs = 24 * 60 * 60 * 1000 } = {}) {
+  const goalRows = new Map();
+  const taskRows = new Map();
+  const goal = (id) => {
+    if (id == null) return null;
+    if (!goalRows.has(id)) goalRows.set(id, { id, statuses: new Set(), folded: false, mergeCorrected: false });
+    return goalRows.get(id);
+  };
+  const task = (id) => {
+    if (id == null) return null;
+    if (!taskRows.has(id)) taskRows.set(id, { id, statuses: new Set(), retry: false });
+    return taskRows.get(id);
+  };
+
+  for (const g of goals ?? []) {
+    const row = goal(g?.id);
+    if (!row) continue;
+    row.projectId = g.projectId ?? row.projectId ?? null;
+    row.createdAt = firstTime(row.createdAt, g.createdAt);
+    row.doingAt = firstTime(row.doingAt, g.startedAt);
+    row.status = g.status ?? row.status ?? null;
+    if (g.status) row.statuses.add(g.status);
+    if (g.status === 'review') row.reviewAt = firstTime(row.reviewAt, g.reviewReachedAt ?? g.updatedAt);
+    if (g.status === 'folded' || g.foldedInto != null) row.folded = true;
+    if (g.noFold || g.status === 'reverted') row.mergeCorrected = true;
+  }
+  for (const t of tasks ?? []) {
+    const row = task(t?.id);
+    if (!row) continue;
+    row.goalId = t.goalId ?? row.goalId ?? null;
+    row.projectId = t.projectId ?? row.projectId ?? null;
+    row.createdAt = firstTime(row.createdAt, t.createdAt);
+    row.doingAt = firstTime(row.doingAt, t.startedAt);
+    row.finishedAt = firstTime(row.finishedAt, t.finishedAt);
+    row.status = t.status ?? row.status ?? null;
+    if (t.status) row.statuses.add(t.status);
+    if ((t.runAttempts ?? 0) > 1 || (t.retryCount ?? 0) > 0) row.retry = true;
+    row.errorCategory = row.errorCategory ?? classifyInternalQualityTaskError(t);
+  }
+
+  for (const e of events ?? []) {
+    const at = e?.at;
+    if (e?.goalId != null) {
+      const row = goal(e.goalId);
+      if (row) {
+        row.projectId = e.projectId ?? row.projectId ?? null;
+        if (e.type === 'goal_created') row.createdAt = firstTime(row.createdAt, at);
+        if (e.type === 'goal_doing_started') row.doingAt = firstTime(row.doingAt, at);
+        if (e.type === 'goal_review_reached') row.reviewAt = firstTime(row.reviewAt, at);
+        if (e.type === 'goal_failed') row.statuses.add(e.status ?? 'failed');
+        if (e.type === 'goal_folded') row.folded = true;
+        if (e.type === 'goal_fold_unfolded' || e.type === 'goal_reverted') row.mergeCorrected = true;
+      }
+    }
+    if (e?.taskId != null) {
+      const row = task(e.taskId);
+      if (row) {
+        row.goalId = e.goalId ?? row.goalId ?? null;
+        row.projectId = e.projectId ?? row.projectId ?? null;
+        if (e.type === 'task_created') row.createdAt = firstTime(row.createdAt, at);
+        if (e.type === 'task_doing_started') row.doingAt = firstTime(row.doingAt, at);
+        if (e.type === 'task_finished') {
+          row.finishedAt = firstTime(row.finishedAt, at);
+          row.status = e.status ?? row.status ?? null;
+          if (e.status) row.statuses.add(e.status);
+          row.errorCategory = e.category ?? row.errorCategory ?? null;
+        }
+        if (e.type === 'task_retry_requested') row.retry = true;
+        if (e.type === 'task_skipped') {
+          row.status = 'skipped';
+          row.statuses.add('skipped');
+        }
+      }
+    }
+  }
+
+  const goalList = [...goalRows.values()];
+  const taskList = [...taskRows.values()];
+  const startedGoals = goalList.filter((g) => g.doingAt != null);
+  const reviewGoals = startedGoals.filter((g) => g.reviewAt != null || g.statuses.has('review'));
+  const failedGoals = startedGoals.filter((g) => [...g.statuses].some((s) => INTERNAL_FAILURE_GOAL_STATUSES.has(s)));
+  const terminalTasks = taskList.filter((t) => INTERNAL_TERMINAL_TASK_STATUSES.has(t.status) || [...t.statuses].some((s) => INTERNAL_TERMINAL_TASK_STATUSES.has(s)));
+  const failedTasks = taskList.filter((t) => t.statuses.has('failed') || t.statuses.has('interrupted') || ['failed', 'interrupted'].includes(t.status));
+  const retryTasks = taskList.filter((t) => t.retry);
+  const skippedTasks = taskList.filter((t) => t.statuses.has('skipped') || t.status === 'skipped');
+  const infraTasks = terminalTasks.filter((t) => t.errorCategory === 'infra');
+  const agentTasks = terminalTasks.filter((t) => t.errorCategory === 'agent');
+  const foldedGoals = goalList.filter((g) => g.folded);
+  const mergeCorrectedGoals = foldedGoals.filter((g) => g.mergeCorrected);
+  const staleGoals = goalList.filter((g) => {
+    if (!INTERNAL_OPEN_GOAL_STATUSES.has(g.status)) return false;
+    const base = g.doingAt ?? g.createdAt;
+    return base != null && nowMs - base >= staleAfterMs;
+  });
+
+  return {
+    generatedAt: new Date(nowMs).toISOString(),
+    privacy: {
+      promptIncluded: false,
+      personalInfoIncluded: false,
+      fields: ['ids', 'projectId', 'status', 'category', 'timestamps'],
+    },
+    staleAfterMs,
+    eventDefinitions: INTERNAL_QUALITY_EVENT_DEFINITIONS,
+    counts: {
+      goals: goalList.length,
+      startedGoals: startedGoals.length,
+      reviewReachedGoals: reviewGoals.length,
+      failedGoals: failedGoals.length,
+      tasks: taskList.length,
+      terminalTasks: terminalTasks.length,
+      failedTasks: failedTasks.length,
+      retryTasks: retryTasks.length,
+      skippedTasks: skippedTasks.length,
+      infraErrorTasks: infraTasks.length,
+      agentErrorTasks: agentTasks.length,
+      foldedGoals: foldedGoals.length,
+      mergeCorrectedGoals: mergeCorrectedGoals.length,
+      staleGoals: staleGoals.length,
+    },
+    rates: {
+      reviewReach: rate(reviewGoals.length, startedGoals.length),
+      failure: rate(failedGoals.length, startedGoals.length),
+      retry: rate(retryTasks.length, failedTasks.length || terminalTasks.length),
+      infraError: rate(infraTasks.length, terminalTasks.length),
+      agentError: rate(agentTasks.length, terminalTasks.length),
+      misintegration: rate(mergeCorrectedGoals.length, foldedGoals.length),
+      stale: rate(staleGoals.length, goalList.length),
+      skip: rate(skippedTasks.length, terminalTasks.length || taskList.length),
+    },
+    durations: {
+      requestToDoingMs: summarizeMs(startedGoals.map((g) => g.doingAt - g.createdAt)),
+      doingToReviewMs: summarizeMs(reviewGoals.map((g) => g.reviewAt == null ? null : g.reviewAt - g.doingAt)),
+    },
+  };
+}
+
 // Token-frugal execution planning -------------------------------------------------
 // A visible Project is the user's mental workspace. Internally, Manager can
 // route goals into smaller workstreams and session policies so unrelated work
@@ -268,6 +507,87 @@ export function buildContextHandoffSummary({ goal = null, tasks = [] } = {}) {
   ].filter(Boolean).join('\n').slice(0, 4000);
 }
 
+export function goalSessionFor(goal, agent) {
+  if (!goal) return null;
+  const a = String(agent || goal.agent || 'claude-code');
+  const map = goal.sessions && typeof goal.sessions === 'object' ? goal.sessions : null;
+  if (map?.[a]) return String(map[a]);
+  if (goal.sessionId && !map && (!goal.sessionAgent || goal.sessionAgent === a)) return String(goal.sessionId);
+  return null;
+}
+
+export function setGoalAgentSession(goal, agent, sessionId) {
+  if (!goal || !sessionId) return null;
+  const a = String(agent || goal.agent || 'claude-code');
+  goal.sessions = { ...(goal.sessions && typeof goal.sessions === 'object' ? goal.sessions : {}), [a]: String(sessionId) };
+  if (!goal.agent || goal.agent === a) {
+    goal.sessionId = String(sessionId);
+    goal.sessionAgent = a;
+  }
+  return String(sessionId);
+}
+
+export function switchGoalAgentSession(goal, nextAgent) {
+  if (!goal) return null;
+  const previousAgent = String(goal.agent || 'claude-code');
+  if (goal.sessionId) setGoalAgentSession(goal, previousAgent, goal.sessionId);
+  goal.agent = nextAgent;
+  const sessionId = goalSessionFor(goal, nextAgent);
+  goal.sessionId = sessionId;
+  goal.sessionAgent = nextAgent;
+  return sessionId;
+}
+
+function compactList(items, { label, empty = 'not detected', max = 12 } = {}) {
+  const vals = [...new Set((items ?? []).map((x) => String(x ?? '').trim()).filter(Boolean))];
+  if (!vals.length) return `${label}: ${empty}`;
+  const shown = vals.slice(0, max);
+  const rest = vals.length - shown.length;
+  return `${label}: ${shown.join(', ')}${rest > 0 ? ` (+${rest} more)` : ''}`;
+}
+
+export function buildWorkerContextBlock({
+  agentName = 'claude-code',
+  model = null,
+  effort = null,
+  permissionMode = null,
+  cwd = null,
+  resumeSession = null,
+  sessionMode = null,
+  projectRules = [],
+  skills = [],
+  mcpSettings = [],
+  images = [],
+  selectedSkill = null,
+} = {}) {
+  const displayName = agentName === 'codex' ? 'Codex' : 'Claude Code';
+  const rules = (projectRules ?? []).map((r) => typeof r === 'string' ? r : r?.name).filter(Boolean);
+  const skillNames = (skills ?? []).map((s) => {
+    if (typeof s === 'string') return s;
+    const prefix = s?.kind === 'command' ? '/' : '';
+    const suffix = s?.source ? ` (${s.source})` : '';
+    return s?.name ? `${prefix}${s.name}${suffix}` : '';
+  });
+  const session = resumeSession
+    ? `resume ${resumeSession}`
+    : sessionMode === 'cold-handoff' || sessionMode === 'compact'
+      ? `${sessionMode}; no hidden transcript assumed`
+      : 'fresh for this agent/goal';
+  return [
+    'MANAGER-RUN CONTEXT (explicitly inherited; missing items are shown instead of silently dropped):',
+    `Agent: ${displayName} (${agentName})`,
+    `Selected model/effort: ${model || 'not specified'} / ${effort || 'not specified'}`,
+    `Permission mode: ${permissionMode || 'not specified'}`,
+    `Session: ${session}`,
+    `Working directory: ${cwd || 'not specified'}`,
+    compactList(rules, { label: 'Project rules files', empty: 'CLAUDE.md/AGENTS.md not detected in this worktree' }),
+    compactList(skillNames, { label: 'Available skills/commands' }),
+    selectedSkill ? `Selected skill: /${selectedSkill}` : 'Selected skill: none',
+    compactList(mcpSettings, { label: 'MCP/settings', empty: 'not detected or not introspected' }),
+    (images ?? []).length ? `Attached images: ${images.length} (${images.join(', ')})` : 'Attached images: none',
+  ].join('\n');
+}
+
 // task 6 (2026-07-16): "saved X%" used to be a proxy for cache-hit ratio —
 // this goal's own cache-read tokens discounted 0.1x, compared against this
 // same goal's raw total. That's real math, but it has nothing to do with
@@ -879,6 +1199,42 @@ export function workerResultText({ result = '', err = '', code = 0, timedOut = f
   return tail && isForcedStop(code, timedOut) ? `${reason}\n最後の作業 / last step: ${tail}` : reason;
 }
 
+export function classifyWorkerFailure({ agent = 'claude-code', result = '', err = '', code = 0, timedOut = false, phase = '' } = {}) {
+  const text = [result, err, phase].map((v) => String(v ?? '')).filter(Boolean).join('\n');
+  const low = text.toLowerCase();
+  const infra = (reason, actionIds = ['retry', 'view-log']) => ({
+    owner: 'galda-infra',
+    reason,
+    actionIds,
+  });
+  if (timedOut || /run limit|実行上限|timed out|timeout|タイムアウト/.test(low)) {
+    return infra('timeout', ['retry', 'run-with-codex', 'view-log']);
+  }
+  if (/spawn|enoent|eacces|command not found|executable|worker tool exited early|作業ツールが途中で終了/.test(low)) {
+    return infra('worker-start', ['retry', 'run-with-codex', 'view-log']);
+  }
+  if (/auth probe|preflight|not logged in|logged out|not authenticated|authentication|unauthorized|invalid api key|bad credentials|401\b|403\b|接続が必要|認証/.test(low)) {
+    return infra('auth', ['connect', 'check-connection', 'run-with-codex', 'view-log']);
+  }
+  if (/relay|websocket|socket|econnreset|econnrefused|billing-api unreachable|cf access|cloudflare access/.test(low)) {
+    return infra('relay', ['retry', 'connect', 'view-log']);
+  }
+  if (/chrome|chromium|puppeteer|target closed|browser|navigation timeout|waiting failed|screenshot|headless/.test(low)) {
+    return infra('chrome', ['retry', 'view-log']);
+  }
+  if (/test runner|node --test|npm test|project tests|server exited \(code \d+\) before it was ready|did not report ready in time|test timed out after|tap|not ok \d+/.test(low)) {
+    return infra('test-runner', ['retry-tests', 'view-log']);
+  }
+  if (/pr step failed|openpr|pull request|github|gh:|gh auth|git push|git fetch|git .*failed|pr作成|pr failed/.test(low)) {
+    return infra('pr', ['retry-pr', 'view-log']);
+  }
+  return {
+    owner: 'agent',
+    reason: agent === 'codex' ? 'codex' : 'claude-code',
+    actionIds: ['retry', agent === 'claude-code' ? 'run-with-codex' : 'run-with-claude', 'view-log'],
+  };
+}
+
 // Was the worker forcibly STOPPED (timeout or SIGTERM) rather than failing on
 // its own? Such a task is 'interrupted' (retryable, not a code failure) — never
 // a bare 'failed', which reads as "the worker's code was wrong". Mirrors the
@@ -1000,6 +1356,7 @@ export function buildGoalProofMd({ goalText, items, lang = 'ja' }) {
 // doesn't have to re-read the raw worker log to know what to look at.
 export function buildGoalPrBody({ lang, goal, goalTasks, files, owner, branch, proofRel, proofItemsCount, reviewDescription, reviewSummary }) {
   const L = (en, ja) => (lang === 'en' ? en : ja);
+  const workspaceMode = workspaceModeLabel(goal?.workspaceMode ?? goal?.worktree, lang);
   return [
     ...((reviewSummary?.check || reviewSummary?.changed) ? [
       L('## Check first', '## 確認ポイント'),
@@ -1018,6 +1375,9 @@ export function buildGoalPrBody({ lang, goal, goalTasks, files, owner, branch, p
     '',
     goal.text.slice(0, 1500),
     '',
+    L(`Workspace mode: ${workspaceMode}`, `workspace mode: ${workspaceMode}`),
+    ...(goal.workspaceWarning ? ['', L(`Workspace warning: ${goal.workspaceWarning}`, `workspace warning: ${goal.workspaceWarning}`)] : []),
+    '',
     ...buildReviewRuleSection(reviewDescription),
     L(`Implemented by Manager for AI: the goal was decomposed into ${goalTasks.length} task(s), each executed by a Claude Code worker (flat-rate, no extra API), tests written and run per task.${proofItemsCount ? ' Tasks with a pass condition were verified independently in a headless browser.' : ''}`,
       `Manager for AI が実装: ゴールを${goalTasks.length}個のタスクに分解し、Claude Code worker が順に実行（既存サブスク・追加API無し・タスク毎にテストを作成し実行）。${proofItemsCount ? '成功条件つきタスクは headless ブラウザで独立検証済み。' : ''}`),
@@ -1147,6 +1507,54 @@ export function classifyTestGate({ current = [], baseline = [] } = {}) {
   return { newFailures, preExisting, blocked: newFailures.length > 0 };
 }
 
+const PR_SAFETY_SCRATCH_RE = /(^|\/)\.tmp|\.log$|(^|\/)\.manager-wt(\/|$)|(^|\/)node_modules(\/|$)|(^|\/)secret\.key$/;
+
+export function classifyPrSafety({ baseline = null, files = [], currentFiles = [], currentBranch = null } = {}) {
+  if (!baseline?.sharedCheckout) return null;
+  const dirty = (baseline.dirtyFiles ?? []).filter((f) => f && !PR_SAFETY_SCRATCH_RE.test(f));
+  if (dirty.length) {
+    return {
+      code: 'dirty-baseline',
+      message: [
+        'PR creation skipped: this goal started in a dirty shared workspace, so Manager cannot prove the PR would contain only this task.',
+        `Existing dirty files at goal start: ${dirty.slice(0, 8).join(', ')}${dirty.length > 8 ? ` +${dirty.length - 8} more` : ''}.`,
+        'Repair: commit/stash/revert those unrelated changes, then rerun this reply with worktree on or from a clean checkout.',
+      ].join(' '),
+    };
+  }
+  if ((Number(baseline.aheadOfDefault) || 0) > 0) {
+    return {
+      code: 'branch-history',
+      message: [
+        'PR creation skipped: this goal started from a shared checkout with local commits ahead of the default branch.',
+        'Repair: switch to a clean default-branch checkout or enable worktree isolation, then rerun the task/reply so only this goal is in the PR.',
+      ].join(' '),
+    };
+  }
+  if (baseline.branch && currentBranch && baseline.branch !== currentBranch) {
+    return {
+      code: 'branch-changed',
+      message: [
+        `PR creation skipped: the shared checkout branch changed from ${baseline.branch} to ${currentBranch} during this goal.`,
+        'Repair: return to the baseline branch or rerun from a clean isolated worktree.',
+      ].join(' '),
+    };
+  }
+  const allowed = new Set(files ?? []);
+  const extra = (currentFiles ?? []).filter((f) => f && !allowed.has(f) && !PR_SAFETY_SCRATCH_RE.test(f));
+  if (extra.length) {
+    return {
+      code: 'extra-dirty-files',
+      message: [
+        'PR creation skipped: the shared checkout contains files outside this goal/task change list.',
+        `Extra files: ${extra.slice(0, 8).join(', ')}${extra.length > 8 ? ` +${extra.length - 8} more` : ''}.`,
+        'Repair: move those unrelated changes away, then rerun PR creation from a clean checkout.',
+      ].join(' '),
+    };
+  }
+  return null;
+}
+
 // A manager test-run that was KILLED before it could finish is inconclusive, not
 // a red. When the machine is saturated (prod + several worker goals all standing
 // up real servers + headless Chrome), `npm test` gets killed at its execFile
@@ -1232,6 +1640,40 @@ export function classifyVerifyGate({
   return { blocked, kind, proofAdvisory };
 }
 
+export function buildVerificationInfraError({ source = 'verification', detail = '', retryOnly = true } = {}) {
+  const text = String(detail ?? '').replace(/\s+/g, ' ').trim();
+  if (!text) return null;
+  return {
+    source,
+    title: '検証基盤エラー',
+    detail: text.slice(0, 600),
+    retryOnly: !!retryOnly,
+  };
+}
+
+export function verificationInfraErrorFrom({ testResult = null, proofNote = null } = {}) {
+  if (testResult?.inconclusive) {
+    return buildVerificationInfraError({
+      source: 'tests',
+      detail: 'Project tests could not complete because the verification runner was interrupted or saturated. The implementation result is still ready for human review; press 再検証 to rerun verification only.',
+    });
+  }
+  if (testResult?.infraOnly) {
+    const n = testResult.infraFlakes || testResult.failed || '';
+    return buildVerificationInfraError({
+      source: 'tests',
+      detail: `Project tests had ${n} infrastructure-only failure(s): a server could not boot, Chrome closed, or a wait timed out under machine load. This is not treated as an implementation failure; press 再検証 to rerun verification only.`,
+    });
+  }
+  if (proofNote) {
+    return buildVerificationInfraError({
+      source: 'proof',
+      detail: `${proofNote}。実装結果はReviewで確認できます。再検証ではコードを再実装せず、検証だけを再実行します。`,
+    });
+  }
+  return null;
+}
+
 // Serializes async work so at most one item runs at a time. The goal-verify
 // pipeline uses this to stop two goals' `npm test` runs (each spins up real
 // headless Chrome + real servers) from ever overlapping — running two full
@@ -1533,6 +1975,7 @@ export function buildReviewDigest({ goals, tasks } = {}) {
       checkLine: plan ? `PLAN — approve to execute: ${checkLine}`.slice(0, 90) : checkLine,
       pr: g.pr ?? null,
       testResult: g.testResult ?? null,
+      verificationInfraError: g.verificationInfraError ?? null,
       proof: goalTasks.find((t) => t.proof)?.proof ?? null,
       plan,
       planText: plan ? (g.planText ?? '') : null,
@@ -1545,6 +1988,7 @@ export function buildReviewDigest({ goals, tasks } = {}) {
       }
       if (existing.proof == null) existing.proof = row.proof;
       if (existing.testResult == null) existing.testResult = row.testResult;
+      if (existing.verificationInfraError == null) existing.verificationInfraError = row.verificationInfraError;
       continue;
     }
     if (row.pr) byPr.set(row.pr, row);
@@ -2098,6 +2542,25 @@ export function hasGitChanges(porcelainStatus) {
   return Boolean(String(porcelainStatus ?? '').trim());
 }
 
+export function resolveWorkspaceMode(input) {
+  if (input === 'direct-workspace' || input === 'direct') return 'direct-workspace';
+  if (input === 'isolated-worktree' || input === 'worktree' || input === true) return 'isolated-worktree';
+  if (input === false) return 'direct-workspace';
+  return 'isolated-worktree';
+}
+
+export function workspaceModeLabel(mode, lang = 'en') {
+  const m = resolveWorkspaceMode(mode);
+  if (m === 'direct-workspace') {
+    return lang === 'ja'
+      ? 'direct workspace（現在の作業状態を引き継ぐ）'
+      : 'direct workspace (inherits the current working state)';
+  }
+  return lang === 'ja'
+    ? 'isolated worktree（cleanな分離環境）'
+    : 'isolated worktree (clean separate checkout)';
+}
+
 // ---- project rules files (ONE-CONVERSATION §1.5a) --------------------------
 // The files that hold a project's working rules — the instructions the connected
 // AI actually reads (Claude Code reads CLAUDE.md from cwd; Codex reads AGENTS.md).
@@ -2139,6 +2602,67 @@ export function goalsConflict(filesA, filesB) {
   return b.some((f) => setA.has(f));
 }
 
+const REVIEW_FOLD_STOPWORDS = new Set([
+  'the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'onto', 'task', 'todo', 'goal',
+  'fix', 'add', 'update', 'change', 'make', 'view', 'list', 'section', 'button', 'status',
+  'する', 'した', 'して', 'こと', 'ため', 'よう', 'これ', 'それ', 'ところ', 'タスク', '表示', '追加', '修正',
+  'セクション', 'カード',
+]);
+function foldTextTokens(text) {
+  const s = String(text ?? '').toLowerCase();
+  const ascii = s.match(/[a-z0-9][a-z0-9+#._-]{1,}/g) ?? [];
+  const cjkRuns = s.match(/[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}ー]{2,}/gu) ?? [];
+  const cjk = [];
+  for (const run of cjkRuns) {
+    if (run.length <= 4) cjk.push(run);
+    else for (let i = 0; i < run.length - 1; i++) cjk.push(run.slice(i, i + 2));
+  }
+  return [...new Set([...ascii, ...cjk]
+    .map((t) => t.replace(/^#+/, '').trim())
+    .filter((t) => t.length >= 2 && !REVIEW_FOLD_STOPWORDS.has(t)))];
+}
+export function foldObjectivesRelated(a, b) {
+  const ta = foldTextTokens([a?.text, a?.title, a?.summary].filter(Boolean).join(' '));
+  const tb = foldTextTokens([b?.text, b?.title, b?.summary].filter(Boolean).join(' '));
+  if (!ta.length || !tb.length) return false;
+  const sb = new Set(tb);
+  const overlap = ta.filter((t) => sb.has(t));
+  if (overlap.length < 2) return false;
+  if (!overlap.some((t) => /[a-z0-9]/i.test(t))) return false;
+  const smaller = Math.min(ta.length, tb.length);
+  const ratio = overlap.length / Math.max(1, smaller);
+  return ratio >= 0.45 || overlap.length >= 4;
+}
+export function parseGitUnifiedDiffLocations(diffText) {
+  const out = [];
+  let file = null;
+  for (const raw of String(diffText ?? '').split('\n')) {
+    const plus = raw.match(/^\+\+\+ b\/(.+)$/);
+    if (plus) { file = plus[1]; continue; }
+    if (raw.startsWith('+++ /dev/null')) { file = null; continue; }
+    const h = raw.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (!h || !file) continue;
+    const oldStart = Number(h[1]), oldLen = h[2] == null ? 1 : Number(h[2]);
+    const newStart = Number(h[3]), newLen = h[4] == null ? 1 : Number(h[4]);
+    out.push({
+      file,
+      oldStart, oldEnd: oldStart + Math.max(1, oldLen) - 1,
+      newStart, newEnd: newStart + Math.max(1, newLen) - 1,
+    });
+  }
+  return out;
+}
+function rangesOverlap(aStart, aEnd, bStart, bEnd, margin = 2) {
+  return Math.max(aStart, bStart) <= Math.min(aEnd, bEnd) + margin;
+}
+export function foldLocationsOverlap(a, b) {
+  const la = a?.changeLocations ?? [], lb = b?.changeLocations ?? [];
+  if (!la.length || !lb.length) return false;
+  return la.some((x) => lb.some((y) => x.file === y.file
+    && (rangesOverlap(x.newStart, x.newEnd, y.newStart, y.newEnd)
+      || rangesOverlap(x.oldStart, x.oldEnd, y.oldStart, y.oldEnd))));
+}
+
 // Which of `otherGoals` (each `{ id, changedFiles }`) touch at least one path
 // this goal (`{ id, changedFiles }`) also touched? Returns their ids, in the
 // order they appear in `otherGoals` — server.mjs stamps these onto
@@ -2187,7 +2711,15 @@ export function pickFoldTarget(goal, candidates) {
   const overlapping = (candidates ?? []).filter(
     (g) => g && g.id !== goal.id && goalsConflict(files, g.changedFiles),
   );
-  return overlapping.length === 1 ? overlapping[0].id : null;
+  const eligible = overlapping.filter((g) => foldObjectivesRelated(goal, g) || foldLocationsOverlap(goal, g));
+  return eligible.length === 1 ? eligible[0].id : null;
+}
+
+// Two requests remain two human-review decisions by default, even when they
+// touch the same files. Legacy automatic folding is available only when a
+// project explicitly opts into it.
+export function autoFoldReviewsEnabled(project) {
+  return project?.autoFoldReviews === true;
 }
 
 // Which of `commits` (newest-first, as returned by parseGitLog) are new
@@ -2526,11 +3058,21 @@ export function buildGoalTask(goal, { id, num, passCondition = null, createdAt }
     title: goalTaskTitle(goal.text), detail: goal.text, passCondition,
     model: goal.model, effort: goal.effort, agent: goal.agent,
     mode: goal.mode ?? 'auto', skill: goal.skill ?? null,
+    workspaceMode: resolveWorkspaceMode(goal.workspaceMode ?? goal.worktree),
+    worktree: goal.worktree === false ? false : undefined,
     status: 'queued', createdAt, priority: '中',
     result: null, changedFiles: [], secs: null, activity: [], proof: null, usage: null,
   };
 }
 
+// Stability roadmap 03/08: the intake planner is no longer on the default
+// implementation route. It is reserved for the user explicitly selecting Plan
+// mode, where the product is allowed to ask the planning layer for structure or
+// clarification before the worker still receives the verbatim request.
+export function shouldUsePlannerForGoal(goal) {
+  return goal?.mode === 'plan';
+}
+
 // ---- worker prompt ---------------------------------------------------------
 // The instruction the worker (Claude Code / Codex) actually reads. Pure:
 // (task, goal, lastFailure, agentName) -> string, so it is unit-testable.
@@ -2544,13 +3086,14 @@ export function buildGoalTask(goal, { id, num, passCondition = null, createdAt }
 // Together they turned "design 3 patterns as an artifact" into one minimal
 // tweak. North star: we never re-judge the request — the user's verbatim words
 // are the source of truth and the worker delivers exactly what they ask for.
-export function workerPrompt(task, goal, lastFailure, agentName = 'claude-code') {
+export function workerPrompt(task, goal, lastFailure, agentName = 'claude-code', runContext = null) {
   // Optional skill the user attached to this goal. Empirically (scratch worker,
   // haiku, custom fixture skill) the reliably-firing form is an explicit Skill-tool
   // instruction as the FIRST line; a bare "/name" first line did not consistently
   // trigger the skill in `claude -p`. See commit body for the run evidence.
   const skill = task?.skill ?? goal?.skill;
   const displayName = agentName === 'codex' ? 'Codex' : 'Claude Code';
+  const workspaceMode = workspaceModeLabel(task?.workspaceMode ?? goal?.workspaceMode ?? goal?.worktree, 'en');
   // Report back to the human in the SAME language they wrote the goal in (Masa
   // 2026-07-15: "撃った言語で返す"). JP characters → Japanese, otherwise English.
   const replyLang = detectRequestLanguage(goal?.text || task?.title || '') === 'ja' ? '日本語' : 'English';
@@ -2563,9 +3106,11 @@ export function workerPrompt(task, goal, lastFailure, agentName = 'claude-code')
     // TASK/DETAIL below is a paraphrase from the planner — when they differ,
     // follow the user's words.
     goal?.text ? `USER'S REQUEST (verbatim — the source of truth; deliver exactly this):\n${goal.text}` : '',
+    runContext ? (typeof runContext === 'string' ? runContext : buildWorkerContextBlock(runContext)) : '',
     '',
     `TASK ${task.num}: ${task.title}`,
     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(' ')}` : '',
     task.passCondition ? `\nEXPLICIT PASS CONDITION (verified externally by a headless browser after you finish — NOT by you): ${task.passCondition}` : '',
     lastFailure ? `\nPREVIOUS ATTEMPT FAILED EXTERNAL VERIFICATION: ${lastFailure}\nYour previous changes are on disk. Diagnose and fix.` : '',
@@ -2606,6 +3151,7 @@ export function workerPrompt(task, goal, lastFailure, agentName = 'claude-code')
     // (research, summaries, answers) simply skip this — the worker decides,
     // never us.
     `- 人が実際に動かして結果を見られる依頼なら、最後にプロジェクト直下へ ${RUN_DECL_FILE} を書く: {"cmd": "<起動コマンド>", "url": "<開くURL>", "note": "<何が見えるか1行>", "check": "<人に何を見て判断してほしいか1行>", "title": "<この作業のチケット名。対象が分かる程度に説明的で動作を含む短い名前。例「看板モードの追加」「ヘッダのズレの修正」。依頼文をそのまま写さない>"}。Manager はこれを使って人に「動かして見る」と「何を見ればいいか」を出す。動かして見せるものが無い依頼（調査・要約・質問への回答など）では書かなくてよい。`,
+    `- Markdown・設計文書・調査メモなど文章そのものが成果物なら、${RUN_DECL_FILE} に別のHTMLや過去のURLを書かない。最終回答に成果物の本文も貼り、保存先のMarkdownリンクを添えること。「ファイルに書きました」だけで終わらない。`,
     `- 「ローカルで見れない」というフィードバックには、ターミナル操作や npx の再実行を案内して終わらないこと。${RUN_DECL_FILE} を実際に開ける内容へ更新し、可能なら自分でURLへ接続確認してから完了すること。`,
     // Links are rendered as links. The product cannot tell a real one from a
     // decorative one, so the only place this can be held is here.
@@ -3027,6 +3573,33 @@ export function latestGoalOutcomeTask(tasks = []) {
       - Date.parse(a.finishedAt || a.startedAt || a.createdAt || 0))[0] ?? null;
 }
 
+export function buildDirtyWorkspacePrBlock({ dirtyFiles = [], branch = null, base = null, ahead = 0 } = {}) {
+  const files = [...new Set(dirtyFiles)].filter(Boolean);
+  const branchRisk = branch && base && branch !== base;
+  const aheadCount = Number(ahead) || 0;
+  if (!files.length && !branchRisk && aheadCount === 0) return null;
+  const pieces = [];
+  if (files.length) pieces.push(`workspace was already dirty at goal start (${files.slice(0, 6).join(', ')}${files.length > 6 ? ` +${files.length - 6} more` : ''})`);
+  if (branchRisk) pieces.push(`current branch is ${branch}, not ${base}`);
+  if (aheadCount > 0) pieces.push(`current checkout has ${aheadCount} commit(s) ahead of ${base ?? 'the default branch'}`);
+  return {
+    message: `Not opening a PR because this run used the shared checkout and ${pieces.join('; ')}. Clean/stash unrelated changes or rerun with isolated worktree, then retry PR.`,
+    repair: {
+      kind: 'dirty-workspace',
+      title: 'PRを止めました / PR blocked',
+      steps: [
+        '既存のdirty差分をcommit/stash/破棄して、このtask以外の変更を片付ける',
+        'WorktreeをONにして同じreplyを再実行する',
+        '状態がきれいになったら「PR再試行」を押す',
+      ],
+      dirtyFiles: files.slice(0, 20),
+      branch,
+      base,
+      ahead: aheadCount,
+    },
+  };
+}
+
 // Plain-text snapshot of Review/Attention/Done fed to the /api/ask LLM pass —
 // same three buckets app/index.html's renderTasks() renders (goal.status
 // 'review'/'blocked' + task.status failed/interrupted + task.status