@moretea-labs/forge 1.8.0 → 1.8.2

package/src/runtime/control-plane/generated-cache-retention.ts

@@ -25,6 +25,8 @@ export interface GeneratedCacheRetentionOptions {
   maxEntries?: number;
   maxRemovals?: number;
   processCommands?: string[];
+  rootStartIndex?: number;
+  scanStartIndex?: number;
 }
 
 export interface GeneratedCacheRetentionReport {
@@ -37,6 +39,19 @@ export interface GeneratedCacheRetentionReport {
   budgetExhausted: boolean;
 }
 
+export interface GeneratedCacheRepositoryRootSet {
+  canonicalRoot: string;
+  checkouts: ReadonlyArray<{
+    localRoot: string;
+    worktree: boolean;
+    lifecycle?: 'active' | 'removed' | 'archived';
+  }>;
+}
+
+export interface RepositoryGeneratedCacheRetentionReport extends GeneratedCacheRetentionReport {
+  rootsInspected: number;
+}
+
 export type BrowserDisposableArtifactKind = 'screenshots' | 'downloads' | 'diagnostics';
 
 export interface BrowserArtifactRetentionOptions {
@@ -81,6 +96,7 @@ export interface XCTestDeviceCleanupReport {
 
 interface Candidate {
   path: string;
+  cacheRoot?: string;
   kind:
     | 'forge_ios_derived_data'
     | 'harness_derived_data'
@@ -105,7 +121,7 @@ function pathInside(root: string, path: string): boolean {
   return rel !== '' && rel !== '..' && !rel.startsWith(`..${sep}`);
 }
 
-function collectProcessCommands(): string[] {
+function collectProcessCommands(): string[] | undefined {
   try {
     return execFileSync('ps', ['-axo', 'command='], {
       encoding: 'utf8',
@@ -113,7 +129,8 @@ function collectProcessCommands(): string[] {
       maxBuffer: 2 * 1024 * 1024,
     }).split('\n').map((line) => line.trim()).filter(Boolean);
   } catch {
-    return [];
+    // Missing process evidence is not proof that a cache is idle.
+    return undefined;
   }
 }
 
@@ -128,6 +145,19 @@ function commandReferencesPath(commands: readonly string[], repoRoot: string, pa
     || (canonicalRelative && command.includes(canonicalRelative)));
 }
 
+function hasSymlinkAncestor(root: string, path: string): boolean {
+  const rel = relative(resolve(root), resolve(path));
+  if (!rel || rel === '..' || rel.startsWith(`..${sep}`)) return true;
+  let current = resolve(root);
+  try {
+    for (const part of rel.split(sep)) {
+      current = join(current, part);
+      if (lstatSync(current).isSymbolicLink()) return true;
+    }
+    return false;
+  } catch { return true; }
+}
+
 function containsTrackedFiles(repoRoot: string, path: string): boolean {
   const rel = relative(resolve(repoRoot), resolve(path));
   if (!rel || rel === '..' || rel.startsWith(`..${sep}`)) return true;
@@ -144,88 +174,106 @@ function containsTrackedFiles(repoRoot: string, path: string): boolean {
   }
 }
 
-function directChildDirectories(root: string, predicate: (name: string) => boolean, budget: { remaining: number }): string[] {
-  if (!existsSync(root) || budget.remaining <= 0) return [];
+const REBUILDABLE_XCODE_CHILDREN = [
+  'Build', 'ModuleCache.noindex', 'Index.noindex', 'CompilationCache.noindex',
+  'SDKExplicitPrecompiledModules', 'SDKStatCaches.noindex',
+] as const;
+
+function rotatedEntries(root: string, round: number) {
+  try {
+    const entries = readdirSync(root, { withFileTypes: true }).sort((a, b) => String(a.name).localeCompare(String(b.name)));
+    if (entries.length > 1) {
+      const offset = ((Math.trunc(round) % entries.length) + entries.length) % entries.length;
+      entries.push(...entries.splice(0, offset));
+    }
+    return entries;
+  } catch { return []; }
+}
+
+function directChildDirectories(root: string, predicate: (name: string) => boolean, budget: { remaining: number }, round = 0): string[] {
   const found: string[] = [];
-  let entries;
-  try { entries = readdirSync(root, { withFileTypes: true }); } catch { return found; }
-  for (const entry of entries) {
+  if (budget.remaining <= 0) return found;
+  for (const entry of rotatedEntries(root, round)) {
     if (budget.remaining <= 0) break;
     budget.remaining -= 1;
-    const name = String(entry.name);
-    if (entry.isDirectory() && predicate(name)) found.push(join(root, name));
+    if (entry.isDirectory() && predicate(String(entry.name))) found.push(join(root, String(entry.name)));
   }
   return found;
 }
 
 function directChildFiles(root: string, budget: { remaining: number }): string[] {
-  if (!existsSync(root) || budget.remaining <= 0) return [];
   const found: string[] = [];
-  let entries;
-  try { entries = readdirSync(root, { withFileTypes: true }); } catch { return found; }
-  for (const entry of entries) {
+  if (budget.remaining <= 0) return found;
+  for (const entry of rotatedEntries(root, 0)) {
     if (budget.remaining <= 0) break;
     budget.remaining -= 1;
-    if (entry.isFile()) found.push(join(root, entry.name));
+    if (entry.isFile()) found.push(join(root, String(entry.name)));
   }
   return found;
 }
 
-function nestedDerivedDataDirectories(root: string, maxDepth: number, budget: { remaining: number }): string[] {
-  if (!existsSync(root) || budget.remaining <= 0) return [];
+function isXcodeCacheRoot(root: string): boolean {
+  try {
+    const info = lstatSync(join(root, 'info.plist'));
+    return info.isFile() && !info.isSymbolicLink() && REBUILDABLE_XCODE_CHILDREN.some((name) => {
+      try { const stat = lstatSync(join(root, name)); return stat.isDirectory() && !stat.isSymbolicLink(); } catch { return false; }
+    });
+  } catch { return false; }
+}
+
+function nestedDerivedDataDirectories(root: string, maxDepth: number, budget: { remaining: number }, round: number): string[] {
   const found: string[] = [];
-  const visit = (dir: string, depth: number): void => {
+  const visit = (dir: string, depth: number, visitRound: number): void => {
     if (depth > maxDepth || budget.remaining <= 0) return;
-    let entries;
-    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    const entries = rotatedEntries(dir, visitRound);
+    // Divide at each level rather than correlating parent/child rotations.
+    const childRound = Math.floor(visitRound / Math.max(1, entries.length));
     for (const entry of entries) {
       if (budget.remaining <= 0) return;
       budget.remaining -= 1;
-      if (!entry.isDirectory()) continue;
-      const path = join(dir, String(entry.name));
-      if (String(entry.name) === 'DerivedData') {
-        found.push(path);
-        continue;
-      }
-      visit(path, depth + 1);
+      const name = String(entry.name);
+      if (!entry.isDirectory() || ['.git', 'node_modules', 'SourcePackages', 'Logs', ...REBUILDABLE_XCODE_CHILDREN].includes(name) || name.endsWith('.xcresult')) continue;
+      const path = join(dir, name);
+      if (isXcodeCacheRoot(path)) found.push(path);
+      else visit(path, depth + 1, childRound);
     }
   };
-  visit(root, 0);
+  visit(root, 0, round);
   return found;
 }
 
-function discoverCandidates(repoRoot: string, maxEntries: number): { candidates: Candidate[]; inspected: number; truncated: boolean } {
+function discoverCandidates(repoRoot: string, maxEntries: number, scanRound: number): { candidates: Candidate[]; inspected: number; truncated: boolean } {
   const root = resolve(repoRoot);
   const budget = { remaining: Math.max(1, maxEntries) };
   const initial = budget.remaining;
   const candidates: Candidate[] = [];
-
-  // Browser artifacts are direct children of small, explicitly owned roots.
-  // Scan them before recursively walking potentially high-cardinality cache
-  // trees so cache history cannot starve their retention policy.
-  for (const path of directChildFiles(join(root, '.forge', 'browser', 'uploads'), budget)) {
-    candidates.push({ path, kind: 'forge_browser_upload' });
-  }
-  for (const path of directChildFiles(join(root, '.forge', 'browser', 'screenshots'), budget)) {
-    candidates.push({ path, kind: 'forge_browser_screenshot' });
-  }
-  for (const path of directChildDirectories(join(root, '.forge', 'ios', 'DerivedData'), () => true, budget)) {
-    candidates.push({ path, kind: 'forge_ios_derived_data' });
-  }
-  for (const path of directChildDirectories(join(root, '.ai', 'harness'), (name) => name.startsWith('deriveddata-'), budget)) {
-    candidates.push({ path, kind: 'harness_derived_data' });
-  }
-  for (const path of nestedDerivedDataDirectories(join(root, '.repo-harness'), 5, budget)) {
-    candidates.push({ path, kind: 'repo_harness_derived_data' });
-  }
-  for (const path of nestedDerivedDataDirectories(join(root, '.tmp'), 6, budget)) {
-    candidates.push({ path, kind: 'tmp_derived_data' });
+  // Preserve browser staging priority. Cache namespace and nested entry rotations
+  // use independent visit ordinals, so protected early entries cannot starve peers.
+  for (const path of directChildFiles(join(root, '.forge', 'browser', 'uploads'), budget)) candidates.push({ path, kind: 'forge_browser_upload' });
+  for (const path of directChildFiles(join(root, '.forge', 'browser', 'screenshots'), budget)) candidates.push({ path, kind: 'forge_browser_screenshot' });
+  const namespaces: Array<{ root: string; kind: Candidate['kind']; depth?: number }> = [
+    { root: join(root, '.forge', 'ios', 'DerivedData'), kind: 'forge_ios_derived_data' },
+    { root: join(root, '.ai', 'harness'), kind: 'harness_derived_data' },
+    { root: join(root, '.repo-harness'), kind: 'repo_harness_derived_data', depth: 5 },
+    { root: join(root, '.tmp'), kind: 'tmp_derived_data', depth: 6 },
+  ];
+  const offset = ((Math.trunc(scanRound) % namespaces.length) + namespaces.length) % namespaces.length;
+  namespaces.push(...namespaces.splice(0, offset));
+  const entryRound = Math.floor(scanRound / namespaces.length);
+  for (const namespace of namespaces) {
+    const cacheRoots = namespace.depth === undefined
+      ? directChildDirectories(namespace.root, () => true, budget, entryRound).filter(isXcodeCacheRoot)
+      : nestedDerivedDataDirectories(namespace.root, namespace.depth, budget, entryRound);
+    for (const cacheRoot of cacheRoots) {
+      // Never remove the bucket: Logs, results, SourcePackages and unknown files
+      // are evidence/dependencies, not disposable build cache.
+      for (const name of REBUILDABLE_XCODE_CHILDREN) {
+        const path = join(cacheRoot, name);
+        if (existsSync(path)) candidates.push({ path, kind: namespace.kind, cacheRoot });
+      }
+    }
   }
-  return {
-    candidates: candidates.filter((candidate, index, values) => values.findIndex((item) => resolve(item.path) === resolve(candidate.path)) === index),
-    inspected: initial - budget.remaining,
-    truncated: budget.remaining <= 0,
-  };
+  return { candidates, inspected: initial - budget.remaining, truncated: budget.remaining <= 0 };
 }
 
 function retentionGraceMs(candidate: Candidate, explicitGraceMs: number | undefined): number {
@@ -261,7 +309,7 @@ export function cleanupGeneratedRepositoryCaches(
   const maxEntries = Math.max(1, Math.floor(options.maxEntries ?? DEFAULT_SCAN_BUDGET));
   let remainingRemovals = Math.max(1, Math.floor(options.maxRemovals ?? DEFAULT_REMOVAL_BUDGET));
   const commands = options.processCommands ?? collectProcessCommands();
-  const discovered = discoverCandidates(repoRoot, maxEntries);
+  const discovered = discoverCandidates(repoRoot, maxEntries, options.scanStartIndex ?? 0);
   const report: GeneratedCacheRetentionReport = {
     inspected: discovered.inspected,
     eligible: 0,
@@ -272,26 +320,34 @@ export function cleanupGeneratedRepositoryCaches(
     budgetExhausted: discovered.truncated,
   };
 
+  if (commands === undefined) {
+    report.errors.push('process_inventory_unavailable: generated-cache reclamation skipped');
+    report.skippedByReason.process_inventory_unavailable = 1;
+    return report;
+  }
   for (const candidate of discovered.candidates) {
     const ownedRoot = candidateOwnedRoot(repoRoot, candidate);
     const fileCandidate = candidate.kind === 'forge_browser_upload' || candidate.kind === 'forge_browser_screenshot';
     try {
       const stat = lstatSync(candidate.path);
-      if ((fileCandidate ? !stat.isFile() : !stat.isDirectory()) || stat.isSymbolicLink() || !pathInside(ownedRoot, candidate.path)) {
+      if ((fileCandidate ? !stat.isFile() : !stat.isDirectory()) || stat.isSymbolicLink() || hasSymlinkAncestor(repoRoot, candidate.path) || !pathInside(ownedRoot, candidate.path)) {
         increment(report.skippedByReason, 'ownership_unproven');
         report.retainedPaths.push(relative(repoRoot, candidate.path));
         continue;
       }
-      if (nowMs - stat.mtimeMs < retentionGraceMs(candidate, options.graceMs)) {
+      const usedAt = candidate.cacheRoot ? Math.max(stat.mtimeMs, lstatSync(candidate.cacheRoot).mtimeMs) : stat.mtimeMs;
+      if (nowMs - usedAt < retentionGraceMs(candidate, options.graceMs)) {
         increment(report.skippedByReason, 'retention_grace');
         continue;
       }
-      if (commandReferencesPath(commands, repoRoot, candidate.path)) {
+      if (commandReferencesPath(commands, repoRoot, candidate.cacheRoot ?? candidate.path)
+        || (candidate.cacheRoot && commands.some((command) => /(?:^|[/\s])xcodebuild(?:\s|$)/.test(command)
+          && !/(?:^|\s)-derivedDataPath(?:\s|=)/.test(command)))) {
         increment(report.skippedByReason, 'active_process');
         report.retainedPaths.push(relative(repoRoot, candidate.path));
         continue;
       }
-      if (containsTrackedFiles(repoRoot, candidate.path)) {
+      if (containsTrackedFiles(repoRoot, candidate.cacheRoot ?? candidate.path)) {
         increment(report.skippedByReason, 'tracked_content');
         report.retainedPaths.push(relative(repoRoot, candidate.path));
         continue;
@@ -302,6 +358,12 @@ export function cleanupGeneratedRepositoryCaches(
         increment(report.skippedByReason, 'cleanup_budget_exhausted');
         continue;
       }
+      // Recheck last-use immediately before removal: discovery and Git probes
+      // may overlap a cache reuse that refreshed the bucket after our first stat.
+      if (candidate.cacheRoot && lstatSync(candidate.cacheRoot).mtimeMs !== usedAt && nowMs - lstatSync(candidate.cacheRoot).mtimeMs < retentionGraceMs(candidate, options.graceMs)) {
+        increment(report.skippedByReason, 'retention_grace');
+        continue;
+      }
       remainingRemovals -= 1;
       rmSync(candidate.path, { recursive: true, force: true });
       report.removedPaths.push(relative(repoRoot, candidate.path).replace(/\\/g, '/'));
@@ -313,6 +375,90 @@ export function cleanupGeneratedRepositoryCaches(
   return report;
 }
 
+/**
+ * Apply the same generated-cache policy to the canonical checkout and every
+ * active managed worktree, sharing one scan/removal budget across the whole
+ * repository. Work lifecycle is intentionally not cache authority: stale but
+ * recoverable Work may keep its source checkout while rebuildable caches age
+ * out independently. Active build/test processes are still protected by
+ * cleanupGeneratedRepositoryCaches().
+ */
+export function cleanupGeneratedRepositoryCheckoutCaches(
+  repository: GeneratedCacheRepositoryRootSet,
+  options: GeneratedCacheRetentionOptions = {},
+): RepositoryGeneratedCacheRetentionReport {
+  let remainingEntries = Math.max(1, Math.floor(options.maxEntries ?? DEFAULT_SCAN_BUDGET));
+  let remainingRemovals = Math.max(1, Math.floor(options.maxRemovals ?? DEFAULT_REMOVAL_BUDGET));
+  const processCommands = options.processCommands ?? collectProcessCommands();
+  const roots = [
+    repository.canonicalRoot,
+    ...repository.checkouts
+      .filter((checkout) => checkout.worktree && (checkout.lifecycle ?? 'active') === 'active')
+      .map((checkout) => checkout.localRoot),
+  ].filter((root, index, values) => values.findIndex((item) => canonical(item) === canonical(root)) === index);
+  if (roots.length > 1) {
+    const offset = ((Math.trunc(options.rootStartIndex ?? 0) % roots.length) + roots.length) % roots.length;
+    roots.push(...roots.splice(0, offset));
+  }
+  const rawRoots = roots.map((root) => resolve(root));
+  const canonicalRoots = roots.map((root) => canonical(root));
+  const processCommandsForRoot = (root: string): string[] | undefined => {
+    const rawRoot = resolve(root);
+    const canonicalRoot = canonical(root);
+    return processCommands?.filter((command) => {
+      const referencedRootIndexes = rawRoots
+        .map((candidate, index) => command.includes(candidate) || command.includes(canonicalRoots[index]!) ? index : -1)
+        .filter((index) => index >= 0);
+      if (referencedRootIndexes.length === 0) return true;
+      return referencedRootIndexes.some((index) => rawRoots[index] === rawRoot || canonicalRoots[index] === canonicalRoot);
+    });
+  };
+
+  const aggregate: RepositoryGeneratedCacheRetentionReport = {
+    rootsInspected: 0,
+    inspected: 0,
+    eligible: 0,
+    removedPaths: [],
+    retainedPaths: [],
+    skippedByReason: {},
+    errors: [],
+    budgetExhausted: false,
+  };
+
+  if (processCommands === undefined) {
+    aggregate.errors.push('process_inventory_unavailable: generated-cache reclamation skipped');
+    aggregate.skippedByReason.process_inventory_unavailable = 1;
+    return aggregate;
+  }
+  for (const root of roots) {
+    if (remainingEntries <= 0 || remainingRemovals <= 0) {
+      aggregate.budgetExhausted = true;
+      break;
+    }
+    const report = cleanupGeneratedRepositoryCaches(root, {
+      ...options,
+      processCommands: processCommandsForRoot(root),
+      scanStartIndex: options.scanStartIndex ?? Math.floor((options.rootStartIndex ?? 0) / Math.max(1, roots.length)),
+      maxEntries: remainingEntries,
+      maxRemovals: remainingRemovals,
+    });
+    aggregate.rootsInspected += 1;
+    aggregate.inspected += report.inspected;
+    aggregate.eligible += report.eligible;
+    aggregate.removedPaths.push(...report.removedPaths.map((path) => `${root}:${path}`));
+    aggregate.retainedPaths.push(...report.retainedPaths.map((path) => `${root}:${path}`));
+    for (const [reason, count] of Object.entries(report.skippedByReason)) {
+      aggregate.skippedByReason[reason] = (aggregate.skippedByReason[reason] ?? 0) + count;
+    }
+    aggregate.errors.push(...report.errors.map((error) => `${root}:${error}`));
+    remainingEntries = Math.max(0, remainingEntries - report.inspected);
+    remainingRemovals = Math.max(0, remainingRemovals - report.removedPaths.length);
+    aggregate.budgetExhausted ||= report.budgetExhausted;
+  }
+  if (remainingEntries <= 0 || remainingRemovals <= 0) aggregate.budgetExhausted = true;
+  return aggregate;
+}
+
 function emptyBrowserArtifactClassReport(): BrowserArtifactClassRetentionReport {
   return {
     inspected: 0,
@@ -469,6 +615,7 @@ export function cleanupIdleXCTestDevices(controllerHome: string): XCTestDeviceCl
   if (deviceDirectories <= 4) return { attempted: false, removedDevices: 0, skippedReason: 'below_cleanup_threshold' };
 
   const commands = collectProcessCommands();
+  if (commands === undefined) return { attempted: false, removedDevices: 0, skippedReason: 'process_inventory_unavailable' };
   if (commands.some((command) => /(?:^|\/)(?:xcodebuild|xctest|swiftc)(?:\s|$)/.test(command))) {
     return { attempted: false, removedDevices: 0, skippedReason: 'active_xcode_process' };
   }

package/src/runtime/control-plane/global-scheduler/autonomous-continuation.ts

@@ -0,0 +1,248 @@
+import { createHash } from 'crypto';
+import type { RepositoryRecord } from '../../../cli/repositories/types';
+import {
+  controllerRoundBlockerClass,
+  controllerSessionBlocksRecovery,
+  getControllerRoundRelay,
+  listCurrentControllerRoundRelays,
+  getControllerSession,
+  getRetainedControllerSession,
+} from '../../../../packages/kernel/controller/api/index';
+import {
+  currentTaskSemanticProjectionForWork,
+  getWorkContract,
+  readActiveWorkCandidates,
+  semanticWorkState,
+  workSemanticView,
+} from '../../../../packages/kernel/work/api/index';
+import { workHasActiveExecution } from '../../execution/work-activity';
+import { readRequirement } from '../persistence/requirement-store';
+import { assertAutomatedOperationAllowed } from '../governance/external-effects';
+import {
+  controllerHostForScheduledBinding,
+  ensureScheduledControllerBindingForWork,
+} from '../../root/scheduled-controller-composition';
+import { ensureWorkflowSupervisorEnrollmentForWork } from '../../root/workflow-supervisor-composition';
+import { reconcileControllerProgression } from '../../root/controller-progression-composition';
+import { prepareControllerRoundOccurrence, resumeControllerRoundOccurrence } from '../../../../packages/kernel/controller/api/index';
+import { ensureControllerDispositionContinuation } from '../../workflow/schedules/work-continuation';
+import { deriveForgeActionableFailureCode, maybeRegisterForgeActionableFailureRepair } from '../../diagnostics/incident-repair';
+
+const DEFAULT_MAX_CONTINUATIONS = 2;
+
+export interface SchedulerAutonomousContinuationResult {
+  scanned: number;
+  eligible: number;
+  dispatched: number;
+  supervisorEnrolled: number;
+  failed: number;
+  skippedByReason: Record<string, number>;
+}
+
+export interface SchedulerAutonomousContinuationDependencies {
+  hasActiveExecution?: typeof workHasActiveExecution;
+  authorizeWake?: typeof assertAutomatedOperationAllowed;
+  ensureSupervisorEnrollment?: typeof ensureWorkflowSupervisorEnrollmentForWork;
+  hostForBinding?: typeof controllerHostForScheduledBinding;
+  ensureBinding?: typeof ensureScheduledControllerBindingForWork;
+  prepareOccurrence?: typeof prepareControllerRoundOccurrence;
+  resumeOccurrence?: typeof resumeControllerRoundOccurrence;
+}
+
+function skip(counts: Record<string, number>, reason: string): void {
+  counts[reason] = (counts[reason] ?? 0) + 1;
+}
+
+function planlessOccurrenceId(workId: string, semanticRevision: number): string {
+  const digest = createHash('sha256').update(workId + '\0semantic:' + semanticRevision).digest('hex').slice(0, 32);
+  return 'work-liveness:v2:' + digest;
+}
+
+function livenessMayReconcileExistingRound(record: ReturnType<typeof getControllerRoundRelay>): boolean {
+  if (!record) return true;
+  if (record.status === 'pending_release' || record.status === 'claimed') return true;
+  if (record.status === 'waiting') return true;
+  if (record.status === 'dispatching') return !record.providerDispatchStartedAt;
+  if (record.status === 'dispatched') return true;
+  return record.status === 'blocked' && controllerRoundBlockerClass(record) === 'provider_dispatch_outcome_unknown';
+}
+
+/**
+ * Single Scheduler liveness scanner. Scheduler selects only which open Work
+ * needs another mechanical opportunity; reconcileControllerProgression owns the
+ * stateless composition of existing authorities.
+ */
+export async function runSchedulerAutonomousContinuationReconciliation(input: {
+  controllerHome: string;
+  nowMs: number;
+  repositories: readonly Pick<RepositoryRecord, 'repoId' | 'canonicalRoot' | 'localRoot'>[];
+  maxContinuations?: number;
+  dependencies?: SchedulerAutonomousContinuationDependencies;
+}): Promise<SchedulerAutonomousContinuationResult> {
+  const maxContinuations = Math.max(1, Math.min(Math.trunc(input.maxContinuations ?? DEFAULT_MAX_CONTINUATIONS), 8));
+  const hasActiveExecution = input.dependencies?.hasActiveExecution ?? workHasActiveExecution;
+  const authorizeWake = input.dependencies?.authorizeWake ?? assertAutomatedOperationAllowed;
+
+  let scanned = 0;
+  let eligible = 0;
+  let dispatched = 0;
+  let supervisorEnrolled = 0;
+  let failed = 0;
+  let materialized = 0;
+  const skippedByReason: Record<string, number> = {};
+
+  for (const repository of input.repositories) {
+    if (materialized >= maxContinuations) break;
+    const store = { controllerHome: input.controllerHome, repoId: repository.repoId };
+    let works: ReturnType<typeof readActiveWorkCandidates>['contracts'];
+    try {
+      const active = readActiveWorkCandidates({ ...store, limit: 100 });
+      const candidates = new Map(active.contracts.map((work) => [work.workId, work]));
+      for (const invalid of active.invalid) {
+        skip(skippedByReason, 'invalid_work_contract');
+        console.error('[forge liveness] skipped invalid Work authority ' + repository.repoId + '/' + invalid.workId + ': ' + invalid.error);
+      }
+      // Semantic Work authority is Forge-scoped; the repository list is only
+      // an execution projection. Existing relay references must use the same
+      // canonical lookup as launcher admission, never infer deletion from a list.
+      for (const relay of listCurrentControllerRoundRelays(store, 100)) {
+        try {
+          const work = getWorkContract(store, relay.originWorkId);
+          if (work) candidates.set(work.workId, work);
+        } catch (error) {
+          skip(skippedByReason, 'invalid_relay_work_contract');
+          console.error('[forge liveness] skipped invalid relay Work authority ' + repository.repoId + '/' + relay.originWorkId + ':', error);
+        }
+      }
+      works = [...candidates.values()];
+    } catch (error) {
+      failed += 1;
+      console.error('[forge liveness] failed to read current Work authority for ' + repository.repoId + ':', error);
+      continue;
+    }
+
+    for (const work of works) {
+      if (materialized >= maxContinuations) break;
+      scanned += 1;
+      if (semanticWorkState(work) !== 'open') { skip(skippedByReason, 'semantic_work_terminal'); continue; }
+      if (hasActiveExecution(input.controllerHome, repository.repoId, work.workId)) { skip(skippedByReason, 'active_execution'); continue; }
+
+      const liveOwner = getControllerSession(store, work.workId);
+      if (liveOwner && controllerSessionBlocksRecovery(store, work.workId, { nowMs: input.nowMs })) {
+        skip(skippedByReason, 'active_controller_session');
+        continue;
+      }
+
+      const currentTask = currentTaskSemanticProjectionForWork(work);
+      const relayScopeId = currentTask.requirementId ? 'requirement:' + currentTask.requirementId : undefined;
+      const continuationHint = 'Resume exact Work ' + currentTask.workId + '; scheduler observed no active execution or live Controller owner and no unresolved semantic blocker.';
+
+      const requirementRecord = work.requirementId
+        ? readRequirement({ controllerHome: input.controllerHome }, work.requirementId)
+        : undefined;
+      if (work.requirementId && !requirementRecord) { skip(skippedByReason, 'requirement_missing'); continue; }
+      const requirementState = requirementRecord?.value.state;
+      if (requirementState === 'waiting_for_user') { skip(skippedByReason, 'requirement_waiting_for_user'); continue; }
+      if (requirementState === 'done' || requirementState === 'cancelled') { skip(skippedByReason, 'requirement:' + requirementState); continue; }
+
+      const existingRound = getControllerRoundRelay(store, work.workId);
+      if (!livenessMayReconcileExistingRound(existingRound)) {
+        skip(skippedByReason, `controller_round_${existingRound!.status}`);
+        continue;
+      }
+      const occurrenceId = existingRound?.occurrenceId
+        ?? planlessOccurrenceId(work.workId, workSemanticView(work).revision);
+
+      const retainedSession = getRetainedControllerSession(store, work.workId);
+      if (!retainedSession) { skip(skippedByReason, 'retained_controller_session_missing'); continue; }
+      if (retainedSession.controllerType === 'human') { skip(skippedByReason, 'human_controller'); continue; }
+
+      eligible += 1;
+      try {
+        authorizeWake('external_controller_wake', {
+          work_id: work.workId,
+          controller_type: retainedSession.controllerType,
+          relay_scope_id: relayScopeId,
+          recovery_reason: 'ownerless_work_ready_to_continue',
+        });
+
+        const progression = await reconcileControllerProgression(
+          {
+            controllerHome: input.controllerHome,
+            repoId: repository.repoId,
+            repoRoot: repository.canonicalRoot ?? repository.localRoot,
+          },
+          {
+            occurrenceId,
+            workId: work.workId,
+            relayScopeId,
+            continuationHint,
+            scheduleName: 'autonomous-work-liveness',
+          },
+          {
+            ...(input.dependencies?.ensureSupervisorEnrollment
+              ? { ensureSupervisorEnrollment: input.dependencies.ensureSupervisorEnrollment }
+              : {}),
+            ...(input.dependencies?.ensureBinding ? { ensureBinding: input.dependencies.ensureBinding } : {}),
+            ...(input.dependencies?.prepareOccurrence ? { prepareOccurrence: input.dependencies.prepareOccurrence } : {}),
+            ...(input.dependencies?.resumeOccurrence ? { resumeOccurrence: input.dependencies.resumeOccurrence } : {}),
+            ...(input.dependencies?.hostForBinding ? { hostForBinding: input.dependencies.hostForBinding } : {}),
+          },
+        );
+
+        if (progression.status === 'chatgpt_enrolled') {
+          supervisorEnrolled += 1;
+          materialized += 1;
+          continue;
+        }
+        if (progression.status === 'provider_dispatched') {
+          // The occurrence identity is the dedupe fence. A reused dispatched
+          // relay is already complete; reporting it as a fresh dispatch makes
+          // repeated scheduler scans look like new progress even though no
+          // provider call occurred.
+          if (progression.reused) {
+            skip(skippedByReason, 'controller_progression:already_dispatched');
+            continue;
+          }
+          dispatched += 1;
+          materialized += 1;
+          continue;
+        }
+        if (progression.status === 'wait_for_user') {
+          const settledRound = getControllerRoundRelay(store, work.workId);
+          if (settledRound?.status === 'waiting_for_user' && settledRound.handoffId) {
+            ensureControllerDispositionContinuation(input.controllerHome, repository.repoId, settledRound);
+          }
+        }
+        if (progression.status === 'chatgpt_not_enrolled') {
+          skip(skippedByReason, 'workflow_supervisor:' + progression.supervisorEnrollment.status);
+        } else {
+          skip(skippedByReason, 'controller_progression:' + progression.status);
+        }
+      } catch (error) {
+        failed += 1;
+        const reason = error instanceof Error ? error.message : String(error);
+        if (retainedSession.controllerType !== 'chatgpt') {
+          try {
+            maybeRegisterForgeActionableFailureRepair({
+              controllerHome: input.controllerHome,
+              now: () => input.nowMs,
+              observation: {
+                observationId: `progression:liveness:${repository.repoId}:${work.workId}:${input.nowMs}`,
+                source: 'progression',
+                code: deriveForgeActionableFailureCode('SCHEDULER_AUTONOMOUS_CONTINUATION_FAILED', reason),
+                message: reason,
+                at: new Date(input.nowMs).toISOString(),
+                repoId: repository.repoId,
+                workId: work.workId,
+              },
+            });
+          } catch {}
+        }
+        console.error('[forge liveness] autonomous continuation failed for ' + repository.repoId + '/' + work.workId + ':', reason);
+      }
+    }
+  }
+
+  return { scanned, eligible, dispatched, supervisorEnrolled, failed, skippedByReason };
+}

package/src/runtime/control-plane/global-scheduler/durable-admission.ts

@@ -5,7 +5,7 @@ import {
 import { tickSchedules } from '../../workflow/schedules/engine';
 import type { ExecutionJob } from '../../execution/jobs/types';
 
-const SCHEDULE_TICK_INTERVAL_MS = 30_000;
+export const SCHEDULE_TICK_INTERVAL_MS = 30_000;
 
 export function schedulerDurableAdmissionRequiresPolicy(input: {
   activeJobs: readonly ExecutionJob[];