@moretea-labs/forge 1.8.1 → 1.8.2

package/src/runtime/root/service.ts

@@ -1,5 +1,6 @@
+import { writeAtomicTextFile } from '../shared/atomic-text-file';
 import { createHash, randomUUID } from 'crypto';
-import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync } from 'fs';
 import { homedir } from 'os';
 import { dirname, isAbsolute, join, relative, resolve } from 'path';
 import { resolveControllerHome } from '../../cli/repositories/controller-home';
@@ -37,13 +38,6 @@ function xml(value: string): string {
   return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;');
 }
 
-function atomicWrite(path: string, content: string, mode = 0o600): void {
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  const temporary = `${path}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
-  writeFileSync(temporary, content, { encoding: 'utf8', mode });
-  renameSync(temporary, path);
-}
-
 export function forgeRuntimeServicePaths(controllerHome: string): ForgeRuntimeServicePaths {
   const home = resolveControllerHome(controllerHome);
   const serviceRoot = join(home, 'runtime', 'service');
@@ -194,6 +188,91 @@ async function retireLegacyBrowserAutomationLaunchAgent(controllerHome: string):
   rmSync(legacy.installedPlistPath, { force: true });
 }
 
+/**
+ * Read the previously installed exact launchd contract only when config.json
+ * cannot be validated. Both canonical source and installed contracts must be
+ * identical and must still identify the active immutable Runtime release.
+ * A stale/mismatched plist never supplies a guessed listener port.
+ */
+function verifiedRuntimeLaunchdContract(controllerHome: string): { port: number; args: string[] } | undefined {
+  try {
+    const paths = forgeRuntimeServicePaths(controllerHome);
+    const active = readActiveRuntimeRelease(paths.controllerHome);
+    if (!active || !activeRuntimeEntrypoint(paths.controllerHome)) return undefined;
+    if (!existsSync(paths.sourcePlistPath) || !existsSync(paths.installedPlistPath)) return undefined;
+    if (statSync(paths.sourcePlistPath).size > 128 * 1024 || statSync(paths.installedPlistPath).size > 128 * 1024) return undefined;
+    const source = readFileSync(paths.sourcePlistPath, 'utf8');
+    if (source !== readFileSync(paths.installedPlistPath, 'utf8')) return undefined;
+    const parseXmlString = (raw: string): string | undefined => {
+      if (/&(?!(?:amp|lt|gt|quot|apos);)/.test(raw) || /[<>]/.test(raw)) return undefined;
+      return raw.replace(/&(amp|lt|gt|quot|apos);/g, (_, entity: string) =>
+        ({ amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" })[entity] ?? '');
+    };
+    const label = /<key>Label<\/key>\s*<string>([^<]*)<\/string>/.exec(source);
+    if (!label || parseXmlString(label[1]!) !== paths.label) return undefined;
+    const program = /<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(source);
+    if (!program) return undefined;
+    const args: string[] = [];
+    const text = program[1]!;
+    const itemPattern = /\s*<string>([^<]*)<\/string>\s*/g;
+    let cursor = 0;
+    for (let match = itemPattern.exec(text); match; match = itemPattern.exec(text)) {
+      if (match.index !== cursor) return undefined;
+      const value = parseXmlString(match[1]!);
+      if (value === undefined) return undefined;
+      args.push(value);
+      cursor = itemPattern.lastIndex;
+    }
+    if (cursor !== text.length || args[0] !== resolve(paths.activeEntrypointPath)) return undefined;
+    const exactValue = (flag: string): string | undefined => {
+      const indices = args.flatMap((arg, index) => arg === flag ? [index] : []);
+      return indices.length === 1 ? args[indices[0]! + 1] : undefined;
+    };
+    if (exactValue('--controller-home') !== paths.controllerHome
+      || exactValue('--release-manifest') !== resolve(active.manifestPath)) return undefined;
+    const portString = exactValue('--port');
+    if (!portString || !/^[1-9]\d{0,4}$/.test(portString)) return undefined;
+    const port = Number(portString);
+    return port <= 65_535 ? { port, args } : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Read-only projection of the original installed launchd contract. */
+export function verifiedRuntimePortFromLaunchdContract(controllerHome: string): number | undefined {
+  return verifiedRuntimeLaunchdContract(controllerHome)?.port;
+}
+
+/** Use the one existing config writer only after service and listener quiescence. */
+export function restoreRuntimeConfigFromVerifiedLaunchdContract(controllerHome: string): boolean {
+  const proven = verifiedRuntimeLaunchdContract(controllerHome);
+  if (!proven) return false;
+  const arg = (flag: string): string | undefined => {
+    const indices = proven.args.flatMap((value, index) => value === flag ? [index] : []);
+    return indices.length === 1 ? proven.args[indices[0]! + 1] : undefined;
+  };
+  const host = arg('--host');
+  const authTokenFile = arg('--auth-token-file');
+  if (!host || !authTokenFile) return false;
+  try {
+    const topologyString = arg('--deployment-topology');
+    const topology = topologyString ? JSON.parse(topologyString) as RuntimeDeploymentTopology : undefined;
+    writeForgeRuntimeServiceConfig({
+      schemaVersion: 1,
+      controllerHome: forgeRuntimeServicePaths(controllerHome).controllerHome,
+      host,
+      port: proven.port,
+      authTokenFile,
+      ...(arg('--repo') ? { repositoryRoot: arg('--repo') } : {}),
+      ...(topology ? { topology } : {}),
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export function activeRuntimeLaunchSpec(controllerHome: string): ActiveRuntimeLaunchSpec | undefined {
   const home = resolveControllerHome(controllerHome);
   const active = readActiveRuntimeRelease(home);
@@ -346,8 +425,8 @@ export function ensureForgeRuntimeLaunchAgentContract(
     ? readFileSync(desired.paths.installedPlistPath, 'utf8')
     : undefined;
   const changed = existingSource !== desired.plist || (input.installUserLaunchAgent === true && existingInstalled !== desired.plist);
-  if (existingSource !== desired.plist) atomicWrite(desired.paths.sourcePlistPath, desired.plist);
-  if (input.installUserLaunchAgent === true && existingInstalled !== desired.plist) atomicWrite(desired.paths.installedPlistPath, desired.plist, 0o644);
+  if (existingSource !== desired.plist) writeAtomicTextFile(desired.paths.sourcePlistPath, desired.plist);
+  if (input.installUserLaunchAgent === true && existingInstalled !== desired.plist) writeAtomicTextFile(desired.paths.installedPlistPath, desired.plist, 0o644);
   return { paths: desired.paths, mode: desired.mode, changed };
 }
 
@@ -367,7 +446,7 @@ export function writeForgeRuntimeServiceConfig(input: ForgeRuntimeServiceConfig)
   const config = validateForgeRuntimeServiceConfig(input);
   const paths = forgeRuntimeServicePaths(config.controllerHome);
   mkdirSync(join(paths.serviceRoot, 'logs'), { recursive: true, mode: 0o700 });
-  atomicWrite(paths.configPath, `${JSON.stringify(config, null, 2)}\n`);
+  writeAtomicTextFile(paths.configPath, `${JSON.stringify(config, null, 2)}\n`);
   return { config, paths };
 }
 

package/src/runtime/root/types.ts

@@ -84,12 +84,6 @@ export interface RuntimeReleaseManifest {
   browserAutomationHelperEntrypoint?: 'browser-automation-helper';
   browserAutomationHelperArtifactIdentity?: string;
   browserAutomationHelperContractIdentity?: string;
-  codeGraphNodeEntrypoint?: 'codegraph-node';
-  codeGraphNodeArtifactIdentity?: string;
-  codeGraphSidecarEntrypoint?: 'codegraph-sidecar.cjs';
-  codeGraphSidecarArtifactIdentity?: string;
-  codeGraphLibraryRoot?: 'codegraph-lib';
-  codeGraphLibraryArtifactIdentity?: string;
   packageRoot?: 'package';
   packageArtifactIdentity?: string;
   controllerUiRoot?: 'ui-dist';

package/src/runtime/root/workflow-supervisor-composition.ts

@@ -12,11 +12,12 @@ import {
 import {
   bindChatgptWorkConversation,
   getChatgptWorkConversationBinding,
+  listChatgptWorkBindingsForConversation,
   rebindChatgptWorkConversation,
   type ChatgptWorkConversationBinding,
 } from '../../../adapters/chatgpt/work-conversation-binding-store';
 import { readRequirement } from '../control-plane/persistence/requirement-store';
-import { getWorkflowSupervisorCurrentConversation, getWorkflowSupervisorTaskByConversationId, registerWorkflowSupervisorTask, reserveWorkflowSupervisorEnrollment } from '../../../supervisor/client';
+import { bindWorkflowSupervisorScheduledWake, getWorkflowSupervisorCurrentConversation, getWorkflowSupervisorTask, getWorkflowSupervisorTaskByConversationId, getWorkflowSupervisorTaskStall, registerWorkflowSupervisorTask, reserveWorkflowSupervisorEnrollment, wakeWorkflowSupervisorScheduledTask } from '../../../supervisor/client';
 import { resolveWorkflowSupervisorForgeHome, workflowSupervisorSocketPath } from '../../../supervisor/paths';
 import type { WorkflowSupervisorLifecycleHooks, WorkflowSupervisorTask } from '../../../supervisor/types';
 import { getRuntimeWriteClaim } from './write-fence';
@@ -130,15 +131,37 @@ export function inheritWorkflowSupervisorConversationBinding(
   });
 }
 
-function workflowSupervisorContractText(task: WorkflowSupervisorTask, key: string): string | undefined {
+export function workflowSupervisorContractText(task: WorkflowSupervisorTask, key: string): string | undefined {
   const value = task.completionContract[key] ?? task.userBlockerPolicy[key];
   return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
 
-function workflowSupervisorOriginWorkId(task: WorkflowSupervisorTask, repoId: string): string | undefined {
+function workflowSupervisorOriginWorkId(
+  task: WorkflowSupervisorTask,
+  repoId: string,
+  controllerHome: string,
+  conversationId = task.conversationId,
+): string | undefined {
   const legacyWorkPrefix = `forge:${repoId}:work:`;
-  return workflowSupervisorContractText(task, 'work_id')
+  const explicit = workflowSupervisorContractText(task, 'work_id')
     ?? (task.taskId.startsWith(legacyWorkPrefix) ? task.taskId.slice(legacyWorkPrefix.length) || undefined : undefined);
+  const original = explicit ? getWorkContract({ controllerHome, repoId }, explicit) : undefined;
+  if (explicit && (!original || semanticWorkState(original) === 'open')) return explicit;
+  const active = listChatgptWorkBindingsForConversation({ controllerHome, repoId }, conversationId)
+    .map(({ workId }) => getWorkContract({ controllerHome, repoId }, workId))
+    .filter((work): work is NonNullable<typeof work> => Boolean(work && semanticWorkState(work) === 'open'));
+  // A terminal predecessor retains its audit and conversation binding. Only
+  // explicit successor lineage within the same Requirement can transfer the
+  // active Work projection; siblings cannot inherit the predecessor's task.
+  if (explicit) {
+    const successors = active.filter((work) => work.predecessorWorkId === explicit
+      && original?.requirementId && work.requirementId === original.requirementId);
+    return successors.length === 1 && active.length === 1 ? successors[0]!.workId : explicit;
+  }
+  // Standalone enrollment predates Work binding. It may project into one
+  // unambiguous open Work, without creating a second conversation authority.
+  if (task.continuationPolicy.kind !== 'standalone_supervisor') return undefined;
+  return active.length === 1 ? active[0]!.workId : undefined;
 }
 
 /**
@@ -152,7 +175,7 @@ function workflowSupervisorWorkProgressFingerprint(controllerHome: string, task:
   const repoId = workflowSupervisorContractText(task, 'repo_id');
   const taskControllerHome = workflowSupervisorContractText(task, 'controller_home');
   if (!repoId || (taskControllerHome && taskControllerHome !== controllerHome)) return undefined;
-  const workId = workflowSupervisorOriginWorkId(task, repoId);
+  const workId = workflowSupervisorOriginWorkId(task, repoId, controllerHome);
   if (!workId) return undefined;
   const work = getWorkContract({ controllerHome, repoId }, workId);
   if (!work) return undefined;
@@ -195,20 +218,44 @@ function createForgeWorkflowSupervisorBrowserTaskActive(controllerHome: string):
     const taskControllerHome = workflowSupervisorContractText(task, 'controller_home');
     if (!repoId || taskControllerHome !== controllerHome) return false;
     if (requirementId && readRequirement({ controllerHome }, requirementId)?.value.state === 'cancelled') return false;
-    const workId = workflowSupervisorOriginWorkId(task, repoId);
+    const workId = workflowSupervisorOriginWorkId(task, repoId, controllerHome);
     if (!requirementId && !workId) return false;
-    // An existing task may outlive the Work that originally enrolled it. Its
-    // durable task/effect chain still owns the original Goal; absence cannot
-    // mean DONE, NEEDS_USER, nor permit a replacement provider send.
+    // An independent Requirement Goal can outlive an execution Work; an exact
+    // Work-owned Supervisor cannot initiate another Send after that Work closes.
+    if (terminalWorkSupervisorStopReason(controllerHome, task)) return false;
     const binding = workId ? getChatgptWorkConversationBinding({ controllerHome, repoId }, workId) : undefined;
     return !binding || binding.conversationId === task.conversationId;
   };
 }
 
+/**
+ * Only an exact Work-owned Supervisor task follows that Work's terminal state.
+ * Requirement-owned autonomous Goals and standalone tasks keep their own
+ * explicit lifecycle; a completed lower-layer carrier is not goal completion.
+ */
+function terminalWorkSupervisorStopReason(controllerHome: string, task: WorkflowSupervisorTask): string | undefined {
+  const repoId = workflowSupervisorContractText(task, 'repo_id');
+  const workId = workflowSupervisorContractText(task, 'work_id');
+  const taskHome = workflowSupervisorContractText(task, 'controller_home');
+  if (!repoId || !workId || (taskHome && taskHome !== controllerHome)) return undefined;
+  if (task.taskId !== `forge:${repoId}:work:${workId}`
+    || task.continuationPolicy.kind === 'standalone_supervisor') return undefined;
+  const work = getWorkContract({ controllerHome, repoId }, workId);
+  if (!work) return undefined;
+  const state = semanticWorkState(work);
+  return state !== 'open'
+    ? `Exact Work ${workId} is ${state}; stop its Work-owned Supervisor continuation without changing the original Work or any successor Schedule.`
+    : undefined;
+}
+
 export function forgeWorkflowSupervisorLifecycleHooks(controllerHome: string): WorkflowSupervisorLifecycleHooks {
   const browserTaskActive = createForgeWorkflowSupervisorBrowserTaskActive(controllerHome);
   return {
+    terminalWorkStopReasonForTask: (task) => terminalWorkSupervisorStopReason(controllerHome, task),
     canonicalObjectiveForTask: (task) => {
+      // Standalone Supervisor owns its full objective; Work execution context
+      // must never silently replace the original autonomous business goal.
+      if (task.continuationPolicy.kind === 'standalone_supervisor') return undefined;
       const repoId = workflowSupervisorContractText(task, 'repo_id');
       const requirementId = workflowSupervisorContractText(task, 'requirement_id');
       const taskControllerHome = workflowSupervisorContractText(task, 'controller_home');
@@ -220,7 +267,7 @@ export function forgeWorkflowSupervisorLifecycleHooks(controllerHome: string): W
         const outcome = readRequirement({ controllerHome }, requirementId)?.value.outcomeStatement?.trim();
         if (outcome) return outcome;
       }
-      const workId = workflowSupervisorOriginWorkId(task, repoId);
+      const workId = workflowSupervisorOriginWorkId(task, repoId, controllerHome);
       if (!workId) return undefined;
       const work = getWorkContract({ controllerHome, repoId }, workId);
       // Legacy / independent Work without Requirement authority keeps the
@@ -231,9 +278,21 @@ export function forgeWorkflowSupervisorLifecycleHooks(controllerHome: string): W
       const repoId = workflowSupervisorContractText(task, 'repo_id');
       const taskControllerHome = workflowSupervisorContractText(task, 'controller_home');
       if (!repoId || (taskControllerHome && taskControllerHome !== controllerHome)) return undefined;
-      const workId = workflowSupervisorOriginWorkId(task, repoId);
+      const workId = workflowSupervisorOriginWorkId(task, repoId, controllerHome);
       if (!workId) return undefined;
-      return renderCognitiveAttentionForWork({ controllerHome, repoId, workId, query: task.objective, maxItems: 6, maxBytes: 8 * 1024 });
+      const cognitive = renderCognitiveAttentionForWork({ controllerHome, repoId, workId, query: task.objective, maxItems: 6, maxBytes: 5 * 1024 });
+      if (task.continuationPolicy.kind !== 'standalone_supervisor') return cognitive;
+      const work = getWorkContract({ controllerHome, repoId }, workId);
+      if (!work) return cognitive;
+      // Thin evidence, not a second task/goal authority. Recent semantic refs
+      // carry the concrete next step even when Cognitive recall is empty.
+      const refs = (work.semanticResultRefs ?? []).slice(-5).map((ref) => ref.slice(0, 500));
+      return [
+        `Canonical Work: ${workId} (read-only execution context; Supervisor objective remains authoritative).`,
+        `Work objective: ${work.objective.slice(0, 600)}`,
+        ...refs.map((ref) => `Work evidence: ${ref}`),
+        ...(cognitive ? [cognitive] : []),
+      ].join('\n').slice(0, 8_000);
     },
     effectDispatchEvidence: ({ task }) => {
       const claim = getRuntimeWriteClaim();
@@ -255,7 +314,7 @@ export function forgeWorkflowSupervisorLifecycleHooks(controllerHome: string): W
       if (effect.kind !== 'enrollment') return undefined;
       const repoId = workflowSupervisorContractText(task, 'repo_id');
       const requirementId = workflowSupervisorContractText(task, 'requirement_id');
-      const workId = repoId ? workflowSupervisorOriginWorkId(task, repoId) : undefined;
+      const workId = repoId ? workflowSupervisorOriginWorkId(task, repoId, controllerHome) : undefined;
       const taskControllerHome = workflowSupervisorContractText(task, 'controller_home');
       if (!repoId || (!requirementId && !workId) || taskControllerHome !== controllerHome) return undefined;
       const store = { controllerHome, repoId };
@@ -308,16 +367,26 @@ export function forgeWorkflowSupervisorLifecycleHooks(controllerHome: string): W
     browserTaskActive,
     bootstrapConversationBound: (task, context) => {
       const repoId = workflowSupervisorContractText(task, 'repo_id');
-      const workId = workflowSupervisorContractText(task, 'work_id');
+      const declaredWorkId = workflowSupervisorContractText(task, 'work_id');
       const taskControllerHome = workflowSupervisorContractText(task, 'controller_home');
-      if (!repoId || !workId || taskControllerHome !== controllerHome) return;
-      const existing = getChatgptWorkConversationBinding({ controllerHome, repoId }, workId);
+      if (!repoId || taskControllerHome !== controllerHome) return;
+      // On migration, retain the sole active Work projection even for a
+      // standalone task without work_id or a completed predecessor. Prefer
+      // a binding already moved to the new conversation on duplicate callbacks.
+      const currentWorkId = workflowSupervisorOriginWorkId(task, repoId, controllerHome);
+      const bindingWorkId = context?.migratedFromConversationId
+        ? (currentWorkId && currentWorkId !== declaredWorkId
+          ? currentWorkId
+          : workflowSupervisorOriginWorkId(task, repoId, controllerHome, context.migratedFromConversationId) ?? declaredWorkId)
+        : declaredWorkId;
+      if (!bindingWorkId) return;
+      const existing = getChatgptWorkConversationBinding({ controllerHome, repoId }, bindingWorkId);
       if (existing && existing.conversationId !== task.conversationId) {
         if (!context?.migratedFromConversationId || context.migratedFromConversationId !== existing.conversationId) {
           throw new Error('WORKFLOW_SUPERVISOR_BOOTSTRAP_WORK_CONVERSATION_CONFLICT');
         }
         rebindChatgptWorkConversation({ controllerHome, repoId }, {
-          workId,
+          workId: bindingWorkId,
           previousConversationId: existing.conversationId,
           conversationUrl: task.conversationUrl,
           localAlias: existing.localAlias,
@@ -326,7 +395,7 @@ export function forgeWorkflowSupervisorLifecycleHooks(controllerHome: string): W
       }
       if (!existing) {
         bindChatgptWorkConversation({ controllerHome, repoId }, {
-          workId,
+          workId: bindingWorkId,
           conversationUrl: task.conversationUrl,
           localAlias: 'Forge autonomous execution',
         });
@@ -336,7 +405,7 @@ export function forgeWorkflowSupervisorLifecycleHooks(controllerHome: string): W
       if (effect.kind !== 'enrollment') return;
       const repoId = workflowSupervisorContractText(task, 'repo_id');
       const requirementId = workflowSupervisorContractText(task, 'requirement_id');
-      const workId = repoId ? workflowSupervisorOriginWorkId(task, repoId) : undefined;
+      const workId = repoId ? workflowSupervisorOriginWorkId(task, repoId, controllerHome) : undefined;
       const taskControllerHome = workflowSupervisorContractText(task, 'controller_home');
       if (!repoId || (!requirementId && !workId) || taskControllerHome !== controllerHome) return;
       const store = { controllerHome, repoId };
@@ -408,9 +477,62 @@ export async function bindCurrentWorkflowSupervisorConversationForWork(
   return { status: 'bound', binding };
 }
 
+export async function bindWorkflowSupervisorScheduledWakeForWork(
+  options: { controllerHome: string; repoId: string },
+  workId: string,
+  scheduleId: string,
+): Promise<{ status: 'bound'; taskId: string } | { status: 'not_enrolled' | 'binding_deferred' }> {
+  const forgeHome = resolveWorkflowSupervisorForgeHome(options.controllerHome);
+  if (!existsSync(workflowSupervisorSocketPath(forgeHome))) return { status: 'binding_deferred' };
+  const exactTaskId = taskIdForWork(options.repoId, workId);
+  let task = await getWorkflowSupervisorTask(forgeHome, exactTaskId);
+  if (!task) {
+    const binding = getChatgptWorkConversationBinding(options, workId);
+    if (binding) {
+      const authority = await getWorkflowSupervisorTaskByConversationId(forgeHome, binding.conversationId);
+      if (authority) {
+        const ownerRepoId = typeof authority.task.completionContract.repo_id === 'string'
+          ? authority.task.completionContract.repo_id : authority.task.continuationPolicy.repo_id;
+        if (ownerRepoId !== options.repoId || authority.task.completionContract.work_id !== workId) {
+          throw new Error('WORKFLOW_SUPERVISOR_SCHEDULE_WORK_IDENTITY_MISMATCH');
+        }
+        task = authority.task;
+      }
+    }
+  }
+  if (!task) return { status: 'not_enrolled' };
+  const bound = await bindWorkflowSupervisorScheduledWake(forgeHome, {
+    taskId: task.taskId,
+    repoId: options.repoId,
+    workId,
+    scheduleId,
+  });
+  return { status: 'bound', taskId: bound.task.taskId };
+}
+
+export async function wakeWorkflowSupervisorScheduledTaskForWork(
+  options: { controllerHome: string; repoId: string },
+  workId: string,
+  scheduleId: string,
+  occurrenceId: string,
+): Promise<{ status: 'woken' | 'not_waiting' | 'not_enrolled' | 'binding_deferred'; taskId?: string; effectId?: string }> {
+  const binding = await bindWorkflowSupervisorScheduledWakeForWork(options, workId, scheduleId);
+  if (binding.status !== 'bound') return binding;
+  if (!binding.taskId) throw new Error('WORKFLOW_SUPERVISOR_SCHEDULE_BINDING_TASK_ID_MISSING');
+  const forgeHome = resolveWorkflowSupervisorForgeHome(options.controllerHome);
+  const stall = await getWorkflowSupervisorTaskStall(forgeHome, binding.taskId);
+  if (stall.state !== 'waiting') return { status: 'not_waiting', taskId: binding.taskId };
+  const wake = await wakeWorkflowSupervisorScheduledTask(forgeHome, {
+    taskId: binding.taskId, scheduleId, occurrenceId,
+  });
+  return { status: 'woken', taskId: binding.taskId, effectId: wake.effect.effectId };
+}
+
 export async function ensureWorkflowSupervisorEnrollmentForWork(
   options: { controllerHome: string; repoId: string },
   workId: string,
+  scheduledWakeScheduleId?: string,
+  scheduleOccurrenceId?: string,
 ): Promise<{ status: WorkflowSupervisorEnrollmentStatus; taskId?: string; effectId?: string; reason?: string }> {
   const boundary = workflowSupervisorBoundaryForWork(options, workId);
   if (boundary.status === 'not_eligible') return { status: boundary.status };
@@ -421,6 +543,55 @@ export async function ensureWorkflowSupervisorEnrollmentForWork(
   const taskId = taskIdForWork(options.repoId, workId);
   if (!existsSync(workflowSupervisorSocketPath(forgeHome))) return { status: 'daemon_unavailable', taskId };
 
+  // A Work-derived Supervisor id is a durable task reservation, not a
+  // registration template to rewrite on every Scheduler wake. In particular,
+  // an explicitly stopped historical task remains terminal even if its Work is
+  // still open, and a live bootstrap retains its original immutable objective
+  // and effect when the lower Work wording changes. Do not mint a replacement
+  // send, mutate Task identity, or use lower ControllerRound state to revive it.
+  const existingWorkTask = await getWorkflowSupervisorTask(forgeHome, taskId);
+  if (existingWorkTask) {
+    const existingRepoId = typeof existingWorkTask.completionContract.repo_id === 'string'
+      ? existingWorkTask.completionContract.repo_id
+      : existingWorkTask.continuationPolicy.repo_id;
+    const existingWorkId = existingWorkTask.completionContract.work_id;
+    if (existingRepoId !== options.repoId || existingWorkId !== workId) {
+      throw new Error('WORKFLOW_SUPERVISOR_TASK_ID_CONFLICT');
+    }
+    let stall = await getWorkflowSupervisorTaskStall(forgeHome, taskId);
+    if (stall.state === 'terminal') {
+      return { status: 'lower_layer_not_ready', reason: 'WORKFLOW_SUPERVISOR_TASK_TERMINAL' };
+    }
+    if (scheduledWakeScheduleId) {
+      await bindWorkflowSupervisorScheduledWake(forgeHome, {
+        taskId,
+        repoId: options.repoId,
+        workId,
+        scheduleId: scheduledWakeScheduleId,
+      });
+      stall = await getWorkflowSupervisorTaskStall(forgeHome, taskId);
+      if (stall.state === 'waiting') {
+        if (!scheduleOccurrenceId) return { status: 'lower_layer_not_ready', taskId, reason: 'SCHEDULE_OCCURRENCE_ID_REQUIRED' };
+        const wake = await wakeWorkflowSupervisorScheduledTask(forgeHome, {
+          taskId, scheduleId: scheduledWakeScheduleId, occurrenceId: scheduleOccurrenceId,
+        });
+        return { status: 'enrolled', taskId, effectId: wake.effect.effectId };
+      }
+    }
+    const ownedRequirementId = typeof existingWorkTask.completionContract.requirement_id === 'string'
+      ? existingWorkTask.completionContract.requirement_id : undefined;
+    if (ownedRequirementId !== getWorkContract(options, workId)?.requirementId) {
+      throw new Error('WORKFLOW_SUPERVISOR_TASK_REQUIREMENT_CONFLICT');
+    }
+    if (boundary.status === 'conversation_pending') {
+      if (existingWorkTask.continuationPolicy.kind !== 'forge_goal_outer_turn') {
+        throw new Error('WORKFLOW_SUPERVISOR_TASK_ID_CONFLICT');
+      }
+      const effect = await reserveWorkflowSupervisorEnrollment(forgeHome, taskId);
+      return { status: 'enrolled', taskId, effectId: effect.effectId };
+    }
+  }
+
   // Once an exact conversation is already owned by a Supervisor task, that
   // task is the outer-turn authority. ControllerRound is only first-admission
   // execution context and must not regain veto power over later continuation.
@@ -445,6 +616,22 @@ export async function ensureWorkflowSupervisorEnrollmentForWork(
           reason: `WORKFLOW_SUPERVISOR_TASK_TERMINAL:${existingAuthority.terminal}`,
         };
       }
+      if (scheduledWakeScheduleId) {
+        await bindWorkflowSupervisorScheduledWake(forgeHome, {
+          taskId: existingAuthority.task.taskId,
+          repoId: options.repoId,
+          workId,
+          scheduleId: scheduledWakeScheduleId,
+        });
+        const stall = await getWorkflowSupervisorTaskStall(forgeHome, existingAuthority.task.taskId);
+        if (stall.state === 'waiting') {
+          if (!scheduleOccurrenceId) return { status: 'lower_layer_not_ready', taskId: existingAuthority.task.taskId, reason: 'SCHEDULE_OCCURRENCE_ID_REQUIRED' };
+          const wake = await wakeWorkflowSupervisorScheduledTask(forgeHome, {
+            taskId: existingAuthority.task.taskId, scheduleId: scheduledWakeScheduleId, occurrenceId: scheduleOccurrenceId,
+          });
+          return { status: 'enrolled', taskId: existingAuthority.task.taskId, effectId: wake.effect.effectId };
+        }
+      }
       const effect = await reserveWorkflowSupervisorEnrollment(forgeHome, existingAuthority.task.taskId);
       return { status: 'enrolled', taskId: existingAuthority.task.taskId, effectId: effect.effectId };
     }
@@ -476,6 +663,7 @@ export async function ensureWorkflowSupervisorEnrollmentForWork(
       ...(boundary.status === 'outer_turn'
         ? { exact_conversation_id: boundary.conversationId, exact_conversation_url: boundary.conversationUrl }
         : { bootstrap: true }),
+      ...(scheduledWakeScheduleId ? { scheduled_wake_schedule_id: scheduledWakeScheduleId } : {}),
       outer_turn_owner: 'workflow_supervisor',
     },
     userBlockerPolicy: {