@moretea-labs/forge 1.5.1 → 1.7.0

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

@@ -9,10 +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 { runStandaloneChatgptPrompt, runWorkChatgptContinuation } from '../../control-plane/launcher/chatgpt-work-continuation';
+import {
+  beginInitialControllerRoundDispatch,
+  buildControllerRoundRelayPrompt,
+  finishControllerRoundRelayDispatch,
+} from '../../control-plane/facade/controller-round-relay';
 import {
   getOccurrence,
   getSchedule,
@@ -24,7 +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,
@@ -35,12 +42,24 @@ import type {
 const execFileAsync = promisify(execFile);
 const LIVE_MAINTENANCE_OPERATION = 'runtime_maintenance_apply';
 const EXTERNAL_CONTROLLER_WAKE_OPERATION = 'external_controller_wake';
+const BROWSER_PROBE_OPERATION = 'browser_probe';
+const GITHUB_ISSUE_WATCH_OPERATION = 'github_issue_watch';
 
 function isDeterministicSchedule(schedule: RepositorySchedule): boolean {
-  // Kernel may execute only fully deterministic, allowlisted schedule operations.
-  // Semantic / model-backed schedules remain external-controller handoffs.
+  // Kernel executes only typed, bounded dispatch operations.
   return schedule.action.operation === LIVE_MAINTENANCE_OPERATION
-    || schedule.action.operation === EXTERNAL_CONTROLLER_WAKE_OPERATION;
+    || schedule.action.operation === EXTERNAL_CONTROLLER_WAKE_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 {
@@ -101,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);
@@ -223,19 +248,15 @@ 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.' };
   }
 }
 
-function continuationWorkId(schedule: RepositorySchedule): string | undefined {
-  if (schedule.action.operation !== EXTERNAL_CONTROLLER_WAKE_OPERATION) return undefined;
+function workBoundScheduleWorkId(schedule: RepositorySchedule): string | undefined {
+  if (schedule.action.operation !== EXTERNAL_CONTROLLER_WAKE_OPERATION
+    && schedule.action.operation !== BROWSER_PROBE_OPERATION) return undefined;
   const value = schedule.action.arguments?.work_id;
   return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
@@ -251,7 +272,7 @@ function executionJobBelongsToWork(job: ReturnType<typeof listExecutionJobs>[num
 
 async function stopReason(controllerHome: string, schedule: RepositorySchedule): Promise<string | undefined> {
   const projection = readRepositoryProjection(controllerHome, schedule.repoId);
-  const workId = continuationWorkId(schedule);
+  const workId = workBoundScheduleWorkId(schedule);
   const work = workId ? getWorkContract({ controllerHome, repoId: schedule.repoId }, workId) : undefined;
   if (schedule.stopConditions.includes('human_review_required')) {
     if (workId) {
@@ -344,12 +365,284 @@ 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;
+  const explicit = new Set(launchArgs.filter((value) => value.startsWith('--')).map((value) => value.split('=', 1)[0]));
+  const add = (flag: string, value: unknown) => {
+    if (explicit.has(flag) || typeof value !== 'string' || !value.trim()) return;
+    launchArgs.push(flag, value.trim());
+  };
+  add('--model', args.model);
+  add('--reasoning', args.reasoning);
+  add('--tab-policy', args.tab_policy);
+  return launchArgs;
+}
+
+async function executeExternalControllerWake(
+  controllerHome: string,
+  schedule: RepositorySchedule,
+  occurrence: ScheduleOccurrence,
+  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';
+  if (!workId) {
+    return decideOccurrence(controllerHome, schedule, occurrence, 'operation_blocked', 'skipped', 'EXTERNAL_CONTROLLER_WAKE_WORK_ID_REQUIRED');
+  }
+  if (!['chatgpt', 'codex', 'claude', 'grok'].includes(controllerType)) {
+    return decideOccurrence(controllerHome, schedule, occurrence, 'operation_blocked', 'skipped', 'EXTERNAL_CONTROLLER_WAKE_TYPE_INVALID');
+  }
+  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 });
+    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 });
+    return decideOccurrence(controllerHome, schedule, occurrence, 'nothing_to_do', 'skipped', `Work ${workId} is terminal (${work.status}); automatic continuation stopped.`);
+  }
+  const existingOwner = getControllerSession(workStore, workId);
+  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}.`);
+  }
+  const launchReservation = getExternalControllerLaunchReservation(workStore, workId);
+  if (launchReservation) {
+    saveSchedule(controllerHome, { ...schedule, 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(
+    controllerHome,
+    schedule,
+    occurrence,
+    'execute',
+    'running',
+    'Deterministic external Controller wake is starting through Thin Launcher.',
+    occurrenceDecisionEvidence({
+      operation: schedule.action.operation,
+      workId,
+      controllerType,
+      ...(controllerType === 'chatgpt' ? {
+        model: typeof args.model === 'string' ? args.model : 'gpt-5.6',
+        reasoning: typeof args.reasoning === 'string' ? args.reasoning : 'high',
+        tabPolicy: typeof args.tab_policy === 'string' ? args.tab_policy : 'auto',
+      } : {}),
+      ...extraEvidence,
+    }),
+  );
+  try {
+    const repository = getRepository(schedule.repoId, controllerHome, { includeRemoved: true });
+    const continuationPrompt = typeof args.continuation_prompt === 'string'
+      ? args.continuation_prompt
+      : `Scheduled continuation ${occurrence.occurrenceId} from ${schedule.scheduleId}. Read current Forge state and continue only the bounded Work objective.`;
+    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';
+      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 = await launchSuperController({
+      work: { controllerHome, repoId: schedule.repoId },
+      handoff: { controllerHome, repoId: schedule.repoId },
+    }, {
+      controllerType: controllerType as 'codex' | 'claude' | 'grok',
+      executable: typeof args.executable === 'string' ? args.executable : undefined,
+      args: externalControllerLaunchArgs(args, controllerType),
+      workId,
+      handoffId: typeof args.handoff_id === 'string' ? args.handoff_id : undefined,
+      browserSessionId: typeof args.browser_session_id === 'string' ? args.browser_session_id : undefined,
+      conversationUrl: typeof args.conversation_url === 'string' ? args.conversation_url : undefined,
+      launchReservationMs: typeof args.launch_reservation_ms === 'number' ? args.launch_reservation_ms : typeof args.lease_ms === 'number' ? args.lease_ms : undefined,
+      continuationPrompt,
+      cwd: repository.canonicalRoot,
+    });
+    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: `External Controller wake started ${launched.controllerType} pid=${String(launched.pid ?? 'unknown')} for Work ${workId}.`,
+    });
+  } 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.',
+        reason,
+        creationReason: 'repeated_infrastructure_failure',
+        blockingDecision: 'Repair the external Controller/browser launch path or update the saved session reference.',
+        recommendedDecision: 'Inspect launcher/browser readiness, then retrigger this bounded continuation.',
+        recommendedPrompt: `Resume Work ${workId} manually, inspect failed wake occurrence ${occurrence.occurrenceId}, and repair the configured external Controller launch path before unattended continuation resumes.`,
+        statusSummary: 'Scheduled external Controller wake failed.',
+        blockedBy: ['external_controller_wake_failed'],
+        attemptedActions: [`schedule:${schedule.scheduleId}`, `work:${workId}`, `controller:${controllerType}`],
+      },
+    });
+    const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
+    saveSchedule(controllerHome, { ...latest, lastTriggeredAt: timestamp, lastOccurrenceId: occurrence.occurrenceId });
+    return failed.occurrence ?? saveOccurrence(controllerHome, { ...wakeDecision, status: 'failed', reason });
+  }
+}
+
 export async function evaluateSchedule(
   controllerHome: string,
   schedule: RepositorySchedule,
   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;
@@ -548,76 +841,212 @@ export async function evaluateSchedule(
 
   const args = schedule.action.arguments ?? {};
   if (schedule.action.operation === EXTERNAL_CONTROLLER_WAKE_OPERATION) {
-    const workId = typeof args.work_id === 'string' ? args.work_id.trim() : '';
-    const controllerType = typeof args.controller_type === 'string' ? args.controller_type.trim() : 'chatgpt';
-    if (!workId) {
-      return decideOccurrence(controllerHome, schedule, occurrence, 'operation_blocked', 'skipped', 'EXTERNAL_CONTROLLER_WAKE_WORK_ID_REQUIRED');
-    }
-    if (!['chatgpt', 'codex', 'claude', 'grok'].includes(controllerType)) {
-      return decideOccurrence(controllerHome, schedule, occurrence, 'operation_blocked', 'skipped', 'EXTERNAL_CONTROLLER_WAKE_TYPE_INVALID');
-    }
-    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', `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: occurrenceId });
-      return decideOccurrence(controllerHome, schedule, occurrence, 'nothing_to_do', 'skipped', `Work ${workId} is terminal (${work.status}); automatic continuation stopped.`);
+    return executeExternalControllerWake(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;
     }
-    const existingOwner = getControllerSession(workStore, workId);
-    if (existingOwner) {
-      saveSchedule(controllerHome, { ...schedule, lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId });
-      return decideOccurrence(controllerHome, schedule, occurrence, 'nothing_to_do', 'skipped', `Work ${workId} already has an active Controller ${existingOwner.controllerId}.`);
+  }
+
+  if (schedule.action.operation === BROWSER_PROBE_OPERATION) {
+    const workId = typeof args.work_id === 'string' ? args.work_id.trim() : '';
+    const keepaliveOnly = args.keepalive_only === true;
+    if (!workId && !keepaliveOnly) {
+      return decideOccurrence(controllerHome, schedule, occurrence, 'operation_blocked', 'skipped', 'SCHEDULE_BROWSER_PROBE_WORK_ID_REQUIRED');
     }
-    const launchReservation = getExternalControllerLaunchReservation(workStore, workId);
-    if (launchReservation) {
-      saveSchedule(controllerHome, { ...schedule, lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId });
-      return decideOccurrence(controllerHome, schedule, occurrence, 'nothing_to_do', 'skipped', `Work ${workId} already has a pending external Controller launch ${launchReservation.reservationId}.`);
+    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.`);
+      }
     }
-    const wakeDecision = decideOccurrence(
-      controllerHome,
-      schedule,
-      occurrence,
-      'execute',
-      'running',
-      'Deterministic external Controller wake is starting through Thin Launcher.',
-      occurrenceDecisionEvidence({ operation: schedule.action.operation, workId, controllerType }),
-    );
+
     try {
       const repository = getRepository(schedule.repoId, controllerHome, { includeRemoved: true });
-      const launched = launchSuperController({
-        work: { controllerHome, repoId: schedule.repoId },
-        handoff: { controllerHome, repoId: schedule.repoId },
-      }, {
-        controllerType: controllerType as 'chatgpt' | 'codex' | 'claude' | 'grok',
-        executable: typeof args.executable === 'string' ? args.executable : undefined,
-        args: Array.isArray(args.launch_args) ? args.launch_args.map(String) : [],
-        workId,
-        handoffId: typeof args.handoff_id === 'string' ? args.handoff_id : undefined,
-        browserSessionId: typeof args.browser_session_id === 'string' ? args.browser_session_id : undefined,
-        conversationUrl: typeof args.conversation_url === 'string' ? args.conversation_url : undefined,
-        launchReservationMs: typeof args.launch_reservation_ms === 'number' ? args.launch_reservation_ms : typeof args.lease_ms === 'number' ? args.lease_ms : undefined,
-        continuationPrompt: typeof args.continuation_prompt === 'string'
-          ? args.continuation_prompt
-          : `Scheduled continuation ${occurrence.occurrenceId} from ${schedule.scheduleId}. Read current Forge state and continue only the bounded Work objective.`,
-        cwd: repository.canonicalRoot,
-      });
+      const probe = await executeScheduledBrowserProbe({ controllerHome, repository, occurrenceId, args });
       const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
-      saveSchedule(controllerHome, {
+      const observationEvidence = occurrenceDecisionEvidence({
+        probeStatus: probe.status,
+        url: probe.url,
+        projectedLineCount: probe.projectedLineCount,
+        observedChars: probe.observedChars,
+        truncated: probe.truncated,
+      });
+
+      if (probe.status === 'auth_required') {
+        const observedSchedule = saveSchedule(controllerHome, {
+          ...latest,
+          lastTriggeredAt: timestamp,
+          lastOccurrenceId: occurrenceId,
+          lastObservationAt: timestamp,
+          lastObservationStatus: 'auth_required',
+          consecutiveFailures: 0,
+          nextEligibleAt: undefined,
+          pausedReason: undefined,
+        });
+        if (args.wake_on_auth_required !== false) {
+          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 ${workId ? 'watcher' : 'keepalive'} requires authentication: ${probe.authReason ?? 'login marker matched'}`, observationEvidence);
+      }
+
+      if (probe.status === 'keepalive') {
+        const observedSchedule = saveSchedule(controllerHome, {
+          ...latest,
+          lastTriggeredAt: timestamp,
+          lastOccurrenceId: occurrenceId,
+          lastObservationAt: timestamp,
+          lastObservationStatus: 'keepalive',
+          consecutiveFailures: 0,
+          consecutiveNoops: 0,
+          nextEligibleAt: undefined,
+          pausedReason: undefined,
+        });
+        return decideOccurrence(controllerHome, observedSchedule, occurrence, 'execute', 'succeeded', 'Browser session keepalive refreshed successfully.', observationEvidence);
+      }
+
+      const observation = classifyScheduledBrowserObservation(
+        latest.lastObservationFingerprint,
+        probe.fingerprint,
+        args.wake_on_first_observation === true,
+      );
+      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,
         lastTriggeredAt: timestamp,
         lastOccurrenceId: occurrenceId,
+        lastObservationAt: timestamp,
+        lastObservationFingerprint: probe.fingerprint,
+        lastObservationChangedAt: changed ? timestamp : latest.lastObservationChangedAt,
+        lastObservationStatus: observationStatus,
         consecutiveFailures: 0,
+        consecutiveNoops: shouldWake ? 0 : (latest.consecutiveNoops ?? 0) + 1,
         nextEligibleAt: undefined,
         pausedReason: undefined,
       });
-      return saveOccurrence(controllerHome, {
-        ...wakeDecision,
-        status: 'succeeded',
-        reason: `External Controller wake started ${launched.controllerType} pid=${String(launched.pid ?? 'unknown')} for Work ${workId}.`,
-      });
+
+      if (!shouldWake) {
+        const reason = observation.status === 'baseline'
+          ? 'Browser watcher baseline recorded; no Controller wake was emitted.'
+          : 'Browser watcher observation is unchanged; no Controller wake was emitted.';
+        return decideOccurrence(controllerHome, observedSchedule, occurrence, 'nothing_to_do', 'skipped', reason, { ...observationEvidence, observationStatus });
+      }
+
+      const wakeArgs = {
+        ...args,
+        continuation_prompt: typeof args.continuation_prompt === 'string'
+          ? args.continuation_prompt
+          : `Scheduled browser watcher ${schedule.scheduleId} detected a changed external observation. Read the current external state, correlate it with Work ${workId}, and continue only the bounded Work objective.`,
+      };
+      return executeExternalControllerWake(controllerHome, observedSchedule, occurrence, timestamp, wakeArgs, { ...observationEvidence, observationStatus });
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
       const failed = applyScheduleFailure(controllerHome, schedule.scheduleId, schedule.repoId, occurrence.occurrenceId, {
@@ -625,21 +1054,21 @@ export async function evaluateSchedule(
         decision: 'execute',
         reason,
         handoff: {
-          title: `External Controller wake ${occurrence.occurrenceId} failed`,
-          summary: 'Forge recorded the schedule trigger but could not wake the configured external Controller.',
+          title: `Browser watcher occurrence ${occurrence.occurrenceId} failed`,
+          summary: 'A bounded browser probe failed before Forge could compare the external observation.',
           reason,
           creationReason: 'repeated_infrastructure_failure',
-          blockingDecision: 'Repair the external Controller/browser launch path or update the saved session reference.',
-          recommendedDecision: 'Inspect launcher/browser readiness, then retrigger this bounded continuation.',
-          recommendedPrompt: `Resume Work ${workId} manually, inspect failed wake occurrence ${occurrence.occurrenceId}, and repair the configured external Controller launch path before unattended continuation resumes.`,
-          statusSummary: 'Scheduled external Controller wake failed.',
-          blockedBy: ['external_controller_wake_failed'],
-          attemptedActions: [`schedule:${schedule.scheduleId}`, `work:${workId}`, `controller:${controllerType}`],
+          blockingDecision: 'Repair browser/session readiness or update the watcher target before unattended probing resumes.',
+          recommendedDecision: 'Inspect the browser plugin/session and retrigger the watcher after the target is readable.',
+          recommendedPrompt: `Inspect browser watcher schedule ${schedule.scheduleId} for Work ${workId}, repair the failed browser probe, then retrigger one bounded occurrence.`,
+          statusSummary: 'Scheduled browser watcher failed.',
+          blockedBy: ['browser_probe_failed'],
+          attemptedActions: [`schedule:${schedule.scheduleId}`, `work:${workId}`, 'operation:browser_probe'],
         },
       });
       const latest = getSchedule(controllerHome, schedule.repoId, schedule.scheduleId);
       saveSchedule(controllerHome, { ...latest, lastTriggeredAt: timestamp, lastOccurrenceId: occurrenceId });
-      return failed.occurrence ?? saveOccurrence(controllerHome, { ...wakeDecision, status: 'failed', reason });
+      return failed.occurrence ?? saveOccurrence(controllerHome, { ...occurrence, status: 'failed', decision: 'execute', reason });
     }
   }