@moretea-labs/forge 1.6.0 → 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,7 +71,7 @@ export interface RepositorySchedule {
   consecutiveNoops?: number;
   nextEligibleAt?: string;
   pausedReason?: string;
-  /** Last deterministic external observation for browser_watch/browser_keepalive. */
+  /** Last deterministic external observation for browser or issue watchers. */
   lastObservationAt?: string;
   lastObservationFingerprint?: string;
   lastObservationChangedAt?: string;

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

@@ -22,7 +22,7 @@ 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;
@@ -106,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) } : {}),
@@ -146,10 +147,13 @@ 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 operation = scheduleMode === 'continuation' ? 'external_controller_wake' : 'browser_probe';
   const actionArguments = scheduleMode === 'continuation'
@@ -157,9 +161,10 @@ export function createWorkContinuationSchedule(
     : 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' ? `Keep browser session alive for Work ${work.workId}`
-        : `Continue Work ${work.workId}`);
+    || (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,
@@ -169,7 +174,7 @@ export function createWorkContinuationSchedule(
     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_terminal', 'human_review_required', 'external_blocker'];
+  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
@@ -178,7 +183,7 @@ export function createWorkContinuationSchedule(
   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);
+      .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, {
@@ -196,7 +201,7 @@ export function createWorkContinuationSchedule(
         saveSchedule(controllerHome, {
           ...duplicate,
           enabled: false,
-          pausedReason: `Superseded by authoritative continuation ${schedule.scheduleId} for Work ${work.workId}.`,
+          pausedReason: `Superseded by authoritative continuation ${schedule.scheduleId} for Work ${work!.workId}.`,
         });
       }
       return { schedule, work };
@@ -205,7 +210,7 @@ export function createWorkContinuationSchedule(
 
   const semantic = JSON.stringify({
     repoId,
-    workId: work.workId,
+    workId: work?.workId,
     controllerType,
     scheduleMode,
     trigger,
@@ -215,7 +220,9 @@ export function createWorkContinuationSchedule(
     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,
@@ -277,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(

package/src/testing/test-governance.ts

@@ -26,30 +26,24 @@ export type TestModule = (typeof TEST_MODULES)[number];
 export type TestResource = (typeof TEST_RESOURCES)[number];
 export type TestGate = 'affected' | 'core' | 'integration' | 'infrastructure' | 'fault' | 'full';
 
+/**
+ * Acceptance evidence is the default. Tests must protect externally observable
+ * contracts, migrations/rollback, failure injection, security boundaries, or
+ * a recorded production incident. Do not add tests for private helpers,
+ * implementation payloads, copy, enum order, or mock-only lifecycles.
+ */
+export const TEST_GOVERNANCE_POLICY = 'acceptance-first-no-internal-unit-tests' as const;
+
 export interface TestManifestEntry {
   module: TestModule;
   resource: TestResource;
   smoke?: boolean;
 }
 
-export interface TestBudgetPolicy {
-  maxTestFiles: number;
-  maxTestLines: number;
-  maxPureFiles: number;
-  maxTempIsolatedFiles: number;
-  maxProcessTreeFiles: number;
-  maxGitWorktreeFiles: number;
-  maxFixedPortFiles: number;
-  maxRuntimeSingletonFiles: number;
-  maxControllerHomeIsolatedFiles: number;
-  maxDestructiveFiles: number;
-}
-
 export interface TestManifest {
   version: 1;
   modules: TestModule[];
   resources: TestResource[];
-  policy: TestBudgetPolicy;
   pathModuleRules: Array<{ prefix: string; modules: TestModule[] }>;
   tests: Record<string, TestManifestEntry>;
 }
@@ -232,32 +226,6 @@ export function validateTestManifest(repoRoot: string, manifest = loadTestManife
     if (!TEST_RESOURCES.includes(entry.resource)) errors.push(`${file}: invalid resource ${String(entry.resource)}`);
   }
   if (!Object.values(manifest.tests).some((entry) => entry.smoke)) errors.push('manifest has no core smoke tests');
-  const resourceCounts = Object.values(manifest.tests).reduce<Record<string, number>>((counts, entry) => {
-    counts[entry.resource] = (counts[entry.resource] ?? 0) + 1;
-    return counts;
-  }, {});
-  const testLines = declaredFiles.reduce((total, file) => {
-    try {
-      return total + readFileSync(resolve(repoRoot, file), 'utf8').split('\n').length;
-    } catch (_error) {
-      return total;
-    }
-  }, 0);
-  const budgetChecks: Array<[string, number, number | undefined]> = [
-    ['maxTestFiles', declaredFiles.length, manifest.policy?.maxTestFiles],
-    ['maxTestLines', testLines, manifest.policy?.maxTestLines],
-    ['maxPureFiles', resourceCounts.pure ?? 0, manifest.policy?.maxPureFiles],
-    ['maxTempIsolatedFiles', resourceCounts['temp-isolated'] ?? 0, manifest.policy?.maxTempIsolatedFiles],
-    ['maxProcessTreeFiles', resourceCounts['process-tree'] ?? 0, manifest.policy?.maxProcessTreeFiles],
-    ['maxGitWorktreeFiles', resourceCounts['git-worktree'] ?? 0, manifest.policy?.maxGitWorktreeFiles],
-    ['maxFixedPortFiles', resourceCounts['fixed-port'] ?? 0, manifest.policy?.maxFixedPortFiles],
-    ['maxRuntimeSingletonFiles', resourceCounts['runtime-singleton'] ?? 0, manifest.policy?.maxRuntimeSingletonFiles],
-    ['maxControllerHomeIsolatedFiles', resourceCounts['controller-home-isolated'] ?? 0, manifest.policy?.maxControllerHomeIsolatedFiles],
-    ['maxDestructiveFiles', resourceCounts.destructive ?? 0, manifest.policy?.maxDestructiveFiles],
-  ];
-  for (const [name, actual, limit] of budgetChecks) {
-    if (typeof limit !== 'number' || actual > limit) errors.push(`test budget ${name} exceeded: ${actual} > ${String(limit)}`);
-  }
   return errors;
 }
 

package/assets/reference-configs/heartbeat-triage.md

@@ -1,57 +0,0 @@
-# Heartbeat Triage
-
-Heartbeat triage is the repo-local scheduled discovery loop. It records findings
-for a human to review; it does not approve plans, execute fixes, spawn agents,
-open PRs, or install a persistent scheduler.
-
-## Command
-
-Run from the repository root:
-
-```bash
-bash .ai/harness/scripts/heartbeat-triage.sh run --source scheduled
-```
-
-The command appends a run section to `.ai/harness/triage/inbox.md` and writes a
-JSON snapshot under `.ai/harness/runs/`. Each run records:
-
-- `workflow-check`: `bash .ai/harness/scripts/check-task-workflow.sh --strict`
-- `sprint-next`: `bash .ai/harness/scripts/sprint-backlog.sh next` when an active sprint
-  marker exists, with a read-only sprint-file fallback when it does not
-- `drift-requests`: pending files under `docs/architecture/requests/`
-
-## cron
-
-Example cron entry for a local checkout:
-
-```cron
-17 8 * * * cd /path/to/repo && bash .ai/harness/scripts/heartbeat-triage.sh run --source scheduled >/tmp/forge-heartbeat.log 2>&1
-```
-
-## loop
-
-Example long-running loop for a supervised terminal, launch wrapper, or local
-process manager:
-
-```bash
-while true; do
-  cd /path/to/repo && bash .ai/harness/scripts/heartbeat-triage.sh run --source scheduled
-  sleep 86400
-done
-```
-
-## Adoption Review
-
-Every run includes an "Adoption review due" date fourteen days out. The review
-question is narrow: did the inbox produce any human-accepted triage item? If no
-item is accepted during the review window, remove the scheduler and keep the
-runner as an on-demand diagnostic command.
-
-## Guardrails
-
-- Keep scheduler installation manual and host-local.
-- Treat workflow failures and drift requests as inbox entries, not process
-  crashes.
-- Keep `.ai/harness/triage/inbox.md` as runtime state, not a source-of-truth
-  plan or task ledger.
-- Keep execution authority in the normal plan -> contract -> verify flow.