@moretea-labs/forge 1.8.1 → 1.8.2

package/src/runtime/root/workflow-supervisor-runtime.ts

@@ -1,7 +1,8 @@
 import { once } from 'node:events';
+import { createHash } from 'node:crypto';
 import { WorkflowSupervisorControlPlane } from '../../../supervisor/control-plane';
 import { forgeWorkflowSupervisorValidators } from '../../../supervisor/forge-validators';
-import { forgeWorkflowSupervisorLifecycleHooks } from './workflow-supervisor-composition';
+import { forgeWorkflowSupervisorLifecycleHooks, workflowSupervisorContractText } from './workflow-supervisor-composition';
 import { resolveWorkflowSupervisorForgeHome, workflowSupervisorSocketPath } from '../../../supervisor/paths';
 import {
   createWorkflowSupervisorServer,
@@ -12,12 +13,46 @@ import { startWorkflowSupervisorNativeBrowserAdapter, type WorkflowSupervisorNat
 import type { WorkflowSupervisorConsumerStatus } from '../../../supervisor/types';
 import { WorkflowSupervisorStore } from '../../../supervisor/store';
 import { createComputerInteractionTargetAuthority } from '../../../adapters/computer/interaction-target-authority';
-import { MacOsChatgptConversationTargetPort } from '../plugins/computer-chatgpt-macos-target';
 import { ChromeExtensionChatgptConversationTargetPort } from '../../../adapters/computer/chatgpt-extension-target';
-import { PreferredChatgptConversationTargetPort } from '../../../adapters/computer/chatgpt-target-router';
 import { createRuntimeComputerTargetPersistence } from './computer-target-persistence';
-import { listDirectActivities, listUserRequests, recordDirectActivity, recordUserRequest, resolveUserRequest } from '../../../packages/kernel/identity/api/index';
+import { getDirectActivity, listUserRequests, recordDirectActivity, recordUserRequest, resolveUserRequest } from '../../../packages/kernel/identity/api/index';
 import { getRuntimeWriteClaim } from './write-fence';
+import { getRepository } from '../../cli/repositories/registry';
+import { getWorkContract } from '../../../packages/kernel/work/api/index';
+import { getChatgptWorkConversationBinding, parseChatgptConversationIdentity } from '../../../adapters/chatgpt/work-conversation-binding-store';
+import { isTerminalSemanticWorkState } from '../../../packages/kernel/work/api/index';
+import { findActivePluginCapabilityAuthorization, pluginCapabilityAuthorizationOwnerScope } from '../plugins/capability-authorization-grants';
+import { readPluginActionReceiptForRequest, submitAssistantPluginAction, type PluginActionReceipt } from '../plugins/store';
+import { loadGmailPluginConfig } from '../plugins/google-shared';
+import { GMAIL_OWNER_NOTIFICATION_CAPABILITY_ID, GMAIL_PLUGIN_ID } from '../plugins/gmail-adapter';
+
+/** An uncertain external send remains owned by its original immutable plugin receipt. */
+export function recordUnknownSupervisorNotificationReceipt(
+  controllerHome: string,
+  taskId: string,
+  requestId: string,
+  receipt: Pick<PluginActionReceipt, 'receiptId' | 'requestId' | 'pluginId' | 'actionId' | 'status' | 'effectOutcome'>,
+): boolean {
+  if (receipt.requestId !== requestId || receipt.pluginId !== GMAIL_PLUGIN_ID
+    || receipt.actionId !== 'send_owner_notification'
+    || receipt.status !== 'failed' || receipt.effectOutcome !== 'outcome_unknown') return false;
+  const activityId = `workflow-supervisor-notification-unknown-${requestId}`;
+  const existing = getDirectActivity(controllerHome, activityId);
+  if (existing?.receiptRef && existing.receiptRef !== receipt.receiptId) {
+    throw new Error(`WORKFLOW_SUPERVISOR_NOTIFICATION_RECEIPT_CONFLICT: ${requestId}`);
+  }
+  if (!existing) recordDirectActivity(controllerHome, {
+    activityId,
+    capabilityId: 'workflow-supervisor.notification',
+    kind: 'direct_execution',
+    targetScope: `workflow-supervisor-task:${taskId}`,
+    principalId: 'forge-runtime',
+    status: 'failed',
+    receiptRef: receipt.receiptId,
+    summary: 'Gmail notification delivery outcome is unknown. Preserve the exact provider receipt and request ID; do not resend or rekey without authoritative reconciliation.',
+  });
+  return true;
+}
 
 export interface RuntimeWorkflowSupervisorHandle {
   readonly done: Promise<void>;
@@ -61,7 +96,7 @@ export async function startWorkflowSupervisorRuntime(
   const transportActivityId = (taskId?: string): string => `workflow-supervisor-transport-${(taskId ?? 'instance').replace(/[^a-zA-Z0-9._-]/g, '_')}`;
   const reportTransportState = (projection: WorkflowSupervisorTransportProjection): void => {
     const activityId = transportActivityId(projection.taskId);
-    const existing = listDirectActivities(controllerHome, 200).find((item) => item.activityId === activityId);
+    const existing = getDirectActivity(controllerHome, activityId);
     const recovered = projection.state === 'recovered';
     recordDirectActivity(controllerHome, {
       activityId,
@@ -86,7 +121,7 @@ export async function startWorkflowSupervisorRuntime(
   const stallActivityId = (taskId: string): string => `workflow-supervisor-stall-${taskId.replace(/[^a-zA-Z0-9._-]/g, '_')}`;
   const reportTaskStall = (projection: WorkflowSupervisorStallProjection): void => {
     const activityId = stallActivityId(projection.taskId);
-    const existing = listDirectActivities(controllerHome, 200).find((item) => item.activityId === activityId);
+    const existing = getDirectActivity(controllerHome, activityId);
     const exhausted = projection.state === 'exhausted';
     if (!exhausted && !existing) return;
     const budget = projection.generations !== undefined && projection.maxGenerations !== undefined
@@ -99,7 +134,7 @@ export async function startWorkflowSupervisorRuntime(
       targetScope: `workflow-supervisor-task:${projection.taskId}`,
       principalId: 'forge-runtime',
       status: exhausted ? 'running' : 'completed',
-      startedAt: existing?.startedAt ?? projection.observedAt,
+      startedAt: exhausted && existing?.status !== 'running' ? projection.observedAt : existing?.startedAt ?? projection.observedAt,
       ...(!exhausted ? { completedAt: projection.observedAt } : {}),
       summary: exhausted
         ? projection.stallKind === 'provider_resume_exhausted'
@@ -125,10 +160,330 @@ export async function startWorkflowSupervisorRuntime(
       },
     });
   };
+  const notificationRequestId = (...parts: string[]): string => `wfsn_${createHash('sha256').update(parts.join('\u0000')).digest('hex').slice(0, 32)}`;
+  const notificationOrigin = { surface: 'system' as const };
+  const notificationOwnerScope = pluginCapabilityAuthorizationOwnerScope({ surface: 'system', actor: 'plugin_action_execute' });
+  const findNotificationGrant = (repoId: string, target: { kind: 'gmail-mailbox'; id: string; identityFingerprint: string } | undefined) => target && findActivePluginCapabilityAuthorization(controllerHome, {
+    ownerScope: notificationOwnerScope,
+    repoId,
+    pluginId: GMAIL_PLUGIN_ID,
+    capabilityId: GMAIL_OWNER_NOTIFICATION_CAPABILITY_ID,
+    target,
+    scopes: ['gmail.send'],
+    risk: 'remote_write',
+  });
+  const sendSupervisorNotification = async (input: {
+    taskId: string;
+    requestId: string;
+    kind: 'user_action_required' | 'continuation_exhausted';
+    subject: string;
+    reason: string;
+    effectId?: string;
+    userRequestId?: string;
+    repoId?: string;
+    workId?: string;
+    conversationUrl?: string;
+    objective?: string;
+    occurredAt?: string;
+    stillActive?: () => boolean;
+  }): Promise<void> => {
+    if (input.stillActive && !input.stillActive()) return;
+    const task = store.getTask(input.taskId);
+    const repoId = (task ? workflowSupervisorContractText(task, 'repo_id') : undefined) ?? input.repoId;
+    const candidateConversationUrl = task?.conversationUrl ?? input.conversationUrl;
+    if (!repoId || !candidateConversationUrl) return;
+    let conversationUrl: string;
+    try { conversationUrl = parseChatgptConversationIdentity(candidateConversationUrl).conversationUrl; }
+    catch { return; } // Never fabricate a ChatGPT session link.
+    const repository = getRepository(repoId, controllerHome);
+    if (!repository) return;
+    // Read the exact prior receipt before grant checks or changing args. An
+    // outcome-unknown send must never be resubmitted under any envelope.
+    const prior = readPluginActionReceiptForRequest(controllerHome, input.requestId);
+    if (prior && recordUnknownSupervisorNotificationReceipt(controllerHome, input.taskId, input.requestId, prior)) return;
+    const mailbox = loadGmailPluginConfig(repository.canonicalRoot, { controllerHome, repoId }).accountEmail?.trim().toLowerCase();
+    const target = mailbox ? {
+      kind: 'gmail-mailbox' as const,
+      id: mailbox,
+      identityFingerprint: `gmail-profile:${mailbox}`,
+    } : undefined;
+    const grant = findNotificationGrant(repoId, target);
+    if (!grant) {
+      recordUserRequest(controllerHome, {
+        kind: 'user_action_request',
+        rootCauseKey: `workflow-supervisor.notification-auth:${repoId}:${mailbox ?? 'unconfigured'}`,
+        title: 'Authorize owner-only Gmail alerts',
+        summary: `Forge cannot email owner authorization notices until Gmail action authorize_owner_notifications is approved for the configured and Google-verified owner mailbox${mailbox ? ` (${mailbox})` : ''}. The send-only grant lasts up to 90 days, cannot archive email or contact other recipients, and creates no email when authorized. Unsent events remain in UserRequest.`,
+        actionRequired: 'grant_permission',
+        targetScope: task ? { scopeKind: 'workflow_supervisor_task', scopeId: input.taskId, repoId, ...(input.workId ? { workId: input.workId } : {}) }
+          : { scopeKind: 'work', scopeId: input.workId ?? input.taskId, repoId, ...(input.workId ? { workId: input.workId } : {}) },
+        presentation: {
+          severity: 'blocked',
+          creationReason: 'scheduled_gmail_notification_authorization_required',
+          reason: 'EXTERNAL_EFFECT_AUTHORIZATION_REQUIRED',
+          currentState: {
+            taskId: input.taskId,
+            repoId,
+            ...(mailbox ? { mailbox } : {}),
+            pluginId: GMAIL_PLUGIN_ID,
+            capabilityId: GMAIL_OWNER_NOTIFICATION_CAPABILITY_ID,
+            authorizationAction: 'authorize_owner_notifications',
+            scopes: ['gmail.send'],
+            grantLifetimeDays: 90,
+          },
+        },
+      });
+      return;
+    }
+    // Opt-in is prospective. Do not replay a backlog of old blockers or
+    // historical terminal completions when the owner first grants email access.
+    if (input.occurredAt && Date.parse(input.occurredAt) <= Date.parse(grant.createdAt)) return;
+    if (input.stillActive && !input.stillActive()) return;
+    const workId = (task ? workflowSupervisorContractText(task, 'work_id') : undefined) ?? input.workId;
+    const body = [
+      'Forge Workflow Supervisor 检测到需要人工处理的事件。',
+      `事件：${input.kind}`,
+      `原因：${input.reason.slice(0, 1800)}`,
+      `任务：${task?.taskId ?? input.taskId}`,
+      `Work：${workId ?? '未绑定 Work'}`,
+      ...(task?.objective || input.objective ? [`目标：${(task?.objective ?? input.objective ?? '').slice(0, 800)}`] : []),
+      `ChatGPT 会话链接：${conversationUrl}`,
+      ...(repoId && workId ? [`Forge Work 查询：rh_work operation=get repo_id=${repoId} work_id=${workId}`] : []),
+      ...(input.effectId ? [`Effect：${input.effectId}`] : []),
+      ...(input.userRequestId ? [`UserRequest：${input.userRequestId}`] : []),
+      '处理或恢复后，Forge 会继续沿用原有任务与 effect；不要手动重复发送。',
+    ].join('\n').slice(0, 11000);
+    try {
+      const submitted = await submitAssistantPluginAction(controllerHome, repository, {
+        pluginId: GMAIL_PLUGIN_ID,
+        actionId: 'send_owner_notification',
+        requestId: input.requestId,
+        args: { subject: input.subject, body_text: body },
+        origin: {
+          surface: 'system',
+          correlationId: input.requestId,
+          ...(input.effectId ? { causationId: input.effectId } : {}),
+        },
+        authorizationGrantRefs: [grant.grantId],
+      });
+      if (recordUnknownSupervisorNotificationReceipt(controllerHome, input.taskId, input.requestId, submitted.receipt)) {
+        process.stderr.write(`[workflow-supervisor-notification] ${input.requestId}: outcome_unknown; receipt ${submitted.receipt.receiptId} retained without resend\n`);
+      }
+    } catch (error) {
+      const failureMessage = error instanceof Error ? error.message : String(error);
+      const failureCode = /^([A-Z][A-Z0-9_]+)(?::|$)/.exec(failureMessage)?.[1];
+      const loginRequired = failureCode === 'PLUGIN_AUTH_REQUIRED' || failureCode === 'PLUGIN_AUTH_FAILED';
+      const authorizationRequired = loginRequired || [
+        'PLUGIN_CAPABILITY_GRANT_REQUIRED',
+        'GMAIL_AUTOMATION_DISABLED',
+        'GMAIL_AUTOMATION_MAILBOX_NOT_CONFIGURED',
+        'GMAIL_AUTOMATION_MAILBOX_MISMATCH',
+        'EXTERNAL_EFFECT_AUTHORIZATION_REQUIRED',
+      ].includes(failureCode ?? '');
+      if (authorizationRequired && failureCode) {
+        const workId = (task ? workflowSupervisorContractText(task, 'work_id') : undefined) ?? input.workId;
+        recordUserRequest(controllerHome, {
+          kind: 'user_action_request',
+          rootCauseKey: `workflow-supervisor.notification-send-auth:${input.taskId}:${input.requestId}`,
+          title: loginRequired ? 'Gmail notification reauthorization required' : 'Gmail notification authorization required',
+          summary: `Forge could not send the notification to the configured Gmail profile${mailbox ? ` (${mailbox})` : ''} because the exact Gmail provider action failed with ${failureCode}: ${failureMessage}. No alternate provider or automatic resend was used. Restore the Gmail authorization or exact mailbox grant, then continue from the original task.`,
+          actionRequired: loginRequired ? 'login' : 'grant_permission',
+          targetScope: {
+            scopeKind: task ? 'workflow_supervisor_task' : 'work',
+            scopeId: task ? input.taskId : (workId ?? input.taskId),
+            repoId,
+            ...(workId ? { workId } : {}),
+          },
+          presentation: {
+            severity: 'blocked',
+            creationReason: 'scheduled_gmail_notification_authorization_failed',
+            reason: failureCode,
+            currentState: {
+              taskId: input.taskId,
+              repoId,
+              ...(workId ? { workId } : {}),
+              ...(mailbox ? { mailbox } : {}),
+              pluginId: GMAIL_PLUGIN_ID,
+              capabilityId: GMAIL_OWNER_NOTIFICATION_CAPABILITY_ID,
+              actionId: 'send_owner_notification',
+              requestId: input.requestId,
+              ...(input.effectId ? { effectId: input.effectId } : {}),
+              errorCode: failureCode,
+            },
+          },
+        });
+      }
+      process.stderr.write(`[workflow-supervisor-notification] ${input.requestId}: ${failureMessage}\\n`);
+    }
+  };
+  let notificationReconciliationInFlight: Promise<void> | undefined;
+  const reconcileSupervisorNotifications = (): void => {
+    if (closing || notificationReconciliationInFlight) return;
+    notificationReconciliationInFlight = (async () => {
+      const allRequests = listUserRequests(controllerHome);
+      for (const request of allRequests.filter((item) => item.status === 'pending' && item.rootCauseKey.startsWith('workflow-supervisor.notification-auth:'))) {
+        const taskId = request.targetScope?.scopeId;
+        if (!taskId) continue;
+        const task = store.getTask(taskId);
+        if (!task) continue;
+        const repoId = workflowSupervisorContractText(task, 'repo_id');
+        const workId = workflowSupervisorContractText(task, 'work_id');
+        if (!repoId) continue;
+        if (workId) {
+          const work = getWorkContract({ controllerHome, repoId }, workId);
+          if (!work || isTerminalSemanticWorkState(work.semanticState)) {
+            resolveUserRequest(controllerHome, { requestId: request.requestId, decision: 'underlying_work_terminal', resolvedBy: 'forge-runtime' });
+            continue;
+          }
+        }
+        const repository = getRepository(repoId, controllerHome);
+        if (!repository) continue;
+        const mailbox = loadGmailPluginConfig(repository.canonicalRoot, { controllerHome, repoId }).accountEmail?.trim().toLowerCase();
+        const target = mailbox ? {
+          kind: 'gmail-mailbox' as const,
+          id: mailbox,
+          identityFingerprint: `gmail-profile:${mailbox}`,
+        } : undefined;
+        if (findNotificationGrant(repoId, target)) {
+          resolveUserRequest(controllerHome, { requestId: request.requestId, decision: 'gmail_automation_authorized', resolvedBy: 'forge-runtime' });
+        }
+      }
+
+      // One canonical pending UserRequest -> one Gmail notice. Never email
+      // our own notification-grant blockers. A request opts in only when it
+      // was created after the owner-notification grant, so enabling this
+      // capability cannot fan out the backlog that predated authorization.
+      for (const request of allRequests.filter((item) => item.status === 'pending'
+        && ['grant_permission', 'login', 'confirm_destructive'].includes(item.actionRequired)
+        && !item.rootCauseKey.startsWith('workflow-supervisor.notification-'))) {
+        const scope = request.targetScope;
+        const task = (scope?.scopeKind === 'workflow_supervisor_task' ? store.getTask(scope.scopeId) : undefined)
+          ?? (scope?.workId || scope?.scopeKind === 'work'
+            ? store.listTasks().find((candidate) => workflowSupervisorContractText(candidate, 'work_id') === (scope?.workId ?? scope?.scopeId))
+            : undefined);
+        const workId = scope?.workId ?? (scope?.scopeKind === 'work' ? scope.scopeId : undefined);
+        const repoId = scope?.repoId ?? (task ? workflowSupervisorContractText(task, 'repo_id') : undefined);
+        const bound = !task && workId && repoId
+          ? getChatgptWorkConversationBinding({ controllerHome, repoId }, workId) : undefined;
+        const taskId = task?.taskId ?? (bound ? `work:${workId}` : undefined);
+        if (!taskId || (!task && !bound)) continue;
+        const work = repoId && workId ? getWorkContract({ controllerHome, repoId }, workId) : undefined;
+        if (repoId && workId) {
+          if (!work || isTerminalSemanticWorkState(work.semanticState)) {
+            resolveUserRequest(controllerHome, { requestId: request.requestId, decision: 'underlying_work_terminal', resolvedBy: 'forge-runtime' });
+            continue;
+          }
+        }
+        const repoIdForMail = repoId;
+        const repositoryForMail = repoIdForMail ? getRepository(repoIdForMail, controllerHome) : undefined;
+        const configuredMailbox = repositoryForMail && repoIdForMail
+          ? loadGmailPluginConfig(repositoryForMail.canonicalRoot, { controllerHome, repoId: repoIdForMail }).accountEmail?.trim().toLowerCase()
+          : undefined;
+        const grant = repoIdForMail && configuredMailbox ? findNotificationGrant(repoIdForMail, {
+          kind: 'gmail-mailbox', id: configuredMailbox, identityFingerprint: `gmail-profile:${configuredMailbox}`,
+        }) : undefined;
+        if (!grant || Date.parse(request.createdAt) <= Date.parse(grant.createdAt)) continue;
+        const effectId = typeof request.presentation?.currentState?.effectId === 'string' ? request.presentation.currentState.effectId : undefined;
+        const actionLabel = request.actionRequired === 'login' ? '登录授权' : request.actionRequired === 'confirm_destructive' ? '操作确认' : '执行授权';
+        await sendSupervisorNotification({
+          taskId,
+          repoId: repoIdForMail,
+          workId,
+          ...(bound ? { conversationUrl: bound.conversationUrl } : {}),
+          ...(work?.objective ? { objective: work.objective } : {}),
+          requestId: notificationRequestId('user-action', request.requestId),
+          occurredAt: request.createdAt,
+          kind: 'user_action_required',
+          subject: `[Forge] 需要处理：${actionLabel}`,
+          reason: request.summary,
+          effectId,
+          userRequestId: request.requestId,
+          stillActive: () => listUserRequests(controllerHome, 'pending').some((item) => item.requestId === request.requestId),
+        });
+      }
+
+      for (const task of store.listTasks()) {
+        const taskId = task.taskId;
+        const activity = getDirectActivity(controllerHome, stallActivityId(taskId));
+        if (activity?.capabilityId !== 'workflow-supervisor.continuation'
+          || activity.status !== 'running'
+          || activity.targetScope !== `workflow-supervisor-task:${taskId}`) continue;
+        const stall = controlPlane.taskStall(taskId);
+        if (!stall || !(stall.state === 'provider_resume_exhausted'
+          || (stall.state === 'retryable' && stall.generations >= stall.maxGenerations))) continue;
+        const reason = stall.state === 'provider_resume_exhausted'
+          ? 'Supervisor 的 provider resume 尝试已确认耗尽；原 effect 仍被保留，不会盲目重发。'
+          : `Supervisor 自动派发尝试已确认耗尽（${stall.generations}/${stall.maxGenerations}）；原 effect 仍被保留，不会盲目重发。`;
+        await sendSupervisorNotification({
+          taskId,
+          requestId: notificationRequestId('stall', taskId, stall.state, stall.effectId),
+          occurredAt: activity.startedAt,
+          kind: 'continuation_exhausted',
+          subject: `[Forge] 自动续跑已耗尽：${taskId}`,
+          reason,
+          effectId: stall.effectId,
+          stillActive: () => {
+            const currentActivity = getDirectActivity(controllerHome, stallActivityId(taskId));
+            const currentStall = controlPlane.taskStall(taskId);
+            if (!currentStall) return false;
+            const currentStallExhausted = currentStall.state === 'provider_resume_exhausted'
+              || (currentStall.state === 'retryable' && currentStall.generations >= currentStall.maxGenerations);
+            return currentActivity?.status === 'running'
+              && currentActivity.targetScope === `workflow-supervisor-task:${taskId}`
+              && currentStallExhausted
+              && currentStall.state === stall.state
+              && currentStall.effectId === stall.effectId;
+          },
+        });
+      }
+
+      for (const task of store.listTasks()) {
+        if (store.terminalAction(task.taskId) !== 'NEEDS_USER') continue;
+        const completion = store.getLatestCompletion(task.taskId);
+        if (!completion || completion.action !== 'NEEDS_USER') continue;
+        const repoId = workflowSupervisorContractText(task, 'repo_id');
+        const workId = workflowSupervisorContractText(task, 'work_id');
+        if (repoId && workId) {
+          const work = getWorkContract({ controllerHome, repoId }, workId);
+          if (!work || isTerminalSemanticWorkState(work.semanticState)) continue;
+        }
+        const relatedRequests = allRequests.filter((request) => request.targetScope?.scopeId === task.taskId
+          && request.rootCauseKey.startsWith(`workflow-supervisor.transport-human:${task.taskId}:`));
+        if (relatedRequests.some((request) => request.status === 'pending')) continue;
+        const completionCommittedAt = Date.parse(completion.committedAt);
+        if (relatedRequests.some((request) => {
+          const resolvedAt = Date.parse(request.resolution?.resolvedAt ?? '');
+          return Number.isFinite(resolvedAt) && Number.isFinite(completionCommittedAt) && resolvedAt >= completionCommittedAt;
+        })) continue;
+        await sendSupervisorNotification({
+          taskId: task.taskId,
+          requestId: notificationRequestId('terminal-needs-user', task.taskId, completion.completionFingerprint),
+          occurredAt: completion.committedAt,
+          kind: 'user_action_required',
+          subject: `[Forge] 需要人工处理：${task.taskId}`,
+          reason: completion.proposal.reason,
+          effectId: completion.sourceEffectId,
+          stillActive: () => {
+            const currentTask = store.getTask(task.taskId);
+            const currentCompletion = store.getLatestCompletion(task.taskId);
+            if (store.terminalAction(task.taskId) !== 'NEEDS_USER' || currentCompletion?.completionFingerprint !== completion.completionFingerprint) return false;
+            const currentRepoId = currentTask ? workflowSupervisorContractText(currentTask, 'repo_id') : undefined;
+            const currentWorkId = currentTask ? workflowSupervisorContractText(currentTask, 'work_id') : undefined;
+            if (currentRepoId && currentWorkId) {
+              const currentWork = getWorkContract({ controllerHome, repoId: currentRepoId }, currentWorkId);
+              if (!currentWork || isTerminalSemanticWorkState(currentWork.semanticState)) return false;
+            }
+            return true;
+          },
+        });
+      }
+    })()
+      .catch((error) => { process.stderr.write(`[workflow-supervisor-notification-reconcile] ${error instanceof Error ? error.message : String(error)}\\n`); })
+      .finally(() => { notificationReconciliationInFlight = undefined; });
+  };
   const targetAuthority = createComputerInteractionTargetAuthority(createRuntimeComputerTargetPersistence());
   const extensionTargetPort = new ChromeExtensionChatgptConversationTargetPort(controllerHome, targetAuthority);
-  const appleEventsTargetPort = new MacOsChatgptConversationTargetPort(controllerHome, targetAuthority);
-  const targetPort = new PreferredChatgptConversationTargetPort(extensionTargetPort, appleEventsTargetPort);
+  const targetPort = extensionTargetPort;
   const browserConsumerStatus = (): WorkflowSupervisorConsumerStatus => nativeBrowser?.status() ?? {
     enabled: browserAdapterEnabled,
     running: false,
@@ -153,7 +508,7 @@ export async function startWorkflowSupervisorRuntime(
   const reconcileCommittedContinuations = (): void => {
     if (closing || reconciliationInFlight) return;
     reconciliationInFlight = controlPlane.reconcileCommittedContinuations()
-      .then(() => undefined)
+      .then(() => { reconcileSupervisorNotifications(); })
       .catch((error) => { process.stderr.write(`[workflow-supervisor-reconcile] ${error instanceof Error ? error.message : String(error)}\\n`); })
       .finally(() => { reconciliationInFlight = undefined; });
   };

package/src/runtime/safe-tooling/google-credential-store.ts

@@ -14,16 +14,11 @@ const KEYCHAIN_ACCOUNT: Record<StoredGoogleCredentialKind, string> = {
   'refresh-token': 'refresh-token',
   'client-secret': 'client-secret',
 };
-const memoryCache = new Map<string, string>();
 
 function keychainService(service: StoredGoogleService): string {
   return `${KEYCHAIN_SERVICE_PREFIX}.${service}`;
 }
 
-function cacheKey(service: StoredGoogleService, kind: StoredGoogleCredentialKind): string {
-  return `${service}:${kind}`;
-}
-
 const macKeychainAdapter: GoogleCredentialStoreAdapter = {
   available: () => process.platform === 'darwin',
   read(service, kind = 'refresh-token') {
@@ -66,7 +61,6 @@ let adapter: GoogleCredentialStoreAdapter = macKeychainAdapter;
 
 export function setGoogleCredentialStoreAdapterForTest(next?: GoogleCredentialStoreAdapter): void {
   adapter = next ?? macKeychainAdapter;
-  memoryCache.clear();
 }
 
 export function googleCredentialStoreStatus(): Record<string, unknown> {
@@ -87,13 +81,10 @@ function readStoredGoogleCredential(
     ? ['google-workspace']
     : [service, 'google-workspace'];
   for (const candidate of candidates) {
-    const key = cacheKey(candidate, kind);
-    const cached = memoryCache.get(key);
-    if (cached) return { value: cached, source: `keychain:${candidate}:${kind}` };
     if (!adapter.available()) continue;
+    // Keychain is the authority: another Forge process may have rotated this credential.
     const value = adapter.read(candidate, kind)?.trim();
     if (!value) continue;
-    memoryCache.set(key, value);
     return { value, source: `keychain:${candidate}:${kind}` };
   }
   return undefined;
@@ -104,7 +95,6 @@ function writeStoredGoogleCredential(service: StoredGoogleService, kind: StoredG
   if (!normalized) throw new Error(kind === 'refresh-token' ? 'GOOGLE_REFRESH_TOKEN_REQUIRED' : 'GOOGLE_CLIENT_SECRET_REQUIRED');
   if (!adapter.available()) throw new Error('GOOGLE_CREDENTIAL_STORE_UNAVAILABLE');
   adapter.write(service, normalized, kind);
-  memoryCache.set(cacheKey(service, kind), normalized);
 }
 
 export function readStoredGoogleRefreshToken(service: StoredGoogleService): { token: string; source: string } | undefined {

package/src/runtime/safe-tooling/ios-development.ts

@@ -1,5 +1,5 @@
 import { createHash } from 'crypto';
-import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, utimesSync, writeFileSync } from 'fs';
 import { basename, dirname, join, relative, resolve, sep } from 'path';
 import { spawnSync } from 'child_process';
 import type { RepositoryRecord } from '../../cli/repositories/types';
@@ -155,13 +155,26 @@ function sanitize(value: string): string {
 
 function stableBuildDerivedDataPath(
   repository: RepositoryRecord,
-  input: { workspace?: string; project?: string; scheme: string; configuration: string; destination: string },
+  input: { workspace?: string; project?: string; scheme: string; configuration: string; destinationPlatform: 'ios_simulator' | 'ios' },
 ): string {
-  const identity = JSON.stringify([input.workspace ?? '', input.project ?? '', input.scheme, input.configuration, input.destination]);
+  const identity = JSON.stringify([input.workspace ?? '', input.project ?? '', input.scheme, input.configuration, input.destinationPlatform]);
   const digest = createHash('sha256').update(identity).digest('hex').slice(0, 16);
   return join(safeArtifactDir(repository, 'DerivedData'), `build-${sanitize(input.scheme)}-${digest}`);
 }
 
+// Xcode owns invalidation within this checkout-local, platform/configuration bucket.
+// Device identity and test selectors affect execution, not the reusable build cache.
+function runCachedXcodeCommand(repository: RepositoryRecord, derivedDataPath: string, args: string[], timeoutMs: number): IosCommandResult {
+  const touch = (): void => { const usedAt = now(); utimesSync(derivedDataPath, usedAt, usedAt); };
+  touch();
+  try {
+    return runCommand('xcodebuild', args, { cwd: repository.canonicalRoot, timeoutMs });
+  } finally {
+    // Reuse may only modify descendants; keep last-use grace on the bucket itself.
+    touch();
+  }
+}
+
 function boundedText(value: string, maxBytes = 20_000): { content: string; truncated: boolean } {
   const buffer = Buffer.from(value, 'utf-8');
   if (buffer.byteLength <= maxBytes) return { content: value, truncated: false };
@@ -427,7 +440,7 @@ export function iosAppBuild(repository: RepositoryRecord, input: {
     : udid
       ? `platform=iOS Simulator,id=${udid}`
       : `platform=iOS Simulator,name=${input.simulatorName ?? 'iPhone 16 Pro'}`;
-  const derivedDataPath = stableBuildDerivedDataPath(repository, { workspace, project, scheme, configuration, destination });
+  const derivedDataPath = stableBuildDerivedDataPath(repository, { workspace, project, scheme, configuration, destinationPlatform });
   const derivedDataReused = existsSync(derivedDataPath);
   mkdirSync(derivedDataPath, { recursive: true });
   const priorBuiltApps = derivedDataReused ? findBuiltApps(repository, derivedDataPath) : [];
@@ -445,7 +458,7 @@ export function iosAppBuild(repository: RepositoryRecord, input: {
       '-authenticationKeyIssuerID', authentication.issuerId,
     );
   }
-  const result = runCommand('xcodebuild', args, { cwd: repository.canonicalRoot, timeoutMs: input.timeoutMs ?? 10 * 60_000 });
+  const result = runCachedXcodeCommand(repository, derivedDataPath, args, input.timeoutMs ?? 10 * 60_000);
   const sensitiveValues = authentication
     ? [authentication.privateKeyPath, authentication.keyId, authentication.issuerId]
     : [];
@@ -509,8 +522,9 @@ export function iosXcodeTest(repository: RepositoryRecord, input: {
   if (!scheme) throw new Error('IOS_SCHEME_REQUIRED: provide scheme or share at least one Xcode scheme');
   const workspace = safeRepoRelativePath(repository.canonicalRoot, input.workspace ?? listedReady.workspace);
   const project = safeRepoRelativePath(repository.canonicalRoot, input.project ?? listedReady.project);
-  const derivedDataPath = join(safeArtifactDir(repository, 'DerivedData'), `tests-${sanitize(scheme)}`);
-  const resultBundlePath = join(safeArtifactDir(repository, 'test-results'), `${timestamp()}-${sanitize(scheme)}.xcresult`);
+  const configuration = input.configuration ?? 'Debug';
+  const derivedDataPath = stableBuildDerivedDataPath(repository, { workspace, project, scheme, configuration, destinationPlatform: 'ios_simulator' });
+  const resultBundlePath = join(safeArtifactDir(repository, 'test-results'), `${artifactStamp()}-${sanitize(scheme)}.xcresult`);
   mkdirSync(derivedDataPath, { recursive: true });
   const args = ['test'];
   if (workspace) args.push('-workspace', workspace);
@@ -531,7 +545,7 @@ export function iosXcodeTest(repository: RepositoryRecord, input: {
     if (normalized) args.push(`-only-testing:${normalized}`);
   }
   args.push('-derivedDataPath', derivedDataPath, '-resultBundlePath', resultBundlePath);
-  const result = runCommand('xcodebuild', args, { cwd: repository.canonicalRoot, timeoutMs: input.timeoutMs ?? 15 * 60_000 });
+  const result = runCachedXcodeCommand(repository, derivedDataPath, args, input.timeoutMs ?? 15 * 60_000);
   return {
     ready: result.ok,
     ok: result.ok,

package/src/runtime/safe-tooling/job-summary.ts

@@ -1,4 +1,4 @@
-import { redactMcpText } from '../../cli/mcp/redaction';
+import { redactMcpText } from '../../../adapters/mcp/redaction';
 import type { ExecutionJob } from '../execution/jobs/types';
 import { buildJobOperationDigest } from '../control-plane/facade/operation-digest';
 import {

package/src/runtime/safe-tooling/workspace-auth.ts

@@ -56,6 +56,7 @@ function pluginAuthSummary(manifest: AssistantPluginManifest): Record<string, un
     lifecycleReason: manifest.lifecycle.reason,
     healthState: manifest.health.state,
     ready: manifest.health.ready,
+    readinessMode: manifest.health.details?.readinessMode,
     authRequired: manifest.health.errors.some((error) => /access token|auth|authorization|oauth/i.test(error)),
     errors: manifest.health.errors.slice(0, 5),
     warnings: manifest.health.warnings.slice(0, 5),
@@ -74,7 +75,9 @@ export function buildWorkspaceAuthStatus(manifests: AssistantPluginManifest[]):
     actionRequired: summaries.filter((entry) => entry.authRequired === true || entry.ready !== true).map((entry) => ({
       pluginId: entry.pluginId,
       reason: entry.lifecycleReason,
-      next: 'Call workspace_auth_login_prepare and open the returned local OAuth URL. The callback stores the refresh token in macOS Keychain.',
+      next: entry.readinessMode === 'live_token_unverified'
+        ? 'Run a read-only provider action. If Google requires client_secret, restore the matching OAuth client secret in macOS Keychain; if it cannot be recovered, configure a dedicated OAuth client ID and matching secret, then reauthorize.'
+        : 'Call workspace_auth_login_prepare and open the returned local OAuth URL. The callback stores the refresh token in macOS Keychain.',
     })),
     safety: {
       credentialMaterialReturned: false,

package/src/runtime/shared/atomic-text-file.ts

@@ -0,0 +1,21 @@
+import { randomUUID } from 'crypto';
+import { mkdirSync, renameSync, rmSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+
+/**
+ * The single atomic text writer for Forge-managed service and release files.
+ * Create private parent directories, use a collision-resistant temporary file,
+ * preserve the caller-selected target mode, and remove abandoned temp files
+ * after a failed write or rename. An atomic rename is not an fsync guarantee.
+ */
+export function writeAtomicTextFile(path: string, content: string, mode = 0o600): void {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, content, { encoding: 'utf8', mode, flag: 'wx' });
+    renameSync(temporary, path);
+  } catch (error) {
+    try { rmSync(temporary, { force: true }); } catch { /* preserve original write failure */ }
+    throw error;
+  }
+}

package/src/runtime/shared/json-files.ts

@@ -16,11 +16,16 @@ export function readJsonFile<T>(path: string, fallback?: T): T {
   }
 }
 
-export function writeJsonAtomic(path: string, value: unknown): void {
+export function writeJsonAtomic(path: string, value: unknown, options?: { mode?: number }): void {
   ensureParent(path);
   const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
-  writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
-  renameSync(temporary, path);
+  try {
+    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', ...(options?.mode === undefined ? {} : { mode: options.mode }) });
+    renameSync(temporary, path);
+  } catch (error) {
+    rmSync(temporary, { force: true });
+    throw error;
+  }
 }
 
 export function appendJsonLine(path: string, value: unknown): void {