@moretea-labs/forge 1.5.1 → 1.7.0

package/src/runtime/workflow/schedules/github-issue-watch.ts

@@ -0,0 +1,158 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { resolveTrustedExecutable } from '../../shared/trusted-executable';
+
+const execFileAsync = promisify(execFile);
+
+export interface GithubIssueWatchIssue {
+  number: number;
+  title: string;
+  state: 'open' | 'closed';
+  updatedAt: string;
+  url: string;
+}
+
+export interface GithubIssueWatchState {
+  schemaVersion: 1;
+  observedAt: string;
+  signatures: Record<string, string>;
+}
+
+export interface GithubIssueWatchObservation {
+  status: 'baseline' | 'unchanged' | 'changed';
+  shouldWake: boolean;
+  changedOpenIssues: GithubIssueWatchIssue[];
+  issues: GithubIssueWatchIssue[];
+  nextState: GithubIssueWatchState;
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function boundedNumber(value: unknown, fallback: number, min: number, max: number): number {
+  return typeof value === 'number' && Number.isFinite(value)
+    ? Math.max(min, Math.min(Math.trunc(value), max))
+    : fallback;
+}
+
+function issueSignature(issue: GithubIssueWatchIssue): string {
+  return `${issue.state}:${issue.updatedAt}`;
+}
+
+function normalizeIssue(value: unknown): GithubIssueWatchIssue | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  const record = value as Record<string, unknown>;
+  const number = typeof record.number === 'number' && Number.isFinite(record.number) ? Math.trunc(record.number) : undefined;
+  const title = stringValue(record.title);
+  const state = record.state === 'open' || record.state === 'closed' ? record.state : undefined;
+  const updatedAt = stringValue(record.updatedAt);
+  const url = stringValue(record.url);
+  if (!number || !title || !state || !updatedAt || !url) return undefined;
+  return { number, title, state, updatedAt, url };
+}
+
+export function normalizeGithubIssueWatchState(value: unknown): GithubIssueWatchState | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  const record = value as Record<string, unknown>;
+  const signaturesValue = record.signatures;
+  if (!signaturesValue || typeof signaturesValue !== 'object' || Array.isArray(signaturesValue)) return undefined;
+  const signatures = Object.fromEntries(Object.entries(signaturesValue as Record<string, unknown>)
+    .filter((entry): entry is [string, string] => typeof entry[1] === 'string'));
+  return {
+    schemaVersion: 1,
+    observedAt: stringValue(record.observedAt) ?? new Date(0).toISOString(),
+    signatures,
+  };
+}
+
+export function classifyGithubIssueWatchObservation(
+  issues: GithubIssueWatchIssue[],
+  previousState: GithubIssueWatchState | undefined,
+  options: { since?: string; wakeOnFirstObservation?: boolean; observedAt?: string } = {},
+): GithubIssueWatchObservation {
+  const observedAt = options.observedAt ?? new Date().toISOString();
+  const signatures = Object.fromEntries(issues.map((issue) => [String(issue.number), issueSignature(issue)]));
+  const firstObservation = !previousState;
+  const sinceMs = options.since ? Date.parse(options.since) : Number.NaN;
+  const changedOpenIssues = issues.filter((issue) => {
+    if (issue.state !== 'open') return false;
+    if (!firstObservation) return previousState.signatures[String(issue.number)] !== issueSignature(issue);
+    if (options.wakeOnFirstObservation === true) return true;
+    return Number.isFinite(sinceMs) && Date.parse(issue.updatedAt) > sinceMs;
+  });
+  return {
+    status: firstObservation ? 'baseline' : changedOpenIssues.length > 0 ? 'changed' : 'unchanged',
+    shouldWake: changedOpenIssues.length > 0,
+    changedOpenIssues,
+    issues,
+    nextState: { schemaVersion: 1, observedAt, signatures },
+  };
+}
+
+const DEFAULT_GH_EXECUTABLE_CANDIDATES = [
+  '/opt/homebrew/bin/gh',
+  '/usr/local/bin/gh',
+  '/usr/bin/gh',
+] as const;
+
+export function resolveGithubIssueWatchExecutable(
+  args: Record<string, unknown>,
+  env: NodeJS.ProcessEnv = process.env,
+  preferredPaths: readonly string[] = DEFAULT_GH_EXECUTABLE_CANDIDATES,
+): string {
+  const configured = stringValue(args.gh_executable) ?? stringValue(env.FORGE_GH_EXECUTABLE);
+  const resolved = resolveTrustedExecutable({
+    name: 'gh',
+    configured,
+    preferredPaths,
+    env,
+  });
+  if (resolved.configuredInvalid) {
+    throw new Error('SCHEDULE_GITHUB_ISSUE_WATCH_GH_EXECUTABLE_INVALID: gh_executable/FORGE_GH_EXECUTABLE must be an absolute executable path.');
+  }
+  if (!resolved.executable) {
+    throw new Error('SCHEDULE_GITHUB_ISSUE_WATCH_GH_EXECUTABLE_NOT_FOUND: GitHub CLI was not found in trusted Homebrew/system locations or PATH.');
+  }
+  return resolved.executable;
+}
+
+export async function executeScheduledGithubIssueWatch(input: {
+  repoRoot: string;
+  args: Record<string, unknown>;
+  observedAt?: string;
+}): Promise<GithubIssueWatchObservation> {
+  const repository = stringValue(input.args.github_repository);
+  if (!repository || !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repository)) {
+    throw new Error('SCHEDULE_GITHUB_ISSUE_WATCH_REPOSITORY_REQUIRED');
+  }
+  const limit = boundedNumber(input.args.issue_limit, 50, 10, 100);
+  const timeoutMs = boundedNumber(input.args.timeout_ms, 15_000, 1_000, 60_000);
+  try {
+    const ghExecutable = resolveGithubIssueWatchExecutable(input.args);
+    const result = await execFileAsync(ghExecutable, [
+      'api',
+      '-H', 'Accept: application/vnd.github+json',
+      `repos/${repository}/issues?state=all&sort=updated&direction=desc&per_page=${limit}`,
+      '--jq', 'map(select(.pull_request|not)) | map({number,title,state,updatedAt:.updated_at,url:.html_url})',
+    ], {
+      cwd: input.repoRoot,
+      encoding: 'utf8',
+      timeout: timeoutMs,
+      maxBuffer: 2 * 1024 * 1024,
+    });
+    const parsed = JSON.parse(String(result.stdout)) as unknown;
+    if (!Array.isArray(parsed)) throw new Error('GitHub issue response was not an array.');
+    const issues = parsed.map(normalizeIssue).filter((issue): issue is GithubIssueWatchIssue => Boolean(issue));
+    const previousState = normalizeGithubIssueWatchState(input.args.issue_watch_state);
+    return classifyGithubIssueWatchObservation(issues, previousState, {
+      since: stringValue(input.args.issue_watch_since),
+      wakeOnFirstObservation: input.args.wake_on_first_observation === true,
+      observedAt: input.observedAt,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.startsWith('SCHEDULE_GITHUB_ISSUE_WATCH_GH_EXECUTABLE_')) throw error;
+    throw new Error(`SCHEDULE_GITHUB_ISSUE_WATCH_FAILED: ${message}`);
+  }
+}

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

@@ -11,14 +11,21 @@ import {
 
 const TERMINAL_OCCURRENCE_STATUSES = new Set<ScheduleOccurrence['status']>(['succeeded', 'failed', 'shadowed', 'skipped']);
 
-function computeScheduleFailureState(schedule: ReturnType<typeof getSchedule>, nextFailures: number): Pick<ReturnType<typeof getSchedule>, 'consecutiveFailures' | 'nextEligibleAt' | 'enabled' | 'pausedReason'> {
-  const shouldPause = nextFailures >= schedule.policy.maxFailures;
+function computeScheduleBackoff(schedule: ReturnType<typeof getSchedule>, nextFailures: number): string {
   const backoffBase = Math.max(1, schedule.policy.backoffBaseMinutes ?? schedule.policy.cooldownMinutes ?? 1);
   const backoffMax = Math.max(backoffBase, schedule.policy.backoffMaxMinutes ?? 24 * 60);
-  const backoffMinutes = Math.min(backoffMax, backoffBase * (2 ** Math.max(0, nextFailures - 1)));
+  // Persistent readiness failures may span hours or days. Cap the exponent so
+  // the calculation stays bounded even while the observable failure count grows.
+  const exponent = Math.min(16, Math.max(0, nextFailures - 1));
+  const backoffMinutes = Math.min(backoffMax, backoffBase * (2 ** exponent));
+  return new Date(Date.now() + backoffMinutes * 60_000).toISOString();
+}
+
+function computeScheduleFailureState(schedule: ReturnType<typeof getSchedule>, nextFailures: number): Pick<ReturnType<typeof getSchedule>, 'consecutiveFailures' | 'nextEligibleAt' | 'enabled' | 'pausedReason'> {
+  const shouldPause = nextFailures >= schedule.policy.maxFailures;
   return {
     consecutiveFailures: nextFailures,
-    nextEligibleAt: new Date(Date.now() + backoffMinutes * 60_000).toISOString(),
+    nextEligibleAt: computeScheduleBackoff(schedule, nextFailures),
     enabled: shouldPause ? false : schedule.enabled,
     pausedReason: shouldPause ? 'Maximum consecutive failures reached.' : undefined,
   };
@@ -68,6 +75,43 @@ export function applyScheduleFailure(
   return { schedule: nextSchedule, occurrence: nextOccurrence };
 }
 
+export function applyScheduleRetryableFailure(
+  controllerHome: string,
+  scheduleId: string,
+  repoId: string,
+  occurrenceId: string,
+  options: {
+    outcome: 'failed' | 'skipped';
+    decision: ScheduleDecisionType;
+    reason: string;
+    countFailure?: boolean;
+  },
+): { schedule: ReturnType<typeof getSchedule>; occurrence?: ScheduleOccurrence } {
+  const schedule = getSchedule(controllerHome, repoId, scheduleId);
+  const occurrence = getOccurrence(controllerHome, repoId, occurrenceId);
+  let nextOccurrence = occurrence;
+  if (occurrence && !TERMINAL_OCCURRENCE_STATUSES.has(occurrence.status)) {
+    nextOccurrence = saveOccurrence(controllerHome, {
+      ...occurrence,
+      status: options.outcome,
+      decision: options.decision,
+      reason: options.reason,
+    });
+  }
+  const countFailure = options.countFailure !== false;
+  const nextFailures = countFailure ? schedule.consecutiveFailures + 1 : schedule.consecutiveFailures;
+  const nextSchedule = saveSchedule(controllerHome, {
+    ...schedule,
+    consecutiveFailures: nextFailures,
+    nextEligibleAt: computeScheduleBackoff(schedule, Math.max(1, nextFailures)),
+    // Retryable readiness/semantic-wait failures never turn a durable schedule
+    // into a manual-resume task. Respect a concurrent explicit pause, however.
+    enabled: schedule.enabled,
+    pausedReason: schedule.enabled ? undefined : schedule.pausedReason,
+  });
+  return { schedule: nextSchedule, occurrence: nextOccurrence };
+}
+
 export function markScheduledExecutionRunning(controllerHome: string, job: ExecutionJob): void {
   if (job.type !== 'scheduled-occurrence') return;
   const occurrenceId = typeof job.payload.occurrenceId === 'string' ? job.payload.occurrenceId : undefined;

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

@@ -1,9 +1,14 @@
 import { createHash, randomUUID } from 'crypto';
-import { existsSync, readdirSync } from 'fs';
+import { existsSync, readdirSync, rmSync } from 'fs';
 import { join } from 'path';
 import { repositoryControllerRoot } from '../../../cli/repositories/controller-home';
 import { withControllerLock } from '../../../cli/repositories/locks';
-import { createHandoffItem, getHandoffItem } from '../../control-plane/facade/handoff-inbox-store';
+import {
+  createHandoffItem,
+  getHandoffItem,
+  listHandoffItems,
+  resolveHandoffItem,
+} from '../../control-plane/facade/handoff-inbox-store';
 import { readJsonFile, writeJsonAtomic } from '../../shared/json-files';
 import { appendRuntimeEvent } from '../../evidence/event-ledger';
 import type { RepositorySchedule, ScheduleDecision, ScheduleOccurrence } from './types';
@@ -159,17 +164,120 @@ export function listSchedules(controllerHome: string, repoId: string): Repositor
   } catch { return []; }
 }
 
+export function deleteSchedule(controllerHome: string, repoId: string, scheduleId: string): RepositorySchedule {
+  return withControllerLock(controllerHome, { scope: 'task', repoId, taskId: `schedule-${scheduleId}` }, `delete-schedule:${scheduleId}`, () => {
+    const current = getSchedule(controllerHome, repoId, scheduleId);
+    if (current.enabled) throw new Error(`SCHEDULE_DELETE_REQUIRES_PAUSED: ${scheduleId}`);
+    if (listActiveOccurrences(controllerHome, repoId, scheduleId).length > 0) {
+      throw new Error(`SCHEDULE_DELETE_ACTIVE_OCCURRENCE: ${scheduleId}`);
+    }
+    rmSync(schedulePath(controllerHome, repoId, scheduleId), { force: true });
+    const requestRecordPath = requestPath(controllerHome, repoId, current.requestId);
+    if (existsSync(requestRecordPath)) {
+      const record = readJsonFile<ScheduleRequestRecord>(requestRecordPath);
+      if (record.scheduleId === scheduleId) rmSync(requestRecordPath, { force: true });
+    }
+    appendRuntimeEvent(controllerHome, {
+      repoId,
+      entityType: 'schedule',
+      entityId: scheduleId,
+      eventType: 'schedule_deleted',
+      requestId: current.requestId,
+      revision: current.revision + 1,
+      data: { name: current.name },
+    });
+    return current;
+  }, 10_000);
+}
+
+function scheduleFailureClass(reason: string): string {
+  const trimmed = reason.trim();
+  const explicitCode = trimmed.match(/^([A-Z][A-Z0-9_]{2,})(?::|\b)/)?.[1];
+  if (explicitCode) return explicitCode;
+  const prefix = (trimmed.split(':', 1)[0] ?? trimmed)
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase()
+    .slice(0, 120);
+  return prefix || 'unknown_failure';
+}
+
+function activeScheduleFailureHandoff(
+  controllerHome: string,
+  repoId: string,
+  scheduleId: string,
+  creationReason: ScheduleOccurrenceHandoffInput['creationReason'],
+  reason: string,
+) {
+  const failureClass = scheduleFailureClass(reason);
+  return listHandoffItems({ controllerHome, repoId, status: 'active', limit: 100 }).find((item) => (
+    item.currentState?.taskId === scheduleId
+    && item.creationReason === creationReason
+    && scheduleFailureClass(item.reason) === failureClass
+  ));
+}
+
+function stableScheduleFailureHandoffId(
+  controllerHome: string,
+  repoId: string,
+  scheduleId: string,
+  creationReason: ScheduleOccurrenceHandoffInput['creationReason'],
+  reason: string,
+  occurrenceId: string,
+): string {
+  const digest = createHash('sha256')
+    .update(`${scheduleId}:${creationReason}:${scheduleFailureClass(reason)}`)
+    .digest('hex')
+    .slice(0, 20);
+  const baseId = `schedule-failure-${digest}`;
+  if (!getHandoffItem({ controllerHome, repoId }, baseId)) return baseId;
+  // A previous failure streak may already have resolved the stable item. Handoff
+  // records are immutable apart from lifecycle status, so use one new epoch id;
+  // subsequent failures in this streak will discover and reuse the active item.
+  const epoch = createHash('sha256').update(occurrenceId).digest('hex').slice(0, 8);
+  return `${baseId}-${epoch}`;
+}
+
+function resolveRecoveredScheduleFailureHandoffs(controllerHome: string, occurrence: ScheduleOccurrence): void {
+  try {
+    const active = listHandoffItems({ controllerHome, repoId: occurrence.repoId, status: 'active', limit: 100 })
+      .filter((item) => (
+        item.currentState?.taskId === occurrence.scheduleId
+        && item.creationReason === 'repeated_infrastructure_failure'
+      ));
+    for (const item of active) {
+      try {
+        resolveHandoffItem(
+          { controllerHome, repoId: occurrence.repoId },
+          item.id,
+          {
+            decision: `Schedule ${occurrence.scheduleId} recovered on occurrence ${occurrence.occurrenceId}.`,
+            resolver: 'schedule-runtime',
+          },
+        );
+      } catch {
+        // The succeeded occurrence remains authoritative. Inbox cleanup is
+        // best-effort and must never turn schedule recovery into a failure.
+      }
+    }
+  } catch {
+    // Preserve successful Schedule settlement even if Inbox storage is unavailable.
+  }
+}
+
 export function saveOccurrence(controllerHome: string, occurrence: ScheduleOccurrence): ScheduleOccurrence {
-  return withControllerLock(controllerHome, { scope: 'task', repoId: occurrence.repoId, taskId: `schedule-${occurrence.scheduleId}` }, `save-occurrence:${occurrence.occurrenceId}`, () => {
+  const next = withControllerLock(controllerHome, { scope: 'task', repoId: occurrence.repoId, taskId: `schedule-${occurrence.scheduleId}` }, `save-occurrence:${occurrence.occurrenceId}`, () => {
     const existingPath = occurrencePath(controllerHome, occurrence.repoId, occurrence.occurrenceId);
     const previous = existsSync(existingPath) ? readJsonFile<ScheduleOccurrence>(existingPath) : undefined;
-    const next = { ...occurrence, revision: (previous?.revision ?? occurrence.revision ?? 0) + 1, updatedAt: new Date().toISOString() };
-    writeJsonAtomic(existingPath, next);
-    upsertOccurrenceIndexUnlocked(controllerHome, next);
-    const schedule = getSchedule(controllerHome, next.repoId, next.scheduleId);
-    appendRuntimeEvent(controllerHome, { repoId: next.repoId, entityType: 'occurrence', entityId: next.occurrenceId, eventType: `occurrence_${next.status}`, requestId: `${schedule.requestId}:${next.windowKey}`, revision: next.revision, correlationId: next.scheduleId, data: { decision: next.decision, jobId: next.jobId, reason: next.reason } });
-    return next;
+    const saved = { ...occurrence, revision: (previous?.revision ?? occurrence.revision ?? 0) + 1, updatedAt: new Date().toISOString() };
+    writeJsonAtomic(existingPath, saved);
+    upsertOccurrenceIndexUnlocked(controllerHome, saved);
+    const schedule = getSchedule(controllerHome, saved.repoId, saved.scheduleId);
+    appendRuntimeEvent(controllerHome, { repoId: saved.repoId, entityType: 'occurrence', entityId: saved.occurrenceId, eventType: `occurrence_${saved.status}`, requestId: `${schedule.requestId}:${saved.windowKey}`, revision: saved.revision, correlationId: saved.scheduleId, data: { decision: saved.decision, jobId: saved.jobId, reason: saved.reason } });
+    return saved;
   }, 10_000);
+  if (next.status === 'succeeded') resolveRecoveredScheduleFailureHandoffs(controllerHome, next);
+  return next;
 }
 
 export function getOccurrence(controllerHome: string, repoId: string, occurrenceId: string): ScheduleOccurrence | undefined {
@@ -184,7 +292,20 @@ export function recordScheduleOccurrenceHandoff(
   input: ScheduleOccurrenceHandoffInput,
 ): ScheduleOccurrence {
   if (occurrence.handoffId) return occurrence;
-  const handoffId = `schedule-${occurrence.occurrenceId}`;
+  const reusable = input.creationReason === 'repeated_infrastructure_failure'
+    ? activeScheduleFailureHandoff(controllerHome, occurrence.repoId, schedule.scheduleId, input.creationReason, input.reason)
+    : undefined;
+  if (reusable) return saveOccurrence(controllerHome, { ...occurrence, handoffId: reusable.id });
+  const handoffId = input.creationReason === 'repeated_infrastructure_failure'
+    ? stableScheduleFailureHandoffId(
+      controllerHome,
+      occurrence.repoId,
+      schedule.scheduleId,
+      input.creationReason,
+      input.reason,
+      occurrence.occurrenceId,
+    )
+    : `schedule-${occurrence.occurrenceId}`;
   const evidenceRefs: NonNullable<ScheduleOccurrenceHandoffInput['evidenceRefs']> = [
     { title: `Occurrence ${occurrence.occurrenceId}`, summary: occurrence.reason ?? input.reason, detailLevel: 'summary' as const },
   ];

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

@@ -10,10 +10,8 @@ export type ScheduleTriggerType =
   | 'manual';
 
 export interface ScheduleCondition {
-  kind: 'repository_clean' | 'job_succeeded' | 'job_terminal' | 'candidate_observation_threshold';
+  kind: 'repository_clean' | 'job_succeeded' | 'job_terminal';
   jobId?: string;
-  semanticKey?: string;
-  observationThreshold?: number;
 }
 
 export interface ScheduleTrigger {
@@ -73,6 +71,11 @@ export interface RepositorySchedule {
   consecutiveNoops?: number;
   nextEligibleAt?: string;
   pausedReason?: string;
+  /** Last deterministic external observation for browser or issue watchers. */
+  lastObservationAt?: string;
+  lastObservationFingerprint?: string;
+  lastObservationChangedAt?: string;
+  lastObservationStatus?: 'baseline' | 'unchanged' | 'changed' | 'keepalive' | 'auth_required';
 }
 
 export type ScheduleDecisionType =

package/src/runtime/workflow/schedules/work-continuation.ts

@@ -19,9 +19,11 @@ import type {
 } from './types';
 
 export type ContinuationControllerType = 'chatgpt' | 'codex' | 'claude' | 'grok';
+export type WorkScheduleMode = 'continuation' | 'browser_watch' | 'browser_keepalive';
 
 export interface WorkContinuationScheduleInput {
-  workId: string;
+  workId?: string;
+  scheduleMode?: WorkScheduleMode;
   controllerType?: ContinuationControllerType;
   executable?: string;
   launchArgs?: string[];
@@ -30,6 +32,18 @@ export interface WorkContinuationScheduleInput {
   browserSessionId?: string;
   conversationUrl?: string;
   continuationPrompt?: string;
+  probeUrl?: string;
+  probeBrowserSessionId?: string;
+  probeSelector?: string;
+  probeMaxChars?: number;
+  probeTimeoutMs?: number;
+  includeTerms?: string[];
+  ignorePatterns?: string[];
+  loginUrlTerms?: string[];
+  loginTextTerms?: string[];
+  wakeOnFirstObservation?: boolean;
+  wakeOnAuthRequired?: boolean;
+  authRequiredPrompt?: string;
   scheduleName?: string;
   requestId?: string;
   triggerType?: ScheduleTriggerType;
@@ -70,7 +84,7 @@ function activeWork(controllerHome: string, repoId: string, workId: string): Wor
 }
 
 function continuationSchedule(schedule: RepositorySchedule): RepositorySchedule {
-  if (schedule.action.operation !== 'external_controller_wake') {
+  if (!['external_controller_wake', 'browser_probe'].includes(schedule.action.operation)) {
     throw new Error(`SCHEDULE_NOT_WORK_CONTINUATION: ${schedule.scheduleId}`);
   }
   return schedule;
@@ -92,8 +106,9 @@ function normalizedTrigger(input: WorkContinuationScheduleInput): ScheduleTrigge
 }
 
 function wakeArguments(input: WorkContinuationScheduleInput, controllerType: ContinuationControllerType): Record<string, unknown> {
+  const workId = input.workId?.trim();
   return {
-    work_id: input.workId.trim(),
+    ...(workId ? { work_id: workId } : {}),
     controller_type: controllerType,
     ...(input.executable?.trim() ? { executable: input.executable.trim() } : {}),
     ...(input.launchArgs ? { launch_args: input.launchArgs.map(String) } : {}),
@@ -105,55 +120,120 @@ function wakeArguments(input: WorkContinuationScheduleInput, controllerType: Con
   };
 }
 
+function probeArguments(input: WorkContinuationScheduleInput, controllerType: ContinuationControllerType, keepaliveOnly: boolean): Record<string, unknown> {
+  if (!input.probeUrl?.trim() && !input.probeBrowserSessionId?.trim()) {
+    throw new Error('SCHEDULE_BROWSER_PROBE_TARGET_REQUIRED');
+  }
+  return {
+    ...wakeArguments(input, controllerType),
+    ...(input.probeUrl?.trim() ? { probe_url: input.probeUrl.trim() } : {}),
+    ...(input.probeBrowserSessionId?.trim() ? { probe_session_id: input.probeBrowserSessionId.trim() } : {}),
+    ...(input.probeSelector?.trim() ? { selector: input.probeSelector.trim() } : {}),
+    ...(input.probeMaxChars !== undefined ? { max_chars: Math.max(256, Math.min(Math.trunc(input.probeMaxChars), 100_000)) } : {}),
+    ...(input.probeTimeoutMs !== undefined ? { timeout_ms: Math.max(1_000, Math.min(Math.trunc(input.probeTimeoutMs), 120_000)) } : {}),
+    ...(input.includeTerms ? { include_terms: input.includeTerms.map(String).filter(Boolean) } : {}),
+    ...(input.ignorePatterns ? { ignore_patterns: input.ignorePatterns.map(String).filter(Boolean) } : {}),
+    ...(input.loginUrlTerms ? { login_url_terms: input.loginUrlTerms.map(String).filter(Boolean) } : {}),
+    ...(input.loginTextTerms ? { login_text_terms: input.loginTextTerms.map(String).filter(Boolean) } : {}),
+    ...(input.wakeOnFirstObservation === true ? { wake_on_first_observation: true } : {}),
+    ...(input.wakeOnAuthRequired === false ? { wake_on_auth_required: false } : {}),
+    ...(input.authRequiredPrompt?.trim() ? { auth_required_prompt: input.authRequiredPrompt.trim() } : {}),
+    keepalive_only: keepaliveOnly,
+    wake_on_change: !keepaliveOnly,
+  };
+}
+
 export function createWorkContinuationSchedule(
   controllerHome: string,
   repoId: string,
   input: WorkContinuationScheduleInput,
-): { schedule: RepositorySchedule; work: WorkContract } {
-  const work = activeWork(controllerHome, repoId, input.workId);
+): { schedule: RepositorySchedule; work?: WorkContract } {
   const controllerType = input.controllerType ?? 'chatgpt';
+  const scheduleMode = input.scheduleMode ?? 'continuation';
+  const requestedWorkId = input.workId?.trim();
+  if (!requestedWorkId && scheduleMode !== 'browser_keepalive') throw new Error('WORK_ID_REQUIRED');
+  if (!requestedWorkId && scheduleMode === 'browser_keepalive' && controllerType !== 'chatgpt') throw new Error('STANDALONE_BROWSER_KEEPALIVE_CHATGPT_REQUIRED');
+  const work = requestedWorkId ? activeWork(controllerHome, repoId, requestedWorkId) : undefined;
   const trigger = normalizedTrigger(input);
-  const actionArguments = wakeArguments(input, controllerType);
-  assertAutomatedOperationAllowed('external_controller_wake', actionArguments);
-  const name = input.scheduleName?.trim() || `Continue Work ${work.workId}`;
+  const operation = scheduleMode === 'continuation' ? 'external_controller_wake' : 'browser_probe';
+  const actionArguments = scheduleMode === 'continuation'
+    ? wakeArguments(input, controllerType)
+    : probeArguments(input, controllerType, scheduleMode === 'browser_keepalive');
+  assertAutomatedOperationAllowed(operation, actionArguments);
+  const name = input.scheduleName?.trim()
+    || (scheduleMode === 'browser_watch' ? `Watch external state for Work ${work!.workId}`
+      : scheduleMode === 'browser_keepalive'
+        ? (work ? `Keep browser session alive for Work ${work.workId}` : 'Keep browser session alive')
+        : `Continue Work ${work!.workId}`);
+  const policy = {
+    maxActiveOccurrences: 1,
+    maxFailures: input.maxFailures !== undefined ? Math.max(1, Math.trunc(input.maxFailures)) : 3,
+    cooldownMinutes: input.cooldownMinutes !== undefined ? Math.max(0, Math.trunc(input.cooldownMinutes)) : 120,
+    dailyBudgetMinutes: input.dailyBudgetMinutes !== undefined ? Math.max(1, Math.trunc(input.dailyBudgetMinutes)) : 180,
+    shadowMode: input.shadowMode !== false,
+    backoffBaseMinutes: input.backoffBaseMinutes !== undefined ? Math.max(1, Math.trunc(input.backoffBaseMinutes)) : 5,
+    backoffMaxMinutes: input.backoffMaxMinutes !== undefined ? Math.max(1, Math.trunc(input.backoffMaxMinutes)) : 24 * 60,
+  };
+  const stopConditions = input.stopConditions ?? (work ? ['work_terminal', 'human_review_required', 'external_blocker'] : []);
+
+  // A durable Work has one authoritative continuation lane. Changing cadence,
+  // prompt, controller, or policy updates that lane instead of minting another
+  // Workflow. Browser watches/keepalives are intentionally excluded because one
+  // Work may legitimately observe several independent external targets.
+  if (scheduleMode === 'continuation') {
+    const existing = listSchedules(controllerHome, repoId)
+      .filter((candidate) => candidate.action.operation === 'external_controller_wake')
+      .filter((candidate) => candidate.action.arguments?.work_id === work!.workId);
+    const authoritative = [...existing].reverse().find((candidate) => candidate.enabled) ?? existing.at(-1);
+    if (authoritative) {
+      const schedule = saveSchedule(controllerHome, {
+        ...authoritative,
+        name,
+        enabled: true,
+        trigger,
+        policy,
+        action: { operation, target: 'runtime', arguments: actionArguments, resourceClaims: [] },
+        stopConditions,
+        pausedReason: undefined,
+      });
+      for (const duplicate of existing) {
+        if (duplicate.scheduleId === schedule.scheduleId || !duplicate.enabled) continue;
+        saveSchedule(controllerHome, {
+          ...duplicate,
+          enabled: false,
+          pausedReason: `Superseded by authoritative continuation ${schedule.scheduleId} for Work ${work!.workId}.`,
+        });
+      }
+      return { schedule, work };
+    }
+  }
+
   const semantic = JSON.stringify({
     repoId,
-    workId: work.workId,
+    workId: work?.workId,
     controllerType,
+    scheduleMode,
     trigger,
     name,
     actionArguments,
-    policy: {
-      maxFailures: input.maxFailures,
-      cooldownMinutes: input.cooldownMinutes,
-      dailyBudgetMinutes: input.dailyBudgetMinutes,
-      shadowMode: input.shadowMode,
-      backoffBaseMinutes: input.backoffBaseMinutes,
-      backoffMaxMinutes: input.backoffMaxMinutes,
-    },
-    stopConditions: input.stopConditions,
+    policy,
+    stopConditions,
   });
   const requestId = input.requestId?.trim()
-    || `work-continuation:${repoId}:${work.workId}:${createHash('sha256').update(semantic).digest('hex').slice(0, 16)}`;
+    || (work
+      ? `work-continuation:${repoId}:${work.workId}:${createHash('sha256').update(semantic).digest('hex').slice(0, 16)}`
+      : `browser-keepalive:${repoId}:${createHash('sha256').update(semantic).digest('hex').slice(0, 16)}`);
   const schedule = createSchedule(controllerHome, {
     requestId,
     repoId,
     name,
     enabled: true,
     trigger,
-    policy: {
-      maxActiveOccurrences: 1,
-      maxFailures: input.maxFailures !== undefined ? Math.max(1, Math.trunc(input.maxFailures)) : 3,
-      cooldownMinutes: input.cooldownMinutes !== undefined ? Math.max(0, Math.trunc(input.cooldownMinutes)) : 120,
-      dailyBudgetMinutes: input.dailyBudgetMinutes !== undefined ? Math.max(1, Math.trunc(input.dailyBudgetMinutes)) : 180,
-      shadowMode: input.shadowMode !== false,
-      backoffBaseMinutes: input.backoffBaseMinutes !== undefined ? Math.max(1, Math.trunc(input.backoffBaseMinutes)) : 5,
-      backoffMaxMinutes: input.backoffMaxMinutes !== undefined ? Math.max(1, Math.trunc(input.backoffMaxMinutes)) : 24 * 60,
-    },
-    // The schedule only wakes a Controller. The Controller acquires Work/resource
-    // ownership separately, so the wake itself must not claim repository writes.
-    action: { operation: 'external_controller_wake', target: 'runtime', arguments: actionArguments, resourceClaims: [] },
-    stopConditions: input.stopConditions ?? ['work_terminal', 'human_review_required', 'external_blocker'],
+    policy,
+    // Work-bound schedules only perform a deterministic wake or a bounded read-only
+    // browser probe. Controller/Work write ownership is acquired separately.
+    action: { operation, target: 'runtime', arguments: actionArguments, resourceClaims: [] },
+    stopConditions,
   });
   return { schedule, work };
 }
@@ -164,7 +244,7 @@ export function listWorkContinuationSchedules(
   options: WorkContinuationScheduleListOptions = {},
 ): { schedules: RepositorySchedule[]; occurrences?: ScheduleOccurrence[] } {
   const schedules = listSchedules(controllerHome, repoId)
-    .filter((entry) => entry.action.operation === 'external_controller_wake')
+    .filter((entry) => ['external_controller_wake', 'browser_probe'].includes(entry.action.operation))
     .filter((entry) => !options.workId || entry.action.arguments?.work_id === options.workId);
   if (!options.includeOccurrences) return { schedules };
   const scheduleIds = new Set(schedules.map((entry) => entry.scheduleId));
@@ -204,7 +284,13 @@ export function resumeWorkContinuationSchedule(controllerHome: string, repoId: s
   const schedule = continuationSchedule(getSchedule(controllerHome, repoId, scheduleId));
   const workId = typeof schedule.action.arguments?.work_id === 'string' ? schedule.action.arguments.work_id : '';
   activeWork(controllerHome, repoId, workId);
-  return saveSchedule(controllerHome, { ...schedule, enabled: true, pausedReason: undefined });
+  return saveSchedule(controllerHome, {
+    ...schedule,
+    enabled: true,
+    pausedReason: undefined,
+    consecutiveFailures: 0,
+    nextEligibleAt: undefined,
+  });
 }
 
 export async function triggerWorkContinuationSchedule(