@moretea-labs/forge 1.8.0 → 1.8.1

package/src/cli/agent-jobs/executor-health.ts

@@ -1,6 +1,6 @@
 import type { GitHubStatus } from "../github/contracts";
 import type { McpAgentRunnerName } from "../mcp/types";
-import type { ControllerAgent, ControllerTask } from "../controller/types";
+import type { ControllerAgent } from "../controller/types";
 
 export type ExecutorHealthStatus =
   | "available"
@@ -24,7 +24,6 @@ export type ExecutorHealthReason =
   | "unknown";
 
 export type ExecutorHealthFallback =
-  | "use_direct_edit"
   | "enable_local_agent"
   | "run_gh_auth_login"
   | "enable_copilot_coding_agent"
@@ -64,19 +63,6 @@ function normalize(value: string): string {
   return value.toLowerCase().replace(/\s+/g, " ").trim();
 }
 
-function isSmallScopedTask(task: Pick<ControllerTask, "allowedPaths"> | undefined): boolean {
-  return Array.isArray(task?.allowedPaths) && task.allowedPaths.length > 0 && task.allowedPaths.length <= 3;
-}
-
-function localUnavailableMessage(base: string, task?: Pick<ControllerTask, "allowedPaths">): string {
-  if (!isSmallScopedTask(task)) return base;
-  return `${base} Use begin_edit_session/apply_patch/run_check instead of retrying unavailable agents.`;
-}
-
-function localUnavailableFallback(task?: Pick<ControllerTask, "allowedPaths">): ExecutorHealthFallback {
-  return isSmallScopedTask(task) ? "use_direct_edit" : "enable_local_agent";
-}
-
 export function executorHealthCode(health: ExecutorHealth): string {
   switch (health.reason) {
     case "local_dev_runner_disabled":
@@ -104,19 +90,15 @@ export function executorHealthCode(health: ExecutorHealth): string {
 export function classifyLocalExecutorHealth(
   agent: Exclude<ControllerAgent, "github-copilot">,
   policy: LocalExecutorPolicy,
-  task?: Pick<ControllerTask, "allowedPaths">,
 ): ExecutorHealth | null {
   if (!policy.agentRunner) {
     return {
       agent,
       status: "disabled",
       reason: "local_dev_runner_disabled",
-      message: localUnavailableMessage(
-        `Local ${agent} runs are disabled because the dev runner is not enabled.`,
-        task,
-      ),
+      message: `Local ${agent} runs are disabled because the dev runner is not enabled.`,
       remediation: "Enable the controller dev runner before dispatching local Codex or Claude runs.",
-      fallback: localUnavailableFallback(task),
+      fallback: "enable_local_agent",
     };
   }
   if (!policy.allowedAgents.includes(agent)) {
@@ -124,12 +106,9 @@ export function classifyLocalExecutorHealth(
       agent,
       status: "disabled",
       reason: "local_agent_disabled",
-      message: localUnavailableMessage(
-        `Local agent is not enabled: ${agent}.`,
-        task,
-      ),
+      message: `Local agent is not enabled: ${agent}.`,
       remediation: `Enable ${agent} in the controller dev-runner allowedAgents list before retrying.`,
-      fallback: localUnavailableFallback(task),
+      fallback: "enable_local_agent",
     };
   }
   return null;
@@ -137,7 +116,6 @@ export function classifyLocalExecutorHealth(
 
 export function classifyGitHubCopilotPreflight(
   status: GitHubStatus,
-  task?: Pick<ControllerTask, "allowedPaths">,
 ): ExecutorHealth | null {
   if (!status.available) {
     return {
@@ -146,7 +124,7 @@ export function classifyGitHubCopilotPreflight(
       reason: "github_cli_unavailable",
       message: "GitHub CLI (gh) is unavailable, so GitHub Copilot cloud sessions cannot start.",
       remediation: "Install GitHub CLI and ensure `gh --version` works in this repository environment.",
-      fallback: isSmallScopedTask(task) ? "use_direct_edit" : "install_github_cli",
+      fallback: "install_github_cli",
     };
   }
   if (!status.authenticated) {
@@ -175,7 +153,6 @@ export function classifyGitHubCopilotPreflight(
 export function classifyExecutorFailure(
   agent: ControllerAgent,
   message: string,
-  task?: Pick<ControllerTask, "allowedPaths">,
 ): ExecutorHealth | null {
   const text = normalize(message);
   if (!text) return null;
@@ -193,7 +170,7 @@ export function classifyExecutorFailure(
         reason: "copilot_cca_disabled",
         message: "GitHub Copilot cloud agent is not enabled for this account or repository.",
         remediation: "Enable GitHub Copilot Coding Agent / CCA for the account and repository before retrying cloud sessions.",
-        fallback: isSmallScopedTask(task) ? "use_direct_edit" : "enable_copilot_coding_agent",
+        fallback: "enable_copilot_coding_agent",
       };
     }
     return null;
@@ -207,7 +184,7 @@ export function classifyExecutorFailure(
         reason: "codex_insufficient_balance",
         message: "Codex execution is unavailable because the configured API account has insufficient balance.",
         remediation: "Restore API balance or correct the Codex base URL/account configuration before retrying.",
-        fallback: isSmallScopedTask(task) ? "use_direct_edit" : "fix_codex_api_balance_or_base_url",
+        fallback: "fix_codex_api_balance_or_base_url",
       };
     }
     if (text.includes("usage limit")) {
@@ -217,7 +194,7 @@ export function classifyExecutorFailure(
         reason: "codex_usage_limit",
         message: "Codex execution is unavailable because the configured account has reached a usage limit.",
         remediation: "Raise or wait for the Codex usage limit, or correct the API account/base URL configuration before retrying.",
-        fallback: isSmallScopedTask(task) ? "use_direct_edit" : "fix_codex_api_balance_or_base_url",
+        fallback: "fix_codex_api_balance_or_base_url",
       };
     }
     if (
@@ -232,7 +209,7 @@ export function classifyExecutorFailure(
         reason: "codex_auth_required",
         message: "Codex execution is unavailable because authentication is required.",
         remediation: "Authenticate the Codex executor or correct the configured credentials/base URL before retrying.",
-        fallback: isSmallScopedTask(task) ? "use_direct_edit" : "authenticate_codex",
+        fallback: "authenticate_codex",
       };
     }
   }
@@ -243,7 +220,7 @@ export function classifyExecutorFailure(
     reason: "unknown",
     message: `${agent} execution failed for an unclassified reason.`,
     remediation: "Inspect the bounded run error and executor configuration before retrying.",
-    fallback: isSmallScopedTask(task) ? "use_direct_edit" : "inspect_executor_configuration",
+    fallback: "inspect_executor_configuration",
   };
 }
 

package/src/cli/agent-jobs/integration.ts

@@ -13,14 +13,11 @@ import {
   type EditOperation,
   type EditSession,
 } from "../editing/edit-session";
-import { getIssue, updateTask } from "../controller/issue-store";
-import { readTaskRunEvidence } from "../controller/run-evidence";
-import { resolveEffectiveTaskState } from "../controller/task-status-resolver";
 import { resolveMcpPath } from "../mcp/paths";
 import type { McpPolicy } from "../mcp/types";
 import { getAgentJob, markAgentJobClosure, markAgentJobIntegrated, markAgentJobIntegrationReview } from "./job-manager";
 import type { AgentJobMeta, AgentJobPreservationReason } from "./types";
-import { assertRuntimeMayWriteOrThrow } from "../../runtime/root/write-fence";
+import { assertRuntimeMayWriteOrThrow, isRuntimeWriteFenceError } from "../../runtime/root/write-fence";
 
 type IntegrationChangeOutcome = "changed" | "already_integrated";
 
@@ -509,21 +506,22 @@ export function integrateAgentJob(
       ?? undefined;
     assertRuntimeMayWriteOrThrow('integrate_worktree', controllerHome);
   } catch (error) {
-    if (error instanceof Error && error.message.startsWith('WRITER_FENCED:')) throw error;
+    if (isRuntimeWriteFenceError(error)) throw error;
     /* unbound legacy single-runtime */
   }
   let run: AgentJobMeta = getAgentJob(repoRoot, runId);
-  const autoFinalizing = run.status === "running" &&
-    run.autoIntegrate === true &&
-    run.executionMode === "worktree" &&
-    (run.progress?.phase === "finalizing" || run.closureState === "ready_to_integrate");
-  const userResolvableIntegration = run.status === "waiting_for_user" &&
-    run.autoIntegrate === true &&
-    run.executionMode === "worktree" &&
-    Boolean(run.autoIntegrationError);
-  if (run.status !== "succeeded" && !autoFinalizing && !userResolvableIntegration)
+  // Integration is an explicit decision, so an ordinary Run must have finished
+  // successfully. One state is still integrable: a Run that a previous explicit
+  // integration attempt preserved after a failure or a required review. That
+  // preserved worktree is the durable product of that attempt, and refusing to
+  // retry it stranded the isolated work with no path forward.
+  const preservedIntegrationRetry = run.status === "waiting_for_user"
+    && run.executionMode === "worktree"
+    && (run.closureState === "preserved" || run.closureState === "integration_blocked")
+    && Boolean(run.autoIntegrationError || run.preservationReason);
+  if (run.status !== "succeeded" && !preservedIntegrationRetry)
     throw new Error(
-      `only succeeded, auto-finalizing, or preserved waiting_for_user Runs can be integrated (current: ${run.status})`,
+      `only a succeeded Run (or an explicitly preserved integration attempt) can be integrated (current: ${run.status})`,
     );
   if (run.provider !== "local")
     throw new Error(
@@ -531,7 +529,7 @@ export function integrateAgentJob(
     );
   if (run.worktree === repoRoot || !run.branch || !run.baseRevision)
     throw new Error(
-      "Run did not use an isolated Git worktree; its changes are already in the main working tree",
+      "Run did not use an isolated Git worktree; its changes are already in the dispatch checkout",
     );
   if (run.integratedSessionId) {
     const existing = getEditSession(repoRoot, run.integratedSessionId);
@@ -548,28 +546,12 @@ export function integrateAgentJob(
 
   run = markAgentJobClosure(repoRoot, runId, {
     state: "integrating",
-    details: "Applying isolated Run changes to the canonical workspace.",
+    details: "Applying isolated Run changes to the dispatch checkout.",
   });
 
-  const issue = getIssue(repoRoot, run.issueId);
-  const task = issue.tasks.find((entry) => entry.id === run.taskId);
-  if (!task) throw new Error(`task not found: ${run.issueId}/${run.taskId}`);
-  const state = resolveEffectiveTaskState({ issue, task, runs: readTaskRunEvidence(repoRoot, task) });
-  const taskReady = autoFinalizing || userResolvableIntegration
-    ? !state.terminal && !state.inactive && ["review", "ready_to_integrate", "integrating", "integration_blocked", "integrated", "verified"].includes(task.status)
-    : !state.terminal && !state.inactive && ["review", "ready_to_integrate", "integrating", "integration_blocked", "verified"].includes(state.effectiveStatus);
-  if (!taskReady)
-    throw new Error(
-      `task must be active and in review before integration (declared: ${task.status}, effective: ${state.effectiveStatus})`,
-    );
-
   const initialPlan = planFromCurrentWorkspace(repoRoot, run, policy);
   if (initialPlan.changedPaths.length === 0)
     throw new Error("task worktree has no changes to integrate");
-  if (initialPlan.changedPaths.length > 25)
-    throw new Error(
-      `task changed ${initialPlan.changedPaths.length} files; split or manually integrate work larger than 25 files`,
-    );
   if (initialPlan.conflicts.length > 0)
     throw createReviewPacket(
       repoRoot,
@@ -578,10 +560,9 @@ export function integrateAgentJob(
       initialPlan.conflicts,
     );
 
-  const allowedPaths =
-    task.allowedPaths.length > 0
-      ? task.allowedPaths
-      : initialPlan.changedPaths;
+  const allowedPaths = run.allowedPaths?.length
+    ? run.allowedPaths
+    : initialPlan.changedPaths;
   if (initialPlan.operations.length === 0) {
     const applied = finalizeAlreadyIntegratedSession(
       repoRoot,
@@ -592,10 +573,6 @@ export function integrateAgentJob(
       changedFiles: initialPlan.changedPaths,
       changeOutcome: "already_integrated",
     });
-    updateTask(repoRoot, run.issueId, run.taskId, {
-      status: "integrated",
-      note: `${runId} already matched the main workspace and was recorded through edit session ${applied.sessionId}; run focused checks and record verification before acceptance.`,
-    });
     return {
       session: applied,
       changedPaths: initialPlan.changedPaths,
@@ -644,10 +621,6 @@ export function integrateAgentJob(
           changedFiles: refreshedPlan.changedPaths,
           changeOutcome: "already_integrated",
         });
-        updateTask(repoRoot, run.issueId, run.taskId, {
-          status: "integrated",
-          note: `${runId} became already integrated while finish was running and was recorded through edit session ${alreadyIntegrated.sessionId}; run focused checks and record verification before acceptance.`,
-        });
         return {
           session: alreadyIntegrated,
           changedPaths: refreshedPlan.changedPaths,
@@ -683,10 +656,6 @@ export function integrateAgentJob(
     changedFiles: initialPlan.operations.map((operation) => operation.path),
     changeOutcome: "changed",
   });
-  updateTask(repoRoot, run.issueId, run.taskId, {
-    status: "integrated",
-    note: `${runId} integrated through edit session ${applied.sessionId}; run focused checks and record verification before acceptance.`,
-  });
   return {
     session: applied,
     changedPaths: initialPlan.operations.map((operation) => operation.path),

package/src/cli/agent-jobs/job-manager.ts

@@ -122,7 +122,10 @@ function normalizeAgentMeta(
       : meta.worktree === repoRoot
         ? "workspace"
         : "worktree");
-  meta.autoIntegrate = meta.autoIntegrate ?? meta.executionMode === "worktree";
+  // Integration is an explicit model decision. Historical worktree Runs may
+  // retain this field for read compatibility, but a missing value must never
+  // turn a completed execution into a workflow transition.
+  meta.autoIntegrate = meta.autoIntegrate ?? false;
   meta.closureState = meta.closureState ?? (
     meta.provider === "local" && meta.executionMode === "worktree"
       ? meta.worktreeCleanedAt
@@ -1105,7 +1108,7 @@ function attachExecutorFailureHealth(meta: AgentJobMeta, stdoutTail?: string, st
   }
   if (meta.executorHealth) return meta;
   const message = executorFailureMessage(meta, stdoutTail, stderrTail);
-  const health = classifyExecutorFailure(meta.agent, message, { allowedPaths: meta.allowedPaths ?? [] });
+  const health = classifyExecutorFailure(meta.agent, message);
   if (health) meta.executorHealth = health;
   return meta;
 }
@@ -1261,7 +1264,8 @@ function baseMeta(
     eventsPath: relative(opts.repoRoot, paths.eventsPath).replace(/\\/g, "/"),
     timeoutMs: opts.timeoutMs,
     startupDeadlineAt: new Date(Date.now() + agentStartupTimeoutMs()).toISOString(),
-    autoIntegrate: executionMode === "worktree",
+    // A worktree contains concurrent writes; it does not authorize delivery.
+    autoIntegrate: false,
     progress: {
       phase: "starting",
       currentActivity: "已受理，等待异步启动",

package/src/cli/commands/brain-assistant.ts

@@ -1,7 +1,8 @@
 import { readFileSync, statSync } from 'fs';
 import type { Command } from 'commander';
 import { recordExperience, retractExperience, supersedeExperience, type ExperienceDraft } from '../../../packages/kernel/memory/api/index';
-import { controllerExperienceStore } from '../../runtime/control-plane/persistence/experience-store';
+import { controllerExperienceStore, workExperienceProvenance } from '../../runtime/control-plane/persistence/experience-store';
+import { getWorkContract } from '../../../packages/kernel/work/api/index';
 import { prepareAssistantWorkContext } from '../../runtime/context/assistant-work-context';
 
 function readBoundedJson(path: string): unknown {
@@ -17,21 +18,34 @@ export function addBrainAssistantCommands(brain: Command): void {
     .action((options: { controllerHome: string; repoId: string; workId: string; query?: string; channel?: string; account?: string; locale?: string }) => {
       console.log(JSON.stringify(prepareAssistantWorkContext({ ...options, applicability: { channel: options.channel, account: options.account, locale: options.locale } }) ?? { status: 'project_contract_missing' }, null, 2));
     });
-  const experience = brain.command('experience').description('Submit or withdraw Controller-authored, evidence-backed experience');
+  const experience = brain.command('experience').description('Submit or withdraw Work-authored, evidence-backed advisory experience');
   for (const operation of ['record', 'supersede', 'retract'] as const) {
     experience.command(operation)
       .requiredOption('--controller-home <path>').requiredOption('--repo-id <id>').requiredOption('--work-id <id>')
-      .requiredOption('--controller-id <id>').requiredOption('--authority-env <name>', 'Environment variable containing the current Controller capability')
-      .requiredOption('--input <path>', 'Bounded JSON API input; never include the Controller capability')
-      .action((options: { controllerHome: string; repoId: string; workId: string; controllerId: string; authorityEnv: string; input: string }) => {
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(options.authorityEnv)) throw new Error('BRAIN_AUTHORITY_ENV_INVALID');
-        const authorityId = process.env[options.authorityEnv];
-        if (!authorityId) throw new Error('BRAIN_CONTROLLER_AUTHORITY_REQUIRED');
-        const store = controllerExperienceStore({ ...options, identity: { workId: options.workId, controllerId: options.controllerId, authorityId } });
-        const data = readBoundedJson(options.input);
-        const result = operation === 'record' ? recordExperience(store, data as ExperienceDraft)
-          : operation === 'supersede' ? supersedeExperience(store, data as Parameters<typeof supersedeExperience>[1])
-            : retractExperience(store, data as Parameters<typeof retractExperience>[1]);
+      .requiredOption('--input <path>', 'Bounded JSON API input; source Work provenance is derived by Forge')
+      .action((options: { controllerHome: string; repoId: string; workId: string; input: string }) => {
+        const work = getWorkContract({ controllerHome: options.controllerHome, repoId: options.repoId }, options.workId);
+        if (!work) throw new Error(`BRAIN_WORK_NOT_FOUND: ${options.workId}`);
+        const sourceRoundId = workExperienceProvenance(work);
+        const store = controllerExperienceStore({ ...options, identity: { workId: options.workId } });
+        const raw = readBoundedJson(options.input);
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('BRAIN_INPUT_OBJECT_REQUIRED');
+        const data = raw as Record<string, unknown>;
+        const result = operation === 'record'
+          ? recordExperience(store, { ...data, sourceWorkId: options.workId, sourceRoundId } as ExperienceDraft)
+          : operation === 'supersede'
+            ? (() => {
+                const input = data as Parameters<typeof supersedeExperience>[1];
+                return supersedeExperience(store, {
+                  ...input,
+                  draft: { ...input.draft, sourceWorkId: options.workId, sourceRoundId },
+                });
+              })()
+            : retractExperience(store, {
+                ...(data as Parameters<typeof retractExperience>[1]),
+                sourceWorkId: options.workId,
+                sourceRoundId,
+              });
         console.log(JSON.stringify(result, null, 2));
       });
   }

package/src/cli/commands/brain.ts

@@ -14,7 +14,7 @@ import { configuredBrainRoot } from './brain-root';
 import { addBrainAssistantCommands } from './brain-assistant';
 import { resolveRepoPreferredControllerHome } from '../repositories/controller-home';
 import { findRegisteredRepositoryByCheckoutRoot } from '../repositories/registry';
-import { getWorkContract, validateWorkSemantics } from '../../../packages/kernel/work/api/index';
+import { getWorkContract, semanticWorkState } from '../../../packages/kernel/work/api/index';
 
 export type BrainLifecycle = 'always-sync' | 'archive-only' | 'never-sync';
 export type BrainCategory = 'decisions' | 'runbooks' | 'patterns' | 'references';
@@ -561,38 +561,36 @@ function modernBrainPromotionSource(repoRoot: string, opts: BrainPromoteOptions,
     return { sources: [], sections: [], relatedPlan: work.planId ?? '', terminalAt: '', outcome: '', sourceWork: workId, completionReceipt: '', workScope: '' };
   }
   const workScope = `${work.scopeRef.kind}:${work.scopeRef.id}`;
-  if (work.status !== 'completed' || !work.completionReceipt) {
-    issue(issues, 'error', `Brain promotion requires a completed Work with a durable completion receipt: ${workId}`);
+  if (semanticWorkState(work) !== 'completed') {
+    issue(issues, 'error', `Brain promotion requires a semantically completed Work: ${workId}`);
     return { sources: [], sections: [], relatedPlan: work.planId ?? '', terminalAt: '', outcome: '', sourceWork: workId, completionReceipt: '', workScope };
   }
-  try {
-    validateWorkSemantics(work);
-  } catch (error) {
-    issue(issues, 'error', `Work completion evidence is invalid for Brain promotion: ${error instanceof Error ? error.message : String(error)}`);
-    return { sources: [], sections: [], relatedPlan: work.planId ?? '', terminalAt: '', outcome: '', sourceWork: workId, completionReceipt: work.completionReceipt.receiptId, workScope };
-  }
   const receipt = work.completionReceipt;
-  const repositoryDetails = ('targetRevision' in receipt)
+  const semanticResultRefs = [...new Set((work.semanticResultRefs ?? []).map((value) => value.trim()).filter(Boolean))];
+  const repositoryDetails = receipt && 'targetRevision' in receipt
     ? [`- Target revision: ${receipt.targetRevision}`, `- Changed paths: ${receipt.changedPaths.length}`]
     : [];
+  const legacyReceiptDetails = receipt
+    ? [`- Legacy completion receipt: ${receipt.receiptId}`, `- Legacy completion source: ${receipt.source}`]
+    : ['- Legacy completion receipt: none (not required for semantic completion)'];
   const section = [
     `## Source: work:${work.workId}`,
     '',
     `- Objective: ${work.objective}`,
     `- Completion outcome: ${work.completionOutcome ?? 'completed'}`,
-    `- Completion receipt: ${receipt.receiptId}`,
-    `- Completion authority: ${receipt.source}`,
+    `- Semantic result refs: ${semanticResultRefs.length ? semanticResultRefs.join(', ') : '(none recorded)'}`,
     `- Work scope: ${workScope}`,
+    ...legacyReceiptDetails,
     ...repositoryDetails,
     '',
     'This entry is promoted from validated durable Work metadata. Raw process logs, credentials, and chat history are not copied into Brain.',
     '',
   ].join('\n');
   return {
-    sources: [`work:${work.workId}`, `completion:${receipt.receiptId}`],
-    sections: [section], relatedPlan: work.planId ?? '', terminalAt: receipt.recordedAt,
+    sources: [`work:${work.workId}`, ...semanticResultRefs, ...(receipt ? [`completion:${receipt.receiptId}`] : [])],
+    sections: [section], relatedPlan: work.planId ?? '', terminalAt: work.semanticUpdatedAt ?? work.updatedAt,
     outcome: work.completionOutcome ?? 'completed', sourceWork: work.workId,
-    completionReceipt: receipt.receiptId, workScope,
+    completionReceipt: receipt?.receiptId ?? '', workScope,
   };
 }
 

package/src/cli/commands/chatgpt.ts

@@ -13,12 +13,7 @@ import {
 } from '../chatgpt-browser/engine';
 import type { BrowserProviderName, BrowserSessionStatus, NativeBrowserChannel, ThinkingLevel } from '../chatgpt-browser/types';
 import { durableControllerHome } from '../repositories/controller-home';
-import {
-  runWorkChatgptContinuation,
-  type ChatgptAutomationReasoning,
-  type ChatgptAutomationTabPolicy,
-} from '../../runtime/control-plane/launcher/chatgpt-work-continuation';
-import { closeChatgptControllerRoundFromSource, continueChatgptControllerRoundFromSource, openChatgptControllerRoundFromSource } from '../../runtime/control-plane/launcher/chatgpt-round-continuation';
+import { closeChatgptControllerRoundFromSource } from '../../runtime/control-plane/launcher/chatgpt-round-continuation';
 
 interface BrowserCommonOptions {
   repo?: string;
@@ -81,43 +76,6 @@ interface BrowserConsultOptions extends BrowserCommonOptions {
   headless?: boolean;
 }
 
-interface WorkChatgptContinueOptions extends BrowserCommonOptions {
-  controllerHome: string;
-  repoId: string;
-  workId: string;
-  prompt: string;
-  title?: string;
-  session?: string;
-  conversationUrl?: string;
-  model?: string;
-  reasoning?: string;
-  tabPolicy?: string;
-  timeoutMs?: string;
-  controllerAuthorityId?: string;
-  relayScopeId?: string;
-}
-
-interface SourceRoundOpenOptions extends BrowserCommonOptions {
-  controllerHome?: string;
-  repoId: string;
-  workId: string;
-  controllerId: string;
-  principalId: string;
-  controllerInstanceId?: string;
-  continuationPrompt?: string;
-  timeoutMs?: string;
-}
-
-interface SourceRoundContinueOptions extends BrowserCommonOptions {
-  controllerHome?: string;
-  repoId: string;
-  workId: string;
-  controllerAuthorityId: string;
-  relayScopeId: string;
-  reason?: string;
-  timeoutMs?: string;
-}
-
 interface SourceRoundCloseOptions extends BrowserCommonOptions {
   controllerHome?: string;
   repoId: string;
@@ -156,18 +114,6 @@ interface BrowserFollowupOptions extends BrowserCommonOptions {
   oracleBin?: string;
 }
 
-function parseAutomationReasoning(value?: string): ChatgptAutomationReasoning | undefined {
-  if (value === undefined) return undefined;
-  if (value === 'medium' || value === 'high' || value === 'xhigh') return value;
-  throw new Error(`invalid --reasoning "${value}" (expected: medium, high, xhigh)`);
-}
-
-function parseAutomationTabPolicy(value?: string): ChatgptAutomationTabPolicy | undefined {
-  if (value === undefined) return undefined;
-  if (value === 'auto' || value === 'reuse' || value === 'new') return value;
-  throw new Error(`invalid --tab-policy "${value}" (expected: auto, reuse, new)`);
-}
-
 function parseProvider(value?: string): BrowserProviderName {
   if (value === undefined || value === 'oracle') return 'oracle';
   if (value === 'native') return 'native';
@@ -435,114 +381,6 @@ export function buildChatgptCommand(): Command {
       });
     });
 
-  const workContinue = new Command('work-continue')
-    .description('Internal: continue one Forge Work in its bound ChatGPT Web conversation')
-    .option('--repo <path>', 'Repository root for the Work browser session', '.')
-    .requiredOption('--controller-home <path>', 'Explicit Controller Home containing the authoritative Work and conversation binding')
-    .requiredOption('--repo-id <repo-id>', 'Stable Forge repository id')
-    .requiredOption('--work-id <work-id>', 'Stable Forge Work id')
-    .requiredOption('--prompt <text>', 'Bounded continuation prompt')
-    .option('--title <title>', 'Human-readable local conversation alias')
-    .option('--session <session-id>', 'Saved browser session to seed or resume the Work binding')
-    .option('--conversation-url <url>', 'Explicit ChatGPT conversation URL to seed the binding')
-    .option('--model <label>', 'Requested ChatGPT automation model', 'gpt-5.6')
-    .option('--reasoning <level>', 'Reasoning level: medium|high|xhigh', 'high')
-    .option('--tab-policy <policy>', 'Browser tab policy: auto|reuse|new', 'auto')
-    .option('--timeout-ms <ms>', 'Assistant timeout in milliseconds')
-    .option('--controller-authority-id <id>', 'Durable ControllerRound authority for source-mode continuation')
-    .option('--relay-scope-id <id>', 'Durable ControllerRound relay scope paired with controller authority')
-    .action((rawOpts: WorkChatgptContinueOptions) => {
-      void runChatgptAction(async () => {
-        const result = await runWorkChatgptContinuation({
-          controllerHome: durableControllerHome(rawOpts.controllerHome),
-          repoId: rawOpts.repoId,
-          repoRoot: resolveRepoRoot(rawOpts.repo),
-          workId: rawOpts.workId,
-          prompt: rawOpts.prompt,
-          controllerAuthorityId: rawOpts.controllerAuthorityId,
-          relayScopeId: rawOpts.relayScopeId,
-          title: rawOpts.title,
-          browserSessionId: rawOpts.session,
-          conversationUrl: rawOpts.conversationUrl,
-          model: rawOpts.model,
-          reasoning: parseAutomationReasoning(rawOpts.reasoning),
-          tabPolicy: parseAutomationTabPolicy(rawOpts.tabPolicy),
-          timeoutMs: parsePositiveInteger('timeout-ms', rawOpts.timeoutMs),
-        });
-        console.log(JSON.stringify({
-          status: result.status,
-          provider: result.provider,
-          sessionId: result.browserSessionId,
-          conversationUrl: result.conversationUrl,
-          conversationId: result.conversationId,
-          localAlias: result.localAlias,
-          resumedFromBinding: result.resumedFromBinding,
-          model: result.model,
-          reasoning: result.reasoning,
-          tabPolicy: result.tabPolicy,
-          executionPreferenceVerified: result.executionPreferenceVerified,
-          error: result.error,
-        }, null, 2));
-      });
-    });
-  chatgpt.addCommand(workContinue, { hidden: true });
-
-  const roundOpen = new Command('round-open')
-    .description('Internal: open and dispatch one ChatGPT ControllerRound from current source')
-    .option('--repo <path>', 'Repository root used by the ChatGPT Browser delivery host', '.')
-    .option('--controller-home <path>', 'Explicit Controller Home containing ControllerRound authority; defaults to canonical user-level Forge Controller Home')
-    .requiredOption('--repo-id <repo-id>', 'Stable Forge repository id')
-    .requiredOption('--work-id <work-id>', 'Forge Work id to dispatch')
-    .requiredOption('--controller-id <id>', 'Authenticated ChatGPT controller id/principal identity')
-    .requiredOption('--principal-id <id>', 'Authenticated ChatGPT principal id')
-    .option('--controller-instance-id <id>', 'Source launcher instance identity')
-    .option('--continuation-prompt <text>', 'Bounded source-mode continuation instruction')
-    .option('--timeout-ms <ms>', 'Assistant dispatch timeout in milliseconds')
-    .action((rawOpts: SourceRoundOpenOptions) => {
-      void runChatgptAction(async () => {
-        const result = await openChatgptControllerRoundFromSource({
-          controllerHome: durableControllerHome(rawOpts.controllerHome),
-          repoId: rawOpts.repoId,
-          repoRoot: resolveRepoRoot(rawOpts.repo),
-          workId: rawOpts.workId,
-          controllerId: rawOpts.controllerId,
-          principalId: rawOpts.principalId,
-          controllerInstanceId: rawOpts.controllerInstanceId,
-          continuationPrompt: rawOpts.continuationPrompt,
-          timeoutMs: parsePositiveInteger('timeout-ms', rawOpts.timeoutMs),
-        });
-        console.log(JSON.stringify(result, null, 2));
-      });
-    });
-  chatgpt.addCommand(roundOpen, { hidden: true });
-
-  const roundContinue = new Command('round-continue')
-    .description('Internal: close one claimed ChatGPT ControllerRound and immediately dispatch its successor from current source')
-    .option('--repo <path>', 'Repository root used by the ChatGPT Browser delivery host', '.')
-    .option('--controller-home <path>', 'Explicit Controller Home containing ControllerRound authority; defaults to canonical user-level Forge Controller Home')
-    .requiredOption('--repo-id <repo-id>', 'Stable Forge repository id')
-    .requiredOption('--work-id <work-id>', 'Currently claimed Forge Work id')
-    .requiredOption('--controller-authority-id <id>', 'Exact durable ControllerRound authority')
-    .requiredOption('--relay-scope-id <id>', 'Exact durable ControllerRound relay scope')
-    .option('--reason <text>', 'Bounded semantic continuation reason')
-    .option('--timeout-ms <ms>', 'Assistant dispatch timeout in milliseconds')
-    .action((rawOpts: SourceRoundContinueOptions) => {
-      void runChatgptAction(async () => {
-        const result = await continueChatgptControllerRoundFromSource({
-          controllerHome: durableControllerHome(rawOpts.controllerHome),
-          repoId: rawOpts.repoId,
-          repoRoot: resolveRepoRoot(rawOpts.repo),
-          workId: rawOpts.workId,
-          controllerAuthorityId: rawOpts.controllerAuthorityId,
-          relayScopeId: rawOpts.relayScopeId,
-          reason: rawOpts.reason,
-          timeoutMs: parsePositiveInteger('timeout-ms', rawOpts.timeoutMs),
-        });
-        console.log(JSON.stringify(result, null, 2));
-      });
-    });
-  chatgpt.addCommand(roundContinue, { hidden: true });
-
   const roundClose = new Command('round-close')
     .description('Internal: reconcile and close one claimed ChatGPT ControllerRound from current source without dispatching a successor')
     .option('--controller-home <path>', 'Explicit Controller Home containing ControllerRound authority; defaults to canonical user-level Forge Controller Home')