@moretea-labs/forge 1.8.0 → 1.8.1

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;
+});

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

@@ -0,0 +1,150 @@
+import { strict as assert } from 'node:assert';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } 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';
+
+const home = mkdtempSync(join(tmpdir(), 'forge-supervisor-recovery-'));
+let mechanicalNowMs = Date.now();
+const TURN_ADVANCE_MS = WORKFLOW_SUPERVISOR_MIN_TURN_INTERVAL_MS + 1_000;
+const validators = { completionContract: async () => ({ valid: true, reason: 'ok' }), userBlockerPolicy: async () => ({ valid: true, reason: 'ok' }) };
+const control = () => new WorkflowSupervisorControlPlane(new WorkflowSupervisorStore(home, { now: () => mechanicalNowMs }), validators);
+const block = (
+  action: 'CONTINUE' | 'DONE',
+  effectId: string,
+  checkpoint: string,
+  conversationId: string,
+  taskId: string,
+) => `${SUPERVISOR_BLOCK_START}\n${JSON.stringify({
+  action,
+  source_effect_id: effectId,
+  checkpoint,
+  reason: action === 'DONE' ? 'complete' : 'continue',
+  evidence: ['recovery-smoke'],
+  conversation_id: conversationId,
+  task_id: taskId,
+  supervisor_state: action === 'DONE' ? 'done' : 'running',
+  active_scope: `goal:${taskId}`,
+})}\n${SUPERVISOR_BLOCK_END}`;
+
+try {
+  let supervisor = control();
+  const conversationId = '99999999-8888-7777-6666-555555555555';
+  const conversationUrl = `https://chatgpt.com/c/${conversationId}`;
+  supervisor.registerTask({ taskId: 'recovery-task', conversationId, conversationUrl, objective: 'Prove restart recovery.', completionContract: {}, continuationPolicy: {}, userBlockerPolicy: {} });
+  const enrollment = supervisor.reserveEnrollment('recovery-task');
+  let poll = supervisor.browserPoll({ conversationId, conversationUrl });
+  assert.equal(poll.command?.mode, 'send'); assert.equal(poll.command?.dispatchGeneration, 1);
+  assert.equal(supervisor.browserBeginEffect({ conversationId, conversationUrl, effectId: enrollment.effectId, dispatchId: 'enroll-g1', dispatchGeneration: 1, evidence: { latest_user_text: 'before enrollment', latest_assistant_response: 'existing assistant text' } }).started, true);
+
+  supervisor = control();
+  assert.throws(() => supervisor.observeEffect({ effectId: enrollment.effectId, observationId: 'forged-not-applied', outcome: 'not_applied', evidence: { latest_user_text: 'forged' } }), /NOT_APPLIED_PROOF_REQUIRED/);
+  poll = supervisor.browserPoll({ conversationId, conversationUrl });
+  assert.equal(poll.command?.mode, 'reconcile'); assert.equal(poll.command?.dispatchGeneration, 1);
+  supervisor.browserObserveEffect({ conversationId, conversationUrl, effectId: enrollment.effectId, observationId: 'enroll-not-applied', outcome: 'not_applied', evidence: { latest_user_text: 'before enrollment', latest_assistant_response: 'existing assistant text', target_marker_present: false, provider_surface_rendered: true, reason: 'composer_proven_empty' } });
+  mechanicalNowMs += 30_000;
+  poll = supervisor.browserPoll({ conversationId, conversationUrl });
+  assert.equal(poll.command?.mode, 'reconcile'); assert.equal(poll.command?.dispatchGeneration, 1); assert.equal(poll.command?.effectId, enrollment.effectId);
+  assert.equal(supervisor.store.effectDispatchBudget(enrollment.effectId).generations, 1);
+  supervisor.browserObserveEffect({ conversationId, conversationUrl, effectId: enrollment.effectId, observationId: 'enroll-applied', outcome: 'applied', evidence: { exact_user_message: true } });
+  const response1 = block('CONTINUE', enrollment.effectId, 'checkpoint-1', conversationId, 'recovery-task');
+  const turn1 = await supervisor.browserObserveAssistant({ conversationId, conversationUrl, responseText: response1 });
+  const continuation = turn1.successorEffect!;
+
+  mechanicalNowMs += TURN_ADVANCE_MS;
+  poll = supervisor.browserPoll({ conversationId, conversationUrl });
+  assert.equal(poll.command?.effectId, continuation.effectId); assert.equal(poll.command?.dispatchGeneration, 1);
+  assert.equal(supervisor.browserBeginEffect({ conversationId, conversationUrl, effectId: continuation.effectId, dispatchId: 'continue-g1', dispatchGeneration: 1, evidence: { latest_user_text: enrollment.prompt, latest_assistant_response: response1 } }).started, true);
+  supervisor = control();
+  poll = supervisor.browserPoll({ conversationId, conversationUrl }); assert.equal(poll.command?.mode, 'reconcile');
+  supervisor.browserObserveEffect({ conversationId, conversationUrl, effectId: continuation.effectId, observationId: 'bad-proof', outcome: 'not_applied', evidence: { latest_user_text: 'conversation drifted', latest_assistant_response: response1, target_marker_present: false, provider_surface_rendered: true, reason: 'composer_proven_empty' } });
+  poll = supervisor.browserPoll({ conversationId, conversationUrl }); assert.equal(poll.command?.mode, 'reconcile'); assert.equal(poll.command?.dispatchGeneration, 1);
+  // Even the exact pre-send baseline on a rendered page can be stale. A
+  // reopened observer cannot turn provider outcome uncertainty into a resend.
+  supervisor.browserObserveEffect({ conversationId, conversationUrl, effectId: continuation.effectId, observationId: 'stale-baseline-observation', outcome: 'not_applied', evidence: { latest_user_text: enrollment.prompt, latest_assistant_response: response1, target_marker_present: false, provider_surface_rendered: true, reason: 'composer_proven_empty' } });
+  mechanicalNowMs += 30_000;
+  poll = supervisor.browserPoll({ conversationId, conversationUrl }); assert.equal(poll.command?.mode, 'reconcile'); assert.equal(poll.command?.dispatchGeneration, 1); assert.equal(poll.command?.effectId, continuation.effectId);
+  assert.equal(supervisor.browserBeginEffect({ conversationId, conversationUrl, effectId: continuation.effectId, dispatchId: 'continue-g1-duplicate', dispatchGeneration: 1, evidence: { latest_user_text: enrollment.prompt, latest_assistant_response: response1 } }).started, false);
+  assert.equal(supervisor.store.effectDispatchBudget(continuation.effectId).generations, 1);
+  supervisor.browserObserveEffect({ conversationId, conversationUrl, effectId: continuation.effectId, observationId: 'continue-applied', outcome: 'applied', evidence: { exact_user_message: true } });
+
+  const response2 = block('CONTINUE', continuation.effectId, 'checkpoint-2', conversationId, 'recovery-task');
+  const turn2a = await supervisor.browserObserveAssistant({ conversationId, conversationUrl, responseText: response2 });
+  const turn2b = await supervisor.browserObserveAssistant({ conversationId, conversationUrl, responseText: response2 });
+  assert.equal(turn2a.successorEffect?.effectId, turn2b.successorEffect?.effectId); assert.equal(turn2b.deduplicated, true);
+  const terminalEffect = turn2a.successorEffect!;
+  mechanicalNowMs += TURN_ADVANCE_MS;
+  poll = supervisor.browserPoll({ conversationId, conversationUrl });
+  assert.equal(supervisor.browserBeginEffect({ conversationId, conversationUrl, effectId: terminalEffect.effectId, dispatchId: 'terminal-g1', dispatchGeneration: poll.command!.dispatchGeneration, evidence: { latest_user_text: continuation.prompt, latest_assistant_response: response2 } }).started, true);
+  supervisor.browserObserveEffect({ conversationId, conversationUrl, effectId: terminalEffect.effectId, observationId: 'terminal-applied', outcome: 'applied', evidence: { exact_user_message: true } });
+  const done = await supervisor.browserObserveAssistant({ conversationId, conversationUrl, responseText: block('DONE', terminalEffect.effectId, 'done', conversationId, 'recovery-task') });
+  assert.equal(done.terminal, true);
+  supervisor = control();
+  assert.equal(supervisor.browserTasks().length, 0);
+  const terminalPoll = supervisor.browserPoll({ conversationId, conversationUrl });
+  assert.equal(terminalPoll.terminal, 'DONE'); assert.equal(terminalPoll.command, undefined);
+
+  // Prove the unattended contract across repeated supervisor process/repository
+  // re-openings. Every round reconstructs the control plane from durable state,
+  // applies exactly one effect, emits CONTINUE, and must publish exactly one
+  // successor effect without a user-authored "continue" turn.
+  const unattendedTaskId = 'unattended-ten-round-task';
+  const unattendedConversationId = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee';
+  const unattendedConversationUrl = `https://chatgpt.com/c/${unattendedConversationId}`;
+  supervisor.registerTask({
+    taskId: unattendedTaskId,
+    conversationId: unattendedConversationId,
+    conversationUrl: unattendedConversationUrl,
+    objective: 'Complete ten autonomous continuation rounds across supervisor restart.',
+    completionContract: {}, continuationPolicy: {}, userBlockerPolicy: {},
+  });
+  let effect = supervisor.reserveEnrollment(unattendedTaskId);
+  const observedEffectIds = new Set<string>();
+  for (let round = 1; round <= 10; round += 1) {
+    supervisor = control();
+    assert.equal(observedEffectIds.has(effect.effectId), false);
+    observedEffectIds.add(effect.effectId);
+    supervisor.observeEffect({
+      effectId: effect.effectId,
+      observationId: `unattended-applied-${round}`,
+      outcome: 'applied',
+      evidence: { exact_user_message: true },
+    });
+    const responseText = block('CONTINUE', effect.effectId, `unattended-checkpoint-${round}`, unattendedConversationId, unattendedTaskId);
+    const advanced = await supervisor.observeAssistantTurn({
+      taskId: unattendedTaskId,
+      conversationId: unattendedConversationId,
+      responseText,
+    });
+    assert.equal(advanced.terminal, false);
+    assert.ok(advanced.successorEffect);
+    const replay = await supervisor.observeAssistantTurn({
+      taskId: unattendedTaskId,
+      conversationId: unattendedConversationId,
+      responseText,
+    });
+    assert.equal(replay.deduplicated, true);
+    assert.equal(replay.successorEffect?.effectId, advanced.successorEffect.effectId);
+    effect = advanced.successorEffect;
+  }
+  assert.equal(observedEffectIds.size, 10);
+  supervisor = control();
+  supervisor.observeEffect({
+    effectId: effect.effectId,
+    observationId: 'unattended-terminal-applied',
+    outcome: 'applied',
+    evidence: { exact_user_message: true },
+  });
+  const unattendedDone = await supervisor.observeAssistantTurn({
+    taskId: unattendedTaskId,
+    conversationId: unattendedConversationId,
+    responseText: block('DONE', effect.effectId, 'unattended-done', unattendedConversationId, unattendedTaskId),
+  });
+  assert.equal(unattendedDone.terminal, true);
+  supervisor = control();
+  assert.equal(supervisor.browserPoll({ conversationId: unattendedConversationId, conversationUrl: unattendedConversationUrl }).terminal, 'DONE');
+
+  console.log('[workflow-supervisor-restart-recovery-smoke] OK');
+} finally { rmSync(home, { recursive: true, force: true }); }

package/scripts/smoke-workflow-supervisor.ts

@@ -0,0 +1,103 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { strict as assert } from 'node:assert';
+import { createConnection } from 'node:net';
+import { createRequirement, updateRequirement } from '../src/runtime/control-plane/persistence/requirement-store';
+import {
+  registerWorkflowSupervisorTask,
+  reserveWorkflowSupervisorEnrollment,
+} from '../supervisor/client';
+import { WorkflowSupervisorControlPlane } from '../supervisor/control-plane';
+import { forgeWorkflowSupervisorValidators } from '../supervisor/forge-validators';
+import { workflowSupervisorSocketPath } from '../supervisor/paths';
+import { renderSupervisorReceipt } from '../supervisor/protocol';
+import { WorkflowSupervisorStore, workflowSupervisorDatabasePath } from '../supervisor/store';
+import { createWorkflowSupervisorServer } from '../supervisor/server';
+
+const home = mkdtempSync(join(tmpdir(), 'forge-workflow-supervisor-'));
+try {
+  assert.equal(workflowSupervisorDatabasePath(home), join(home, 'supervisor', 'supervisor.sqlite'));
+  let allowDone = false;
+  const control = new WorkflowSupervisorControlPlane(new WorkflowSupervisorStore(home), {
+    completionContract: async () => ({ valid: allowDone, reason: allowDone ? 'verified' : 'missing_goal_evidence' }),
+    userBlockerPolicy: async () => ({ valid: false, reason: 'not_user_only' }),
+  });
+  const taskInput = { taskId: 'task-smoke', conversationId: 'conv-smoke', conversationUrl: 'https://chatgpt.com/c/conv-smoke', objective: 'finish smoke goal', completionContract: {}, continuationPolicy: { active_scope: 'goal:task-smoke' }, userBlockerPolicy: {} };
+  control.registerTask(taskInput);
+  assert.throws(() => control.registerTask({ ...taskInput, completionContract: { changed: true } }), /WORKFLOW_SUPERVISOR_TASK_ID_CONFLICT/);
+  const enrollment = control.reserveEnrollment('task-smoke');
+  assert.match(enrollment.prompt, new RegExp(enrollment.effectId));
+  control.observeEffect({ effectId: enrollment.effectId, observationId: 'obs-1', outcome: 'applied' });
+  const response = (effect: string, action: 'CONTINUE'|'DONE') => renderSupervisorReceipt(taskInput, effect, action);
+  const first = await control.observeAssistantTurn({ taskId: 'task-smoke', conversationId: 'conv-smoke', responseText: response(enrollment.effectId, 'CONTINUE') });
+  assert(first.successorEffect); assert.equal(first.terminal, false);
+  const duplicate = await control.observeAssistantTurn({ taskId: 'task-smoke', conversationId: 'conv-smoke', responseText: response(enrollment.effectId, 'CONTINUE') });
+  assert.equal(duplicate.successorEffect?.effectId, first.successorEffect.effectId); assert.equal(duplicate.deduplicated, true);
+  assert.throws(() => control.registerTask({ taskId: 'task-smoke', conversationId: 'conv-smoke', conversationUrl: 'https://chatgpt.com/c/conv-smoke', objective: 'changed objective', completionContract: {}, continuationPolicy: {}, userBlockerPolicy: {} }), /WORKFLOW_SUPERVISOR_TASK_ID_CONFLICT/);
+  control.observeEffect({ effectId: first.successorEffect.effectId, observationId: 'obs-2', outcome: 'applied' });
+  const rejected = await control.observeAssistantTurn({ taskId: 'task-smoke', conversationId: 'conv-smoke', responseText: response(first.successorEffect.effectId, 'DONE') });
+  assert.equal(rejected.terminal, false); assert.equal(rejected.validation?.valid, false); assert(rejected.successorEffect);
+  control.observeEffect({ effectId: rejected.successorEffect.effectId, observationId: 'obs-3', outcome: 'applied' });
+  allowDone = true;
+  const done = await control.observeAssistantTurn({ taskId: 'task-smoke', conversationId: 'conv-smoke', responseText: response(rejected.successorEffect.effectId, 'DONE') });
+  assert.equal(done.terminal, true); assert.equal(done.successorEffect, undefined);
+
+  const socketPath = workflowSupervisorSocketPath(home);
+  const server = createWorkflowSupervisorServer({ controlPlane: control, socketPath });
+  await new Promise<void>((resolve) => server.once('listening', resolve));
+  const health = await new Promise<Record<string, any>>((resolve, reject) => {
+    const socket = createConnection(socketPath);
+    let buffer = '';
+    socket.once('error', reject);
+    socket.on('data', (chunk) => {
+      buffer += chunk.toString('utf8');
+      const newline = buffer.indexOf('\n');
+      if (newline < 0) return;
+      socket.end();
+      resolve(JSON.parse(buffer.slice(0, newline)) as Record<string, any>);
+    });
+    socket.once('connect', () => socket.write(`${JSON.stringify({ id: 'health-1', method: 'health', params: {} })}\n`));
+  });
+  assert.equal(health.ok, true); assert.equal(health.result.status, 'ready');
+
+  const rpcTaskInput = {
+    taskId: 'task-rpc-smoke', conversationId: 'conv-rpc-smoke', conversationUrl: 'https://chatgpt.com/c/conv-rpc-smoke', objective: 'rpc enrollment smoke',
+    completionContract: { kind: 'smoke' }, continuationPolicy: { kind: 'smoke' }, userBlockerPolicy: { kind: 'smoke' },
+  };
+  const rpcTask = await registerWorkflowSupervisorTask(home, rpcTaskInput);
+  assert.equal(rpcTask.taskId, rpcTaskInput.taskId);
+  const rpcEnrollment = await reserveWorkflowSupervisorEnrollment(home, rpcTask.taskId);
+  const rpcEnrollmentReplay = await reserveWorkflowSupervisorEnrollment(home, rpcTask.taskId);
+  assert.equal(rpcEnrollmentReplay.effectId, rpcEnrollment.effectId);
+
+  const controllerHome = join(home, 'controller');
+  const validators = forgeWorkflowSupervisorValidators();
+  createRequirement({ controllerHome }, { requirementId: 'REQ-SUPERVISOR-DONE', title: 'Supervisor done validator', outcomeStatement: 'Validate canonical semantic completion.' });
+  updateRequirement({ controllerHome }, { requirementId: 'REQ-SUPERVISOR-DONE', action: 'smoke_activate', mutate: (current) => ({ ...current, state: 'active' }) });
+  const doneTask = {
+    ...rpcTaskInput,
+    taskId: 'task-validator-done',
+    completionContract: { kind: 'forge_requirement_done', controller_home: controllerHome, requirement_id: 'REQ-SUPERVISOR-DONE' },
+    userBlockerPolicy: { kind: 'forge_requirement_waiting_for_user', controller_home: controllerHome, requirement_id: 'REQ-SUPERVISOR-DONE' },
+    createdAt: new Date().toISOString(),
+  };
+  assert.equal((await validators.completionContract(doneTask, { action: 'DONE', sourceEffectId: 'fx_smokevalidator', checkpoint: 'done', reason: 'done', evidence: [] })).valid, false);
+  updateRequirement({ controllerHome }, {
+    requirementId: 'REQ-SUPERVISOR-DONE', action: 'smoke_semantic_acceptance',
+    mutate: (current) => ({ ...current, state: 'done', semanticAcceptance: { reviewer: 'smoke', rationale: 'validated', planIds: [], acceptedAt: new Date().toISOString() } }),
+  });
+  assert.equal((await validators.completionContract(doneTask, { action: 'DONE', sourceEffectId: 'fx_smokevalidator', checkpoint: 'done', reason: 'done', evidence: [] })).valid, true);
+
+  createRequirement({ controllerHome }, { requirementId: 'REQ-SUPERVISOR-USER', title: 'Supervisor user validator', outcomeStatement: 'Validate genuine user-only wait.' });
+  updateRequirement({ controllerHome }, { requirementId: 'REQ-SUPERVISOR-USER', action: 'smoke_activate', mutate: (current) => ({ ...current, state: 'active' }) });
+  updateRequirement({ controllerHome }, {
+    requirementId: 'REQ-SUPERVISOR-USER', action: 'smoke_user_wait',
+    mutate: (current) => ({ ...current, state: 'waiting_for_user', needsAttention: true, attentionSummary: 'User authorization is required.' }),
+  });
+  const userTask = { ...doneTask, taskId: 'task-validator-user', completionContract: { kind: 'forge_requirement_done', controller_home: controllerHome, requirement_id: 'REQ-SUPERVISOR-USER' }, userBlockerPolicy: { kind: 'forge_requirement_waiting_for_user', controller_home: controllerHome, requirement_id: 'REQ-SUPERVISOR-USER' } };
+  assert.equal((await validators.userBlockerPolicy(userTask, { action: 'NEEDS_USER', sourceEffectId: 'fx_smokevalidator', checkpoint: 'user', reason: 'user action', evidence: [] })).valid, true);
+
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  console.log('[workflow-supervisor-smoke] OK');
+} finally { rmSync(home, { recursive: true, force: true }); }

package/scripts/verify-forge-runtime.sh

@@ -11,11 +11,12 @@ command -v bun >/dev/null 2>&1 || {
 
 TEST_FILES=(
   "tests/runtime/facade-contracts.test.ts"
-  "tests/runtime/route-policy.test.ts"
   "tests/runtime/forge-runtime-service.test.ts"
   "tests/cli/local-bridge.test.ts"
   "tests/runtime/thin-harness-gateway-routing.test.ts"
   "tests/runtime/runtime-observability.test.ts"
+  "tests/runtime/release-session.test.ts"
+  "tests/runtime/local-recovery-plugin.test.ts"
   "tests/unit/test-governance.test.ts"
 )