@openprd/cli 0.1.0 → 0.1.8

package/src/run-harness.js

@@ -1,8 +1,18 @@
 import fs from 'node:fs/promises';
+import path from 'node:path';
+import { labelExecutionMode, taskExecutionStrategy, describeExecutionStrategy } from './execution-strategy.js';
 import { appendJsonl, appendText, cjoin, exists, readJson, readJsonl, writeJson, writeText } from './fs-utils.js';
-import { OPENPRD_HARNESS_TURN_STATE, recordKnowledgeReviewSignal, reviewKnowledgeWorkspace } from './knowledge.js';
+import {
+  OPENPRD_HARNESS_TURN_STATE,
+  recordKnowledgeReviewSignal,
+  recordKnowledgeSkillAdoption,
+  resolveKnowledgeSkillMatches,
+  reviewKnowledgeWorkspace,
+} from './knowledge.js';
 import { readSessionBinding } from './session-binding.js';
+import { readSessionRegistryEntry } from './session-registry.js';
 import { timestamp } from './time.js';
+import { readWorkspaceRegistry } from './workspace-registry.js';
 
 const OPENPRD_HARNESS_DIR = cjoin('.openprd', 'harness');
 const OPENPRD_HARNESS_RUN_STATE = cjoin(OPENPRD_HARNESS_DIR, 'run-state.json');
@@ -11,18 +21,28 @@ const OPENPRD_HARNESS_LEARNINGS = cjoin(OPENPRD_HARNESS_DIR, 'learnings.md');
 const OPENPRD_HARNESS_LOOP_FEATURE_LIST = cjoin(OPENPRD_HARNESS_DIR, 'feature-list.json');
 const OPENPRD_HARNESS_REQUIREMENT_GATE = cjoin(OPENPRD_HARNESS_DIR, 'requirement-gate.json');
 const OPENPRD_HARNESS_REQUIREMENT_GATES_DIR = cjoin(OPENPRD_HARNESS_DIR, 'requirement-gates');
+const OPENPRD_HARNESS_SESSION_BINDINGS_DIR = cjoin(OPENPRD_HARNESS_DIR, 'session-bindings');
 const OPENPRD_HARNESS_EVENTS = cjoin(OPENPRD_HARNESS_DIR, 'events.jsonl');
 const OPENPRD_WORK_UNITS_DIR = cjoin('.openprd', 'engagements', 'work-units');
+const OPENPRD_PARALLEL_WORKER_IMPLEMENTATION_TASK_THRESHOLD = 3;
 const OPENPRD_LOOP_REQUIRED_IMPLEMENTATION_TASK_THRESHOLD = 10;
 const CONTINUATION_SESSION_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i;
 const CONTINUATION_TASK_HANDLE_PATTERN = /\b[a-z0-9._-]+:T\d{3}\.\d{2}:[a-z0-9._-]+\b/i;
 const CONTINUATION_WORK_UNIT_PATTERN = /\bwu-[a-z0-9._-]+\b/i;
-const CONTINUATION_EXPLICIT_PATTERN = /(继续(这个|这条|当前)?(对话|任务|会话|记录|历史)?|续做|接着做|继续执行|继续推进)/i;
+const CONTINUATION_EXPLICIT_PATTERN = /(?:(?:继续|续做|接着做|继续执行|继续推进)(?:这个|这条|当前)?\s*(?:对话|任务|会话|记录|历史|Codex\s*任务)|(?:对话|任务|会话|记录|历史|Codex\s*任务).{0,6}(?:继续|续做|接着做|继续执行|继续推进)|^(?:继续|续做|接着做|继续执行|继续推进)\s*(?::|：))/i;
 const CONTINUATION_CURRENT_PATTERN = /(继续当前|当前(这个|这条)?(任务|会话|记录|需求|变更)|current\s+(task|change|session)|resume current)/i;
+const SHORT_AFFIRMATIVE_PATTERN = /^(可以|好|行|确认|没问题|OK|ok|yes|Yes|yep|Yep)[。！!,.，\s]*$/;
 function harnessFile(projectRoot, relativePath) {
   return cjoin(projectRoot, relativePath);
 }
 
+function rootsEqual(left, right) {
+  if (!left || !right) {
+    return false;
+  }
+  return path.resolve(left) === path.resolve(right);
+}
+
 async function ensureRunHarness(projectRoot) {
   await fs.mkdir(harnessFile(projectRoot, OPENPRD_HARNESS_DIR), { recursive: true });
   const statePath = harnessFile(projectRoot, OPENPRD_HARNESS_RUN_STATE);
@@ -74,6 +94,7 @@ function compactTask(task) {
   if (!task) {
     return null;
   }
+  const executionStrategy = taskExecutionStrategy(task);
   return {
     id: task.id,
     taskHandle: task.taskHandle ?? null,
@@ -85,6 +106,60 @@ function compactTask(task) {
     oracle: task.metadata?.oracle ?? null,
     deps: task.metadata?.deps ?? null,
     type: task.metadata?.type ?? task.metadata?.category ?? task.metadata?.kind ?? null,
+    executionStrategy,
+    executionStrategyDescription: describeExecutionStrategy(executionStrategy),
+  };
+}
+
+function workerCandidateFromTask(task) {
+  const executionStrategy = taskExecutionStrategy(task);
+  if (executionStrategy.ownerRole !== 'worker') {
+    return null;
+  }
+  return {
+    id: task.id,
+    title: task.title,
+    parallelGroup: executionStrategy.parallelGroup,
+    writeScope: executionStrategy.writeScope,
+    localVerify: executionStrategy.localVerify,
+  };
+}
+
+function buildParallelPlan({ executionMode, taskState, focusTask, worktreeRecommended = false }) {
+  const eligible = executionMode !== 'serial';
+  const workerCandidates = (taskState?.tasks ?? [])
+    .filter((task) => !task.checked)
+    .map(workerCandidateFromTask)
+    .filter(Boolean);
+  const groups = [...new Set(workerCandidates.map((task) => task.parallelGroup))];
+  const focusCandidate = focusTask?.executionStrategy?.ownerRole === 'worker'
+    ? {
+        id: focusTask.id,
+        title: focusTask.title,
+        parallelGroup: focusTask.executionStrategy.parallelGroup,
+        writeScope: focusTask.executionStrategy.writeScope,
+        localVerify: focusTask.executionStrategy.localVerify,
+      }
+    : workerCandidates.find((task) => task.id === focusTask?.id) ?? null;
+
+  return {
+    eligible,
+    coordinator: 'main-agent',
+    integrationOwner: 'main-agent',
+    worktreeRecommended,
+    shardBasis: eligible ? 'write-scope-and-parallel-group' : 'single-thread',
+    suggestedWorkers: eligible ? Math.min(workerCandidates.length, worktreeRecommended ? 4 : 3) : 0,
+    workerTaskCount: workerCandidates.length,
+    groups,
+    focusTask: focusCandidate,
+    workerCandidates: workerCandidates.slice(0, worktreeRecommended ? 4 : 3),
+    summary: eligible
+      ? (
+          worktreeRecommended
+            ? '建议主 Agent 按 write-scope 和 parallel-group 把任务分给多个隔离 worker，会后由主 Agent 统一做集成审查和总验证。'
+            : '建议主 Agent 按 write-scope 和 parallel-group 分配边界清晰的 worker shard，worker 先做局部实现和局部验证，再由主 Agent 收口。'
+        )
+      : '当前任务保持主 Agent 串行推进即可。',
   };
 }
 
@@ -132,9 +207,83 @@ function reviewMarkCommand(snapshot) {
 function executionGate() {
   return {
     requiresExplicitIntent: true,
+    confirmationChecklistRequired: true,
     allowedIntents: ['开发', '实现', '修复', '继续任务', '落地执行', '深度调研', '深度对标', '复刻落地', '提交'],
     readOnlyIntents: ['看看', '规划', '梳理', '分析', '评估', '预计动哪些文件', '怎么改', '代码审查'],
-    rule: '只有当用户当前明确要求实现、继续、深度调研、对标或提交时，才运行 executionCommand。规划、分析、文件影响范围和审查类请求保持只读，并基于证据回答。',
+    rule: '只有当用户当前明确要求实现、继续、深度调研、对标或提交时，才运行 executionCommand。单纯的“请帮我实现/继续实现”只表示有执行意图，不表示可以跳过 requirement 摘要确认、`capture/classify/synthesize` 写入路径或 review；只有用户明确表示“不需要进行任何确认”时，才允许静默走完整 requirement write path，并对当前精确匹配的稳定 review artifact 记录确认。若还需要向用户索取执行授权，先展示 executionConfirmationChecklist，再请求明确确认；规划、分析、文件影响范围和审查类请求保持只读，并基于证据回答。',
+  };
+}
+
+function buildExecutionConfirmationChecklist(recommendation) {
+  if (!recommendation?.executionCommand) {
+    return null;
+  }
+  const parallelPlan = recommendation.parallelPlan ?? null;
+  const scope = [
+    '只在这次已经确认的范围内继续推进',
+    parallelPlan?.eligible ? '如果需要分头推进，会先划清各自负责的部分，再统一收口' : null,
+  ].filter(Boolean);
+  return {
+    required: true,
+    title: '开始动手前先确认这些',
+    objective: recommendation.title ?? '继续推进本次调整',
+    scope,
+    implementationItems: [
+      '我会先核对当前情况，再继续整理后续落地内容。',
+      '我只会在这次已经确认的范围内继续，不会顺手扩到别的事项。',
+      parallelPlan?.eligible ? '如果需要多人配合，我会先划清边界，再统一收口检查。' : null,
+    ].filter(Boolean),
+    outOfScope: [
+      '不会默认处理这次范围以外的历史问题。',
+      '不会默认顺带做提交、发布或额外的全局调整。',
+      '如果真的需要扩大范围，我会先单独说明。',
+    ].filter(Boolean),
+    verification: [
+      '完成后我会补做这次调整需要的检查。',
+      parallelPlan?.eligible ? '如果是分头推进，会先各自自检，再统一做总检查。' : null,
+      '在宣布完成前，我会再做一次整体核对。',
+    ].filter(Boolean),
+    risks: [
+      '这一步会正式写入当前工作区。',
+      '如果牵出和本次无关的历史遗留问题，我会单列说明，不把它混成本次失败。',
+      parallelPlan?.eligible ? '如果多人同时推进，我会避免范围互相踩踏。' : null,
+    ],
+    confirmationPrompt: '如果你希望我现在就按这次范围继续，我就直接往下做。',
+  };
+}
+
+function recommendationNeedsExtraExecutionConfirmation(recommendation, requirementGate) {
+  if (!recommendation?.executionCommand) {
+    return false;
+  }
+  const reviewContinuationAuthorized = Boolean(requirementGate?.reviewActionAuthorization?.continueAfterReview);
+  const silentReviewRecordingAuthorized = requirementGate?.status === 'review-recording-authorized';
+  const implementationAlreadyAuthorized = requirementGate?.status === 'execution-authorized';
+  const explicitExecution = Boolean(requirementGate?.intent?.explicitExecution);
+
+  if (recommendation.type === 'prd-change') {
+    return !(reviewContinuationAuthorized || silentReviewRecordingAuthorized);
+  }
+  if (recommendation.type === 'task' || recommendation.type === 'loop-task') {
+    return !(implementationAlreadyAuthorized || (explicitExecution && (reviewContinuationAuthorized || silentReviewRecordingAuthorized)));
+  }
+  return true;
+}
+
+function withExecutionConfirmationChecklist(recommendation, options = {}) {
+  if (!recommendationNeedsExtraExecutionConfirmation(recommendation, options.requirementGate)) {
+    return {
+      ...recommendation,
+      executionConfirmationChecklist: null,
+    };
+  }
+  const checklist = buildExecutionConfirmationChecklist(recommendation);
+  if (!checklist) {
+    return recommendation;
+  }
+  return {
+    ...recommendation,
+    executionConfirmationChecklist: checklist,
   };
 }
 
@@ -160,7 +309,7 @@ function analyzeRunMessage(message = null) {
   const workUnitId = text.match(CONTINUATION_WORK_UNIT_PATTERN)?.[0] ?? null;
   const explicit = CONTINUATION_EXPLICIT_PATTERN.test(text);
   const explicitCurrent = CONTINUATION_CURRENT_PATTERN.test(text);
-  const requested = explicit || Boolean(sessionId || taskHandle || workUnitId);
+  const requested = explicit || Boolean(taskHandle || workUnitId);
   if (!requested) {
     return {
       kind: 'default',
@@ -200,6 +349,14 @@ function normalizeSearchText(value) {
     .trim();
 }
 
+function stripMarkdownText(value) {
+  return String(value ?? '')
+    .replace(/\[[^\]]*]\([^)]+\)/g, ' ')
+    .replace(/[`*_>#~-]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
 function uniqueItems(items) {
   return [...new Set(items.filter(Boolean))];
 }
@@ -263,6 +420,77 @@ function scoreSearchCandidate(query, fields = []) {
   return bestScore;
 }
 
+function isShortAffirmativeMessage(message) {
+  return SHORT_AFFIRMATIVE_PATTERN.test(stripMarkdownText(message));
+}
+
+function requirementGateMatchesMessage(message, gate) {
+  if (!gate?.active) {
+    return false;
+  }
+  const text = String(message ?? '').trim();
+  if (!text || isShortAffirmativeMessage(text)) {
+    return true;
+  }
+  const gateFields = [
+    gate.promptPreview,
+    gate.reviewActionAuthorization?.promptPreview,
+  ].filter(Boolean);
+  if (gateFields.length === 0) {
+    return true;
+  }
+  const queryTokens = searchTokens(text);
+  const gateTokens = uniqueItems(gateFields.flatMap((field) => searchTokens(field)));
+  const sharedTokens = queryTokens.filter((token) => gateTokens.includes(token));
+  if (sharedTokens.some((token) => token.length >= 6)) {
+    return true;
+  }
+  const overlapBase = Math.min(queryTokens.length, gateTokens.length);
+  if (sharedTokens.length >= 2 && overlapBase > 0 && (sharedTokens.length / overlapBase) >= 0.5) {
+    return true;
+  }
+  return scoreSearchCandidate(text, gateFields) >= 80;
+}
+
+function assessRequirementGateRelevance({ message, gate, laneRequest, resolvedTarget }) {
+  if (!gate?.active) {
+    return {
+      active: false,
+      matchedCurrentMessage: false,
+      relevance: 'inactive',
+      reason: null,
+    };
+  }
+  if (laneRequest?.requested || resolvedTarget?.matched) {
+    return {
+      active: true,
+      matchedCurrentMessage: false,
+      relevance: 'background',
+      reason: '当前请求正在显式继续历史会话/任务，或已定位到更具体目标；active requirement intake 仅作为背景提醒。',
+    };
+  }
+  const matchedCurrentMessage = requirementGateMatchesMessage(message, gate);
+  return {
+    active: true,
+    matchedCurrentMessage,
+    relevance: matchedCurrentMessage ? 'primary' : 'background',
+    reason: matchedCurrentMessage
+      ? '当前请求与 active requirement intake 匹配，优先继续这条需求入口。'
+      : '当前请求与 active requirement intake 的摘要不匹配；旧 gate 仅作为背景提醒，不抢本轮默认路线。',
+  };
+}
+
+function appendRequirementGateReminder(reason, requirementGateAssessment, requirementGate) {
+  if (requirementGateAssessment?.relevance !== 'background' || !requirementGate?.active) {
+    return reason;
+  }
+  const reminder = [
+    requirementGateAssessment.reason,
+    requirementGate?.promptPreview ? `历史需求摘要: ${requirementGate.promptPreview}` : null,
+  ].filter(Boolean).join(' ');
+  return [reason, reminder].filter(Boolean).join(' ');
+}
+
 async function readFirstHeading(filePath, fallback = null) {
   const text = await fs.readFile(filePath, 'utf8').catch(() => '');
   const heading = text.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? null;
@@ -540,13 +768,43 @@ async function readSessionEvents(projectRoot, sessionId) {
   return events.filter((event) => event?.sessionId === sessionId);
 }
 
-async function resolveSessionTarget(projectRoot, sessionId, index, loopFeatureList) {
+async function readLoopFeatureList(projectRoot) {
+  return readJson(harnessFile(projectRoot, OPENPRD_HARNESS_LOOP_FEATURE_LIST)).catch(() => null);
+}
+
+async function findSessionWorkspaceCandidates(projectRoot, sessionId, options = {}) {
+  const registry = await readWorkspaceRegistry(options).catch(() => null);
+  if (!registry) {
+    return [];
+  }
+  const currentRoot = path.resolve(projectRoot);
+  const candidates = [];
+  for (const entry of registry.entries) {
+    if (rootsEqual(entry.workspaceRoot, currentRoot)) {
+      continue;
+    }
+    const bindingPath = cjoin(entry.workspaceRoot, OPENPRD_HARNESS_SESSION_BINDINGS_DIR, `${sessionId}.json`);
+    const gatePath = cjoin(entry.workspaceRoot, OPENPRD_HARNESS_REQUIREMENT_GATES_DIR, `${sessionId}.json`);
+    if (await exists(bindingPath)) {
+      candidates.push({ workspaceRoot: entry.workspaceRoot, source: 'session-binding' });
+      continue;
+    }
+    if (await exists(gatePath)) {
+      candidates.push({ workspaceRoot: entry.workspaceRoot, source: 'requirement-gate' });
+    }
+  }
+  return candidates;
+}
+
+async function resolveSessionTargetInWorkspace(projectRoot, sessionId, index, loopFeatureList, options = {}) {
   const binding = await readSessionBinding(projectRoot, sessionId);
   const gate = await readSessionRequirementGate(projectRoot, sessionId);
   const events = await readSessionEvents(projectRoot, sessionId);
   const directBindingArtifacts = binding ? { sessionBinding: true } : {};
+  const workspaceRoot = path.resolve(projectRoot);
   if (binding?.taskHandle) {
-    return resolveTaskHandleTarget(binding.taskHandle, index, loopFeatureList, {
+    return {
+      ...(resolveTaskHandleTarget(binding.taskHandle, index, loopFeatureList, {
       source: 'session-binding',
       sessionId,
       workUnitId: binding.workUnitId ?? null,
@@ -557,7 +815,10 @@ async function resolveSessionTarget(projectRoot, sessionId, index, loopFeatureLi
         events: events.length,
       },
       reason: `会话 ${sessionId} 的 lane 绑定命中任务句柄 ${binding.taskHandle}。`,
-    });
+      }) ?? {}),
+      workspaceRoot,
+      sameWorkspace: options.sameWorkspace ?? true,
+    };
   }
   if (binding?.changeId) {
     return {
@@ -576,6 +837,8 @@ async function resolveSessionTarget(projectRoot, sessionId, index, loopFeatureLi
         requirementGate: Boolean(gate),
         events: events.length,
       },
+      workspaceRoot,
+      sameWorkspace: options.sameWorkspace ?? true,
     };
   }
   if (binding?.workUnitId) {
@@ -596,6 +859,8 @@ async function resolveSessionTarget(projectRoot, sessionId, index, loopFeatureLi
         ...boundWorkUnitTarget,
         changeId: boundWorkUnitTarget.changeId ?? binding.changeId ?? null,
         title: boundWorkUnitTarget.title ?? binding.title ?? null,
+        workspaceRoot,
+        sameWorkspace: options.sameWorkspace ?? true,
       };
     }
   }
@@ -619,18 +884,22 @@ async function resolveSessionTarget(projectRoot, sessionId, index, loopFeatureLi
   };
   const taskHandle = extractFirstSelectorMatch(texts, CONTINUATION_TASK_HANDLE_PATTERN);
   if (taskHandle) {
-    return resolveTaskHandleTarget(taskHandle, index, loopFeatureList, {
+    return {
+      ...(resolveTaskHandleTarget(taskHandle, index, loopFeatureList, {
       source: 'session',
       sessionId,
       promptPreview,
       artifacts,
       reason: `会话 ${sessionId} 的本地记录命中任务句柄 ${taskHandle}。`,
-    });
+      }) ?? {}),
+      workspaceRoot,
+      sameWorkspace: options.sameWorkspace ?? true,
+    };
   }
   const workUnitId = gate?.reviewActionAuthorization?.workUnitId
     ?? extractFirstSelectorMatch(texts, CONTINUATION_WORK_UNIT_PATTERN);
   if (workUnitId) {
-    return resolveWorkUnitTarget(projectRoot, workUnitId, index, {
+    const resolvedWorkUnitTarget = await resolveWorkUnitTarget(projectRoot, workUnitId, index, {
       source: 'session',
       sessionId,
       promptPreview,
@@ -638,6 +907,11 @@ async function resolveSessionTarget(projectRoot, sessionId, index, loopFeatureLi
       query: texts.join(' '),
       reason: `会话 ${sessionId} 的本地记录命中工作单元 ${workUnitId}。`,
     });
+    return {
+      ...resolvedWorkUnitTarget,
+      workspaceRoot,
+      sameWorkspace: options.sameWorkspace ?? true,
+    };
   }
   const semanticMatch = resolveSemanticTarget(texts.join(' '), index, {
     source: 'session',
@@ -647,7 +921,11 @@ async function resolveSessionTarget(projectRoot, sessionId, index, loopFeatureLi
     reason: `会话 ${sessionId} 的本地 requirement / hook 历史命中已有任务对象。`,
   });
   if (semanticMatch) {
-    return semanticMatch;
+    return {
+      ...semanticMatch,
+      workspaceRoot,
+      sameWorkspace: options.sameWorkspace ?? true,
+    };
   }
   return {
     matched: false,
@@ -663,22 +941,98 @@ async function resolveSessionTarget(projectRoot, sessionId, index, loopFeatureLi
       ? `本地找到了会话 ${sessionId} 的 requirement gate / hook 事件，但还没有足够证据绑定到具体 change/task/work unit。`
       : `本地没有会话 ${sessionId} 的 requirement gate、hook 事件或 work unit 绑定。`,
     artifacts,
+    workspaceRoot,
+    sameWorkspace: options.sameWorkspace ?? true,
   };
 }
 
+async function resolveSessionTarget(projectRoot, sessionId, index, loopFeatureList, options = {}) {
+  const registryEntry = await readSessionRegistryEntry(sessionId, options).catch(() => null);
+  if (registryEntry?.workspaceRoot && !rootsEqual(registryEntry.workspaceRoot, projectRoot)) {
+    const targetArtifacts = await options.resolveWorkspaceArtifacts?.(registryEntry.workspaceRoot) ?? {
+      index,
+      loopFeatureList: await readLoopFeatureList(registryEntry.workspaceRoot),
+    };
+    const resolved = await resolveSessionTargetInWorkspace(
+      registryEntry.workspaceRoot,
+      sessionId,
+      targetArtifacts.index ?? index,
+      targetArtifacts.loopFeatureList ?? loopFeatureList,
+      { sameWorkspace: false },
+    );
+    return {
+      ...resolved,
+      workspaceRoot: registryEntry.workspaceRoot,
+      registryEntry,
+      reason: [
+        `全局 session registry 已把会话 ${sessionId} 归属到 ${registryEntry.workspaceRoot}。`,
+        resolved.reason,
+      ].filter(Boolean).join(' '),
+    };
+  }
+
+  const localResolution = await resolveSessionTargetInWorkspace(projectRoot, sessionId, index, loopFeatureList, {
+    sameWorkspace: true,
+  });
+  if (localResolution.matched || registryEntry) {
+    return {
+      ...localResolution,
+      registryEntry,
+    };
+  }
+
+  const candidates = await findSessionWorkspaceCandidates(projectRoot, sessionId, options);
+  if (candidates.length === 1) {
+    const candidate = candidates[0];
+    const targetArtifacts = await options.resolveWorkspaceArtifacts?.(candidate.workspaceRoot) ?? {
+      index,
+      loopFeatureList: await readLoopFeatureList(candidate.workspaceRoot),
+    };
+    const resolved = await resolveSessionTargetInWorkspace(
+      candidate.workspaceRoot,
+      sessionId,
+      targetArtifacts.index ?? index,
+      targetArtifacts.loopFeatureList ?? loopFeatureList,
+      { sameWorkspace: false },
+    );
+    return {
+      ...resolved,
+      workspaceRoot: candidate.workspaceRoot,
+      candidates,
+      reason: [
+        `全局 session registry 还没有会话 ${sessionId}，已根据 repo-local 线索定位到候选工作区 ${candidate.workspaceRoot}。`,
+        resolved.reason,
+      ].filter(Boolean).join(' '),
+    };
+  }
+  if (candidates.length > 1) {
+    return {
+      ...localResolution,
+      source: 'session-candidates',
+      workspaceRoot: null,
+      candidates,
+      reason: `全局 session registry 还没有会话 ${sessionId}，并且在多个工作区都找到了候选线索：${candidates.map((item) => item.workspaceRoot).join('、')}。`,
+    };
+  }
+  return localResolution;
+}
+
 async function resolveRunTarget({
   projectRoot,
   message,
   request,
   index,
   loopFeatureList,
+  resolveWorkspaceArtifacts,
 }) {
   const text = String(message ?? '').trim();
   if (!text) {
     return null;
   }
   if (request.sessionId) {
-    return resolveSessionTarget(projectRoot, request.sessionId, index, loopFeatureList);
+    return resolveSessionTarget(projectRoot, request.sessionId, index, loopFeatureList, {
+      resolveWorkspaceArtifacts,
+    });
   }
   if (request.taskHandle) {
     return resolveTaskHandleTarget(request.taskHandle, index, loopFeatureList);
@@ -694,8 +1048,8 @@ async function resolveRunTarget({
   return resolveSemanticTarget(text, index);
 }
 
-function selectFocusedChangeId(request, resolvedTarget, activeChange) {
-  if (resolvedTarget?.changeId) {
+function selectFocusedChangeId(projectRoot, request, resolvedTarget, activeChange) {
+  if (resolvedTarget?.changeId && (!resolvedTarget.workspaceRoot || rootsEqual(resolvedTarget.workspaceRoot, projectRoot))) {
     return resolvedTarget.changeId;
   }
   if (request.sessionId || request.taskHandle || request.workUnitId) {
@@ -733,7 +1087,7 @@ function describeRunLane(lane) {
   return `继续已有任务 (${selectorLabel}: ${target})`;
 }
 
-function buildRunLane({ message, recommendation, activeChange, latestPrd, loopFeatureList, resolvedTarget }) {
+function buildRunLane({ message, recommendation, activeChange, latestPrd, loopFeatureList, resolvedTarget, projectRoot }) {
   const request = analyzeRunMessage(message);
   if (!request.requested) {
     if (resolvedTarget?.matched) {
@@ -743,6 +1097,7 @@ function buildRunLane({ message, recommendation, activeChange, latestPrd, loopFe
         taskId: resolvedTarget.taskId ?? recommendation?.task?.id ?? null,
         changeId: resolvedTarget.changeId ?? recommendation?.changeId ?? null,
         workUnitId: resolvedTarget.workUnitId ?? latestPrd?.workUnitId ?? null,
+        workspaceRoot: resolvedTarget.workspaceRoot ?? projectRoot,
       };
       const lane = {
         kind: 'targeted',
@@ -753,6 +1108,7 @@ function buildRunLane({ message, recommendation, activeChange, latestPrd, loopFe
         matched: Boolean(target.sessionId || target.taskHandle || target.taskId || target.changeId || target.workUnitId),
         resolution: resolvedTarget,
         activeChange,
+        currentProjectRoot: projectRoot,
       };
       return {
         ...lane,
@@ -776,6 +1132,7 @@ function buildRunLane({ message, recommendation, activeChange, latestPrd, loopFe
       taskId: resolvedTarget?.taskId ?? null,
       changeId: resolvedTarget?.changeId ?? null,
       workUnitId: resolvedTarget?.workUnitId ?? null,
+      workspaceRoot: resolvedTarget?.workspaceRoot ?? projectRoot,
     };
     matched = Boolean(resolvedTarget?.matched);
   } else if (request.selectorType === 'task-handle') {
@@ -785,6 +1142,7 @@ function buildRunLane({ message, recommendation, activeChange, latestPrd, loopFe
       taskId: resolvedTarget?.taskId ?? matchedLoopTask?.id ?? null,
       changeId: resolvedTarget?.changeId ?? matchedLoopTask?.changeId ?? null,
       workUnitId: resolvedTarget?.workUnitId ?? null,
+      workspaceRoot: resolvedTarget?.workspaceRoot ?? projectRoot,
     };
     matched = Boolean(resolvedTarget?.matched || matchedLoopTask);
   } else if (request.selectorType === 'work-unit') {
@@ -794,6 +1152,7 @@ function buildRunLane({ message, recommendation, activeChange, latestPrd, loopFe
       taskId: resolvedTarget?.taskId ?? null,
       changeId: resolvedTarget?.changeId ?? null,
       workUnitId: resolvedTarget?.workUnitId ?? request.workUnitId ?? null,
+      workspaceRoot: resolvedTarget?.workspaceRoot ?? projectRoot,
     };
     matched = Boolean(resolvedTarget?.matched);
   } else {
@@ -803,6 +1162,7 @@ function buildRunLane({ message, recommendation, activeChange, latestPrd, loopFe
       taskId: recommendation?.task?.id ?? null,
       changeId: recommendation?.changeId ?? activeChange ?? null,
       workUnitId: latestPrd?.workUnitId ?? null,
+      workspaceRoot: projectRoot,
     };
     matched = Boolean(target.taskHandle || target.taskId || target.changeId || target.workUnitId);
   }
@@ -812,6 +1172,7 @@ function buildRunLane({ message, recommendation, activeChange, latestPrd, loopFe
     matched,
     resolution: resolvedTarget ?? null,
     activeChange,
+    currentProjectRoot: projectRoot,
   };
   return {
     ...lane,
@@ -821,6 +1182,8 @@ function buildRunLane({ message, recommendation, activeChange, latestPrd, loopFe
 
 function buildSessionContinuationRecommendation(recommendation, lane) {
   const sessionId = lane?.target?.sessionId ?? lane?.sessionId ?? lane?.selector ?? null;
+  const targetWorkspaceRoot = lane?.target?.workspaceRoot ?? lane?.resolution?.workspaceRoot ?? lane?.currentProjectRoot ?? null;
+  const crossWorkspace = Boolean(targetWorkspaceRoot && lane?.currentProjectRoot && !rootsEqual(targetWorkspaceRoot, lane.currentProjectRoot));
   const recoveredTarget = [
     lane?.target?.changeId ? `变更 ${lane.target.changeId}` : null,
     lane?.target?.taskHandle ? `任务句柄 ${lane.target.taskHandle}` : null,
@@ -830,11 +1193,16 @@ function buildSessionContinuationRecommendation(recommendation, lane) {
     type: 'session-continuation',
     title: sessionId ? `恢复历史会话 ${sessionId}` : '恢复历史会话',
     command: sessionId
-      ? `openprd run . --context --message ${shellQuote(sessionId)}`
+      ? (
+          crossWorkspace
+            ? `openprd run ${shellQuote(targetWorkspaceRoot)} --context --message ${shellQuote(sessionId)}`
+            : `openprd run . --context --message ${shellQuote(sessionId)}`
+        )
       : 'openprd run . --context',
     verifyCommand: 'openprd run . --verify',
     reason: [
-      '当前请求给出的是工具无关的会话 ID；先按本地会话索引恢复该会话历史，再决定后续任务对象。',
+      '当前请求给出的是工具无关的会话 ID；先按全局 session registry 和 repo-local 线索恢复该会话历史，再决定后续任务对象。',
+      crossWorkspace ? `该会话归属到工作区 ${targetWorkspaceRoot}，不能继续复用当前工作区的 active 状态。` : null,
       recoveredTarget ? `本地已恢复到 ${recoveredTarget}。` : (lane?.resolution?.reason ?? '本地还没有足够证据把这个会话绑定到具体 change/task/work unit。'),
       lane?.resolution?.promptPreview ? `会话摘要: ${lane.resolution.promptPreview}` : null,
       '不能用相似历史、当前 active change 或当前 requirement gate 替代这个会话 ID。',
@@ -852,6 +1220,11 @@ function buildSessionContinuationRecommendation(recommendation, lane) {
       : null,
     coverageItem: null,
     continuationTarget: lane.target ?? null,
+    isolation: {
+      required: true,
+      worktreeRecommended: true,
+      reason: crossWorkspace ? '跨工作区恢复时先回到正确 workspace，再在隔离环境里继续实现。' : '历史会话恢复默认建议使用独立 session / cwd，避免共享执行线内容。',
+    },
     previousRecommendation: recommendation
       ? {
           type: recommendation.type ?? null,
@@ -881,6 +1254,9 @@ function buildUnresolvedContinuationRecommendation({ message, request, resolutio
       `当前请求显式给出了${selectorLabel}，但本地 OpenPrd 索引还不能把它精确绑定到 change/task/work unit。`,
       resolution?.reason ?? null,
       activeChange ? `当前工作区 active change ${activeChange} 只作为背景提醒，不会自动顶替这个显式目标。` : null,
+      Array.isArray(resolution?.candidates) && resolution.candidates.length > 0
+        ? `候选工作区: ${resolution.candidates.map((item) => item.workspaceRoot).join('、')}。`
+        : null,
     ].filter(Boolean).join(' '),
     changeId: null,
     task: null,
@@ -958,11 +1334,11 @@ function buildPrdPromotionRecommendation({ changes, next }) {
 
   return {
     type: 'prd-change',
-    title: `生成 ${suggestedChangeId} 的 change 和任务拆解`,
+    title: '整理本次调整，并拆出后续任务',
     command: 'openprd review . --open',
     executionCommand: `openprd change . --generate --change ${shellQuote(suggestedChangeId)}`,
     verifyCommand: `openprd change . --validate --change ${shellQuote(suggestedChangeId)}`,
-    reason: '最新 PRD review.html 已确认，但还没有 active change；进入实现前需要先生成 change、spec 和结构化任务。',
+    reason: '这版需求已经确认，下一步先整理本次调整范围，再拆出可直接执行的后续任务。',
     changeId: suggestedChangeId,
     task: null,
     coverageItem: null,
@@ -983,9 +1359,9 @@ function buildRequirementIntakeRecommendation({ gate, next, activeChange }) {
     'clarify-user': '继续本轮需求入口澄清',
     classify: '补齐本轮需求的产品类型',
     interview: '补齐本轮需求的关键事实',
-    synthesize: '生成本轮需求的 PRD 评审稿',
+    synthesize: '生成本轮需求的确认稿',
     diagram: '生成本轮需求的可视化评审',
-    review: '确认本轮需求的 review.html',
+    review: '查看并确认本轮需求稿',
     freeze: '进入本轮需求定稿前检查',
     handoff: '导出本轮需求交接包',
   };
@@ -995,8 +1371,8 @@ function buildRequirementIntakeRecommendation({ gate, next, activeChange }) {
     command: next?.recommendation?.suggestedCommand ?? 'openprd clarify .',
     verifyCommand: 'openprd run . --verify',
     reason: [
-      '当前有 active requirement intake；先围绕本轮需求完成澄清、评审、change 和任务拆解。',
-      activeChange ? `历史 active change ${activeChange} 仅作为提醒，不抢本轮默认执行路线。` : null,
+      '当前有一条还在推进中的新需求；先把需求澄清、确认，再整理本次调整和后续任务。',
+      activeChange ? `之前还有一项历史事项 ${activeChange}，这里只把它当背景提醒，不抢这次主线。` : null,
       next?.recommendation?.reason ?? null,
     ].filter(Boolean).join(' '),
     changeId: null,
@@ -1011,7 +1387,86 @@ function buildRequirementIntakeRecommendation({ gate, next, activeChange }) {
   };
 }
 
+function buildStoredVerificationRecommendation(runState, options = {}) {
+  const lastVerification = runState?.lastVerification;
+  if (!lastVerification || lastVerification.taskReady !== true) {
+    return null;
+  }
+  const workspaceReady = lastVerification.workspaceReady === true;
+  const workspaceAttention = lastVerification.workspaceAttention ?? null;
+  const changeId = lastVerification.changeId ?? options.focusedChangeId ?? options.activeChange ?? null;
+  return {
+    type: workspaceReady ? 'verification-ready' : 'verification-workspace-attention',
+    title: workspaceReady ? '当前项目已完成并通过验证' : '当前任务已完成，工作区还有待处理项',
+    command: 'openprd run . --verify',
+    verifyCommand: 'openprd run . --verify',
+    reason: workspaceReady
+      ? '最近一次 run verify 已经闭环，当前没有待执行任务或待澄清入口；除非有新需求进入，否则优先复用已沉淀结果。'
+      : (workspaceAttention?.detail ?? '最近一次 run verify 显示任务级验证已通过，但工作区级别还有待补证据或待收口项。'),
+    changeId,
+    task: null,
+    coverageItem: null,
+    verification: lastVerification,
+  };
+}
+
+function buildVerificationRecommendation({ changeId, readiness, workspaceAttention, knowledgeReview, qualityCheck }) {
+  if (readiness.taskReady !== true) {
+    return {
+      type: 'verification-fix',
+      title: '先修复当前验证失败项',
+      command: 'openprd run . --verify',
+      verifyCommand: 'openprd run . --verify',
+      reason: '最近一次 run verify 没有通过当前任务级验证，需要先修复标准、变更或任务级检查失败项。',
+      changeId,
+      task: null,
+      coverageItem: null,
+      verification: {
+        ...readiness,
+        workspaceAttention,
+        knowledgeCandidateId: knowledgeReview?.candidateId ?? null,
+        qualityReportPath: qualityCheck?.reportPath ?? null,
+      },
+    };
+  }
+  if (readiness.workspaceReady === true) {
+    return {
+      type: 'verification-ready',
+      title: '当前项目已完成并通过验证',
+      command: 'openprd run . --verify',
+      verifyCommand: 'openprd run . --verify',
+      reason: '最近一次 run verify、quality、standards 和变更验证都已闭环；当前没有新的待执行动作时，不应该再回到 clarify-user。',
+      changeId,
+      task: null,
+      coverageItem: null,
+      verification: {
+        ...readiness,
+        workspaceAttention,
+        knowledgeCandidateId: knowledgeReview?.candidateId ?? null,
+        qualityReportPath: qualityCheck?.reportPath ?? null,
+      },
+    };
+  }
+  return {
+    type: 'verification-workspace-attention',
+    title: '当前任务已完成，工作区还有待处理项',
+    command: 'openprd run . --verify',
+    verifyCommand: 'openprd run . --verify',
+    reason: workspaceAttention?.detail ?? '最近一次 run verify 显示当前任务已通过，但工作区级别还有待补证据或待收口项。',
+    changeId,
+    task: null,
+    coverageItem: null,
+    verification: {
+      ...readiness,
+      workspaceAttention,
+      knowledgeCandidateId: knowledgeReview?.candidateId ?? null,
+      qualityReportPath: qualityCheck?.reportPath ?? null,
+    },
+  };
+}
+
 function buildRunRecommendation({
+  projectRoot,
   message,
   changes,
   activeChange,
@@ -1021,8 +1476,10 @@ function buildRunRecommendation({
   next,
   loopFeatureList,
   requirementGate,
+  requirementGateAssessment,
   laneRequest,
   resolvedTarget,
+  runState,
 }) {
   if (
     ['task-handle', 'work-unit'].includes(laneRequest?.selectorType)
@@ -1035,7 +1492,7 @@ function buildRunRecommendation({
       activeChange,
     });
   }
-  if (requirementGate?.active && !laneRequest?.requested && !resolvedTarget?.matched) {
+  if (requirementGateAssessment?.relevance === 'primary') {
     return buildRequirementIntakeRecommendation({ gate: requirementGate, next, activeChange });
   }
   if (taskState?.nextTask) {
@@ -1044,6 +1501,29 @@ function buildRunRecommendation({
     const pendingTasks = Number(taskState.summary?.pending ?? 0);
     const implementationTasks = Number(taskState.summary?.implementation?.total ?? 0);
     const pendingImplementationTasks = Number(taskState.summary?.implementation?.pending ?? 0);
+    const laneRequiresIsolation = Boolean(
+      resolvedTarget?.workspaceRoot && !rootsEqual(resolvedTarget.workspaceRoot, projectRoot)
+        || ['session', 'task-handle', 'work-unit'].includes(laneRequest?.selectorType ?? '')
+    );
+    const executionMode = laneRequiresIsolation
+      ? 'parallel-workers-isolated'
+      : (
+      implementationTasks >= OPENPRD_LOOP_REQUIRED_IMPLEMENTATION_TASK_THRESHOLD
+      || pendingImplementationTasks >= OPENPRD_LOOP_REQUIRED_IMPLEMENTATION_TASK_THRESHOLD
+    )
+      ? 'parallel-workers-isolated'
+      : (
+          implementationTasks >= OPENPRD_PARALLEL_WORKER_IMPLEMENTATION_TASK_THRESHOLD
+          || pendingImplementationTasks >= OPENPRD_PARALLEL_WORKER_IMPLEMENTATION_TASK_THRESHOLD
+        )
+          ? 'parallel-workers'
+          : 'serial';
+    const parallelPlan = buildParallelPlan({
+      executionMode,
+      taskState,
+      focusTask: task,
+      worktreeRecommended: laneRequiresIsolation || executionMode === 'parallel-workers-isolated',
+    });
     if (
       implementationTasks >= OPENPRD_LOOP_REQUIRED_IMPLEMENTATION_TASK_THRESHOLD
       || pendingImplementationTasks >= OPENPRD_LOOP_REQUIRED_IMPLEMENTATION_TASK_THRESHOLD
@@ -1051,7 +1531,7 @@ function buildRunRecommendation({
       const loopReady = loopFeatureList?.changeId === taskState.changeId && Array.isArray(loopFeatureList.tasks);
       return {
         type: 'loop-task',
-        title: `用 Loop 执行 ${task.id}: ${task.title}`,
+        title: `继续推进：${task.title}`,
         command: `openprd tasks . --change ${shellQuote(taskState.changeId)}`,
         preparationCommand: loopReady
           ? `openprd loop . --next --item ${shellQuote(task.id)}`
@@ -1061,11 +1541,15 @@ function buildRunRecommendation({
           : `openprd loop . --plan --change ${shellQuote(taskState.changeId)} && openprd loop . --run --agent codex --item ${shellQuote(task.id)}`,
         commitCommand: `openprd loop . --finish --item ${shellQuote(task.id)} --commit`,
         verifyCommand: `openprd loop . --verify --item ${shellQuote(task.id)}`,
-        reason: `当前变更包含 ${implementationTasks} 个实质实现任务，达到 ${OPENPRD_LOOP_REQUIRED_IMPLEMENTATION_TASK_THRESHOLD} 个实现任务的拆分阈值；建议使用独立 worktree 和 OpenPrd Loop 单任务会话，且只有用户明确要求开发、继续任务或深度对标落地时才执行。`,
+        reason: laneRequiresIsolation
+          ? '这件事来自指定历史记录，最好放到单独环境里接着做，避免和别的事项串线。'
+          : '待落地内容比较多，适合拆成一个个独立小任务推进，再统一收口检查。',
         changeId: taskState.changeId,
         task,
         coverageItem: null,
         intentGate: executionGate(),
+        executionMode,
+        parallelPlan,
         loop: {
           required: true,
           threshold: OPENPRD_LOOP_REQUIRED_IMPLEMENTATION_TASK_THRESHOLD,
@@ -1078,17 +1562,27 @@ function buildRunRecommendation({
         },
       };
     }
+    const lightweightReason = laneRequiresIsolation
+      ? '这件事来自指定历史记录，最好放到单独环境里继续，避免和别的事项串线。'
+      : executionMode === 'parallel-workers'
+        ? '待处理的落地内容比较多，适合先分头推进，再统一收口检查。'
+        : '已经有一项可以继续推进的后续任务；只要用户明确要继续，就可以往下做。';
     return {
       type: 'task',
-      title: `推进 ${task.id}: ${task.title}`,
+      title: `继续推进：${task.title}`,
       command: `openprd tasks . --change ${shellQuote(taskState.changeId)}`,
+      preparationCommand: executionMode === 'parallel-workers'
+        ? `openprd loop . --plan --change ${shellQuote(taskState.changeId)}`
+        : null,
       executionCommand: `openprd tasks . --change ${shellQuote(taskState.changeId)} --advance --verify --item ${shellQuote(task.id)}`,
       verifyCommand: task.verify ?? `openprd tasks . --change ${shellQuote(taskState.changeId)} --verify --item ${shellQuote(task.id)}`,
-      reason: '存在一个依赖已就绪的 OpenPrd 任务；只有用户明确要求开发、实现或继续任务时才推进。',
+      reason: lightweightReason,
       changeId: taskState.changeId,
       task,
       coverageItem: null,
       intentGate: executionGate(),
+      executionMode,
+      parallelPlan,
       loop: {
         required: false,
         threshold: OPENPRD_LOOP_REQUIRED_IMPLEMENTATION_TASK_THRESHOLD,
@@ -1096,17 +1590,17 @@ function buildRunRecommendation({
         pendingTasks,
         implementationTasks,
         pendingImplementationTasks,
-        worktreeRecommended: false,
+        worktreeRecommended: laneRequiresIsolation,
       },
     };
   }
   if (taskState && taskState.summary?.pending === 0 && focusedChangeId) {
     return {
       type: 'change-review',
-      title: `校验已完成的变更 ${focusedChangeId}`,
+      title: '检查本次调整是否都已补齐',
       command: `openprd change . --validate --change ${shellQuote(focusedChangeId)}`,
       verifyCommand: `openprd change . --validate --change ${shellQuote(focusedChangeId)}`,
-      reason: '当前激活变更没有待处理的结构化任务。',
+      reason: '当前这次调整里的后续任务已经处理完了。',
       changeId: focusedChangeId,
       task: null,
       coverageItem: null,
@@ -1121,11 +1615,11 @@ function buildRunRecommendation({
     const item = compactCoverageItem(nextCoverage);
     return {
       type: 'discovery',
-      title: `调研 ${item.title}`,
+      title: `继续补充调研：${item.title}`,
       command: 'openprd discovery . --verify',
       executionCommand: `openprd discovery . --advance --item ${shellQuote(item.id)} --claim <evidence-backed-claim> --evidence <path>`,
       verifyCommand: 'openprd discovery . --verify',
-      reason: '存在一个待处理的 OpenPrd discovery 覆盖项；只有用户明确要求深度调研、对标、复刻或持续补全时才推进覆盖项。',
+      reason: '还有一个待补的调研点；只有用户明确要求继续深挖、对标或复刻时再推进。',
       changeId: focusedChangeId ?? activeChange,
       task: null,
       coverageItem: item,
@@ -1135,21 +1629,35 @@ function buildRunRecommendation({
   if (discovery?.coverageMatrix?.summary?.pending === 0 && discovery?.runId) {
     return {
       type: 'discovery-review',
-      title: `校验 discovery run ${discovery.runId}`,
+      title: '检查这轮调研是否已经收口',
       command: 'openprd discovery . --verify',
       verifyCommand: 'openprd discovery . --verify',
-      reason: '当前 discovery run 没有待处理覆盖项。',
+      reason: '当前这轮调研已经没有待补项了。',
       changeId: focusedChangeId ?? activeChange,
       task: null,
       coverageItem: null,
     };
   }
+  const storedVerificationRecommendation = (
+    requirementGateAssessment?.relevance !== 'primary'
+    && !laneRequest?.requested
+    && !resolvedTarget?.matched
+    && (next?.recommendation?.nextAction ?? 'clarify-user') === 'clarify-user'
+  )
+    ? buildStoredVerificationRecommendation(runState, {
+      activeChange,
+      focusedChangeId,
+    })
+    : null;
+  if (storedVerificationRecommendation) {
+    return storedVerificationRecommendation;
+  }
   return {
     type: 'workflow',
-    title: next?.recommendation?.nextAction ?? 'Inspect OpenPrd next action',
+    title: next?.recommendation?.nextAction ?? '查看当前建议下一步',
     command: next?.recommendation?.suggestedCommand ?? 'openprd next .',
     verifyCommand: 'openprd validate .',
-    reason: next?.recommendation?.reason ?? 'No active task or discovery item was found.',
+    reason: next?.recommendation?.reason ?? '当前没有找到可以直接继续推进的任务或调研项。',
     changeId: focusedChangeId ?? activeChange,
     task: null,
     coverageItem: null,
@@ -1188,11 +1696,25 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
         status: next.analysisSnapshot.status ?? null,
       }
     : null;
-  const loopFeatureList = await readJson(harnessFile(projectRoot, OPENPRD_HARNESS_LOOP_FEATURE_LIST)).catch(() => null);
+  const resolutionCache = new Map();
+  async function resolveWorkspaceArtifacts(targetProjectRoot) {
+    const key = path.resolve(targetProjectRoot);
+    if (resolutionCache.has(key)) {
+      return resolutionCache.get(key);
+    }
+    const targetChanges = await listOpenPrdChangesWorkspace(targetProjectRoot).catch(() => null);
+    const artifacts = {
+      changes: targetChanges,
+      index: await buildRunResolutionIndex(targetProjectRoot, targetChanges, listOpenSpecTaskWorkspace).catch(() => null),
+      loopFeatureList: await readLoopFeatureList(targetProjectRoot),
+    };
+    resolutionCache.set(key, artifacts);
+    return artifacts;
+  }
+  const currentWorkspaceArtifacts = await resolveWorkspaceArtifacts(projectRoot);
+  const loopFeatureList = currentWorkspaceArtifacts.loopFeatureList;
   const shouldResolveTarget = Boolean(String(options.message ?? '').trim());
-  const resolutionIndex = shouldResolveTarget
-    ? await buildRunResolutionIndex(projectRoot, changes, listOpenSpecTaskWorkspace)
-    : null;
+  const resolutionIndex = shouldResolveTarget ? currentWorkspaceArtifacts.index : null;
   const resolvedTarget = shouldResolveTarget
     ? await resolveRunTarget({
         projectRoot,
@@ -1200,15 +1722,23 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
         request: laneRequest,
         index: resolutionIndex,
         loopFeatureList,
+        resolveWorkspaceArtifacts,
       })
     : null;
-  const focusedChangeId = selectFocusedChangeId(laneRequest, resolvedTarget, activeChange);
+  const requirementGateAssessment = assessRequirementGateRelevance({
+    message: options.message,
+    gate: requirementGate,
+    laneRequest,
+    resolvedTarget,
+  });
+  const focusedChangeId = selectFocusedChangeId(projectRoot, laneRequest, resolvedTarget, activeChange);
   const taskState = focusedChangeId
     ? await listOpenSpecTaskWorkspace(projectRoot, { change: focusedChangeId }).catch(() => null)
     : null;
   const resumedDiscovery = await resumeOpenSpecDiscoveryWorkspace(projectRoot).catch(() => null);
   const discovery = shouldSurfaceDiscoveryInRunContext(resumedDiscovery) ? resumedDiscovery : null;
   const recommendation = buildRunRecommendation({
+    projectRoot,
     message: options.message,
     changes,
     activeChange,
@@ -1218,8 +1748,10 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
     next,
     loopFeatureList,
     requirementGate,
+    requirementGateAssessment,
     laneRequest,
     resolvedTarget,
+    runState,
   });
   const nextTask = compactTask(taskState?.nextTask ?? null);
   const lane = buildRunLane({
@@ -1229,8 +1761,58 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
     latestPrd,
     loopFeatureList,
     resolvedTarget,
+    projectRoot,
   });
-  const effectiveRecommendation = applyLaneToRecommendation(recommendation, lane);
+  const recommendationWithGateReminder = {
+    ...recommendation,
+    reason: appendRequirementGateReminder(
+      recommendation.reason,
+      requirementGateAssessment,
+      requirementGate,
+    ),
+  };
+  const effectiveRecommendation = withExecutionConfirmationChecklist(
+    applyLaneToRecommendation(recommendationWithGateReminder, lane),
+    { requirementGate },
+  );
+  const knowledgeSkillMatches = await resolveKnowledgeSkillMatches(projectRoot, {
+    message: options.message,
+    prompt: options.message,
+    recommendationTitle: effectiveRecommendation.title,
+    recommendationReason: effectiveRecommendation.reason,
+    activeChange,
+    nextTaskTitle: nextTask?.title,
+    relatedFiles: [
+      focusedChangeId ? `openprd/changes/${focusedChangeId}/tasks.md` : null,
+      activeChange ? `openprd/changes/${activeChange}` : null,
+    ].filter(Boolean),
+    limit: options.hookInject ? 4 : 3,
+  }).catch(() => ({ matched: [], summary: { matched: 0 } }));
+  const knowledgeAdoption = knowledgeSkillMatches.matched?.length > 0
+    ? await recordKnowledgeSkillAdoption(projectRoot, {
+      matches: knowledgeSkillMatches.matched,
+      stages: options.hookInject ? ['hit', 'referenced', 'injected'] : ['hit', 'referenced'],
+      source: options.hookInject ? 'run-context-hook' : 'run-context',
+      sessionId: lane.target?.sessionId ?? resolvedTarget?.sessionId ?? requirementGate?.sessionId ?? null,
+      promptPreview: options.message,
+    }).catch(() => null)
+    : null;
+  const knowledgeStageBump = {
+    hitCount: options.hookInject ? 1 : 1,
+    referencedCount: 1,
+    injectedCount: options.hookInject ? 1 : 0,
+  };
+  const renderedKnowledgeSkills = (knowledgeSkillMatches.matched ?? []).map((skill) => ({
+    ...skill,
+    adoption: skill.adoption
+      ? {
+        ...skill.adoption,
+        hitCount: Number(skill.adoption.hitCount ?? 0) + knowledgeStageBump.hitCount,
+        referencedCount: Number(skill.adoption.referencedCount ?? 0) + knowledgeStageBump.referencedCount,
+        injectedCount: Number(skill.adoption.injectedCount ?? 0) + knowledgeStageBump.injectedCount,
+      }
+      : skill.adoption,
+  }));
 
   const context = {
     ok: validation.valid,
@@ -1251,6 +1833,9 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
           promptPreview: requirementGate.promptPreview ?? null,
           intakeMode: requirementGate.intakeMode ?? null,
           sessionId: requirementGate.sessionId ?? null,
+          relevance: requirementGateAssessment.relevance,
+          matchedCurrentMessage: requirementGateAssessment.matchedCurrentMessage,
+          relevanceReason: requirementGateAssessment.reason,
         }
       : null,
     prdReviewState: next?.prdReviewState
@@ -1267,6 +1852,7 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
     focus: {
       changeId: focusedChangeId,
       source: resolvedTarget?.source ?? null,
+      workspaceRoot: resolvedTarget?.workspaceRoot ?? projectRoot,
       sessionId: resolvedTarget?.sessionId ?? lane.target?.sessionId ?? null,
       taskHandle: resolvedTarget?.taskHandle ?? null,
       workUnitId: resolvedTarget?.workUnitId ?? null,
@@ -1290,6 +1876,14 @@ async function buildRunContext(projectRoot, dependencies, options = {}) {
       : null,
     lane,
     recommendation: effectiveRecommendation,
+    knowledgeSkills: {
+      matched: renderedKnowledgeSkills,
+      summary: {
+        matched: renderedKnowledgeSkills.length,
+        hookInjected: Boolean(options.hookInject && renderedKnowledgeSkills.length > 0),
+        adoption: knowledgeAdoption?.summary ?? null,
+      },
+    },
     files: {
       runState: OPENPRD_HARNESS_RUN_STATE,
       iterations: OPENPRD_HARNESS_ITERATIONS,
@@ -1351,6 +1945,51 @@ async function verifyRunWorkspace(projectRoot, dependencies, options = {}) {
     verifyOpenSpecDiscoveryWorkspace,
     verifyQualityWorkspace,
   } = dependencies;
+  const summarizeWorkspaceAttention = (quality) => {
+    const report = quality?.report ?? null;
+    const attentionGates = Array.isArray(report?.readiness?.attentionGates)
+      ? report.readiness.attentionGates.filter(Boolean)
+      : [];
+    const activeTasks = report?.evalHarness?.featureCoverage?.activeTasks ?? null;
+    if (attentionGates.length === 1 && attentionGates[0] === 'feature-coverage' && activeTasks?.pending > 0) {
+      const activeChange = activeTasks.activeChange ?? null;
+      const total = Number(activeTasks.total ?? 0);
+      const done = Number(activeTasks.done ?? 0);
+      const pending = Number(activeTasks.pending ?? 0);
+      const blocked = Number(activeTasks.blocked ?? 0);
+      const progress = total > 0 ? `${done}/${total}` : `${done}`;
+      const changeLabel = activeChange ? `active change ${activeChange}` : 'the active task ledger';
+      return {
+        kind: 'feature-coverage-ledger',
+        gate: 'feature-coverage',
+        gates: attentionGates,
+        activeChange,
+        total,
+        done,
+        pending,
+        blocked,
+        summary: 'feature-coverage ledger remains open',
+        detail: `${changeLabel} still has ${pending} pending tasks (${progress} done)${blocked > 0 ? `, with ${blocked} blocked` : ''}. This usually means task bookkeeping or coverage evidence is incomplete, not that the current implementation failed.`,
+      };
+    }
+    if (attentionGates.length > 0) {
+      return {
+        kind: 'quality-gates',
+        gates: attentionGates,
+        summary: `quality attention gates: ${attentionGates.join(', ')}`,
+        detail: `Current task verification passed, but workspace-level quality still needs evidence for: ${attentionGates.join(', ')}.`,
+      };
+    }
+    if (quality?.report?.readiness?.productionReady === false) {
+      return {
+        kind: 'quality-readiness',
+        gates: [],
+        summary: 'quality report is not production-ready',
+        detail: 'Current task verification passed, but the workspace-level quality report still needs attention before overall readiness can be claimed.',
+      };
+    }
+    return null;
+  };
   const context = await buildRunContext(projectRoot, dependencies, options);
   const standards = await checkStandardsWorkspace(projectRoot);
   const validation = await validateWorkspace(projectRoot).then(({ report }) => report);
@@ -1364,9 +2003,12 @@ async function verifyRunWorkspace(projectRoot, dependencies, options = {}) {
       errors: [error instanceof Error ? error.message : String(error)],
     }));
     const productionReady = quality.report?.readiness?.productionReady ?? null;
+    const workspaceAttention = summarizeWorkspaceAttention(quality);
     const qualityErrors = [
       ...(quality.errors ?? []),
-      ...(productionReady === false ? ['Quality report is not production-ready. Review required gates and evidence before claiming readiness.'] : []),
+      ...(productionReady === false
+        ? [workspaceAttention?.detail ?? 'Quality report is not production-ready. Review required gates and evidence before claiming readiness.']
+        : []),
     ];
     checks.push({
       name: 'quality',
@@ -1377,6 +2019,7 @@ async function verifyRunWorkspace(projectRoot, dependencies, options = {}) {
       htmlPath: quality.htmlPath ?? null,
       productionReady,
       attentionGates: quality.report?.readiness?.attentionGates ?? [],
+      workspaceAttention,
     });
   }
   const changeToVerify = context.focus?.changeId ?? context.recommendation?.changeId ?? context.activeChange ?? null;
@@ -1392,8 +2035,16 @@ async function verifyRunWorkspace(projectRoot, dependencies, options = {}) {
   const workspaceChecks = checks;
   const taskReady = taskChecks.every((check) => check.ok);
   const workspaceReady = workspaceChecks.every((check) => check.ok);
-  const ok = taskReady;
   const qualityCheck = checks.find((check) => check.name === 'quality');
+  const workspaceAttention = taskReady && !workspaceReady
+    ? (qualityCheck?.workspaceAttention ?? {
+      kind: 'workspace-checks',
+      checks: workspaceChecks.filter((check) => !check.ok).map((check) => check.name),
+      summary: `workspace attention: ${workspaceChecks.filter((check) => !check.ok).map((check) => check.name).join(', ')}`,
+      detail: `Current task verification passed, but workspace-level checks still need attention: ${workspaceChecks.filter((check) => !check.ok).map((check) => check.name).join(', ')}.`,
+    })
+    : null;
+  const ok = taskReady;
   const readiness = {
     taskReady,
     workspaceReady,
@@ -1408,8 +2059,9 @@ async function verifyRunWorkspace(projectRoot, dependencies, options = {}) {
     workspaceReady,
     productionReady: qualityCheck?.productionReady ?? null,
     attentionGates: qualityCheck?.attentionGates ?? [],
+    workspaceAttentionKind: workspaceAttention?.kind ?? null,
     summary: taskReady
-      ? (workspaceReady ? 'run verify passed' : `run verify task-ready with workspace attention: ${workspaceChecks.filter((check) => !check.ok).map((check) => check.name).join(', ')}`)
+      ? (workspaceReady ? 'run verify passed' : `run verify task-ready with workspace attention: ${workspaceAttention?.summary ?? workspaceChecks.filter((check) => !check.ok).map((check) => check.name).join(', ')}`)
       : `run verify failed: ${taskChecks.filter((check) => !check.ok).map((check) => check.name).join(', ')}`,
   };
   await recordKnowledgeReviewSignal(projectRoot, knowledgeSignal).catch(() => null);
@@ -1422,9 +2074,29 @@ async function verifyRunWorkspace(projectRoot, dependencies, options = {}) {
   }).catch((error) => ({
     ok: false,
     action: 'quality-knowledge-review',
-    skipped: false,
-    errors: [error instanceof Error ? error.message : String(error)],
+      skipped: false,
+      errors: [error instanceof Error ? error.message : String(error)],
   }));
+  const verificationRecommendation = buildVerificationRecommendation({
+    changeId: changeToVerify,
+    readiness,
+    workspaceAttention,
+    knowledgeReview,
+    qualityCheck,
+  });
+  const runState = await readRunState(projectRoot);
+  await writeRunState(projectRoot, {
+    ...runState,
+    lastVerificationAt: timestamp(),
+    lastVerification: {
+      ...readiness,
+      changeId: changeToVerify,
+      workspaceAttention,
+      knowledgeCandidateId: knowledgeReview?.candidateId ?? null,
+      qualityReportPath: qualityCheck?.reportPath ?? null,
+    },
+    lastRecommendation: verificationRecommendation,
+  });
   await appendJsonl(harnessFile(projectRoot, OPENPRD_HARNESS_ITERATIONS), {
     version: 1,
     at: timestamp(),
@@ -1444,8 +2116,10 @@ async function verifyRunWorkspace(projectRoot, dependencies, options = {}) {
     context,
     checks,
     readiness,
+    workspaceAttention,
     warnings,
     knowledgeReview,
+    recommendation: verificationRecommendation,
     errors,
   };
 }