@moretea-labs/forge 1.6.0 → 1.7.0

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

@@ -9,11 +9,15 @@ import {
   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,
@@ -25,8 +29,9 @@ import {
   saveSchedule,
   saveScheduleDecision,
 } 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 +42,24 @@ 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';
 
 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 +120,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 +248,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.' };
@@ -351,6 +365,41 @@ function decideOccurrence(
   return saveOccurrence(controllerHome, { ...occurrence, decision, decisionId, status, reason });
 }
 
+export type ChatgptWakeFailureClass = 'retryable_readiness' | 'semantic_wait' | 'user_action_required' | 'ordinary_failure';
+
+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('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_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',
+    '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 +414,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 +421,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';
@@ -476,7 +442,10 @@ async function executeExternalControllerWake(
     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) {
+  const occurrenceNowMs = Date.parse(timestamp);
+  if (existingOwner && controllerSessionBlocksRecovery(workStore, workId, {
+    nowMs: Number.isFinite(occurrenceNowMs) ? occurrenceNowMs : Date.now(),
+  })) {
     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}.`);
   }
@@ -512,37 +481,81 @@ 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.`,
-      });
+      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)}\n\nScheduled continuation hint: ${continuationPrompt}`;
+        const dispatched = await 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: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
+        });
+        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,
+        });
+        const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
+        saveSchedule(controllerHome, {
+          ...latest,
+          lastTriggeredAt: timestamp,
+          lastOccurrenceId: occurrence.occurrenceId,
+          consecutiveFailures: 0,
+          nextEligibleAt: undefined,
+          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:')) {
+          const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
+          saveSchedule(controllerHome, { ...latest, 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 },
     }, {
@@ -573,10 +586,35 @@ 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,
+      });
+      const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
+      saveSchedule(controllerHome, {
+        ...latest,
+        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.',
@@ -602,6 +640,9 @@ export async function evaluateSchedule(
   force = false,
   triggerContext?: ScheduleTriggerContext,
 ): Promise<ScheduleOccurrence | undefined> {
+  // 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;
@@ -803,24 +844,92 @@ 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 latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
+      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 = () => saveSchedule(controllerHome, {
+        ...getSchedule(controllerHome, schedule.repoId, schedule.scheduleId),
+        action: {
+          ...latest.action,
+          arguments: { ...(latest.action.arguments ?? {}), issue_watch_state: observation.nextState, issue_watch_since: undefined },
+        },
+        lastTriggeredAt: timestamp,
+        lastOccurrenceId: occurrenceId,
+        lastObservationAt: timestamp,
+        lastObservationStatus: observation.status,
+        lastObservationChangedAt: observation.shouldWake ? timestamp : latest.lastObservationChangedAt,
+        consecutiveFailures: 0,
+        consecutiveNoops: observation.shouldWake ? 0 : (latest.consecutiveNoops ?? 0) + 1,
+        nextEligibleAt: undefined,
+        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) {
+        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.`);
+      }
     }
 
     try {
@@ -847,17 +956,44 @@ export async function evaluateSchedule(
           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') {