@moretea-labs/forge 1.8.0 → 1.8.2

package/src/runtime/control-plane/global-scheduler/wake-signal.ts

@@ -35,6 +35,35 @@ export function touchSchedulerWakeSignal(controllerHome: string, reason: string)
   return next;
 }
 
+export function isSchedulerWakeSignalEvent(filename: string | Buffer | null | undefined): boolean {
+  // The wake file shares a directory with scheduler health/state persistence.
+  // Atomic writes to those sibling files can emit multiple directory events.
+  // Node/macOS reports the final filename, while Bun/macOS may report only the
+  // wake file's atomic temporary name; both belong to the same wake authority.
+  // Platforms that omit the filename remain conservative and re-check revision.
+  if (filename == null) return true;
+  const observed = filename.toString();
+  return observed === 'wake-signal.json'
+    || (observed.startsWith('wake-signal.json.') && observed.endsWith('.tmp'));
+}
+
+export function shouldWakeForSchedulerEvent(
+  filename: string | Buffer | null | undefined,
+  expectedRevision: number,
+  observedRevision: number,
+): boolean {
+  if (!isSchedulerWakeSignalEvent(filename)) return false;
+  // A null filename is an ambiguous directory event on some Bun/macOS
+  // combinations. Only treat it as a wake when the durable revision changed;
+  // otherwise the Scheduler's own state.json write would wake it immediately
+  // and turn the idle loop into a CPU-consuming self-trigger cycle.
+  if (filename == null) return observedRevision !== expectedRevision;
+  // A named wake-file event is authoritative even when the revision is equal:
+  // concurrent writers may coalesce onto one revision, while the lifecycle
+  // truth remains in the canonical stores.
+  return true;
+}
+
 export async function waitForSchedulerWakeSignal(
   controllerHome: string,
   expectedRevision: number,
@@ -71,7 +100,18 @@ export async function waitForSchedulerWakeSignal(
 
     signal?.addEventListener('abort', onAbort, { once: true });
     try {
-      watcher = watch(dirname(path), maybeWake);
+      watcher = watch(dirname(path), (_eventType, filename) => {
+        if (!shouldWakeForSchedulerEvent(
+          filename,
+          expectedRevision,
+          readSchedulerWakeSignal(controllerHome).revision,
+        )) return;
+        // A named canonical wake-file event is itself the notification. Do not
+        // make event delivery depend on observing a strictly newer JSON
+        // revision: concurrent writers may legitimately coalesce onto one
+        // revision, while lifecycle truth is read from canonical stores.
+        finish('wakeup');
+      });
       watcher.on?.('error', maybeWake);
     } catch {
       watcher = undefined;
@@ -79,7 +119,7 @@ export async function waitForSchedulerWakeSignal(
     // fs.watch is the primary wake path. Polling is only a lost-event safety
     // net, so keep it coarse enough that an idle scheduler does not perform a
     // read/stat storm while still bounding cross-platform wake loss.
-    const fallbackPollMs = Math.min(2_000, Math.max(250, Math.trunc(options.fallbackPollMs ?? 1_000)));
+    const fallbackPollMs = Math.min(10_000, Math.max(250, Math.trunc(options.fallbackPollMs ?? 1_000)));
     poller = setInterval(maybeWake, fallbackPollMs);
     poller.unref?.();
     timer = setTimeout(() => finish('timeout'), Math.max(0, timeoutMs));

package/src/runtime/control-plane/governance/access-policy.ts

@@ -6,6 +6,7 @@ import {
   writeFileSync,
 } from 'fs';
 import { dirname, join, resolve } from 'path';
+import { isWorkspaceScopeKey, workspaceScopeRoot } from '../../../cli/repositories/controller-home';
 
 export const ACCESS_MODES = ['request', 'full_access'] as const;
 export type AccessMode = (typeof ACCESS_MODES)[number];
@@ -75,7 +76,23 @@ export function normalizeAccessMode(value: unknown, fallback: AccessMode = 'full
 }
 
 export function repositoryAccessPolicyPath(controllerHome: string, repoId: string): string {
-  return join(resolve(controllerHome), 'repositories', repoId, 'controller', 'access-policy.json');
+  // A workspace scope keeps its own access policy in the workspace partition
+  // instead of a synthetic repository partition. Repository/controller scopes
+  // keep their established location.
+  return isWorkspaceScopeKey(repoId)
+    ? join(workspaceScopeRoot(controllerHome, repoId), 'controller', 'access-policy.json')
+    : join(resolve(controllerHome), 'repositories', repoId, 'controller', 'access-policy.json');
+}
+
+/**
+ * Bounded migration read: a workspace policy written to the legacy repository
+ * location still applies until it is rewritten in the workspace partition.
+ */
+function readableAccessPolicyPath(controllerHome: string, repoId: string): string {
+  const current = repositoryAccessPolicyPath(controllerHome, repoId);
+  if (existsSync(current) || !isWorkspaceScopeKey(repoId)) return current;
+  const legacy = join(resolve(controllerHome), 'repositories', repoId, 'controller', 'access-policy.json');
+  return existsSync(legacy) ? legacy : current;
 }
 
 function defaultPolicy(repoId: string): RepositoryAccessPolicy {
@@ -90,7 +107,7 @@ function defaultPolicy(repoId: string): RepositoryAccessPolicy {
 }
 
 export function readRepositoryAccessPolicy(controllerHome: string, repoId: string): RepositoryAccessPolicy {
-  const path = repositoryAccessPolicyPath(controllerHome, repoId);
+  const path = readableAccessPolicyPath(controllerHome, repoId);
   if (!existsSync(path)) return defaultPolicy(repoId);
   try {
     const parsed = JSON.parse(readFileSync(path, 'utf-8')) as Partial<RepositoryAccessPolicy>;

package/src/runtime/control-plane/governance/authorization.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from 'crypto';
 import { existsSync, mkdirSync } from 'fs';
 import { join, relative, resolve } from 'path';
-import { repositoryControllerRoot } from '../../../cli/repositories/controller-home';
+import { isWorkspaceScopeKey, repositoryControllerRoot, scopedOperationRoot } from '../../../cli/repositories/controller-home';
 import { readJsonFile, sanitizeFileComponent, writeJsonAtomic } from '../../shared/json-files';
 import type { AccessMode } from './access-policy';
 
@@ -81,7 +81,7 @@ export interface AuthorizationContext {
 }
 
 function requestRoot(controllerHome: string, repoId: string): string {
-  const root = join(repositoryControllerRoot(controllerHome, repoId), 'controller', 'approval-requests');
+  const root = join(scopedOperationRoot(controllerHome, repoId), 'controller', 'approval-requests');
   mkdirSync(root, { recursive: true, mode: 0o700 });
   return root;
 }
@@ -90,6 +90,23 @@ function requestPath(controllerHome: string, repoId: string, requestId: string):
   return join(requestRoot(controllerHome, repoId), `${sanitizeFileComponent(requestId)}.json`);
 }
 
+/**
+ * Bounded migration read: an approval issued for a workspace scope before the
+ * workspace partition existed is still resolvable instead of failing closed as
+ * a missing request.
+ */
+function readableRequestPath(controllerHome: string, repoId: string, requestId: string): string {
+  const current = requestPath(controllerHome, repoId, requestId);
+  if (existsSync(current) || !isWorkspaceScopeKey(repoId)) return current;
+  const legacy = join(
+    repositoryControllerRoot(controllerHome, repoId),
+    'controller',
+    'approval-requests',
+    `${sanitizeFileComponent(requestId)}.json`,
+  );
+  return existsSync(legacy) ? legacy : current;
+}
+
 function scopeMatches(context: AuthorizationContext): boolean {
   if (context.currentRepositoryId && context.repositoryId !== context.currentRepositoryId) return false;
   if (context.workId && context.boundWorkId && context.workId !== context.boundWorkId) return false;
@@ -163,7 +180,7 @@ export function createGoalDelegation(input: Omit<GoalDelegation, 'schemaVersion'
 }
 
 export function readAuthorizationRequest(controllerHome: string, repositoryId: string, approvalRequestId: string): AuthorizationRequestRecord {
-  const path = requestPath(controllerHome, repositoryId, approvalRequestId);
+  const path = readableRequestPath(controllerHome, repositoryId, approvalRequestId);
   if (!existsSync(path)) throw new Error(`APPROVAL_REQUEST_NOT_FOUND: ${approvalRequestId}`);
   const request = readJsonFile<AuthorizationRequestRecord>(path);
   if (request.repositoryId !== repositoryId || request.approvalRequestId !== approvalRequestId) throw new Error('APPROVAL_REQUEST_IDENTITY_MISMATCH');

package/src/runtime/control-plane/governance/external-effects.ts

@@ -3,7 +3,7 @@ const EXPLICIT_AUTHORIZATION_OPERATIONS = new Set([
   'close_github_issue',
   'repository_remove',
   'repository_disable',
-  'repository_command_execute',
+  'execute_command',
   'configure_github_plugin',
 ]);
 

package/src/runtime/control-plane/launcher/chatgpt-round-continuation.ts

@@ -1,10 +1,5 @@
-import { randomUUID } from 'crypto';
-import { realpathSync } from 'fs';
 import {
   acknowledgeControllerRoundClaim,
-  beginInitialControllerRoundDispatch,
-  beginControllerRoundRelayAfterRelease,
-  finishControllerRoundRelayDispatch,
   getControllerRoundRelay,
   getControllerSession,
   releaseControllerSessionWithAuthority,
@@ -12,166 +7,8 @@ import {
   submitControllerRoundDisposition,
   type ControllerRoundDisposition,
 } from '../../../../packages/kernel/controller/api/index';
-import { chatgptControllerRoundBinding, recordChatgptControllerRoundTabSettlement, renderChatgptControllerRoundPrompt } from '../../root/controller-round-composition';
+import { chatgptControllerRoundBinding } from '../../root/controller-round-composition';
 import { readExecutionSession, updateExecutionSession } from '../execution/session-store';
-import { runWorkChatgptContinuation, type WorkChatgptContinuationResult } from './chatgpt-work-continuation';
-import { getRepository } from '../../../cli/repositories/registry';
-
-export const SOURCE_ROUND_CONTINUATION_INSTRUCTION =
-  '当前为 Forge V2 源码自动续跑模式。不要用已安装旧 Runtime 直接结束本轮，因为旧 Runtime 可能只建立 Work owner 而未 reconciliation provider_dispatch_outcome_unknown。若 Goal 尚未完成且无真实 blocker，必须使用 prompt 提供的 exact current-source round-continue invocation；若本轮应 wait、wait_for_user 或 goal_complete，则必须使用 current-source round-close，它只做 canonical claim acknowledgement、semantic disposition 和 release，绝不派发 successor。不得重新探测 Controller Home、repo/work identity、controller authority 或 relay scope。';
-
-function sourceCheckoutId(controllerHome: string, repoId: string, repoRoot: string): string {
-  const repository = getRepository(repoId, controllerHome);
-  const sourceRoot = realpathSync(repoRoot);
-  const matches = repository.checkouts.filter((checkout) => {
-    if (checkout.lifecycle === 'removed') return false;
-    try { return realpathSync(checkout.canonicalRoot) === sourceRoot; } catch { return false; }
-  });
-  if (matches.length !== 1) {
-    throw new Error(`SOURCE_ROUND_CHECKOUT_IDENTITY_AMBIGUOUS: ${repoId}:${repoRoot}:${matches.length}`);
-  }
-  return matches[0]!.checkoutId;
-}
-
-export function renderSourceRoundContinuationInstruction(input: {
-  controllerHome: string;
-  repoId: string;
-  repoRoot: string;
-  workId: string;
-  controllerAuthorityId: string;
-  relayScopeId: string;
-}): string {
-  const checkoutId = sourceCheckoutId(input.controllerHome, input.repoId, input.repoRoot);
-  const command = [
-    'bun',
-    'src/cli/index.ts',
-    'chatgpt',
-    'round-continue',
-    '--controller-home', input.controllerHome,
-    '--repo-id', input.repoId,
-    '--work-id', input.workId,
-    '--controller-authority-id', input.controllerAuthorityId,
-    '--relay-scope-id', input.relayScopeId,
-  ];
-  const requestId = `source-round-continue:${input.controllerAuthorityId}`;
-  const closeWaitCommand = [
-    'bun',
-    'src/cli/index.ts',
-    'chatgpt',
-    'round-close',
-    '--controller-home', input.controllerHome,
-    '--repo-id', input.repoId,
-    '--work-id', input.workId,
-    '--controller-authority-id', input.controllerAuthorityId,
-    '--relay-scope-id', input.relayScopeId,
-    '--disposition', 'wait',
-  ];
-  const closeWaitRequestId = `source-round-close:wait:${input.controllerAuthorityId}`;
-  return [
-    SOURCE_ROUND_CONTINUATION_INSTRUCTION,
-    `Exact current-source continue invocation: repository_command_execute(repo_id=${JSON.stringify(input.repoId)}, checkout_id=${JSON.stringify(checkoutId)}, command=${JSON.stringify(command)}, request_id=${JSON.stringify(requestId)}).`,
-    `Exact current-source wait/close invocation: repository_command_execute(repo_id=${JSON.stringify(input.repoId)}, checkout_id=${JSON.stringify(checkoutId)}, command=${JSON.stringify(closeWaitCommand)}, request_id=${JSON.stringify(closeWaitRequestId)}).`,
-    `For wait_for_user or goal_complete use the same round-close command with only --disposition changed; wait_for_user must additionally provide --handoff-id for the active Handoff.`,
-    `These exact lifecycle invocations are the sole repository_command_execute exception: do not pass wrapper work_id; CLI --work-id=${input.workId}, --controller-authority-id=${input.controllerAuthorityId}, and --relay-scope-id=${input.relayScopeId} remain the fenced Controller lifecycle authority.`,
-  ].join(' ');
-}
-
-
-export interface SourceChatgptRoundOpenInput {
-  controllerHome: string;
-  repoId: string;
-  repoRoot: string;
-  workId: string;
-  controllerId: string;
-  principalId: string;
-  controllerInstanceId?: string;
-  continuationPrompt?: string;
-  timeoutMs?: number;
-}
-
-export interface SourceChatgptRoundOpenResult {
-  relayStatus: string;
-  controllerAuthorityId: string;
-  relayScopeId: string;
-  dispatch: WorkChatgptContinuationResult;
-}
-
-export async function openChatgptControllerRoundFromSource(
-  input: SourceChatgptRoundOpenInput,
-  dependencies: { dispatch?: typeof runWorkChatgptContinuation } = {},
-): Promise<SourceChatgptRoundOpenResult> {
-  const store = { controllerHome: input.controllerHome, repoId: input.repoId };
-  const binding = chatgptControllerRoundBinding(store, input.workId);
-  const relay = beginInitialControllerRoundDispatch(store, {
-    workId: input.workId,
-    identity: {
-      controllerId: input.controllerId.trim(),
-      controllerType: 'chatgpt',
-      principalId: input.principalId.trim(),
-      controllerInstanceId: input.controllerInstanceId?.trim() || 'source-v2-launcher',
-      sessionId: `source-v2-launch-${randomUUID()}`,
-    },
-    bindingId: binding?.bindingId,
-  });
-  if (relay.status === 'blocked' || !relay.authorityId) {
-    throw new Error(`CONTROLLER_RELAY_LAUNCH_BLOCKED: ${relay.blockedReason ?? relay.relayScopeId}`);
-  }
-  const prompt = [
-    renderChatgptControllerRoundPrompt(store, relay, { exactOriginWork: true }),
-    renderSourceRoundContinuationInstruction({
-      controllerHome: input.controllerHome,
-      repoId: input.repoId,
-      repoRoot: input.repoRoot,
-      workId: input.workId,
-      controllerAuthorityId: relay.authorityId,
-      relayScopeId: relay.relayScopeId,
-    }),
-    input.continuationPrompt?.trim() ? `Continuation: ${input.continuationPrompt.trim()}` : '',
-  ].filter(Boolean).join('\n\n');
-  const dispatch = dependencies.dispatch ?? runWorkChatgptContinuation;
-  const dispatched = await dispatch({
-    controllerHome: input.controllerHome,
-    repoId: input.repoId,
-    repoRoot: input.repoRoot,
-    workId: input.workId,
-    prompt,
-    controllerAuthorityId: relay.authorityId,
-    relayScopeId: relay.relayScopeId,
-    browserSessionId: binding?.browserSessionId,
-    conversationUrl: binding?.conversationUrl,
-    tabPolicy: 'reuse',
-    timeoutMs: input.timeoutMs,
-  });
-  if (dispatched.status === 'failed') {
-    const message = `${dispatched.error?.code ?? 'CONTROLLER_RELAY_DISPATCH_FAILED'}:${dispatched.error?.message ?? 'Controller relay dispatch failed'}`;
-    const outcomeUnknown = dispatched.providerDeliveryStatus === 'outcome_unknown';
-    const completed = finishControllerRoundRelayDispatch(store, {
-      workId: input.workId,
-      ok: false,
-      error: message,
-      outcomeUnknown,
-    });
-    if (!outcomeUnknown) throw new Error(message);
-    return {
-      relayStatus: completed?.status ?? 'blocked',
-      controllerAuthorityId: relay.authorityId,
-      relayScopeId: relay.relayScopeId,
-      dispatch: dispatched,
-    };
-  }
-  const updatedBinding = chatgptControllerRoundBinding(store, input.workId);
-  const completed = finishControllerRoundRelayDispatch(store, {
-    workId: input.workId,
-    ok: true,
-    bindingId: updatedBinding?.bindingId,
-  });
-  return {
-    relayStatus: completed?.status ?? 'missing',
-    controllerAuthorityId: relay.authorityId,
-    relayScopeId: relay.relayScopeId,
-    dispatch: dispatched,
-  };
-}
 
 type SourceChatgptRoundTerminalDisposition = Exclude<ControllerRoundDisposition, 'continue_immediately'>;
 
@@ -191,57 +28,73 @@ interface ReconciledSourceRound {
   bindingId?: string;
 }
 
+/**
+ * Compatibility close-only path for a ControllerRound that was already opened
+ * by a pre-convergence current-source canary. New source-mode open/continue
+ * dispatch is intentionally removed: candidate Runtime must be activated and
+ * all new Work-bound ChatGPT turns flow through Workflow Supervisor.
+ */
 function reconcileClaimedSourceRound(input: {
-  controllerHome: string; repoId: string; workId: string; controllerAuthorityId: string; relayScopeId: string;
-}, options: { allowPendingReleaseContinuation?: boolean } = {}): ReconciledSourceRound {
+  controllerHome: string;
+  repoId: string;
+  workId: string;
+  controllerAuthorityId: string;
+  relayScopeId: string;
+}): ReconciledSourceRound {
   const store = { controllerHome: input.controllerHome, repoId: input.repoId };
   const initialRelay = getControllerRoundRelay(store, input.workId);
   if (!initialRelay) throw new Error(`CONTROLLER_RELAY_ROUND_NOT_OPEN: ${input.workId}`);
-  if (initialRelay.authorityId !== input.controllerAuthorityId.trim()) throw new Error(`CONTROLLER_RELAY_AUTHORITY_MISMATCH: ${input.workId}`);
-  if (initialRelay.relayScopeId !== input.relayScopeId.trim()) throw new Error(`CONTROLLER_RELAY_SCOPE_MISMATCH: ${input.workId}`);
+  if (initialRelay.authorityId !== input.controllerAuthorityId.trim()) {
+    throw new Error(`CONTROLLER_RELAY_AUTHORITY_MISMATCH: ${input.workId}`);
+  }
+  if (initialRelay.relayScopeId !== input.relayScopeId.trim()) {
+    throw new Error(`CONTROLLER_RELAY_SCOPE_MISMATCH: ${input.workId}`);
+  }
 
   const owner = getControllerSession(store, input.workId);
   if (!owner) throw new Error(`CONTROLLER_RELAY_ACTIVE_CLAIM_REQUIRED: ${input.workId}`);
   if (owner.controllerType !== 'chatgpt') throw new Error(`CONTROLLER_RELAY_CHATGPT_ONLY: ${input.workId}`);
   const ownerAuthority = requireControllerOwnershipAuthority(owner, input.workId);
-  const resumablePendingRelease = options.allowPendingReleaseContinuation === true
-    && initialRelay.status === 'pending_release'
-    && initialRelay.disposition === 'continue_immediately'
-    && initialRelay.lifecycleStage === 'semantic_round_closed';
-  const relay = resumablePendingRelease
-    ? initialRelay
-    : acknowledgeControllerRoundClaim(store, { workId: input.workId, session: owner });
+  const relay = acknowledgeControllerRoundClaim(store, { workId: input.workId, session: owner });
   if (!relay) throw new Error(`CONTROLLER_RELAY_ROUND_NOT_OPEN: ${input.workId}`);
-  if (relay.authorityId !== input.controllerAuthorityId.trim()) throw new Error(`CONTROLLER_RELAY_AUTHORITY_MISMATCH: ${input.workId}`);
-  if (relay.relayScopeId !== input.relayScopeId.trim()) throw new Error(`CONTROLLER_RELAY_SCOPE_MISMATCH: ${input.workId}`);
-  if (resumablePendingRelease) {
-    if (relay.controllerId !== owner.controllerId
-      || relay.controllerType !== owner.controllerType
-      || relay.principalId !== ownerAuthority.principalId
-      || relay.controllerInstanceId !== ownerAuthority.controllerInstanceId) {
-      throw new Error(`CONTROLLER_RELAY_PENDING_RELEASE_OWNER_MISMATCH: ${input.workId}`);
-    }
-  } else if (relay.status !== 'claimed') {
+  if (relay.authorityId !== input.controllerAuthorityId.trim()) {
+    throw new Error(`CONTROLLER_RELAY_AUTHORITY_MISMATCH: ${input.workId}`);
+  }
+  if (relay.relayScopeId !== input.relayScopeId.trim()) {
+    throw new Error(`CONTROLLER_RELAY_SCOPE_MISMATCH: ${input.workId}`);
+  }
+  if (relay.status !== 'claimed') {
     throw new Error(`CONTROLLER_RELAY_ROUND_NOT_CLAIMED: ${relay.status}`);
   }
-  const identity = {
-    controllerId: owner.controllerId,
-    controllerType: 'chatgpt' as const,
-    principalId: ownerAuthority.principalId,
-    controllerInstanceId: ownerAuthority.controllerInstanceId,
-    sessionId: owner.sessionId,
-    claimGeneration: ownerAuthority.claimGeneration,
+
+  return {
+    store,
+    owner,
+    ownerAuthority,
+    relay,
+    identity: {
+      controllerId: owner.controllerId,
+      controllerType: 'chatgpt',
+      principalId: ownerAuthority.principalId,
+      controllerInstanceId: ownerAuthority.controllerInstanceId,
+      sessionId: owner.sessionId,
+      claimGeneration: ownerAuthority.claimGeneration,
+    },
+    bindingId: chatgptControllerRoundBinding(store, input.workId)?.bindingId,
   };
-  return { store, owner, ownerAuthority, relay, identity, bindingId: chatgptControllerRoundBinding(store, input.workId)?.bindingId };
 }
 
-function releaseReconciledSourceRound(input: { controllerHome: string; workId: string }, reconciled: ReconciledSourceRound, actorPrefix: string): void {
+function releaseReconciledSourceRound(
+  input: { controllerHome: string; workId: string },
+  reconciled: ReconciledSourceRound,
+): void {
   const released = releaseControllerSessionWithAuthority(reconciled.store, {
     workId: input.workId,
-    actor: `${actorPrefix}:${reconciled.owner.controllerId}`,
+    actor: `source-chatgpt-round-close:${reconciled.owner.controllerId}`,
     authority: reconciled.ownerAuthority,
   });
   if (!released.allowed) throw new Error(`WORK_CONTROLLER_RELEASE_FENCED: ${input.workId}:${released.reason}`);
+
   const sessionIdentity = {
     sessionId: reconciled.owner.sessionId,
     principalId: reconciled.ownerAuthority.principalId,
@@ -249,7 +102,10 @@ function releaseReconciledSourceRound(input: { controllerHome: string; workId: s
   };
   const executionSession = readExecutionSession(input.controllerHome, sessionIdentity);
   if (executionSession?.activeWorkId === input.workId) {
-    updateExecutionSession(input.controllerHome, sessionIdentity, { activeWorkId: undefined, lastValidatedAt: new Date().toISOString() });
+    updateExecutionSession(input.controllerHome, sessionIdentity, {
+      activeWorkId: undefined,
+      lastValidatedAt: new Date().toISOString(),
+    });
   }
 }
 
@@ -270,7 +126,9 @@ export interface SourceChatgptRoundCloseResult {
   relayScopeId: string;
 }
 
-export function closeChatgptControllerRoundFromSource(input: SourceChatgptRoundCloseInput): SourceChatgptRoundCloseResult {
+export function closeChatgptControllerRoundFromSource(
+  input: SourceChatgptRoundCloseInput,
+): SourceChatgptRoundCloseResult {
   if (input.disposition === 'wait_for_user' && !input.handoffId?.trim()) {
     throw new Error('CONTROLLER_RELAY_WAIT_FOR_USER_HANDOFF_REQUIRED');
   }
@@ -285,113 +143,18 @@ export function closeChatgptControllerRoundFromSource(input: SourceChatgptRoundC
     ...(input.handoffId?.trim() ? { handoffId: input.handoffId.trim() } : {}),
     reason: input.reason ?? `source_v2_${input.disposition}`,
   });
-  const expectedStatus = input.disposition === 'wait' ? 'waiting' : input.disposition === 'wait_for_user' ? 'waiting_for_user' : 'goal_complete';
+  const expectedStatus = input.disposition === 'wait'
+    ? 'waiting'
+    : input.disposition === 'wait_for_user'
+      ? 'waiting_for_user'
+      : 'goal_complete';
   if (disposition.status !== expectedStatus) {
     throw new Error(`CONTROLLER_RELAY_CLOSE_STATUS_INVALID: ${disposition.status}`);
   }
-  releaseReconciledSourceRound(input, reconciled, 'source-chatgpt-round-close');
-  return { disposition: input.disposition, dispositionStatus: disposition.status, relayScopeId: disposition.relayScopeId };
-}
-
-export interface SourceChatgptRoundContinueInput {
-  controllerHome: string;
-  repoId: string;
-  repoRoot: string;
-  workId: string;
-  controllerAuthorityId: string;
-  relayScopeId: string;
-  reason?: string;
-  timeoutMs?: number;
-}
-
-export interface SourceChatgptRoundContinueResult {
-  dispositionStatus: string;
-  relayStatus: string;
-  relayWorkId: string;
-  dispatch: WorkChatgptContinuationResult;
-}
-
-export async function continueChatgptControllerRoundFromSource(
-  input: SourceChatgptRoundContinueInput,
-  dependencies: { dispatch?: typeof runWorkChatgptContinuation } = {},
-): Promise<SourceChatgptRoundContinueResult> {
-  // The installed Runtime may be older than the source under canary. It is authoritative only
-  // for establishing the exact live ControllerSession owner. Reconcile that durable owner
-  // through the current source state machine before deciding whether this round is claimed.
-  const reconciled = reconcileClaimedSourceRound(input, { allowPendingReleaseContinuation: true });
-  const { store, owner, relay } = reconciled;
-  // A transport/session failure can happen after the semantic disposition is durably
-  // recorded but before owner release. Retry from that exact post-disposition boundary
-  // instead of resubmitting continue_immediately (which would double-consume round budget).
-  const disposition = relay.status === 'pending_release'
-    ? relay
-    : submitControllerRoundDisposition(store, {
-        workId: input.workId,
-        identity: reconciled.identity,
-        disposition: 'continue_immediately',
-        relayScopeId: input.relayScopeId,
-        requirementId: relay.requirementId,
-        bindingId: reconciled.bindingId,
-        reason: input.reason ?? 'source_v2_immediate_continuation',
-      });
-  if (disposition.status !== 'pending_release') {
-    throw new Error(`CONTROLLER_RELAY_CONTINUATION_NOT_PENDING_RELEASE: ${disposition.status}`);
-  }
-
-  releaseReconciledSourceRound(input, reconciled, 'source-chatgpt-round-continue');
-
-  const nextRelay = beginControllerRoundRelayAfterRelease(store, { workId: input.workId, releasedSession: owner });
-  if (!nextRelay || nextRelay.status !== 'dispatching' || !nextRelay.authorityId) {
-    throw new Error(`CONTROLLER_RELAY_IMMEDIATE_DISPATCH_NOT_READY: ${nextRelay?.status ?? 'missing'}`);
-  }
-  const relayWorkId = nextRelay.originWorkId;
-  const prompt = `${renderChatgptControllerRoundPrompt(store, nextRelay)}\n\n${renderSourceRoundContinuationInstruction({
-    controllerHome: input.controllerHome,
-    repoId: input.repoId,
-    repoRoot: input.repoRoot,
-    workId: relayWorkId,
-    controllerAuthorityId: nextRelay.authorityId,
-    relayScopeId: nextRelay.relayScopeId,
-  })}`;
-  const dispatch = dependencies.dispatch ?? runWorkChatgptContinuation;
-  const dispatched = await dispatch({
-    controllerHome: input.controllerHome,
-    repoId: input.repoId,
-    repoRoot: input.repoRoot,
-    workId: relayWorkId,
-    prompt,
-    controllerAuthorityId: nextRelay.authorityId,
-    relayScopeId: nextRelay.relayScopeId,
-    tabPolicy: 'new',
-    transportConversation: 'fresh',
-    timeoutMs: input.timeoutMs,
-  });
-  if (dispatched.status === 'failed') {
-    const message = `${dispatched.error?.code ?? 'CONTROLLER_RELAY_DISPATCH_FAILED'}:${dispatched.error?.message ?? 'Controller relay dispatch failed'}`;
-    finishControllerRoundRelayDispatch(store, {
-      workId: relayWorkId,
-      ok: false,
-      error: message,
-      outcomeUnknown: dispatched.providerDeliveryStatus === 'outcome_unknown',
-    });
-    throw new Error(message);
-  }
-
-  recordChatgptControllerRoundTabSettlement(store, {
-    workId: relayWorkId,
-    relayScopeId: nextRelay.relayScopeId,
-    status: 'retained_for_immediate_continuation',
-  });
-  const updatedBinding = chatgptControllerRoundBinding(store, relayWorkId);
-  const completed = finishControllerRoundRelayDispatch(store, {
-    workId: relayWorkId,
-    ok: true,
-    bindingId: updatedBinding?.bindingId,
-  });
+  releaseReconciledSourceRound(input, reconciled);
   return {
+    disposition: input.disposition,
     dispositionStatus: disposition.status,
-    relayStatus: completed?.status ?? 'missing',
-    relayWorkId,
-    dispatch: dispatched,
+    relayScopeId: disposition.relayScopeId,
   };
 }