@moretea-labs/forge 1.8.0 → 1.8.1

package/scripts/smoke-unattended-transport-recovery.ts

@@ -0,0 +1,223 @@
+import { strict as assert } from 'node:assert';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { createMcpHttpSessionRegistry } from '../adapters/mcp/transports/http';
+import { authenticatedFacadeControllerIdentity } from '../adapters/mcp/runtime-gateway/controller-authority-adapter';
+import { readExecutionSession, startExecutionSession } from '../src/runtime/control-plane/execution/session-store';
+import {
+  bindControllerSessionBinding,
+  claimControllerSession,
+  getControllerRoundRelay,
+  releaseControllerSession,
+  type ControllerHost,
+} from '../packages/kernel/controller/api/index';
+import { createWorkContract } from '../packages/kernel/work/api/index';
+import { upsertProcessControllerBinding } from '../adapters/controller-process/binding-store';
+import { runSchedulerAutonomousContinuationReconciliation } from '../src/runtime/control-plane/global-scheduler/autonomous-continuation';
+import { WorkflowSupervisorControlPlane } from '../supervisor/control-plane';
+import { SUPERVISOR_BLOCK_END, SUPERVISOR_BLOCK_START } from '../supervisor/protocol';
+import { WorkflowSupervisorStore } from '../supervisor/store';
+
+const root = mkdtempSync(join(tmpdir(), 'forge-unattended-transport-recovery-'));
+const controllerHome = join(root, 'controller');
+const repoId = 'repo-unattended-recovery';
+const workId = 'work-unattended-recovery';
+const oldTransportSessionId = 'mcp-transport-old';
+const newTransportSessionId = 'mcp-transport-new';
+const principalId = 'chatgpt-controller';
+
+const validators = {
+  completionContract: async () => ({ valid: true, reason: 'ok' }),
+  userBlockerPolicy: async () => ({ valid: true, reason: 'ok' }),
+};
+const supervisor = () => new WorkflowSupervisorControlPlane(new WorkflowSupervisorStore(controllerHome), validators);
+
+function block(action: 'CONTINUE' | 'DONE', effectId: string, checkpoint: string, conversationId: string, taskId: string): string {
+  return `${SUPERVISOR_BLOCK_START}\n${JSON.stringify({
+    action,
+    source_effect_id: effectId,
+    checkpoint,
+    reason: action === 'DONE' ? 'complete' : 'continue',
+    evidence: ['unattended-transport-recovery-smoke'],
+    conversation_id: conversationId,
+    task_id: taskId,
+    supervisor_state: action === 'DONE' ? 'done' : 'running',
+    active_scope: `goal:${taskId}`,
+  })}\n${SUPERVISOR_BLOCK_END}`;
+}
+
+try {
+  // 1) Durable execution is created independently of an MCP stream.
+  startExecutionSession(controllerHome, {
+    sessionId: oldTransportSessionId,
+    principalId,
+    controllerInstanceId: 'runtime-before-restart',
+  });
+
+  let transportCloseCount = 0;
+  const registry = createMcpHttpSessionRegistry<
+    { close(): void },
+    { sessionId: string; controllerHome: string }
+  >();
+  registry.register({
+    sessionId: oldTransportSessionId,
+    transport: { close: () => { transportCloseCount += 1; } },
+    toolContext: { sessionId: oldTransportSessionId, controllerHome },
+    route: '/mcp',
+    principalId,
+    connectionId: 'connection-before-disconnect',
+    clientIdentity: 'chatgpt-client',
+  });
+  await registry.close(oldTransportSessionId, 'transport_close');
+  assert.equal(transportCloseCount, 1);
+
+  // 2) Transport loss must not invalidate execution authority. Reading through a
+  // new runtime instance also exercises restart recovery of the durable session.
+  const recoveredExecution = readExecutionSession(controllerHome, {
+    sessionId: oldTransportSessionId,
+    principalId,
+    controllerInstanceId: 'runtime-after-restart',
+  });
+  assert.ok(recoveredExecution);
+  assert.equal(recoveredExecution.controllerInstanceId, 'runtime-after-restart');
+  assert.equal(recoveredExecution.invalidatedAt, undefined);
+
+  // 3) A newly authenticated transport can explicitly carry the prior session
+  // only on the bounded rollover path. The new transport remains the request
+  // binding; the old session is merely the compatibility authority carrier.
+  const rolloverIdentity = authenticatedFacadeControllerIdentity({
+    principalId,
+    sessionId: newTransportSessionId,
+    controllerInstanceId: 'runtime-after-restart',
+    controllerType: 'chatgpt',
+  } as any, {
+    session_id: oldTransportSessionId,
+  }, { allowTransportSessionRollover: true });
+  assert.equal(rolloverIdentity.sessionId, newTransportSessionId);
+  assert.equal(rolloverIdentity.transportSessionId, newTransportSessionId);
+  assert.equal(rolloverIdentity.controllerAuthorityId, oldTransportSessionId);
+  assert.equal(rolloverIdentity.authorityViaSessionCompatibility, true);
+
+  // 4) Scheduler liveness owns unattended Work wake-up. Repeated reconciliation
+  // of the same durable state must never duplicate provider dispatch.
+  createWorkContract({ controllerHome, repoId }, {
+    workId,
+    repoId,
+    objective: 'Continue without manual user wake-ups.',
+    acceptanceCriteria: ['The Work resumes from durable authority.'],
+    allowedPaths: [],
+    forbiddenPaths: [],
+    checks: [],
+    constraints: {},
+    requestedBy: 'chatgpt',
+    dispatchState: 'running',
+    baseRevision: 'abc123',
+  } as Parameters<typeof createWorkContract>[1]);
+
+  const store = { controllerHome, repoId };
+  const controllerAuthorityId = oldTransportSessionId;
+  const owner = claimControllerSession(store, {
+    workId,
+    controllerId: principalId,
+    // This section proves the generic retained-provider wake path. ChatGPT is
+    // intentionally covered by the Workflow Supervisor section below and must
+    // not silently fall back to direct provider dispatch when its daemon is down.
+    controllerType: 'claude',
+    sessionId: oldTransportSessionId,
+    authorityDigest: createHash('sha256').update(controllerAuthorityId).digest('hex'),
+    principalId,
+    controllerInstanceId: 'runtime-before-restart',
+    leaseMs: 60_000,
+  });
+  const binding = upsertProcessControllerBinding(store, {
+    workId,
+    sessionId: owner.sessionId,
+    controllerType: 'claude',
+    executable: 'claude',
+    launchArgs: [],
+  });
+  bindControllerSessionBinding(store, { workId, sessionId: owner.sessionId, binding: binding.binding });
+  releaseControllerSession(store, workId, owner.controllerId);
+
+  let providerDispatches = 0;
+  const host: ControllerHost = {
+    resume: async () => {
+      providerDispatches += 1;
+      return { accepted: true, dispatchId: `dispatch-${providerDispatches}` };
+    },
+  };
+  const schedulerInput = {
+    controllerHome,
+    nowMs: Date.parse('2026-09-22T12:00:00.000Z'),
+    repositories: [{ repoId, canonicalRoot: root, localRoot: root }],
+    dependencies: {
+      authorizeWake: () => undefined,
+      boundaryForWork: () => ({ status: 'not_eligible' as const }),
+      hostForBinding: () => host,
+    },
+  };
+  const firstWake = await runSchedulerAutonomousContinuationReconciliation(schedulerInput);
+  assert.equal(firstWake.dispatched, 1);
+  const duplicateWake = await runSchedulerAutonomousContinuationReconciliation(schedulerInput);
+  assert.equal(duplicateWake.dispatched, 0);
+  assert.equal(providerDispatches, 1);
+  assert.equal(getControllerRoundRelay(store, workId)?.status, 'dispatched');
+
+  // 5) Workflow Supervisor state is durable across process/control-plane
+  // reconstruction. Ten CONTINUE rounds publish exactly one successor each, and
+  // replaying the same completion never creates a second effect.
+  const taskId = 'unattended-transport-recovery-task';
+  const conversationId = '77777777-8888-9999-aaaa-bbbbbbbbbbbb';
+  const conversationUrl = `https://chatgpt.com/c/${conversationId}`;
+  let control = supervisor();
+  control.registerTask({
+    taskId,
+    conversationId,
+    conversationUrl,
+    objective: 'Continue autonomously across reconnects and runtime restarts.',
+    completionContract: {},
+    continuationPolicy: { active_scope: `goal:${taskId}` },
+    userBlockerPolicy: {},
+  });
+  let effect = control.reserveEnrollment(taskId);
+  control.observeEffect({ effectId: effect.effectId, observationId: 'round-0-applied', outcome: 'applied' });
+
+  for (let round = 1; round <= 10; round += 1) {
+    control = supervisor();
+    const response = block('CONTINUE', effect.effectId, `checkpoint-${round}`, conversationId, taskId);
+    const advanced = await control.browserObserveAssistant({ conversationId, conversationUrl, responseText: response });
+    assert.ok(advanced.successorEffect);
+    const replay = await control.browserObserveAssistant({ conversationId, conversationUrl, responseText: response });
+    assert.equal(replay.successorEffect?.effectId, advanced.successorEffect.effectId);
+    assert.equal(replay.deduplicated, true);
+    effect = advanced.successorEffect;
+    control.observeEffect({
+      effectId: effect.effectId,
+      observationId: `round-${round}-applied`,
+      outcome: 'applied',
+    });
+  }
+
+  control = supervisor();
+  const done = await control.browserObserveAssistant({
+    conversationId,
+    conversationUrl,
+    responseText: block('DONE', effect.effectId, 'complete', conversationId, taskId),
+  });
+  assert.equal(done.terminal, true);
+  assert.equal(control.browserTasks().length, 0);
+
+  console.log(JSON.stringify({
+    status: 'ok',
+    transportDisconnectedWithoutExecutionInvalidation: true,
+    reconnectUsedExplicitRolloverAuthority: true,
+    runtimeRestartRecoveredExecution: true,
+    schedulerProviderDispatches: providerDispatches,
+    unattendedContinuationRounds: 10,
+    duplicateSuccessorEffects: 0,
+  }, null, 2));
+} finally {
+  rmSync(root, { recursive: true, force: true });
+}

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,92 @@
+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'), false);
+  const backgroundSource = readFileSync(resolve('adapters/computer/chrome-extension/background.js'), 'utf8');
+  assert.ok(backgroundSource.includes('const PROVIDER_INSTANCE_ID = randomId()'));
+  assert.equal(backgroundSource.includes('chrome.storage'), false);
+  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 }); }