@moretea-labs/forge 1.6.0 → 1.7.1

package/src/runtime/workflow/schedules/engine.ts

@@ -3,17 +3,22 @@ import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { getRepository } from '../../../cli/repositories/registry';
 import { findExecutionJob, listActiveExecutionJobs, listExecutionJobs } from '../../execution/jobs/store';
+import { executionJobBelongsToWork, workHasActiveExecution } from '../../execution/work-activity';
 import { readRepositoryProjection } from '../../projections/materialized-view';
 import {
   applyRuntimeMaintenance,
   previewAutomaticRuntimeMaintenance,
   type RuntimeMaintenanceActionId,
 } from '../../recovery/maintenance-executor';
-import { listCandidateFindings } from '../findings/store';
-import { getControllerSession, getWorkContract, isTerminalWorkContractStatus, listHandoffItems } from '../../control-plane/facade';
+import { appendWorkEvidence, controllerSessionBlocksRecovery, getControllerSession, getWorkContract, isTerminalWorkContractStatus, listHandoffItems } from '../../control-plane/facade';
 import { launchSuperController } from '../../control-plane/launcher/thin-launcher';
 import { getExternalControllerLaunchReservation } from '../../control-plane/launcher/launch-reservation-store';
-import { runScheduledChatgptPrompt, runWorkChatgptContinuation } from '../../control-plane/launcher/chatgpt-work-continuation';
+import { runStandaloneChatgptPrompt, runWorkChatgptContinuation } from '../../control-plane/launcher/chatgpt-work-continuation';
+import {
+  beginInitialControllerRoundDispatch,
+  buildControllerRoundRelayPrompt,
+  finishControllerRoundRelayDispatch,
+} from '../../control-plane/facade/controller-round-relay';
 import {
   getOccurrence,
   getSchedule,
@@ -22,11 +27,12 @@ import {
   recordScheduleOccurrenceHandoff,
   listSchedules,
   saveOccurrence,
-  saveSchedule,
   saveScheduleDecision,
+  updateSchedule,
 } from './store';
-import { applyScheduleFailure } from './settlement';
+import { applyScheduleFailure, applyScheduleRetryableFailure } from './settlement';
 import { classifyScheduledBrowserObservation, executeScheduledBrowserProbe } from './browser-probe';
+import { executeScheduledGithubIssueWatch } from './github-issue-watch';
 import type {
   RepositorySchedule,
   ScheduleDecisionType,
@@ -37,16 +43,26 @@ import type {
 const execFileAsync = promisify(execFile);
 const LIVE_MAINTENANCE_OPERATION = 'runtime_maintenance_apply';
 const EXTERNAL_CONTROLLER_WAKE_OPERATION = 'external_controller_wake';
-const CHATGPT_BROWSER_PROMPT_OPERATION = 'chatgpt_browser_prompt';
 const BROWSER_PROBE_OPERATION = 'browser_probe';
+const GITHUB_ISSUE_WATCH_OPERATION = 'github_issue_watch';
+const DEFAULT_EXTERNAL_CONTROLLER_WAKE_TIMEOUT_MS = 60_000;
+const MAX_EXTERNAL_CONTROLLER_WAKE_TIMEOUT_MS = 120_000;
 
 function isDeterministicSchedule(schedule: RepositorySchedule): boolean {
-  // Kernel may execute only allowlisted, deterministic dispatch operations.
-  // ChatGPT owns semantic work; the Scheduler only dispatches the configured prompt.
+  // Kernel executes only typed, bounded dispatch operations.
   return schedule.action.operation === LIVE_MAINTENANCE_OPERATION
     || schedule.action.operation === EXTERNAL_CONTROLLER_WAKE_OPERATION
-    || schedule.action.operation === CHATGPT_BROWSER_PROMPT_OPERATION
-    || schedule.action.operation === BROWSER_PROBE_OPERATION;
+    || schedule.action.operation === BROWSER_PROBE_OPERATION
+    || schedule.action.operation === GITHUB_ISSUE_WATCH_OPERATION;
+}
+
+function retiredScheduleReason(schedule: RepositorySchedule): string | undefined {
+  if (schedule.action.operation === 'chatgpt_browser_prompt') return 'RETIRED_WORK_FREE_PROMPT_SCHEDULE';
+  if (schedule.action.operation === 'assistant_routine_execute') return 'RETIRED_PERSONAL_ASSISTANT_SCHEDULE';
+  if ((schedule.trigger.condition as { kind?: string } | undefined)?.kind === 'candidate_observation_threshold') {
+    return 'RETIRED_CANDIDATE_FINDING_SCHEDULE';
+  }
+  return undefined;
 }
 
 function normalizedWindow(minutes: number, at = Date.now()): string {
@@ -107,6 +123,12 @@ function cronWindowKey(schedule: RepositorySchedule, at = Date.now()): string {
 }
 
 function triggerWindowKey(schedule: RepositorySchedule, context: ScheduleTriggerContext | undefined, at = Date.now()): string {
+  // Explicit control-plane triggers use a separate identity namespace from timer/cron windows.
+  // A caller-supplied event/request id is the stable retry key; otherwise each manual trigger is distinct.
+  if (context?.source === 'manual' && schedule.trigger.type !== 'manual') {
+    const stableManualKey = context.eventId?.trim();
+    return `manual:${stableManualKey || randomUUID()}`;
+  }
   switch (schedule.trigger.type) {
     case 'cron':
       return cronWindowKey(schedule, at);
@@ -229,11 +251,6 @@ async function triggerDue(
         const due = condition.kind === 'job_succeeded' ? job?.status === 'succeeded' : terminal;
         return { due, reason: due ? undefined : `Condition ${condition.kind} is not met.`, evidence: { jobId: condition.jobId, status: job?.status ?? 'missing' } };
       }
-      const threshold = Math.max(1, condition.observationThreshold ?? 2);
-      const finding = listCandidateFindings(controllerHome, schedule.repoId, { includeTerminal: true, limit: 1000 })
-        .find((entry) => entry.semanticKey === condition.semanticKey);
-      const due = Boolean(finding && finding.observationCount >= threshold);
-      return { due, reason: due ? undefined : 'Candidate observation threshold is not met.', evidence: { semanticKey: condition.semanticKey, observations: finding?.observationCount ?? 0, threshold } };
     }
     default:
       return { due: false, reason: 'Unsupported Schedule trigger.' };
@@ -247,13 +264,17 @@ function workBoundScheduleWorkId(schedule: RepositorySchedule): string | undefin
   return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
 
-function executionJobBelongsToWork(job: ReturnType<typeof listExecutionJobs>[number], workId: string): boolean {
-  if (job.resourceClaims.some((claim) => claim.workId === workId)) return true;
-  const payload = job.payload as Record<string, unknown>;
-  const args = payload.arguments && typeof payload.arguments === 'object' && !Array.isArray(payload.arguments)
-    ? payload.arguments as Record<string, unknown>
-    : undefined;
-  return [payload.workId, payload.work_id, args?.workId, args?.work_id].some((value) => value === workId);
+const HUMAN_ONLY_HANDOFF_REASONS = new Set([
+  'policy_approval_required',
+  'missing_authorization',
+  'invalid_objective',
+  'destructive_action_requires_confirmation',
+]);
+
+function handoffRequiresHumanReview(item: ReturnType<typeof listHandoffItems>[number]): boolean {
+  if (item.approvalAction) return true;
+  if (!item.creationReason) return true;
+  return HUMAN_ONLY_HANDOFF_REASONS.has(item.creationReason);
 }
 
 async function stopReason(controllerHome: string, schedule: RepositorySchedule): Promise<string | undefined> {
@@ -263,8 +284,8 @@ async function stopReason(controllerHome: string, schedule: RepositorySchedule):
   if (schedule.stopConditions.includes('human_review_required')) {
     if (workId) {
       const activeHandoff = listHandoffItems({ controllerHome, repoId: schedule.repoId, status: 'active', limit: 100 })
-        .find((item) => item.workId === workId);
-      if (activeHandoff) return `Work ${workId} has active Handoff ${activeHandoff.id} requiring review.`;
+        .find((item) => item.workId === workId && handoffRequiresHumanReview(item));
+      if (activeHandoff) return `Work ${workId} has active Handoff ${activeHandoff.id} requiring human review.`;
     } else if (projection.currentAttention.length > 0) {
       return 'Repository has jobs requiring human attention.';
     }
@@ -351,6 +372,64 @@ function decideOccurrence(
   return saveOccurrence(controllerHome, { ...occurrence, decision, decisionId, status, reason });
 }
 
+export type ChatgptWakeFailureClass = 'retryable_readiness' | 'semantic_wait' | 'user_action_required' | 'ordinary_failure';
+
+export function externalControllerWakeTimeoutMs(value: unknown): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return DEFAULT_EXTERNAL_CONTROLLER_WAKE_TIMEOUT_MS;
+  return Math.max(5_000, Math.min(Math.trunc(value), MAX_EXTERNAL_CONTROLLER_WAKE_TIMEOUT_MS));
+}
+
+export async function awaitExternalControllerWake<T>(operation: Promise<T>, timeoutMs: number): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise<T>((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`CONTROLLER_WAKE_TOTAL_TIMEOUT: external Controller dispatch exceeded ${timeoutMs}ms.`)), timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+export function classifyChatgptWakeFailure(reason: string): ChatgptWakeFailureClass {
+  const normalized = reason.toUpperCase();
+  if (
+    normalized.includes('CHATGPT_AUTOMATION_LOGIN_REQUIRED')
+    || normalized.includes('PLUGIN_BROWSER_JAVASCRIPT_PERMISSION_REQUIRED')
+    || normalized.includes('PLUGIN_MACOS_CAPABILITY_BROKER_CAPABILITY_UNSUPPORTED')
+    || normalized.includes('AUTHENTICATION_REQUIRED')
+    || normalized.includes('CONSENT_REQUIRED')
+  ) return 'user_action_required';
+  if (normalized.includes('REPEATED_STATE:')) return 'semantic_wait';
+  const retryableMarkers = [
+    'PLUGIN_BROWSER_ATTACH_UNAVAILABLE',
+    'PLUGIN_BROWSER_DEPENDENCY_UNAVAILABLE',
+    'PLUGIN_BROWSER_NODE_HOST_UNAVAILABLE',
+    'PLUGIN_BROWSER_NODE_UNAVAILABLE',
+    'PLUGIN_BROWSER_ACTIVE_TAB_UNAVAILABLE',
+    'PLUGIN_BROWSER_SESSION_STATE_LOST',
+    'PLUGIN_SESSION_NOT_FOUND',
+    'PLUGIN_BROWSER_NATIVE_TAB_IDENTITY_UNPROVEN',
+    'PLUGIN_MACOS_CAPABILITY_BROKER_UNAVAILABLE',
+    'PLUGIN_BROWSER_NATIVE_FOREGROUND_ACTIVATOR_UNAVAILABLE',
+    'CHATGPT_CONTROLLER_BROWSER_ROOT_UNAVAILABLE',
+    'CHATGPT_CONTROLLER_BROWSER_FAILED',
+    'CHATGPT_AUTOMATION_COMPOSER_UNAVAILABLE',
+    'CHATGPT_AUTOMATION_INTELLIGENCE_CONTROL_UNAVAILABLE',
+    'CHATGPT_AUTOMATION_REPLACEMENT_SESSION_NOT_CONFIRMED',
+    'CONTROLLER_WAKE_TOTAL_TIMEOUT',
+    'HTTP 502',
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'ETIMEDOUT',
+    'UND_ERR_CONNECT_TIMEOUT',
+  ];
+  if (retryableMarkers.some((marker) => normalized.includes(marker))) return 'retryable_readiness';
+  return 'ordinary_failure';
+}
+
 function externalControllerLaunchArgs(args: Record<string, unknown>, controllerType: string): string[] {
   const launchArgs = Array.isArray(args.launch_args) ? args.launch_args.map(String) : [];
   if (controllerType !== 'chatgpt') return launchArgs;
@@ -365,90 +444,6 @@ function externalControllerLaunchArgs(args: Record<string, unknown>, controllerT
   return launchArgs;
 }
 
-async function executeChatgptBrowserPrompt(
-  controllerHome: string,
-  schedule: RepositorySchedule,
-  occurrence: ScheduleOccurrence,
-  timestamp: string,
-  args: Record<string, unknown>,
-): Promise<ScheduleOccurrence> {
-  const prompt = typeof args.prompt === 'string' ? args.prompt.trim() : '';
-  if (!prompt) {
-    return decideOccurrence(controllerHome, schedule, occurrence, 'operation_blocked', 'skipped', 'CHATGPT_BROWSER_PROMPT_REQUIRED');
-  }
-  const model = typeof args.model === 'string' ? args.model : 'gpt-5.6';
-  const reasoning = args.reasoning === 'medium' || args.reasoning === 'xhigh' ? args.reasoning : 'high';
-  const tabPolicy = args.tab_policy === 'reuse' || args.tab_policy === 'new' ? args.tab_policy : 'auto';
-  const dispatching = decideOccurrence(
-    controllerHome,
-    schedule,
-    occurrence,
-    'execute',
-    'running',
-    'Forge Scheduler is dispatching the configured prompt through the controller-owned ChatGPT browser session.',
-    occurrenceDecisionEvidence({ operation: CHATGPT_BROWSER_PROMPT_OPERATION, model, reasoning, tabPolicy }),
-  );
-  const result = await runScheduledChatgptPrompt({
-    controllerHome,
-    repoId: schedule.repoId,
-    automationId: schedule.scheduleId,
-    prompt,
-    title: schedule.name,
-    browserSessionId: typeof args.browser_session_id === 'string' ? args.browser_session_id : undefined,
-    conversationUrl: typeof args.conversation_url === 'string' ? args.conversation_url : undefined,
-    model,
-    reasoning,
-    tabPolicy,
-    timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
-  });
-  if (result.status === 'failed') {
-    const reason = result.error?.message ?? 'ChatGPT browser prompt dispatch failed.';
-    const failed = applyScheduleFailure(controllerHome, schedule.scheduleId, schedule.repoId, occurrence.occurrenceId, {
-      outcome: 'failed',
-      decision: 'execute',
-      reason,
-      handoff: {
-        title: `ChatGPT scheduled prompt ${occurrence.occurrenceId} failed`,
-        summary: 'Forge recorded the trigger but could not dispatch the configured ChatGPT prompt.',
-        reason,
-        creationReason: 'repeated_infrastructure_failure',
-        blockingDecision: 'Repair ChatGPT/browser readiness before unattended prompt dispatch resumes.',
-        recommendedDecision: 'Inspect browser attachment and ChatGPT execution preference verification, then retrigger this automation.',
-        recommendedPrompt: `Inspect failed ChatGPT prompt occurrence ${occurrence.occurrenceId} for schedule ${schedule.scheduleId}.`,
-        statusSummary: 'Scheduled ChatGPT prompt dispatch failed.',
-        blockedBy: ['chatgpt_browser_prompt_failed'],
-        attemptedActions: [`schedule:${schedule.scheduleId}`, `browser-session:${result.browserSessionId}`],
-      },
-    });
-    const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
-    saveSchedule(controllerHome, { ...latest, lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId });
-    return failed.occurrence ?? saveOccurrence(controllerHome, { ...dispatching, status: 'failed', reason });
-  }
-  const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
-  const durableConversationUrl = result.conversationUrl && /\/c\/[^/?#]+/.test(result.conversationUrl)
-    ? result.conversationUrl
-    : undefined;
-  saveSchedule(controllerHome, {
-    ...latest,
-    action: durableConversationUrl && tabPolicy !== 'new'
-      ? {
-          ...latest.action,
-          arguments: { ...latest.action.arguments, conversation_url: durableConversationUrl },
-        }
-      : latest.action,
-    lastTriggeredAt: timestamp,
-    lastOccurrenceId: occurrence.occurrenceId,
-    consecutiveFailures: 0,
-    nextEligibleAt: undefined,
-    pausedReason: undefined,
-  });
-  return saveOccurrence(controllerHome, {
-    ...dispatching,
-    status: 'succeeded',
-    reason: `ChatGPT prompt dispatched via ${result.browserSessionId}${result.reusedSession ? ' (reused)' : ' (new session)'}; execution preference ${result.executionPreferenceVerified ? 'verified' : 'not verified'}.`,
-  });
-}
-
 async function executeExternalControllerWake(
   controllerHome: string,
   schedule: RepositorySchedule,
@@ -456,6 +451,7 @@ async function executeExternalControllerWake(
   timestamp: string,
   args: Record<string, unknown>,
   extraEvidence: Record<string, unknown> = {},
+  options: { transientWakeFailure?: boolean } = {},
 ): Promise<ScheduleOccurrence> {
   const workId = typeof args.work_id === 'string' ? args.work_id.trim() : '';
   const controllerType = typeof args.controller_type === 'string' ? args.controller_type.trim() : 'chatgpt';
@@ -468,21 +464,27 @@ async function executeExternalControllerWake(
   const workStore = { controllerHome, repoId: schedule.repoId };
   const work = getWorkContract(workStore, workId);
   if (!work) {
-    saveSchedule(controllerHome, { ...schedule, enabled: false, pausedReason: `Work ${workId} no longer exists.`, lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId });
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ enabled: false, pausedReason: `Work ${workId} no longer exists.`, lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId }));
     return decideOccurrence(controllerHome, schedule, occurrence, 'operation_blocked', 'skipped', `EXTERNAL_CONTROLLER_WAKE_WORK_NOT_FOUND:${workId}`);
   }
   if (isTerminalWorkContractStatus(work.status)) {
-    saveSchedule(controllerHome, { ...schedule, enabled: false, pausedReason: `Work ${workId} is terminal (${work.status}).`, lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId });
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ enabled: false, pausedReason: `Work ${workId} is terminal (${work.status}).`, lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId }));
     return decideOccurrence(controllerHome, schedule, occurrence, 'nothing_to_do', 'skipped', `Work ${workId} is terminal (${work.status}); automatic continuation stopped.`);
   }
   const existingOwner = getControllerSession(workStore, workId);
-  if (existingOwner) {
-    saveSchedule(controllerHome, { ...schedule, lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId });
-    return decideOccurrence(controllerHome, schedule, occurrence, 'nothing_to_do', 'skipped', `Work ${workId} already has an active Controller ${existingOwner.controllerId}.`);
+  const occurrenceNowMs = Date.parse(timestamp);
+  const nowMs = Number.isFinite(occurrenceNowMs) ? occurrenceNowMs : Date.now();
+  if (workHasActiveExecution(controllerHome, schedule.repoId, workId)) {
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId }));
+    return decideOccurrence(controllerHome, schedule, occurrence, 'nothing_to_do', 'skipped', `Work ${workId} has active execution; duplicate Controller wake suppressed.`);
+  }
+  if (existingOwner && controllerSessionBlocksRecovery(workStore, workId, { nowMs })) {
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId }));
+    return decideOccurrence(controllerHome, schedule, occurrence, 'nothing_to_do', 'skipped', `Work ${workId} has a recently active Controller ${existingOwner.controllerId}.`);
   }
   const launchReservation = getExternalControllerLaunchReservation(workStore, workId);
   if (launchReservation) {
-    saveSchedule(controllerHome, { ...schedule, lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId });
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId }));
     return decideOccurrence(controllerHome, schedule, occurrence, 'nothing_to_do', 'skipped', `Work ${workId} already has a pending external Controller launch ${launchReservation.reservationId}.`);
   }
   const wakeDecision = decideOccurrence(
@@ -512,37 +514,79 @@ async function executeExternalControllerWake(
     if (controllerType === 'chatgpt') {
       const reasoning = args.reasoning === 'medium' || args.reasoning === 'xhigh' ? args.reasoning : 'high';
       const tabPolicy = args.tab_policy === 'reuse' || args.tab_policy === 'new' ? args.tab_policy : 'auto';
-      const dispatched = await runWorkChatgptContinuation({
-        controllerHome,
-        repoId: schedule.repoId,
-        repoRoot: repository.canonicalRoot,
-        workId,
-        prompt: continuationPrompt,
-        title: schedule.name,
-        browserSessionId: typeof args.browser_session_id === 'string' ? args.browser_session_id : undefined,
-        conversationUrl: typeof args.conversation_url === 'string' ? args.conversation_url : undefined,
-        model: typeof args.model === 'string' ? args.model : 'gpt-5.6',
-        reasoning,
-        tabPolicy,
-        timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
-      });
-      if (dispatched.status === 'failed') throw new Error(dispatched.error?.message ?? 'CHATGPT_WORK_CONTINUATION_FAILED');
-      const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
-      saveSchedule(controllerHome, {
-        ...latest,
-        lastTriggeredAt: timestamp,
-        lastOccurrenceId: occurrence.occurrenceId,
-        consecutiveFailures: 0,
-        nextEligibleAt: undefined,
-        pausedReason: undefined,
-      });
-      return saveOccurrence(controllerHome, {
-        ...wakeDecision,
-        status: 'succeeded',
-        reason: `ChatGPT Work continuation dispatched via ${dispatched.browserSessionId}; execution preference verified.`,
-      });
+      const timeoutMs = externalControllerWakeTimeoutMs(args.timeout_ms);
+      let relay;
+      try {
+        relay = beginInitialControllerRoundDispatch(workStore, {
+          workId,
+          identity: {
+            controllerId: `schedule:${schedule.scheduleId}`,
+            principalId: 'forge-scheduler',
+            controllerInstanceId: 'forge-runtime-scheduler',
+            sessionId: occurrence.occurrenceId,
+          },
+          requirementId: work.requirementId,
+          browserSessionId: typeof args.browser_session_id === 'string' ? args.browser_session_id : undefined,
+          conversationUrl: typeof args.conversation_url === 'string' ? args.conversation_url : undefined,
+        });
+        if (relay.status === 'blocked') throw new Error(`CONTROLLER_RELAY_LAUNCH_BLOCKED: ${relay.blockedReason ?? relay.relayScopeId}`);
+        const relayPrompt = `${buildControllerRoundRelayPrompt(workStore, relay, { exactOriginWork: true })}\n\nScheduled continuation hint: ${continuationPrompt}`;
+        const dispatched = await awaitExternalControllerWake(runWorkChatgptContinuation({
+          controllerHome,
+          repoId: schedule.repoId,
+          repoRoot: repository.canonicalRoot,
+          workId,
+          prompt: relayPrompt,
+          title: schedule.name,
+          browserSessionId: typeof args.browser_session_id === 'string' ? args.browser_session_id : undefined,
+          conversationUrl: typeof args.conversation_url === 'string' ? args.conversation_url : undefined,
+          model: typeof args.model === 'string' ? args.model : 'gpt-5.6',
+          reasoning,
+          tabPolicy,
+          timeoutMs,
+        }), timeoutMs);
+        if (dispatched.status === 'failed') throw new Error(dispatched.error?.message ?? 'CHATGPT_WORK_CONTINUATION_FAILED');
+        const completedRelay = finishControllerRoundRelayDispatch(workStore, {
+          workId,
+          ok: true,
+          browserSessionId: dispatched.browserSessionId,
+          conversationUrl: dispatched.conversationUrl,
+        });
+        updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, (current) => ({
+          lastTriggeredAt: timestamp,
+          lastOccurrenceId: occurrence.occurrenceId,
+          consecutiveFailures: 0,
+          nextEligibleAt: undefined,
+          ...(current.enabled ? { pausedReason: undefined } : {}),
+        }));
+        const succeededOccurrence = saveOccurrence(controllerHome, {
+          ...wakeDecision,
+          status: 'succeeded',
+          reason: `ChatGPT dispatch action succeeded via ${dispatched.browserSessionId}; relay ${completedRelay?.relayScopeId ?? relay.relayScopeId} remains dispatched until the new Controller claims Work ${workId}.`,
+        });
+        appendWorkEvidence(workStore, workId, {
+          evidenceId: succeededOccurrence.occurrenceId,
+          title: 'scheduled ChatGPT continuation dispatched',
+          summary: `Schedule ${schedule.scheduleId} timer occurrence ${succeededOccurrence.occurrenceId} dispatched the Work-bound ChatGPT continuation successfully.`,
+          detailLevel: 'summary',
+        });
+        return succeededOccurrence;
+      } catch (error) {
+        if (relay) {
+          finishControllerRoundRelayDispatch(workStore, {
+            workId,
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+        if (error instanceof Error && error.message.startsWith('CONTROLLER_RELAY_ROUND_ALREADY_OPEN:')) {
+          updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId }));
+          return decideOccurrence(controllerHome, schedule, wakeDecision, 'nothing_to_do', 'skipped', `Work ${workId} already has an open ChatGPT controller round awaiting claim or disposition.`);
+        }
+        throw error;
+      }
     }
-    const launched = launchSuperController({
+    const launched = await launchSuperController({
       work: { controllerHome, repoId: schedule.repoId },
       handoff: { controllerHome, repoId: schedule.repoId },
     }, {
@@ -557,15 +601,13 @@ async function executeExternalControllerWake(
       continuationPrompt,
       cwd: repository.canonicalRoot,
     });
-    const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
-    saveSchedule(controllerHome, {
-      ...latest,
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, (current) => ({
       lastTriggeredAt: timestamp,
       lastOccurrenceId: occurrence.occurrenceId,
       consecutiveFailures: 0,
       nextEligibleAt: undefined,
-      pausedReason: undefined,
-    });
+      ...(current.enabled ? { pausedReason: undefined } : {}),
+    }));
     return saveOccurrence(controllerHome, {
       ...wakeDecision,
       status: 'succeeded',
@@ -573,10 +615,33 @@ async function executeExternalControllerWake(
     });
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
+    const failureClass = controllerType === 'chatgpt' ? classifyChatgptWakeFailure(reason) : 'ordinary_failure';
+    if (options.transientWakeFailure || failureClass === 'retryable_readiness' || failureClass === 'semantic_wait') {
+      const semanticWait = failureClass === 'semantic_wait';
+      const deferred = applyScheduleRetryableFailure(controllerHome, schedule.scheduleId, schedule.repoId, occurrence.occurrenceId, {
+        outcome: semanticWait ? 'skipped' : 'failed',
+        decision: semanticWait ? 'nothing_to_do' : 'execute',
+        reason: semanticWait
+          ? `Controller wake deferred until durable state changes; schedule remains active: ${reason}`
+          : `Controller wake deferred by transient readiness; schedule remains active with bounded backoff: ${reason}`,
+        countFailure: !semanticWait,
+      });
+      updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({
+        lastTriggeredAt: timestamp,
+        lastOccurrenceId: occurrence.occurrenceId,
+      }));
+      return deferred.occurrence ?? saveOccurrence(controllerHome, {
+        ...wakeDecision,
+        status: semanticWait ? 'skipped' : 'failed',
+        decision: semanticWait ? 'nothing_to_do' : 'execute',
+        reason,
+      });
+    }
     const failed = applyScheduleFailure(controllerHome, schedule.scheduleId, schedule.repoId, occurrence.occurrenceId, {
       outcome: 'failed',
       decision: 'execute',
       reason,
+      ...(failureClass === 'user_action_required' ? { pauseReason: reason } : {}),
       handoff: {
         title: `External Controller wake ${occurrence.occurrenceId} failed`,
         summary: 'Forge recorded the schedule trigger but could not wake the configured external Controller.',
@@ -590,8 +655,7 @@ async function executeExternalControllerWake(
         attemptedActions: [`schedule:${schedule.scheduleId}`, `work:${workId}`, `controller:${controllerType}`],
       },
     });
-    const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
-    saveSchedule(controllerHome, { ...latest, lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId });
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId }));
     return failed.occurrence ?? saveOccurrence(controllerHome, { ...wakeDecision, status: 'failed', reason });
   }
 }
@@ -602,6 +666,13 @@ export async function evaluateSchedule(
   force = false,
   triggerContext?: ScheduleTriggerContext,
 ): Promise<ScheduleOccurrence | undefined> {
+  // The persisted Schedule record is the authority. Callers may legitimately
+  // retain the object returned by create/list/get across multiple trigger
+  // attempts, so never let an older in-memory revision become execution state.
+  schedule = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
+  // Preserve retired schedule records as evidence, but do not create a new
+  // occurrence or resume a controller/external action from their old payload.
+  if (retiredScheduleReason(schedule)) return undefined;
   if (!schedule.enabled && !force) return undefined;
   const due = await triggerDue(controllerHome, schedule, force, triggerContext);
   if (!due.due) return undefined;
@@ -653,7 +724,7 @@ export async function evaluateSchedule(
         attemptedActions: [`operation:${schedule.action.operation}`],
       },
     );
-    saveSchedule(controllerHome, { ...schedule, lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId });
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId }));
     return externalControllerHandoff;
   }
 
@@ -690,7 +761,10 @@ export async function evaluateSchedule(
     return decideOccurrence(controllerHome, schedule, occurrence, 'active_occurrence', 'skipped', 'Maximum active occurrences reached.');
   }
   if (schedule.consecutiveFailures >= schedule.policy.maxFailures) {
-    saveSchedule(controllerHome, { ...schedule, enabled: false, pausedReason: 'Maximum consecutive failures reached.' });
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, (current) => ({
+      enabled: false,
+      pausedReason: current.enabled ? 'Maximum consecutive failures reached.' : current.pausedReason,
+    }));
     return decideOccurrence(controllerHome, schedule, occurrence, 'stopped', 'skipped', 'Schedule paused after repeated failures.');
   }
   if (schedule.nextEligibleAt && Date.parse(schedule.nextEligibleAt) > Date.now() && !force) {
@@ -744,14 +818,14 @@ export async function evaluateSchedule(
           readyForExecution: preview.status.readyForExecution,
         }));
       }
-      saveSchedule(controllerHome, { ...schedule, lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId });
+      updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId }));
       return decideOccurrence(controllerHome, schedule, occurrence, 'would_execute', 'shadowed', 'Shadow mode records the live maintenance decision without applying it.', occurrenceDecisionEvidence({
         actionId: preview.actionId,
         safeCandidates: preview.selectedCandidateIds.length,
         typedSafeCandidates: preview.selectedTypedCandidateIds.length,
       }));
     }
-    saveSchedule(controllerHome, { ...schedule, lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId });
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId }));
     return decideOccurrence(controllerHome, schedule, occurrence, 'would_execute', 'shadowed', 'Shadow mode records the decision without modifying the repository.', due.evidence);
   }
 
@@ -803,24 +877,93 @@ export async function evaluateSchedule(
     return executeExternalControllerWake(controllerHome, schedule, occurrence, timestamp, args);
   }
 
-  if (schedule.action.operation === CHATGPT_BROWSER_PROMPT_OPERATION) {
-    return executeChatgptBrowserPrompt(controllerHome, schedule, occurrence, timestamp, args);
+  if (schedule.action.operation === GITHUB_ISSUE_WATCH_OPERATION) {
+    try {
+      const repository = getRepository(schedule.repoId, controllerHome, { includeRemoved: true });
+      const observation = await executeScheduledGithubIssueWatch({ repoRoot: repository.canonicalRoot, args, observedAt: timestamp });
+      const evidence = occurrenceDecisionEvidence({
+        githubRepository: typeof args.github_repository === 'string' ? args.github_repository : undefined,
+        observationStatus: observation.status,
+        observedIssueCount: observation.issues.length,
+        changedIssueNumbers: observation.changedOpenIssues.map((issue) => issue.number),
+      });
+      const persistObservation = () => updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, (current) => {
+        if (current.action.operation !== GITHUB_ISSUE_WATCH_OPERATION) throw new Error('SCHEDULE_ACTION_CHANGED_DURING_GITHUB_OBSERVATION');
+        return {
+          action: {
+            ...current.action,
+            arguments: { ...(current.action.arguments ?? {}), issue_watch_state: observation.nextState, issue_watch_since: undefined },
+          },
+          lastTriggeredAt: timestamp,
+          lastOccurrenceId: occurrenceId,
+          lastObservationAt: timestamp,
+          lastObservationStatus: observation.status,
+          lastObservationChangedAt: observation.shouldWake ? timestamp : current.lastObservationChangedAt,
+          consecutiveFailures: 0,
+          consecutiveNoops: observation.shouldWake ? 0 : (current.consecutiveNoops ?? 0) + 1,
+          nextEligibleAt: undefined,
+          ...(current.enabled ? { pausedReason: undefined } : {}),
+        };
+      });
+      if (!observation.shouldWake) {
+        const observedSchedule = persistObservation();
+        const reason = observation.status === 'baseline'
+          ? 'GitHub issue watcher baseline recorded; no Controller wake was emitted.'
+          : 'GitHub issue watcher found no new, reopened, or updated open issue.';
+        return decideOccurrence(controllerHome, observedSchedule, occurrence, 'nothing_to_do', 'skipped', reason, evidence);
+      }
+      const issueSummary = observation.changedOpenIssues.slice(0, 10)
+        .map((issue) => `#${issue.number} ${issue.title}`)
+        .join('; ');
+      const wakeArgs = {
+        ...args,
+        continuation_prompt: typeof args.continuation_prompt === 'string'
+          ? `${args.continuation_prompt}\n\nGitHub issue watcher detected: ${issueSummary}`
+          : `GitHub issue watcher detected actionable issue changes: ${issueSummary}. Read current Work/Plan/evidence and process these issues through the bounded repair workflow.`,
+      };
+      const wake = await executeExternalControllerWake(controllerHome, schedule, occurrence, timestamp, wakeArgs, evidence, { transientWakeFailure: true });
+      if (wake.status !== 'failed') persistObservation();
+      return wake;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      const failed = applyScheduleFailure(controllerHome, schedule.scheduleId, schedule.repoId, occurrence.occurrenceId, {
+        outcome: 'failed',
+        decision: 'execute',
+        reason,
+        handoff: {
+          title: `GitHub issue watcher occurrence ${occurrence.occurrenceId} failed`,
+          summary: 'The local GitHub issue poll failed before Forge could compare issue state.',
+          reason,
+          creationReason: 'repeated_infrastructure_failure',
+          blockingDecision: 'Repair GitHub CLI authentication/connectivity before unattended issue monitoring resumes.',
+          recommendedDecision: 'Restore gh read access, then retrigger the watcher.',
+          recommendedPrompt: `Inspect GitHub issue watcher occurrence ${occurrence.occurrenceId} and restore the local read-only gh issue polling path.`,
+          statusSummary: 'GitHub issue watcher poll failed.',
+          blockedBy: ['github_issue_watch_failed'],
+          attemptedActions: [`schedule:${schedule.scheduleId}`, 'gh:api:issues'],
+        },
+      });
+      return failed.occurrence ?? occurrence;
+    }
   }
 
   if (schedule.action.operation === BROWSER_PROBE_OPERATION) {
     const workId = typeof args.work_id === 'string' ? args.work_id.trim() : '';
-    if (!workId) {
+    const keepaliveOnly = args.keepalive_only === true;
+    if (!workId && !keepaliveOnly) {
       return decideOccurrence(controllerHome, schedule, occurrence, 'operation_blocked', 'skipped', 'SCHEDULE_BROWSER_PROBE_WORK_ID_REQUIRED');
     }
-    const workStore = { controllerHome, repoId: schedule.repoId };
-    const work = getWorkContract(workStore, workId);
-    if (!work) {
-      saveSchedule(controllerHome, { ...schedule, enabled: false, pausedReason: `Work ${workId} no longer exists.`, lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId });
-      return decideOccurrence(controllerHome, schedule, occurrence, 'operation_blocked', 'skipped', `SCHEDULE_BROWSER_PROBE_WORK_NOT_FOUND:${workId}`);
-    }
-    if (isTerminalWorkContractStatus(work.status)) {
-      saveSchedule(controllerHome, { ...schedule, enabled: false, pausedReason: `Work ${workId} is terminal (${work.status}).`, lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId });
-      return decideOccurrence(controllerHome, schedule, occurrence, 'nothing_to_do', 'skipped', `Work ${workId} is terminal (${work.status}); browser watcher stopped before probing.`);
+    if (workId) {
+      const workStore = { controllerHome, repoId: schedule.repoId };
+      const work = getWorkContract(workStore, workId);
+      if (!work) {
+        updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ enabled: false, pausedReason: `Work ${workId} no longer exists.`, lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId }));
+        return decideOccurrence(controllerHome, schedule, occurrence, 'operation_blocked', 'skipped', `SCHEDULE_BROWSER_PROBE_WORK_NOT_FOUND:${workId}`);
+      }
+      if (isTerminalWorkContractStatus(work.status)) {
+        updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ enabled: false, pausedReason: `Work ${workId} is terminal (${work.status}).`, lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId }));
+        return decideOccurrence(controllerHome, schedule, occurrence, 'nothing_to_do', 'skipped', `Work ${workId} is terminal (${work.status}); browser watcher stopped before probing.`);
+      }
     }
 
     try {
@@ -836,33 +979,58 @@ export async function evaluateSchedule(
       });
 
       if (probe.status === 'auth_required') {
-        const observedSchedule = saveSchedule(controllerHome, {
-          ...latest,
+        const observedSchedule = updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, (current) => ({
           lastTriggeredAt: timestamp,
           lastOccurrenceId: occurrenceId,
           lastObservationAt: timestamp,
           lastObservationStatus: 'auth_required',
           consecutiveFailures: 0,
           nextEligibleAt: undefined,
-          pausedReason: undefined,
-        });
+          ...(current.enabled ? { pausedReason: undefined } : {}),
+        }));
         if (args.wake_on_auth_required !== false) {
-          const wakeArgs = {
-            ...args,
-            continuation_prompt: typeof args.auth_required_prompt === 'string'
-              ? args.auth_required_prompt
-              : typeof args.continuation_prompt === 'string'
-                ? args.continuation_prompt
-                : `Scheduled browser watcher ${schedule.scheduleId} detected that authentication is required (${probe.authReason ?? 'login marker'}). Inspect the bound external dependency and request user login only if it cannot be restored safely.`,
-          };
-          return executeExternalControllerWake(controllerHome, observedSchedule, occurrence, timestamp, wakeArgs, { ...observationEvidence, authReason: probe.authReason });
+          const authPrompt = typeof args.auth_required_prompt === 'string'
+            ? args.auth_required_prompt
+            : typeof args.continuation_prompt === 'string'
+              ? args.continuation_prompt
+              : `Scheduled browser watcher ${schedule.scheduleId} detected that authentication is required (${probe.authReason ?? 'login marker'}). Inspect the external dependency and request user login only if it cannot be restored safely.`;
+          if (workId) {
+            const wakeArgs = { ...args, continuation_prompt: authPrompt };
+            return executeExternalControllerWake(controllerHome, observedSchedule, occurrence, timestamp, wakeArgs, { ...observationEvidence, authReason: probe.authReason });
+          }
+          const controllerType = typeof args.controller_type === 'string' ? args.controller_type.trim() : 'chatgpt';
+          if (controllerType !== 'chatgpt') {
+            return decideOccurrence(controllerHome, observedSchedule, occurrence, 'operation_blocked', 'skipped', 'STANDALONE_BROWSER_KEEPALIVE_CHATGPT_REQUIRED', observationEvidence);
+          }
+          const dispatched = await runStandaloneChatgptPrompt({
+            controllerHome,
+            repoId: schedule.repoId,
+            scopeId: `schedule:${schedule.scheduleId}`,
+            prompt: authPrompt,
+            browserSessionId: typeof args.browser_session_id === 'string' ? args.browser_session_id : undefined,
+            conversationUrl: typeof args.conversation_url === 'string' ? args.conversation_url : undefined,
+          });
+          if (dispatched.status === 'failed') throw new Error(dispatched.error?.message ?? 'CHATGPT_STANDALONE_PROMPT_FAILED');
+          return decideOccurrence(
+            controllerHome,
+            observedSchedule,
+            occurrence,
+            'execute',
+            'succeeded',
+            'Standalone browser keepalive auth-required prompt dispatched to ChatGPT.',
+            {
+              ...observationEvidence,
+              authReason: probe.authReason,
+              browserSessionId: dispatched.browserSessionId,
+              conversationUrl: dispatched.conversationUrl,
+            },
+          );
         }
-        return decideOccurrence(controllerHome, observedSchedule, occurrence, 'operation_blocked', 'skipped', `Browser watcher requires authentication: ${probe.authReason ?? 'login marker matched'}`, observationEvidence);
+        return decideOccurrence(controllerHome, observedSchedule, occurrence, 'operation_blocked', 'skipped', `Browser ${workId ? 'watcher' : 'keepalive'} requires authentication: ${probe.authReason ?? 'login marker matched'}`, observationEvidence);
       }
 
       if (probe.status === 'keepalive') {
-        const observedSchedule = saveSchedule(controllerHome, {
-          ...latest,
+        const observedSchedule = updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, (current) => ({
           lastTriggeredAt: timestamp,
           lastOccurrenceId: occurrenceId,
           lastObservationAt: timestamp,
@@ -870,8 +1038,8 @@ export async function evaluateSchedule(
           consecutiveFailures: 0,
           consecutiveNoops: 0,
           nextEligibleAt: undefined,
-          pausedReason: undefined,
-        });
+          ...(current.enabled ? { pausedReason: undefined } : {}),
+        }));
         return decideOccurrence(controllerHome, observedSchedule, occurrence, 'execute', 'succeeded', 'Browser session keepalive refreshed successfully.', observationEvidence);
       }
 
@@ -883,19 +1051,18 @@ export async function evaluateSchedule(
       const changed = observation.status === 'changed';
       const shouldWake = args.wake_on_change !== false && observation.shouldWake;
       const observationStatus: RepositorySchedule['lastObservationStatus'] = observation.status;
-      const observedSchedule = saveSchedule(controllerHome, {
-        ...latest,
+      const observedSchedule = updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, (current) => ({
         lastTriggeredAt: timestamp,
         lastOccurrenceId: occurrenceId,
         lastObservationAt: timestamp,
         lastObservationFingerprint: probe.fingerprint,
-        lastObservationChangedAt: changed ? timestamp : latest.lastObservationChangedAt,
+        lastObservationChangedAt: changed ? timestamp : current.lastObservationChangedAt,
         lastObservationStatus: observationStatus,
         consecutiveFailures: 0,
-        consecutiveNoops: shouldWake ? 0 : (latest.consecutiveNoops ?? 0) + 1,
+        consecutiveNoops: shouldWake ? 0 : (current.consecutiveNoops ?? 0) + 1,
         nextEligibleAt: undefined,
-        pausedReason: undefined,
-      });
+        ...(current.enabled ? { pausedReason: undefined } : {}),
+      }));
 
       if (!shouldWake) {
         const reason = observation.status === 'baseline'
@@ -930,8 +1097,7 @@ export async function evaluateSchedule(
           attemptedActions: [`schedule:${schedule.scheduleId}`, `work:${workId}`, 'operation:browser_probe'],
         },
       });
-      const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
-      saveSchedule(controllerHome, { ...latest, lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId });
+      updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({ lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId }));
       return failed.occurrence ?? saveOccurrence(controllerHome, { ...occurrence, status: 'failed', decision: 'execute', reason });
     }
   }
@@ -976,15 +1142,13 @@ export async function evaluateSchedule(
       cancelPendingApprovals: false,
     });
     const appliedCount = result.applied.filter((candidate) => candidate.applied).length;
-    const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
-    saveSchedule(controllerHome, {
-      ...latest,
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, (current) => ({
       lastTriggeredAt: timestamp,
       lastOccurrenceId: occurrenceId,
       consecutiveFailures: 0,
       nextEligibleAt: undefined,
-      pausedReason: undefined,
-    });
+      ...(current.enabled ? { pausedReason: undefined } : {}),
+    }));
     return saveOccurrence(controllerHome, {
       ...decision,
       status: 'succeeded',
@@ -1013,12 +1177,10 @@ export async function evaluateSchedule(
         ],
       },
     });
-    const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
-    saveSchedule(controllerHome, {
-      ...latest,
+    updateSchedule(controllerHome, schedule.repoId, schedule.scheduleId, () => ({
       lastTriggeredAt: timestamp,
       lastOccurrenceId: occurrenceId,
-    });
+    }));
     return failed.occurrence ?? saveOccurrence(controllerHome, {
       ...decision,
       status: 'failed',