@moretea-labs/forge 1.5.1 → 1.6.0

package/src/runtime/control-plane/launcher/chatgpt-work-continuation.ts

@@ -1,4 +1,4 @@
-import { randomUUID } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
 import { executeBrowserPluginAction, readBrowserPluginConfiguration } from '../../plugins/browser-adapter';
 import { controllerPluginRepository } from '../../plugins/store';
 import { getWorkContract } from '../facade/work-contract-store';
@@ -8,10 +8,19 @@ import {
   type ChatgptWorkConversationBinding,
 } from './chatgpt-work-binding-store';
 
-const CONTROLLER_CHATGPT_SESSION_ID = 'forge-chatgpt-supercontroller';
-const CHATGPT_PROMPT_SELECTOR = '[name="prompt-textarea"]';
-const CHATGPT_SEND_KEY = 'Enter';
-const CHATGPT_ALLOWED_DOMAINS = ['chatgpt.com', 'www.chatgpt.com'];
+const LEGACY_CONTROLLER_CHATGPT_SESSION_ID = 'forge-chatgpt-supercontroller';
+export const DEFAULT_CHATGPT_AUTOMATION_MODEL = 'gpt-5.6';
+export const DEFAULT_CHATGPT_AUTOMATION_REASONING = 'high';
+export const DEFAULT_CHATGPT_AUTOMATION_TAB_POLICY = 'auto';
+export const DEFAULT_CHATGPT_AUTOMATION_PLUGIN_MENTION = '@forge';
+const CHATGPT_PROMPT_SELECTOR = 'div#prompt-textarea[contenteditable="true"]';
+const CHATGPT_SEND_SELECTOR = '[data-testid="send-button"]';
+const CHATGPT_INTELLIGENCE_CONTROL_SELECTOR = 'main button';
+const CHATGPT_CAPABILITY_SLIDER_SELECTOR = '[role="slider"]';
+const CHATGPT_CAPABILITY_MENUITEM_SELECTOR = '[role="menuitem"][aria-keyshortcuts~="ArrowLeft"][aria-keyshortcuts~="ArrowRight"]';
+
+export type ChatgptAutomationReasoning = 'medium' | 'high' | 'xhigh';
+export type ChatgptAutomationTabPolicy = 'auto' | 'reuse' | 'new';
 
 export interface WorkChatgptContinuationInput {
   controllerHome: string;
@@ -22,9 +31,39 @@ export interface WorkChatgptContinuationInput {
   title?: string;
   browserSessionId?: string;
   conversationUrl?: string;
+  model?: string;
+  reasoning?: ChatgptAutomationReasoning;
+  tabPolicy?: ChatgptAutomationTabPolicy;
   timeoutMs?: number;
 }
 
+export interface ScheduledChatgptPromptInput {
+  controllerHome: string;
+  repoId: string;
+  automationId: string;
+  prompt: string;
+  title?: string;
+  browserSessionId?: string;
+  conversationUrl?: string;
+  model?: string;
+  reasoning?: ChatgptAutomationReasoning;
+  tabPolicy?: ChatgptAutomationTabPolicy;
+  timeoutMs?: number;
+}
+
+export interface ScheduledChatgptPromptResult {
+  status: 'dispatched' | 'failed';
+  provider: 'controller-browser';
+  browserSessionId: string;
+  conversationUrl?: string;
+  model: string;
+  reasoning: ChatgptAutomationReasoning;
+  tabPolicy: ChatgptAutomationTabPolicy;
+  executionPreferenceVerified: boolean;
+  reusedSession: boolean;
+  error?: { code: string; message: string };
+}
+
 export interface WorkChatgptContinuationResult {
   status: 'dispatched' | 'failed';
   provider: 'controller-browser';
@@ -33,9 +72,15 @@ export interface WorkChatgptContinuationResult {
   conversationId?: string;
   localAlias?: string;
   resumedFromBinding: boolean;
+  model: string;
+  reasoning: ChatgptAutomationReasoning;
+  tabPolicy: ChatgptAutomationTabPolicy;
+  executionPreferenceVerified: boolean;
   error?: { code: string; message: string };
 }
 
+const workflowToolAttributionInstruction = (workId: string): string => `Forge Workflow execution contract: first claim exact Work ${workId}. For every repository_command_execute and repository_safe_patch_apply call in this turn, pass work_id=${workId} explicitly. MCP transport sessions may change between tool calls; never omit this Work id.`;
+
 function requestId(workId: string, actionId: string): string {
   return `chatgpt-work:${workId}:${actionId}:${randomUUID()}`;
 }
@@ -68,7 +113,6 @@ async function ensureControllerChatgptBrowser(controllerHome: string, workId: st
   const repoRoot = repository.canonicalRoot ?? repository.localRoot;
   if (!repoRoot) throw new Error('CHATGPT_CONTROLLER_BROWSER_ROOT_UNAVAILABLE');
   const existing = readBrowserPluginConfiguration(repoRoot);
-  const allowedDomains = [...new Set([...existing.allowedDomains, ...CHATGPT_ALLOWED_DOMAINS])];
   await controllerBrowserAction(controllerHome, workId, 'configure', {
     enabled: true,
     ...(!existing.enabled ? {
@@ -79,7 +123,6 @@ async function ensureControllerChatgptBrowser(controllerHome: string, workId: st
       native_attach_mode: 'auto',
       native_browser_candidates: ['chrome'],
     } : {}),
-    allowed_domains: allowedDomains,
   });
 }
 
@@ -87,11 +130,309 @@ function stringField(value: unknown): string | undefined {
   return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
 
+function normalizeModel(value?: string): string {
+  const model = value?.trim().toLowerCase() || DEFAULT_CHATGPT_AUTOMATION_MODEL;
+  if (model === 'gpt-5.6' || model === 'gpt-5.6-sol' || model === '5.6' || model === '5.6s') return DEFAULT_CHATGPT_AUTOMATION_MODEL;
+  throw new Error(`CHATGPT_AUTOMATION_MODEL_UNSUPPORTED:${value}`);
+}
+
+function normalizeReasoning(value?: ChatgptAutomationReasoning): ChatgptAutomationReasoning {
+  return value ?? DEFAULT_CHATGPT_AUTOMATION_REASONING;
+}
+
+function normalizeTabPolicy(value?: ChatgptAutomationTabPolicy): ChatgptAutomationTabPolicy {
+  return value ?? DEFAULT_CHATGPT_AUTOMATION_TAB_POLICY;
+}
+
+export function stableChatgptWorkBrowserSessionId(repoId: string, workId: string): string {
+  const digest = createHash('sha256').update(`${repoId}\n${workId}`).digest('hex').slice(0, 20);
+  return `forge-chatgpt-work-${digest}`;
+}
+
+export function stableChatgptAutomationBrowserSessionId(repoId: string, automationId: string): string {
+  const digest = createHash('sha256').update(`${repoId}\nautomation\n${automationId}`).digest('hex').slice(0, 20);
+  return `forge-chatgpt-automation-${digest}`;
+}
+
+export function resolveChatgptWorkBrowserSessionId(input: {
+  repoId: string;
+  workId: string;
+  tabPolicy?: ChatgptAutomationTabPolicy;
+  explicitSessionId?: string;
+  boundSessionId?: string;
+}): string {
+  const policy = normalizeTabPolicy(input.tabPolicy);
+  const stable = stableChatgptWorkBrowserSessionId(input.repoId, input.workId);
+  if (policy === 'new') return `${stable}-${randomUUID().slice(0, 8)}`;
+  const explicit = input.explicitSessionId?.trim();
+  if (explicit && explicit !== LEGACY_CONTROLLER_CHATGPT_SESSION_ID) return explicit;
+  const bound = input.boundSessionId?.trim();
+  if (bound && bound !== LEGACY_CONTROLLER_CHATGPT_SESSION_ID) return bound;
+  return stable;
+}
+
+interface BrowserQueryMatch {
+  text?: string;
+  selectorHint?: string;
+}
+
+function queryMatches(result: Record<string, unknown> | undefined): BrowserQueryMatch[] {
+  if (!result || !Array.isArray(result.matches)) return [];
+  return result.matches.filter((value): value is BrowserQueryMatch => Boolean(value) && typeof value === 'object');
+}
+
+function matchText(value: BrowserQueryMatch): string {
+  return typeof value.text === 'string' ? value.text.trim() : '';
+}
+
+function matchSelector(value: BrowserQueryMatch | undefined): string | undefined {
+  return typeof value?.selectorHint === 'string' && value.selectorHint.trim() ? value.selectorHint.trim() : undefined;
+}
+
+function modelLabelMatches(label: string | undefined, model: string): boolean {
+  if (model !== DEFAULT_CHATGPT_AUTOMATION_MODEL || !label) return false;
+  const normalized = label.toLowerCase().replace(/\s+/g, '');
+  return normalized.includes('5.6sol') || normalized.includes('gpt-5.6sol');
+}
+
+function reasoningSliderValue(reasoning: ChatgptAutomationReasoning): number {
+  if (reasoning === 'medium') return 2;
+  if (reasoning === 'high') return 3;
+  return 4;
+}
+
+async function findChatgptIntelligenceControl(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  timeoutMs?: number,
+): Promise<BrowserQueryMatch | undefined> {
+  const result = await controllerBrowserAction(controllerHome, workId, 'query_all', {
+    session_id: browserSessionId,
+    selector: CHATGPT_INTELLIGENCE_CONTROL_SELECTOR,
+    limit: 50,
+    timeout_ms: timeoutMs ?? 60_000,
+  }, timeoutMs);
+  return queryMatches(result).find((match) => /(?:gpt-)?5\.6\s*sol/i.test(matchText(match)));
+}
+
+async function waitForChatgptIntelligenceControl(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  timeoutMs?: number,
+): Promise<BrowserQueryMatch | undefined> {
+  const waitBudgetMs = Math.min(Math.max(timeoutMs ?? 12_000, 1_000), 12_000);
+  const deadline = Date.now() + waitBudgetMs;
+  do {
+    const control = await findChatgptIntelligenceControl(controllerHome, workId, browserSessionId, Math.min(waitBudgetMs, 5_000));
+    if (control) return control;
+    if (Date.now() >= deadline) break;
+    await new Promise((resolveWait) => setTimeout(resolveWait, 500));
+  } while (Date.now() < deadline);
+  return undefined;
+}
+
+async function ensureChatgptExecutionPreference(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  model: string,
+  reasoning: ChatgptAutomationReasoning,
+  timeoutMs?: number,
+): Promise<boolean> {
+  if (model !== DEFAULT_CHATGPT_AUTOMATION_MODEL) throw new Error(`CHATGPT_AUTOMATION_MODEL_UNSUPPORTED:${model}`);
+  let control = await waitForChatgptIntelligenceControl(controllerHome, workId, browserSessionId, timeoutMs);
+  if (!control) throw new Error('CHATGPT_AUTOMATION_INTELLIGENCE_CONTROL_UNAVAILABLE');
+  if (!modelLabelMatches(matchText(control), model)) throw new Error(`CHATGPT_AUTOMATION_MODEL_NOT_VERIFIED:${model}`);
+  let controlSelector = matchSelector(control);
+  if (!controlSelector) throw new Error('CHATGPT_AUTOMATION_INTELLIGENCE_CONTROL_UNAVAILABLE');
+
+  const expanded = await controllerBrowserAction(controllerHome, workId, 'get_attribute', {
+    session_id: browserSessionId,
+    selector: controlSelector,
+    attribute: 'aria-expanded',
+    timeout_ms: timeoutMs ?? 60_000,
+  }, timeoutMs).catch(() => undefined);
+  if (stringField(expanded?.value) !== 'true') {
+    await controllerBrowserAction(controllerHome, workId, 'press', {
+      session_id: browserSessionId,
+      selector: controlSelector,
+      key: 'ArrowDown',
+      timeout_ms: timeoutMs ?? 60_000,
+      post_action_wait_ms: 150,
+    }, timeoutMs);
+  }
+
+  const currentValueResult = await controllerBrowserAction(controllerHome, workId, 'get_attribute', {
+    session_id: browserSessionId,
+    selector: CHATGPT_CAPABILITY_SLIDER_SELECTOR,
+    attribute: 'aria-valuenow',
+    timeout_ms: timeoutMs ?? 60_000,
+  }, timeoutMs).catch(() => undefined);
+  const currentValue = Number(stringField(currentValueResult?.value));
+  const targetValue = reasoningSliderValue(reasoning);
+  if (!Number.isInteger(currentValue) || currentValue < 0 || currentValue > 4) {
+    throw new Error(`CHATGPT_AUTOMATION_REASONING_STATE_UNAVAILABLE:${reasoning}`);
+  }
+  const direction = targetValue > currentValue ? 'ArrowRight' : 'ArrowLeft';
+  for (let index = 0; index < Math.abs(targetValue - currentValue); index += 1) {
+    await controllerBrowserAction(controllerHome, workId, 'press', {
+      session_id: browserSessionId,
+      selector: CHATGPT_CAPABILITY_MENUITEM_SELECTOR,
+      key: direction,
+      timeout_ms: timeoutMs ?? 60_000,
+      post_action_wait_ms: 120,
+    }, timeoutMs);
+  }
+
+  const verifiedValueResult = await controllerBrowserAction(controllerHome, workId, 'get_attribute', {
+    session_id: browserSessionId,
+    selector: CHATGPT_CAPABILITY_SLIDER_SELECTOR,
+    attribute: 'aria-valuenow',
+    timeout_ms: timeoutMs ?? 60_000,
+  }, timeoutMs).catch(() => undefined);
+  if (Number(stringField(verifiedValueResult?.value)) !== targetValue) {
+    throw new Error(`CHATGPT_AUTOMATION_REASONING_NOT_VERIFIED:${reasoning}`);
+  }
+  control = await findChatgptIntelligenceControl(controllerHome, workId, browserSessionId, timeoutMs) ?? control;
+  if (!modelLabelMatches(matchText(control), model)) throw new Error(`CHATGPT_AUTOMATION_MODEL_NOT_VERIFIED:${model}`);
+  controlSelector = matchSelector(control) ?? controlSelector;
+  await controllerBrowserAction(controllerHome, workId, 'press', {
+    session_id: browserSessionId,
+    selector: controlSelector,
+    key: 'Escape',
+    timeout_ms: timeoutMs ?? 60_000,
+    post_action_wait_ms: 100,
+  }, timeoutMs).catch(() => undefined);
+  return true;
+}
+
 function resultUrl(result: Record<string, unknown>): string | undefined {
   return stringField(result.url)
     ?? stringField((result.session as Record<string, unknown> | undefined)?.url);
 }
 
+async function submitChatgptPrompt(
+  controllerHome: string,
+  workId: string,
+  browserSessionId: string,
+  prompt: string,
+  targetUrl: string,
+  timeoutMs?: number,
+): Promise<string> {
+  await controllerBrowserAction(controllerHome, workId, 'fill', {
+    session_id: browserSessionId,
+    selector: CHATGPT_PROMPT_SELECTOR,
+    text: withForgePluginMention(prompt),
+    timeout_ms: timeoutMs ?? 60_000,
+    post_action_wait_ms: 100,
+  }, timeoutMs);
+  const sent = await controllerBrowserAction(controllerHome, workId, 'click', {
+    session_id: browserSessionId,
+    selector: CHATGPT_SEND_SELECTOR,
+    timeout_ms: timeoutMs ?? 60_000,
+    post_action_wait_ms: 1_000,
+  }, timeoutMs);
+  let observedUrl = resultUrl(sent) ?? targetUrl;
+  if (/\/c\/[^/?#]+/.test(observedUrl)) return observedUrl;
+  const deadline = Date.now() + Math.min(Math.max(timeoutMs ?? 8_000, 2_000), 8_000);
+  do {
+    const observed = await controllerBrowserAction(controllerHome, workId, 'query_all', {
+      session_id: browserSessionId,
+      selector: 'main',
+      limit: 1,
+      timeout_ms: Math.min(timeoutMs ?? 3_000, 3_000),
+    }, timeoutMs).catch(() => undefined);
+    observedUrl = observed ? resultUrl(observed) ?? observedUrl : observedUrl;
+    if (/\/c\/[^/?#]+/.test(observedUrl)) return observedUrl;
+    await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+  } while (Date.now() < deadline);
+  throw new Error(`CHATGPT_AUTOMATION_SUBMISSION_NOT_CONFIRMED:${observedUrl}`);
+}
+
+export function withForgePluginMention(prompt: string): string {
+  const value = prompt.trim();
+  if (!value) throw new Error('CHATGPT_AUTOMATION_PROMPT_REQUIRED');
+  if (/^@forge(?:\s|$)/i.test(value)) return value;
+  return `${DEFAULT_CHATGPT_AUTOMATION_PLUGIN_MENTION} ${value}`;
+}
+
+export async function runScheduledChatgptPrompt(input: ScheduledChatgptPromptInput): Promise<ScheduledChatgptPromptResult> {
+  const model = normalizeModel(input.model);
+  const reasoning = normalizeReasoning(input.reasoning);
+  const tabPolicy = normalizeTabPolicy(input.tabPolicy);
+  const stableSessionId = stableChatgptAutomationBrowserSessionId(input.repoId, input.automationId);
+  const explicitSessionId = input.browserSessionId?.trim();
+  const sessionId = tabPolicy === 'new'
+    ? `${stableSessionId}-${randomUUID().slice(0, 8)}`
+    : explicitSessionId || stableSessionId;
+  const targetUrl = tabPolicy === 'new'
+    ? 'https://chatgpt.com/'
+    : input.conversationUrl?.trim() || 'https://chatgpt.com/';
+  let reusedSession = false;
+  try {
+    await ensureControllerChatgptBrowser(input.controllerHome, input.automationId);
+    if (tabPolicy !== 'new') {
+      try {
+        await controllerBrowserAction(input.controllerHome, input.automationId, 'get_text', {
+          session_id: sessionId,
+          selector: 'body',
+          max_chars: 1,
+          timeout_ms: Math.min(input.timeoutMs ?? 60_000, 3_000),
+        }, input.timeoutMs);
+        reusedSession = true;
+      } catch {
+        reusedSession = false;
+      }
+    }
+    if (!reusedSession) {
+      await controllerBrowserAction(input.controllerHome, input.automationId, 'open_page', {
+        session_id: sessionId,
+        url: targetUrl,
+        wait_until: 'domcontentloaded',
+        timeout_ms: input.timeoutMs ?? 60_000,
+        retries: 1,
+      }, input.timeoutMs);
+    }
+    const executionPreferenceVerified = await ensureChatgptExecutionPreference(
+      input.controllerHome,
+      input.automationId,
+      sessionId,
+      model,
+      reasoning,
+      input.timeoutMs,
+    );
+    const observedUrl = await submitChatgptPrompt(input.controllerHome, input.automationId, sessionId, input.prompt, targetUrl, input.timeoutMs);
+    return {
+      status: 'dispatched',
+      provider: 'controller-browser',
+      browserSessionId: sessionId,
+      conversationUrl: observedUrl,
+      model,
+      reasoning,
+      tabPolicy,
+      executionPreferenceVerified,
+      reusedSession,
+    };
+  } catch (error) {
+    return {
+      status: 'failed',
+      provider: 'controller-browser',
+      browserSessionId: sessionId,
+      model,
+      reasoning,
+      tabPolicy,
+      executionPreferenceVerified: false,
+      reusedSession,
+      error: {
+        code: error instanceof Error && error.message.includes(':') ? error.message.split(':', 1)[0] : 'CHATGPT_SCHEDULED_PROMPT_FAILED',
+        message: error instanceof Error ? error.message : String(error),
+      },
+    };
+  }
+}
+
 /**
  * Dispatches a bounded resume prompt to one controller-owned ChatGPT Web tab.
  * Chat history is transport context only. Forge Work/Plan/evidence remain authoritative.
@@ -100,7 +441,16 @@ export async function runWorkChatgptContinuation(input: WorkChatgptContinuationI
   const store = { controllerHome: input.controllerHome, repoId: input.repoId };
   const existing = getChatgptWorkConversationBinding(store, input.workId);
   const seedUrl = input.conversationUrl?.trim() || existing?.conversationUrl;
-  const sessionId = input.browserSessionId?.trim() || CONTROLLER_CHATGPT_SESSION_ID;
+  const model = normalizeModel(input.model);
+  const reasoning = normalizeReasoning(input.reasoning);
+  const tabPolicy = normalizeTabPolicy(input.tabPolicy);
+  const sessionId = resolveChatgptWorkBrowserSessionId({
+    repoId: input.repoId,
+    workId: input.workId,
+    tabPolicy,
+    explicitSessionId: input.browserSessionId,
+    boundSessionId: existing?.latestBrowserSessionId,
+  });
   let binding: ChatgptWorkConversationBinding | undefined = existing;
 
   try {
@@ -125,21 +475,15 @@ export async function runWorkChatgptContinuation(input: WorkChatgptContinuationI
       timeout_ms: input.timeoutMs ?? 60_000,
       retries: 1,
     }, input.timeoutMs);
-    await controllerBrowserAction(input.controllerHome, input.workId, 'fill', {
-      session_id: sessionId,
-      selector: CHATGPT_PROMPT_SELECTOR,
-      text: input.prompt,
-      timeout_ms: input.timeoutMs ?? 60_000,
-      post_action_wait_ms: 100,
-    }, input.timeoutMs);
-    const sent = await controllerBrowserAction(input.controllerHome, input.workId, 'press', {
-      session_id: sessionId,
-      selector: CHATGPT_PROMPT_SELECTOR,
-      key: CHATGPT_SEND_KEY,
-      timeout_ms: input.timeoutMs ?? 60_000,
-      post_action_wait_ms: 1_500,
-    }, input.timeoutMs);
-    const observedUrl = resultUrl(sent) ?? targetUrl;
+    const executionPreferenceVerified = await ensureChatgptExecutionPreference(
+      input.controllerHome,
+      input.workId,
+      sessionId,
+      model,
+      reasoning,
+      input.timeoutMs,
+    );
+    const observedUrl = await submitChatgptPrompt(input.controllerHome, input.workId, sessionId, `${workflowToolAttributionInstruction(input.workId)}\n\n${input.prompt}`, targetUrl, input.timeoutMs);
     if (/\/c\/[^/?#]+/.test(observedUrl)) {
       binding = bindChatgptWorkConversation(store, {
         workId: input.workId,
@@ -156,6 +500,10 @@ export async function runWorkChatgptContinuation(input: WorkChatgptContinuationI
       conversationId: binding?.conversationId,
       localAlias: binding?.localAlias,
       resumedFromBinding: Boolean(existing),
+      model,
+      reasoning,
+      tabPolicy,
+      executionPreferenceVerified,
     };
   } catch (error) {
     return {
@@ -166,6 +514,10 @@ export async function runWorkChatgptContinuation(input: WorkChatgptContinuationI
       conversationId: binding?.conversationId,
       localAlias: binding?.localAlias,
       resumedFromBinding: Boolean(existing),
+      model,
+      reasoning,
+      tabPolicy,
+      executionPreferenceVerified: false,
       error: {
         code: error instanceof Error && error.message.includes(':') ? error.message.split(':', 1)[0] : 'CHATGPT_CONTROLLER_BROWSER_FAILED',
         message: error instanceof Error ? error.message : String(error),

package/src/runtime/control-plane/persistence/requirement-store.ts

@@ -20,6 +20,7 @@ export interface Requirement {
   outcomeStatement: string;
   acceptanceCriteria: string[];
   requiredDeliveryReferences: string[];
+  /** @deprecated Migration compatibility pointer only. Current Plan.requirementId is the relationship authority. */
   activePlanId?: string;
   state: RequirementState;
   needsAttention: boolean;
@@ -124,7 +125,7 @@ export function createRequirement(
 const ALLOWED_TRANSITIONS: Readonly<Record<RequirementState, readonly RequirementState[]>> = {
   planned: ['planned', 'active', 'waiting_for_user', 'cancelled'],
   active: ['active', 'waiting_for_user', 'done', 'cancelled'],
-  waiting_for_user: ['waiting_for_user', 'planned', 'active', 'cancelled'],
+  waiting_for_user: ['waiting_for_user', 'planned', 'active', 'done', 'cancelled'],
   done: ['done', 'cancelled'],
   cancelled: ['cancelled'],
 };
@@ -164,6 +165,7 @@ export function updateRequirement(
   });
 }
 
+/** @deprecated Migration/legacy compatibility only. New Plan creation must bind Plan.requirementId and derive active Plan slices by query. */
 export function setRequirementPlan(
   options: RequirementStoreOptions,
   input: { requirementId: string; planId: string; action?: string },
@@ -189,12 +191,13 @@ export interface RequirementCompletionInput {
 }
 
 /**
- * Complete a Requirement only from the Work-owned completion record.
+ * Project machine-complete Work delivery into a Requirement without asserting
+ * semantic acceptance. The Requirement waits for an explicit ChatGPT/user
+ * decision; a previously audited `done` Requirement is never reopened by
+ * historical execution evidence.
  *
- * This intentionally short-circuits an already audited `done` Requirement
- * before inspecting historical execution facts. A cancelled Run, missing
- * legacy Task receipt, or stale Work projection therefore cannot reopen or
- * rewrite a completed user outcome.
+ * The legacy function name is retained for compatibility with completion
+ * callers. Its authority is evidence projection only, not semantic completion.
  */
 export function completeRequirementFromWork(
   options: RequirementStoreOptions,
@@ -221,19 +224,20 @@ export function completeRequirementFromWork(
   if (receipt.delivery.kind === 'superseded' || receipt.delivery.status !== 'integrated' || !receipt.delivery.reachable) throw new Error('REQUIREMENT_WORK_DELIVERY_NOT_PROVEN');
   if (!['complete', 'maintenance_warning'].includes(receipt.cleanup.status) || receipt.cleanup.blockers.length > 0) throw new Error('REQUIREMENT_WORK_CLEANUP_NOT_PROVEN');
 
+  if (current.value.state === 'waiting_for_user' && current.value.auditRefs.includes(receipt.receiptId)) return current.value;
   return updateRequirement(options, {
     requirementId,
-    action: 'requirement_completed_from_work_receipt',
+    action: 'requirement_delivery_evidence_recorded',
     mutate: (latest) => {
-      // Preserve a concurrent audited completion; stale execution evidence is
-      // never allowed to move a terminal Requirement backwards.
+      // Preserve a concurrent explicit semantic completion; stale execution
+      // evidence is never allowed to move a terminal Requirement backwards.
       if (latest.state === 'done') return latest;
       if (latest.state === 'cancelled') throw new Error('REQUIREMENT_CANCELLED');
       return {
         ...latest,
-        state: 'done',
+        state: 'waiting_for_user',
         needsAttention: false,
-        attentionSummary: undefined,
+        attentionSummary: `Work ${work.workId} delivered machine-valid evidence (${receipt.receiptId}); ChatGPT/user semantic acceptance is still required.`,
         auditRefs: Array.from(new Set([...latest.auditRefs, receipt.receiptId])).slice(-50),
       };
     },

package/src/runtime/diagnostics/mcp-timing.ts

@@ -7,6 +7,10 @@ export interface McpTimingTrace {
   traceId?: string;
   requestId?: string;
   rpcId?: string | number;
+  /** Public Connector ingress versus the authoritative loopback Runtime span. */
+  layer?: 'public_gateway' | 'canonical_runtime';
+  /** Wall-clock start for joining nested spans and later client-side timing when available. */
+  startedAt?: string;
   outcome?: 'ok' | 'error' | 'exception';
   errorCode?: string;
   sessionResolutionMs?: number;
@@ -21,6 +25,8 @@ export interface McpTimingTrace {
   sessionId?: string;
   repoId?: string;
   workId?: string;
+  processId?: string;
+  route?: string;
 }
 
 export interface McpIncident {

package/src/runtime/execution/process-runtime/check-facade.ts

@@ -64,16 +64,7 @@ export function processCheckSemanticScopeKey(
   input: Pick<RunCheckFacadeInput, 'workId' | 'verificationBinding' | 'checkoutId'>,
   reuseScope: 'repository' | 'checkout',
 ): string {
-  const base = reuseScope === 'repository' ? 'repository' : `checkout:${input.checkoutId ?? 'unknown'}`;
-  const binding = input.verificationBinding;
-  const owner = [
-    input.workId ? `work:${input.workId}` : undefined,
-    binding?.executionSessionId ? `execution:${binding.executionSessionId}` : undefined,
-    binding?.editSessionId ? `edit:${binding.editSessionId}:r${binding.editRevision ?? 'unknown'}` : undefined,
-    binding?.issueId ? `issue:${binding.issueId}` : undefined,
-    binding?.taskId ? `task:${binding.taskId}` : undefined,
-  ].filter(Boolean).join('|') || 'unbound';
-  return `${base}|owner:${owner}`;
+  return reuseScope === 'repository' ? 'repository' : `checkout:${input.checkoutId ?? 'unknown'}`;
 }
 
 export interface RunCheckFacadeResult {

package/src/runtime/execution/process-runtime/check-result.ts

@@ -18,10 +18,18 @@ export interface PersistedCheckResultReceipt {
   cacheHit?: boolean;
 }
 
-export function allocatePersistedCheckResultReceiptPath(controllerHome: string, repoId: string): string {
+export function allocatePersistedCheckResultReceiptPath(
+  controllerHome: string,
+  repoId: string,
+  requestId?: string,
+): string {
   const root = join(processLogDir(controllerHome, repoId), 'check-results');
   mkdirSync(root, { recursive: true });
-  return join(root, `${randomUUID()}.json`);
+  const stableRequestId = requestId?.trim();
+  const receiptId = stableRequestId
+    ? `request-${createHash('sha256').update(stableRequestId).digest('hex').slice(0, 32)}`
+    : randomUUID();
+  return join(root, `${receiptId}.json`);
 }
 
 export function writePersistedCheckResultReceipt(path: string, input: Omit<PersistedCheckResultReceipt, 'schemaVersion' | 'receiptId'>): PersistedCheckResultReceipt {

package/src/runtime/execution/process-runtime/command-facade.ts

@@ -273,6 +273,7 @@ export async function executeRepositoryCommandViaProcessRuntime(
       executionIdentity.repositoryId,
       executionIdentity.checkoutId,
       input.repository.defaultBranch,
+      input.repository.canonicalRoot,
     ),
     executionIdentity.repositoryId,
     executionIdentity.checkoutId,