@moretea-labs/forge 1.8.0 → 1.8.2

package/scripts/smoke-user-request-continuation-restart.ts

@@ -0,0 +1,232 @@
+#!/usr/bin/env bun
+import { strict as assert } from 'node:assert';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureControllerHome } from '../src/cli/repositories/controller-home';
+import { registerRepository } from '../src/cli/repositories/registry';
+import {
+  beginControllerRoundProviderDispatch,
+  beginInitialControllerRoundDispatch,
+  finishControllerRoundRelayDispatch,
+  getControllerRoundRelay,
+} from '../packages/kernel/controller/api/index';
+import { claimControllerSession, releaseControllerSession } from '../src/runtime/control-plane/facade/controller-session-store';
+import { createWorkContract } from '../src/runtime/control-plane/facade/work-contract-store';
+import { createHandoffItem } from '../src/runtime/control-plane/facade/handoff-inbox-store';
+import { listUserRequests } from '../packages/kernel/identity/api/index';
+import {
+  createWorkContinuationSchedule,
+  handoffResolvedContinuationEventName,
+  resolveHandoffAndTriggerContinuation,
+} from '../src/runtime/workflow/schedules/work-continuation';
+import { listOccurrences } from '../src/runtime/workflow/schedules/store';
+
+const WORK_ID = 'WORK-USER-REQUEST-PROCESS-RESTART';
+const HANDOFF_ID = 'HND-USER-REQUEST-PROCESS-RESTART';
+const ORIGINAL_OCCURRENCE_ID = 'occ-user-request-original-lineage';
+const META = 'user-request-continuation-meta.json';
+
+interface Meta {
+  repoId: string;
+  scheduleId: string;
+  authorityId: string;
+  firstOccurrenceId?: string;
+}
+
+function arg(name: string): string | undefined {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+function metaPath(root: string): string {
+  return join(root, META);
+}
+
+function readMeta(root: string): Meta {
+  return JSON.parse(readFileSync(metaPath(root), 'utf8')) as Meta;
+}
+
+function writeMeta(root: string, meta: Meta): void {
+  writeFileSync(metaPath(root), JSON.stringify(meta, null, 2), 'utf8');
+}
+
+function initRepository(root: string): string {
+  const repoRoot = join(root, 'repo');
+  mkdirSync(repoRoot, { recursive: true });
+  execFileSync('git', ['init', '-q', '-b', 'main'], { cwd: repoRoot });
+  execFileSync('git', ['config', 'user.email', 'user-request-smoke@example.test'], { cwd: repoRoot });
+  execFileSync('git', ['config', 'user.name', 'UserRequest Smoke'], { cwd: repoRoot });
+  writeFileSync(join(repoRoot, 'README.md'), 'user request continuation smoke\n');
+  execFileSync('git', ['add', '.'], { cwd: repoRoot });
+  execFileSync('git', ['commit', '-qm', 'fixture'], { cwd: repoRoot });
+  return repoRoot;
+}
+
+async function runPhase(root: string, phase: string): Promise<void> {
+  const controllerHome = ensureControllerHome(join(root, 'controller'));
+
+  if (phase === 'setup') {
+    const repoRoot = initRepository(root);
+    const repository = registerRepository({ path: repoRoot, controllerHome, displayName: 'user-request-continuation-smoke' });
+    const store = { controllerHome, repoId: repository.repoId };
+    createWorkContract(store, {
+      workId: WORK_ID,
+      repoId: repository.repoId,
+      checkoutId: repository.activeCheckoutId,
+      objective: 'Resume the exact continuation lineage after one genuine UserRequest is resolved.',
+      acceptanceCriteria: ['One resolution rearms the same occurrence and replay creates no second occurrence.'],
+      allowedPaths: [],
+      forbiddenPaths: [],
+      checks: [],
+      constraints: { workspaceMode: 'current' },
+      requestedBy: 'chatgpt',
+      dispatchState: 'running',
+    });
+    const owner = claimControllerSession(store, {
+      workId: WORK_ID,
+      controllerId: 'user-request-smoke-controller',
+      controllerType: 'chatgpt',
+      sessionId: 'user-request-smoke-session',
+      principalId: 'user-request-smoke-controller',
+      controllerInstanceId: 'runtime-before-user-resolution',
+      leaseMs: 60_000,
+    });
+    const relay = beginInitialControllerRoundDispatch(store, {
+      workId: WORK_ID,
+      occurrenceId: ORIGINAL_OCCURRENCE_ID,
+      identity: {
+        controllerId: owner.controllerId,
+        controllerType: owner.controllerType,
+        principalId: owner.principalId!,
+        controllerInstanceId: owner.controllerInstanceId!,
+        sessionId: owner.sessionId,
+      },
+    });
+    const started = beginControllerRoundProviderDispatch(store, {
+      workId: WORK_ID,
+      authorityId: relay.authorityId!,
+      expectedUpdatedAt: relay.updatedAt,
+    });
+    const eventName = handoffResolvedContinuationEventName(HANDOFF_ID);
+    const schedule = createWorkContinuationSchedule(controllerHome, repository.repoId, {
+      workId: WORK_ID,
+      controllerType: 'chatgpt',
+      triggerType: 'repository-event',
+      eventName,
+      shadowMode: true,
+      cooldownMinutes: 0,
+    }).schedule;
+    createHandoffItem(store, {
+      id: HANDOFF_ID,
+      repoId: repository.repoId,
+      workId: WORK_ID,
+      title: 'Resolve one genuine user blocker',
+      severity: 'needs_review',
+      creationReason: 'missing_authorization',
+      reason: 'The provider requires a user-owned authorization step.',
+      summary: 'Resume the exact continuation after the user action.',
+      currentState: { repoId: repository.repoId, workId: WORK_ID, statusSummary: 'waiting for user authorization' },
+      attemptedActions: [],
+      evidenceRefs: [],
+      recommendedDecision: 'Resolve the authorization blocker.',
+      recommendedPrompt: 'Resolve the blocker and resume the exact continuation.',
+      suggestedNextActions: [],
+    });
+    finishControllerRoundRelayDispatch(store, {
+      workId: WORK_ID,
+      ok: false,
+      waitForUser: true,
+      handoffId: HANDOFF_ID,
+      providerDispatchEffectId: started.providerDispatchEffectId,
+      error: 'CHATGPT_AUTOMATION_LOGIN_REQUIRED',
+    });
+    releaseControllerSession(store, WORK_ID, owner.controllerId);
+    const waiting = getControllerRoundRelay(store, WORK_ID);
+    assert.equal(waiting?.status, 'waiting_for_user');
+    assert.equal(waiting?.occurrenceId, ORIGINAL_OCCURRENCE_ID);
+    assert.equal(waiting?.authorityId, relay.authorityId);
+    const requests = listUserRequests(controllerHome, 'pending');
+    assert.equal(requests.length, 1);
+    assert.equal(requests[0]?.presentation?.legacyHandoffId, HANDOFF_ID);
+    writeMeta(root, { repoId: repository.repoId, scheduleId: schedule.scheduleId, authorityId: relay.authorityId! });
+    return;
+  }
+
+  const meta = readMeta(root);
+  const store = { controllerHome, repoId: meta.repoId };
+
+  if (phase === 'resolve') {
+    const resolved = await resolveHandoffAndTriggerContinuation(controllerHome, meta.repoId, HANDOFF_ID, {
+      decision: 'authorization completed',
+      resolver: 'user-request-smoke-user',
+    });
+    assert.equal(resolved.item.status, 'resolved');
+    assert.equal(resolved.continuationOccurrences.length, 1);
+    assert.equal(resolved.continuationOccurrences[0]?.scheduleId, meta.scheduleId);
+    const relay = getControllerRoundRelay(store, WORK_ID);
+    assert.equal(relay?.status, 'dispatching');
+    assert.equal(relay?.occurrenceId, ORIGINAL_OCCURRENCE_ID);
+    assert.equal(relay?.authorityId, meta.authorityId);
+    const occurrences = listOccurrences(controllerHome, meta.repoId, meta.scheduleId);
+    assert.equal(occurrences.length, 1);
+    assert.equal(occurrences[0]?.triggerContext?.data?.controllerRoundOccurrenceId, ORIGINAL_OCCURRENCE_ID);
+    const requests = listUserRequests(controllerHome, 'resolved');
+    assert.equal(requests.length, 1);
+    assert.equal(requests[0]?.resolution?.decision, 'authorization completed');
+    writeMeta(root, { ...meta, firstOccurrenceId: occurrences[0]!.occurrenceId });
+    return;
+  }
+
+  if (phase === 'replay') {
+    assert.ok(meta.firstOccurrenceId);
+    const replay = await resolveHandoffAndTriggerContinuation(controllerHome, meta.repoId, HANDOFF_ID, {
+      decision: 'authorization completed',
+      resolver: 'user-request-smoke-user',
+    });
+    assert.equal(replay.item.status, 'resolved');
+    const relay = getControllerRoundRelay(store, WORK_ID);
+    assert.equal(relay?.status, 'dispatching');
+    assert.equal(relay?.occurrenceId, ORIGINAL_OCCURRENCE_ID);
+    assert.equal(relay?.authorityId, meta.authorityId);
+    const occurrences = listOccurrences(controllerHome, meta.repoId, meta.scheduleId);
+    assert.equal(occurrences.length, 1);
+    assert.equal(occurrences[0]?.occurrenceId, meta.firstOccurrenceId);
+    assert.equal(listUserRequests(controllerHome, 'resolved').length, 1);
+    return;
+  }
+
+  throw new Error(`UNKNOWN_PHASE:${phase}`);
+}
+
+async function main(): Promise<void> {
+  const phase = arg('--phase');
+  const rootArg = arg('--root');
+  if (phase) {
+    if (!rootArg) throw new Error('--root is required with --phase');
+    await runPhase(rootArg, phase);
+    return;
+  }
+  const root = mkdtempSync(join(tmpdir(), 'forge-user-request-continuation-restart-'));
+  const script = fileURLToPath(import.meta.url);
+  try {
+    for (const nextPhase of ['setup', 'resolve', 'replay']) {
+      const child = spawnSync(process.execPath, [script, '--phase', nextPhase, '--root', root], {
+        cwd: process.cwd(),
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      assert.equal(child.status, 0, `phase ${nextPhase} failed\nstdout:\n${child.stdout ?? ''}\nstderr:\n${child.stderr ?? ''}`);
+    }
+    console.log('[user-request-continuation-process-restart-smoke] OK');
+  } finally {
+    if (existsSync(root)) rmSync(root, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+  process.exitCode = 1;
+});

package/scripts/smoke-workflow-supervisor-chrome-adapter.ts

@@ -0,0 +1,95 @@
+import { strict as assert } from 'node:assert';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { WorkflowSupervisorControlPlane } from '../supervisor/control-plane';
+import { SUPERVISOR_BLOCK_END, SUPERVISOR_BLOCK_START } from '../supervisor/protocol';
+import { WORKFLOW_SUPERVISOR_MIN_TURN_INTERVAL_MS, WorkflowSupervisorStore } from '../supervisor/store';
+import { NativeMessageDecoder, encodeNativeMessage } from '../supervisor/native-messaging/protocol';
+import { renderWorkflowSupervisorNativeManifest } from '../supervisor/native-messaging/manifest';
+import { ALLOWED_BROWSER_METHODS } from '../supervisor/native-messaging/host';
+import { WorkflowSupervisorEphemeralDiscovery } from '../supervisor/server';
+
+const home = mkdtempSync(join(tmpdir(), 'forge-supervisor-chrome-'));
+try {
+  let mechanicalNowMs = Date.now();
+  const turnAdvanceMs = WORKFLOW_SUPERVISOR_MIN_TURN_INTERVAL_MS + 1_000;
+  const control = new WorkflowSupervisorControlPlane(new WorkflowSupervisorStore(home, { now: () => mechanicalNowMs }), { completionContract: async () => ({ valid: true, reason: 'ok' }), userBlockerPolicy: async () => ({ valid: true, reason: 'ok' }) });
+  const conversationId = 'WEB:11111111-2222-3333-4444-555555555555';
+  const conversationUrl = `https://chatgpt.com/c/${conversationId}`;
+  control.registerTask({ taskId: 'task-1', conversationId, conversationUrl, objective: 'Keep implementing the original Forge goal.', completionContract: {}, continuationPolicy: {}, userBlockerPolicy: {} });
+  const enrollment = control.reserveEnrollment('task-1');
+  assert.equal(control.browserTasks().length, 1);
+  let poll = control.browserPoll({ conversationId, conversationUrl });
+  assert.equal(poll.command?.mode, 'send'); assert.equal(poll.command?.effectId, enrollment.effectId);
+  assert.equal(control.browserBeginEffect({ conversationId, conversationUrl, effectId: enrollment.effectId, dispatchId: 'dispatch-1', dispatchGeneration: poll.command!.dispatchGeneration, evidence: { latest_user_text: '', latest_assistant_response: '' } }).started, true);
+  poll = control.browserPoll({ conversationId, conversationUrl }); assert.equal(poll.command?.mode, 'reconcile');
+  control.browserObserveEffect({ conversationId, conversationUrl, effectId: enrollment.effectId, observationId: 'observed-1', outcome: 'applied', evidence: { exact: true } });
+  const response = `Work remains.\n${SUPERVISOR_BLOCK_START}\n${JSON.stringify({ action: 'CONTINUE', source_effect_id: enrollment.effectId, checkpoint: 'step 4', reason: 'more work', evidence: ['receipt'], conversation_id: conversationId, task_id: 'task-1', supervisor_state: 'running', active_scope: 'goal:task-1' })}\n${SUPERVISOR_BLOCK_END}`;
+  const observed = await control.browserObserveAssistant({ conversationId, conversationUrl, responseText: response });
+  assert.equal(observed.action, 'CONTINUE'); assert.ok(observed.successorEffect);
+  mechanicalNowMs += turnAdvanceMs;
+  poll = control.browserPoll({ conversationId, conversationUrl }); assert.equal(poll.command?.effectId, observed.successorEffect?.effectId); assert.equal(poll.command?.mode, 'send');
+  const projectRoutePoll = control.browserPoll({ conversationId, conversationUrl: `https://chatgpt.com/g/not-the-same/c/${conversationId}` });
+  assert.equal(projectRoutePoll.command?.effectId, observed.successorEffect?.effectId);
+  assert.equal(projectRoutePoll.command?.mode, 'send');
+
+  const doneConversationId = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee';
+  const doneConversationUrl = `https://chatgpt.com/c/${doneConversationId}`;
+  control.registerTask({ taskId: 'task-done', conversationId: doneConversationId, conversationUrl: doneConversationUrl, objective: 'Finish once.', completionContract: {}, continuationPolicy: {}, userBlockerPolicy: {} });
+  const doneEffect = control.reserveEnrollment('task-done');
+  const donePoll = control.browserPoll({ conversationId: doneConversationId, conversationUrl: doneConversationUrl });
+  control.browserBeginEffect({ conversationId: doneConversationId, conversationUrl: doneConversationUrl, effectId: doneEffect.effectId, dispatchId: 'dispatch-done', dispatchGeneration: donePoll.command!.dispatchGeneration, evidence: { latest_user_text: '', latest_assistant_response: '' } });
+  control.browserObserveEffect({ conversationId: doneConversationId, conversationUrl: doneConversationUrl, effectId: doneEffect.effectId, observationId: 'observed-done', outcome: 'applied' });
+  const doneResponse = `${SUPERVISOR_BLOCK_START}\n${JSON.stringify({ action: 'DONE', source_effect_id: doneEffect.effectId, checkpoint: 'done', reason: 'complete', evidence: ['receipt'], conversation_id: doneConversationId, task_id: 'task-done', supervisor_state: 'done', active_scope: 'goal:task-done' })}\n${SUPERVISOR_BLOCK_END}`;
+  assert.equal((await control.browserObserveAssistant({ conversationId: doneConversationId, conversationUrl: doneConversationUrl, responseText: doneResponse })).terminal, true);
+  assert.equal(control.browserTasks().some((task) => task.taskId === 'task-done'), false);
+
+  const decoder = new NativeMessageDecoder(); const framed = encodeNativeMessage({ id: 'a', method: 'health', params: {} });
+  assert.deepEqual(decoder.push(framed.subarray(0, 3)), []); assert.deepEqual(decoder.push(framed.subarray(3)), [{ id: 'a', method: 'health', params: {} }]);
+  const manifest = JSON.parse(renderWorkflowSupervisorNativeManifest({ executablePath: '/tmp/forge-workflow-supervisor-host', extensionId: 'a'.repeat(32) }));
+  assert.equal(manifest.allowed_origins[0], `chrome-extension://${'a'.repeat(32)}/`);
+
+  const discovery = new WorkflowSupervisorEphemeralDiscovery();
+  const discovered = discovery.update([
+    { conversation_id: conversationId, canonical_url: conversationUrl, title: ' Avela development ' },
+    { conversation_id: conversationId, canonical_url: conversationUrl, title: 'duplicate tab' },
+    { conversation_id: doneConversationId, canonical_url: doneConversationUrl },
+  ]);
+  assert.equal(discovered.conversations.length, 2);
+  assert.deepEqual(discovered.conversations[0], { conversationId, canonicalUrl: conversationUrl, title: 'Avela development' });
+  assert.equal(discovery.get().conversations[1]?.canonicalUrl, doneConversationUrl);
+  assert.equal(control.browserTasks().length, 1);
+  assert.equal(ALLOWED_BROWSER_METHODS.has('browser_discovery'), true);
+  assert.equal(ALLOWED_BROWSER_METHODS.has('browser_discovery_update'), true);
+  assert.equal(ALLOWED_BROWSER_METHODS.has('computer_extension_claim'), true);
+  assert.equal(ALLOWED_BROWSER_METHODS.has('browser_poll'), false);
+  assert.equal(ALLOWED_BROWSER_METHODS.has('browser_begin_effect'), false);
+  assert.throws(() => discovery.update([{ conversation_id: conversationId, canonical_url: 'https://example.com/c/not-chatgpt' }]), /CHATGPT_URL_INVALID/);
+
+  const coreSource = readFileSync(resolve('adapters/computer/chrome-extension/core.js'), 'utf8');
+  new Function(coreSource)();
+  const browserCore = (globalThis as unknown as { ForgeComputerChatgptCore: { parseConversation(value: string): { conversationId: string; canonicalUrl: string } | null } }).ForgeComputerChatgptCore;
+  assert.equal(browserCore.parseConversation(conversationUrl)?.conversationId, conversationId);
+  assert.equal(browserCore.parseConversation(`https://example.com/c/${conversationId}`), null);
+  const extensionManifest = JSON.parse(readFileSync(resolve('adapters/computer/chrome-extension/manifest.json'), 'utf8')) as { permissions?: string[] };
+  assert.equal(extensionManifest.permissions?.includes('storage'), true);
+  const backgroundSource = readFileSync(resolve('adapters/computer/chrome-extension/background.js'), 'utf8');
+  assert.ok(backgroundSource.includes("chrome.storage.local.get('forgeComputerProviderInstanceId')"));
+  assert.ok(backgroundSource.includes('const instanceId = await providerInstanceId();'));
+  assert.ok(backgroundSource.includes('source: `chrome-extension:${instanceId}`'));
+  assert.equal(backgroundSource.includes('PROVIDER_INSTANCE_ID'), false);
+  assert.ok(backgroundSource.includes('chrome.storage.local.set({ forgeComputerProviderInstanceId: instanceId })'));
+  assert.ok(backgroundSource.includes("nativeRpc('computer_extension_heartbeat'"));
+  assert.ok(backgroundSource.includes('providerInstanceId: instanceId'));
+  assert.ok(backgroundSource.includes("nativeRpc('computer_extension_claim', { provider_instance_id: instanceId })"));
+  assert.ok(backgroundSource.includes("nativeRpc('computer_extension_complete', { provider_instance_id: instanceId"));
+  assert.ok(backgroundSource.includes('chrome.runtime.connectNative'));
+  assert.ok(backgroundSource.includes('chrome.tabs.create({ url, active: false }'));
+  for (const forbidden of ['browser_begin_effect', 'browser_observe_effect', 'browser_poll', 'browser_tasks', 'browser_observe_assistant', 'task_register', 'reserve_enrollment']) assert.equal(backgroundSource.includes(forbidden), false);
+  const contentSource = readFileSync(resolve('adapters/computer/chrome-extension/content.js'), 'utf8');
+  assert.ok(contentSource.includes('forge-computer-chatgpt-snapshot'));
+  assert.ok(contentSource.includes('forge-computer-chatgpt-dispatch'));
+  assert.ok(contentSource.includes('new MutationObserver(notify).observe'));
+  console.log('[workflow-supervisor-chrome-smoke] OK');
+} finally { rmSync(home, { recursive: true, force: true }); }

package/scripts/smoke-workflow-supervisor-process-restart.ts

@@ -0,0 +1,276 @@
+#!/usr/bin/env bun
+import { strict as assert } from 'node:assert';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { WorkflowSupervisorControlPlane } from '../supervisor/control-plane';
+import { SUPERVISOR_BLOCK_END, SUPERVISOR_BLOCK_START } from '../supervisor/protocol';
+import { WORKFLOW_SUPERVISOR_MIN_TURN_INTERVAL_MS, WorkflowSupervisorStore } from '../supervisor/store';
+
+const TASK_ID = 'process-restart-proof-task';
+const CONVERSATION_ID = '11111111-aaaa-bbbb-cccc-222222222222';
+const CONVERSATION_URL = `https://chatgpt.com/c/${CONVERSATION_ID}`;
+const BASELINE_USER = 'before-process-restart-proof';
+const BASELINE_ASSISTANT = 'stable-assistant-baseline';
+
+function arg(name: string): string | undefined {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+const mechanicalNowMs = Number(arg('--now-ms') ?? Date.now());
+const TURN_ADVANCE_MS = WORKFLOW_SUPERVISOR_MIN_TURN_INTERVAL_MS + 1_000;
+
+function control(home: string): WorkflowSupervisorControlPlane {
+  return new WorkflowSupervisorControlPlane(new WorkflowSupervisorStore(home, { now: () => mechanicalNowMs }), {
+    completionContract: async () => ({ valid: true, reason: 'ok' }),
+    userBlockerPolicy: async () => ({ valid: true, reason: 'ok' }),
+  });
+}
+
+function sourceBaseline(home: string, effectId: string, checkpoint: string): { latest_user_text: string; latest_assistant_response: string } {
+  const store = new WorkflowSupervisorStore(home, { now: () => mechanicalNowMs });
+  const effect = store.getEffect(effectId);
+  assert.ok(effect?.sourceCompletionFingerprint, `effect ${effectId} must have source completion`);
+  const completion = store.getCompletion(effect.sourceCompletionFingerprint);
+  assert.ok(completion, `completion ${effect.sourceCompletionFingerprint} must exist`);
+  const sourceEffect = store.getEffect(completion.sourceEffectId);
+  assert.ok(sourceEffect, `source effect ${completion.sourceEffectId} must exist`);
+  return {
+    latest_user_text: sourceEffect.prompt,
+    latest_assistant_response: block('CONTINUE', sourceEffect.effectId, checkpoint),
+  };
+}
+
+function block(action: 'CONTINUE' | 'DONE', effectId: string, checkpoint: string): string {
+  return `${SUPERVISOR_BLOCK_START}\n${JSON.stringify({
+    action,
+    source_effect_id: effectId,
+    checkpoint,
+    reason: action === 'DONE' ? 'complete' : 'continue',
+    evidence: ['process-restart-smoke'],
+    conversation_id: CONVERSATION_ID,
+    task_id: TASK_ID,
+    supervisor_state: action === 'DONE' ? 'done' : 'running',
+    active_scope: `goal:${TASK_ID}`,
+  })}\n${SUPERVISOR_BLOCK_END}`;
+}
+
+async function runPhase(home: string, phase: string): Promise<void> {
+  const supervisor = control(home);
+
+  if (phase === 'arm-enrollment') {
+    supervisor.registerTask({
+      taskId: TASK_ID,
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      objective: 'Prove autonomous continuation survives real process restart.',
+      completionContract: {},
+      continuationPolicy: {},
+      userBlockerPolicy: {},
+    });
+    const enrollment = supervisor.reserveEnrollment(TASK_ID);
+    const poll = supervisor.browserPoll({ conversationId: CONVERSATION_ID, conversationUrl: CONVERSATION_URL });
+    assert.equal(poll.command?.effectId, enrollment.effectId);
+    assert.equal(poll.command?.mode, 'send');
+    assert.equal(poll.command?.dispatchGeneration, 1);
+    assert.equal(supervisor.browserBeginEffect({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      effectId: enrollment.effectId,
+      dispatchId: 'enrollment-g1',
+      dispatchGeneration: 1,
+      evidence: { latest_user_text: BASELINE_USER, latest_assistant_response: BASELINE_ASSISTANT },
+    }).started, true);
+    return;
+  }
+
+  if (phase === 'observe-ambiguous-enrollment') {
+    let poll = supervisor.browserPoll({ conversationId: CONVERSATION_ID, conversationUrl: CONVERSATION_URL });
+    assert.equal(poll.command?.mode, 'reconcile');
+    assert.equal(poll.command?.dispatchGeneration, 1);
+    const effectId = poll.command!.effectId;
+    supervisor.browserObserveEffect({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      effectId,
+      observationId: 'enrollment-g1-stale-negative-observation',
+      outcome: 'not_applied',
+      evidence: {
+        latest_user_text: BASELINE_USER,
+        latest_assistant_response: BASELINE_ASSISTANT,
+        target_marker_present: false,
+        provider_surface_rendered: true,
+        reason: 'composer_proven_empty',
+      },
+    });
+    poll = supervisor.browserPoll({ conversationId: CONVERSATION_ID, conversationUrl: CONVERSATION_URL });
+    assert.equal(poll.command?.effectId, effectId);
+    // A rendered empty composer can be a stale provider view. Across restart,
+    // this observation must retain the original effect/generation, never resend.
+    assert.equal(poll.command?.mode, 'reconcile');
+    assert.equal(poll.command?.dispatchGeneration, 1);
+    assert.equal(supervisor.store.effectDispatchBudget(effectId).generations, 1);
+    assert.equal(supervisor.browserBeginEffect({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      effectId,
+      dispatchId: 'stale-enrollment-resend',
+      dispatchGeneration: 1,
+      evidence: { latest_user_text: BASELINE_USER, latest_assistant_response: BASELINE_ASSISTANT },
+    }).started, false);
+    supervisor.browserObserveEffect({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      effectId,
+      observationId: 'enrollment-g1-unknown',
+      outcome: 'unknown',
+      evidence: { send_boundary_crossed: true },
+    });
+    return;
+  }
+
+  if (phase === 'reconcile-unknown-and-continue-1') {
+    const poll = supervisor.browserPoll({ conversationId: CONVERSATION_ID, conversationUrl: CONVERSATION_URL });
+    assert.equal(poll.command?.mode, 'reconcile');
+    assert.equal(poll.command?.dispatchGeneration, 1);
+    const effectId = poll.command!.effectId;
+    supervisor.browserObserveEffect({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      effectId,
+      observationId: 'enrollment-g1-applied-after-restart',
+      outcome: 'applied',
+      evidence: { exact_user_message: true },
+    });
+    const advanced = await supervisor.browserObserveAssistant({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      responseText: block('CONTINUE', effectId, 'round-1'),
+    });
+    assert.equal(advanced.terminal, false);
+    assert.ok(advanced.successorEffect);
+    return;
+  }
+
+  if (phase === 'continue-2') {
+    const poll = supervisor.browserPoll({ conversationId: CONVERSATION_ID, conversationUrl: CONVERSATION_URL });
+    assert.equal(poll.command?.mode, 'send');
+    assert.equal(poll.command?.dispatchGeneration, 1);
+    const effectId = poll.command!.effectId;
+    assert.equal(supervisor.browserBeginEffect({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      effectId,
+      dispatchId: 'round-2-g1',
+      dispatchGeneration: 1,
+      evidence: sourceBaseline(home, effectId, 'round-1'),
+    }).started, true);
+    supervisor.browserObserveEffect({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      effectId,
+      observationId: 'round-2-applied',
+      outcome: 'applied',
+      evidence: { exact_user_message: true },
+    });
+    const advanced = await supervisor.browserObserveAssistant({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      responseText: block('CONTINUE', effectId, 'round-2'),
+    });
+    assert.equal(advanced.terminal, false);
+    assert.ok(advanced.successorEffect);
+    return;
+  }
+
+  if (phase === 'done-3') {
+    const poll = supervisor.browserPoll({ conversationId: CONVERSATION_ID, conversationUrl: CONVERSATION_URL });
+    assert.equal(poll.command?.mode, 'send');
+    assert.equal(poll.command?.dispatchGeneration, 1);
+    const effectId = poll.command!.effectId;
+    assert.equal(supervisor.browserBeginEffect({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      effectId,
+      dispatchId: 'round-3-g1',
+      dispatchGeneration: 1,
+      evidence: sourceBaseline(home, effectId, 'round-2'),
+    }).started, true);
+    supervisor.browserObserveEffect({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      effectId,
+      observationId: 'round-3-applied',
+      outcome: 'applied',
+      evidence: { exact_user_message: true },
+    });
+    const done = await supervisor.browserObserveAssistant({
+      conversationId: CONVERSATION_ID,
+      conversationUrl: CONVERSATION_URL,
+      responseText: block('DONE', effectId, 'round-3'),
+    });
+    assert.equal(done.terminal, true);
+    assert.equal(done.successorEffect, undefined);
+    return;
+  }
+
+  if (phase === 'quiescent') {
+    assert.equal(supervisor.browserTasks().length, 0);
+    const poll = supervisor.browserPoll({ conversationId: CONVERSATION_ID, conversationUrl: CONVERSATION_URL });
+    assert.equal(poll.terminal, 'DONE');
+    assert.equal(poll.command, undefined);
+    return;
+  }
+
+  throw new Error(`UNKNOWN_PHASE:${phase}`);
+}
+
+async function main(): Promise<void> {
+  const phase = arg('--phase');
+  const homeArg = arg('--home');
+  if (phase) {
+    if (!homeArg) throw new Error('--home is required with --phase');
+    await runPhase(homeArg, phase);
+    return;
+  }
+
+  const home = mkdtempSync(join(tmpdir(), 'forge-supervisor-process-restart-'));
+  const script = fileURLToPath(import.meta.url);
+  const baseNowMs = Date.now();
+  try {
+    for (const [index, nextPhase] of [
+      'arm-enrollment',
+      'observe-ambiguous-enrollment',
+      'reconcile-unknown-and-continue-1',
+      'continue-2',
+      'done-3',
+      'quiescent',
+    ].entries()) {
+      // A successor send is intentionally throttled from the receipt that
+      // authorized it. Advance the deterministic clock by that contract
+      // interval so this restart smoke verifies recovery, not a rate-limit
+      // rejection.
+      const child = spawnSync(process.execPath, [script, '--phase', nextPhase, '--home', home, '--now-ms', String(baseNowMs + index * TURN_ADVANCE_MS)], {
+        cwd: process.cwd(),
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      assert.equal(
+        child.status,
+        0,
+        `phase ${nextPhase} failed\nstdout:\n${child.stdout ?? ''}\nstderr:\n${child.stderr ?? ''}`,
+      );
+    }
+    console.log('[workflow-supervisor-process-restart-smoke] OK');
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+  process.exitCode = 1;
+});