@moretea-labs/forge 1.5.0-rc.1 → 1.5.1

package/src/runtime/execution/process-runtime/command-facade.ts

@@ -42,8 +42,10 @@ export interface RepositoryCommandProcessInput {
   timeoutMs?: number;
   interactiveWaitMs?: number;
   maxOutputBytes?: number;
-  /** Force durable workflow (async apply, release, remote). */
+  /** Force an explicit external/durable workflow boundary. */
   forceDurable?: boolean;
+  /** Return a Process handle immediately without changing execution architecture. */
+  returnHandleImmediately?: boolean;
   requestId?: string;
   workId?: string;
   commandId?: string;
@@ -297,7 +299,7 @@ export async function executeRepositoryCommandViaProcessRuntime(
       correlationId: input.workId,
     },
     signal: input.signal,
-    returnHandleImmediately: input.forceDurable === true,
+    returnHandleImmediately: input.returnHandleImmediately === true,
   });
 
   const route: RepositoryCommandRoute = handle.completed ? 'process_direct' : 'process_managed';

package/src/runtime/execution/process-runtime/gc.ts

@@ -134,7 +134,7 @@ export function gcTerminalProcesses(options: ProcessGcOptions): ProcessGcResult
     for (const victim of victims) {
       if (safeUnlink(victim.path)) removedRecords += 1;
       if (options.deleteLogs !== false) {
-        for (const suffix of ['.stdout.log', '.stderr.log', '.exit.json']) {
+        for (const suffix of ['.stdout.log', '.stderr.log', '.exit.json', '.exit.json.started.json']) {
           if (safeUnlink(join(logs, `${victim.processId}${suffix}`))) removedLogs += 1;
         }
       }

package/src/runtime/execution/process-runtime/index.ts

@@ -7,3 +7,6 @@ export * from './check-receipt';
 export * from './command-facade';
 export * from './gc';
 export type { ProcessCommandDescriptor, ProcessRunnerExitReceipt } from './process-runner-entry';
+export * from './persisted-check';
+
+export * from './check-result';

package/src/runtime/execution/process-runtime/interactive-admission.ts

@@ -4,11 +4,20 @@ const SHORT_COMMANDS = new Set([
   'true', 'false', 'echo', 'printf', 'pwd', 'basename', 'dirname', 'test', '[', 'which',
 ]);
 
+// ChatGPT reaches Process Runtime through a remote MCP hop. Returning a handle
+// immediately for a process that finishes a few milliseconds later forces an
+// additional caller round trip that is much more expensive than a small local
+// completion grace. Keep this far below the retired 800ms-2s waits: genuinely
+// long commands still become managed almost immediately.
+const DEFAULT_COMPLETION_GRACE_MS = 100;
+
 /**
  * Admission is deliberately category-based rather than a second scheduler.
- * Only commands that are predictably sub-second get a synchronous window;
- * builds, tests, shells, and unknown programs return their existing handle
- * immediately. Callers may always explicitly override the recommendation.
+ * Predictable primitives retain the larger short-command window. Other
+ * synchronous commands receive only a tiny completion grace so near-immediate
+ * processes can finish in the originating MCP call instead of forcing a second
+ * remote process_wait round trip. Explicit async/zero-wait callers still return
+ * handles immediately.
  */
 export function durationAwareInteractiveWaitMs(
   command: string | readonly string[],
@@ -17,7 +26,7 @@ export function durationAwareInteractiveWaitMs(
 ): number {
   if (requestedWaitMs !== undefined) return Math.max(0, Math.trunc(requestedWaitMs));
   const normalized = normalizeRepositoryCommand(command);
-  if (normalized.kind !== 'argv') return 0;
+  if (normalized.kind !== 'argv') return DEFAULT_COMPLETION_GRACE_MS;
   const executable = normalized.executable?.split(/[\\/]/).at(-1)?.toLowerCase();
-  return executable && SHORT_COMMANDS.has(executable) ? shortCommandWaitMs : 0;
+  return executable && SHORT_COMMANDS.has(executable) ? shortCommandWaitMs : DEFAULT_COMPLETION_GRACE_MS;
 }

package/src/runtime/execution/process-runtime/persisted-check.ts

@@ -0,0 +1,285 @@
+import { createHash } from 'crypto';
+import { existsSync } from 'fs';
+import { dirname, resolve } from 'path';
+import {
+  controllerCheckExecutionIdentity,
+  listControllerChecks,
+  snapshotControllerCheck,
+} from '../../../cli/controller/check-runner';
+import {
+  currentCliRuntimeTarget,
+  resolveCliChildInvocation,
+  type CliChildInvocation,
+  type CliChildInvocationOptions,
+  type CliRuntimeTarget,
+} from '../../../cli/runtime-invocation';
+import { readRuntimeGeneration, resolveControllerRuntimeSourceRoot } from '../../control-plane/runtime-generation';
+import { cleanupWorkVerificationSnapshot, materializeWorkVerificationSnapshot } from '../../control-plane/execution/work-verification-snapshot';
+import {
+  checkRequiresDurableWorkflow,
+  processCheckSemanticScopeKey,
+  type CheckExecutionMode,
+  type RunCheckFacadeInput,
+  type RunCheckFacadeResult,
+} from './check-facade';
+import { claimsForCheck, toProcessClaims } from './resource-claims';
+import { spawnManagedProcess } from './runtime';
+import { allocatePersistedCheckResultReceiptPath } from './check-result';
+import { durationAwareInteractiveWaitMs } from './interactive-admission';
+const PERSISTED_CHECK_SOURCE_ENTRY = 'src/runtime/execution/process-runtime/check-runner-sidecar.ts';
+
+export function resolvePersistedCheckCliInvocation(
+  cliEntry: string,
+  args: string[],
+  options: CliChildInvocationOptions = {},
+): CliChildInvocation {
+  return resolveCliChildInvocation(cliEntry, args, options);
+}
+
+export function resolveRuntimeCliTarget(controllerHome?: string): CliRuntimeTarget {
+  const moduleSourceRoot = resolve(import.meta.dir, '..', '..', '..', '..');
+  const sourceEntry = resolve(moduleSourceRoot, 'src', 'cli', 'index.ts');
+  const source = resolveControllerRuntimeSourceRoot({
+    explicitRoot: existsSync(sourceEntry) ? moduleSourceRoot : undefined,
+  });
+  const sourceMode = Boolean(source.root && existsSync(resolve(source.root, 'src', 'cli', 'index.ts')));
+  const runtimeEnv = { ...process.env };
+  if (sourceMode) {
+    delete runtimeEnv.FORGE_RUNTIME_EXECUTION;
+    delete runtimeEnv.FORGE_RUNTIME_CLI_ENTRY;
+  }
+  const generation = controllerHome ? readRuntimeGeneration(controllerHome) : undefined;
+  return currentCliRuntimeTarget({
+    env: runtimeEnv,
+    argv: sourceMode ? [] : process.argv,
+    moduleUrl: sourceMode ? undefined : import.meta.url,
+    sourceRoot: source.root,
+    cwd: source.root ?? moduleSourceRoot,
+    sourceRevision: generation?.source.releaseRevision
+      ?? generation?.source.commit
+      ?? process.env.FORGE_ACTIVE_RUNTIME_REVISION,
+  });
+}
+
+export function resolveRuntimeCliEntry(controllerHome?: string): string {
+  return resolveRuntimeCliTarget(controllerHome).entry;
+}
+
+export function persistedCheckSemanticScopeKey(
+  input: Pick<RunCheckFacadeInput, 'workId' | 'verificationBinding' | 'checkoutId'>,
+  reuseScope: 'repository' | 'checkout',
+): string {
+  return processCheckSemanticScopeKey(input, reuseScope);
+}
+
+export function resolvePersistedCheckRuntimeExecutable(
+  cliTarget: CliRuntimeTarget,
+  runtimeExecutable = process.execPath,
+  entryExists: (path: string) => boolean = existsSync,
+): string {
+  if (cliTarget.runtimeKind !== 'compiled_bun_release') return runtimeExecutable;
+  const checkRunner = resolve(dirname(runtimeExecutable), 'forge-check-runner');
+  if (!entryExists(checkRunner)) {
+    throw new Error(`PERSISTED_CHECK_RUNNER_MISSING: ${checkRunner}`);
+  }
+  return checkRunner;
+}
+
+export function resolvePersistedCheckProcessInvocation(
+  cliTarget: CliRuntimeTarget,
+  args: string[],
+  options: { runtimeExecutable?: string; entryExists?: (path: string) => boolean } = {},
+): CliChildInvocation {
+  const runtimeExecutable = options.runtimeExecutable ?? process.execPath;
+  const executable = resolvePersistedCheckRuntimeExecutable(cliTarget, runtimeExecutable, options.entryExists ?? existsSync);
+  if (cliTarget.runtimeKind === 'compiled_bun_release') {
+    return { executable, args };
+  }
+  const sourceEntry = resolve(cliTarget.cwd, PERSISTED_CHECK_SOURCE_ENTRY);
+  if (!(options.entryExists ?? existsSync)(sourceEntry)) {
+    throw new Error(`PERSISTED_CHECK_SOURCE_RUNNER_MISSING: ${sourceEntry}`);
+  }
+  return resolvePersistedCheckCliInvocation(sourceEntry, args, {
+    runtimeExecutable: executable,
+    runtimeKind: cliTarget.runtimeKind,
+    sourceRevision: cliTarget.sourceRevision,
+    immutable: false,
+    ...(cliTarget.runtimeKind === 'package_launcher' ? { launcherEntry: cliTarget.entry } : {}),
+  });
+}
+
+/**
+ * Run a registered check through Process Runtime while keeping check-runner
+ * evidence authoritative. The managed OS process invokes the same immutable
+ * forge CLI bundle with a hidden internal subcommand; that subcommand
+ * executes runControllerCheck, writes the Artifact atomically, mirrors bounded
+ * stdout/stderr, and exits with the exact check status.
+ */
+export async function runPersistedCheckViaProcessRuntime(
+  input: RunCheckFacadeInput,
+): Promise<RunCheckFacadeResult> {
+  const emptyEffects = {
+    executionJobCount: 0,
+    localJobCount: 0,
+    workerSpawnCount: 0,
+    projectionUpdateCount: 0,
+  };
+  const verificationSnapshot = input.verificationSnapshot
+    ? materializeWorkVerificationSnapshot({
+        controllerHome: input.controllerHome,
+        repoId: input.repoId,
+        sourceRoot: input.repoRoot,
+        scope: input.verificationSnapshot,
+      })
+    : undefined;
+  const executionRoot = verificationSnapshot?.root ?? input.repoRoot;
+  const cleanupVerificationSnapshot = () => {
+    if (verificationSnapshot) cleanupWorkVerificationSnapshot(verificationSnapshot.root);
+  };
+  const check = listControllerChecks(executionRoot).find((entry) => entry.id === input.checkId);
+  if (!check) {
+    cleanupVerificationSnapshot();
+    return {
+      mode: 'durable',
+      checkId: input.checkId,
+      durable: {
+        reason: 'check_not_found_or_requires_registry_lookup',
+        suggestedOperation: 'list_checks then run_check with a known check_id',
+      },
+      durableSideEffects: emptyEffects,
+    };
+  }
+  if (input.forceDurable || checkRequiresDurableWorkflow(input.checkId, check)) {
+    cleanupVerificationSnapshot();
+    return {
+      mode: 'durable',
+      checkId: input.checkId,
+      check,
+      durable: {
+        reason: 'multi_phase_or_release_check_requires_durable_workflow',
+        suggestedOperation: 'Claim the related WorkContract and run this check through an external Controller.',
+      },
+      durableSideEffects: emptyEffects,
+    };
+  }
+
+  const interactiveWaitMs = durationAwareInteractiveWaitMs(check.command, input.interactiveWaitMs);
+  const leaseWaitMs = input.leaseWaitMs;
+  const timeoutMs = Math.min(
+    check.timeoutMs,
+    typeof input.timeoutMs === 'number' && Number.isFinite(input.timeoutMs)
+      ? Math.max(1_000, Math.trunc(input.timeoutMs))
+      : check.timeoutMs,
+  );
+  if (!input.executionIdentity) {
+    throw new Error('EXECUTION_IDENTITY_REQUIRED: persisted run_check requires an immutable executionIdentity');
+  }
+  const executionIdentity = input.executionIdentity;
+  if (executionIdentity.repositoryId !== input.repoId) {
+    throw new Error(
+      `EXECUTION_IDENTITY_MISMATCH: check repo ${input.repoId} differs from identity ${executionIdentity.repositoryId}`,
+    );
+  }
+  if (input.checkoutId?.trim() && executionIdentity.checkoutId !== input.checkoutId.trim()) {
+    throw new Error(
+      `CHECKOUT_ROUTE_MISMATCH: check checkout ${input.checkoutId} differs from identity ${executionIdentity.checkoutId}`,
+    );
+  }
+  const claims = claimsForCheck(
+    input.checkId,
+    check.command,
+    executionIdentity.repositoryId,
+    executionIdentity.checkoutId,
+    check.effects,
+  );
+  const checkSnapshot = snapshotControllerCheck(executionRoot, input.checkId);
+  const checkFingerprint = createHash('sha256')
+    .update(JSON.stringify(checkSnapshot))
+    .digest('hex');
+  const semanticCheck = controllerCheckExecutionIdentity(
+    executionRoot,
+    input.checkId,
+    timeoutMs,
+    checkSnapshot,
+  );
+  const processCheckExecution = {
+    schemaVersion: 1 as const,
+    checkId: semanticCheck.checkId,
+    cacheKey: semanticCheck.cacheKey,
+    revision: semanticCheck.revision,
+    definitionDigest: semanticCheck.definitionDigest,
+    environmentFingerprint: semanticCheck.environmentFingerprint,
+    timeoutMs: semanticCheck.timeoutMs,
+    reuseScope: semanticCheck.reuseScope,
+    scopeKey: persistedCheckSemanticScopeKey(input, semanticCheck.reuseScope),
+  };
+  const cliTarget = resolveRuntimeCliTarget(input.controllerHome);
+  const checkResultReceiptPath = allocatePersistedCheckResultReceiptPath(input.controllerHome, input.repoId);
+  const checkArgs = [
+    '--repo',
+    executionRoot,
+    '--check-id',
+    input.checkId,
+    '--timeout-ms',
+    String(timeoutMs),
+    '--expected-check-fingerprint',
+    checkFingerprint,
+    '--result-receipt',
+    checkResultReceiptPath,
+    ...(verificationSnapshot ? ['--cleanup-root', verificationSnapshot.root] : []),
+  ];
+  const invocation = resolvePersistedCheckProcessInvocation(cliTarget, checkArgs);
+  let handle;
+  try {
+    handle = await spawnManagedProcess({
+    controllerHome: input.controllerHome,
+    repoId: executionIdentity.repositoryId,
+    checkoutId: executionIdentity.checkoutId,
+    executionIdentity,
+    workId: input.workId,
+    commandId: input.commandId,
+    command: {
+      kind: 'argv',
+      executable: invocation.executable,
+      args: invocation.args,
+      cwd: executionIdentity.canonicalRoot,
+    },
+    interactiveWaitMs,
+    leaseWaitMs,
+    timeoutMs: timeoutMs + 5_000,
+    resourceClaims: toProcessClaims(claims),
+    checkExecution: processCheckExecution,
+    origin: {
+      surface: 'check',
+      toolName: 'run_check',
+      checkId: input.checkId,
+      requestId: input.requestId,
+      correlationId: input.workId,
+      executionSessionId: input.verificationBinding?.executionSessionId,
+      editSessionId: input.verificationBinding?.editSessionId,
+      editRevision: input.verificationBinding?.editRevision,
+      issueId: input.verificationBinding?.issueId,
+      taskId: input.verificationBinding?.taskId,
+      checkResultReceiptPath,
+      workVerificationSnapshot: Boolean(verificationSnapshot),
+    },
+    signal: input.signal,
+  });
+  } catch (error) {
+    cleanupVerificationSnapshot();
+    throw error;
+  }
+  if (verificationSnapshot && (handle.deduplicated === true || handle.semanticDeduplicated === true)) {
+    cleanupVerificationSnapshot();
+  }
+
+  const mode: CheckExecutionMode = handle.completed ? 'direct' : 'managed';
+  return {
+    mode,
+    checkId: input.checkId,
+    check,
+    process: handle,
+    ok: handle.completed ? handle.ok : undefined,
+    durableSideEffects: handle.durableSideEffects,
+  };
+}

package/src/runtime/execution/process-runtime/resource-claims.ts

@@ -130,6 +130,33 @@ function browserAppleScriptHeredocClaims(script: string): ResourceClaimSpec[] |
   return [claimHostService(`osascript:${uniqueTargets[0]}`, 'write')];
 }
 
+function iosSimulatorTestCommandClaims(
+  command: string | readonly string[],
+  repoId: string,
+  checkoutId?: string,
+): ResourceClaimSpec[] | undefined {
+  const canonical = normalizeRepositoryCommand(command);
+  const isTestAction = (text: string): boolean => /(?:^|\s)(?:test|test-without-building)(?:\s|$)/i.test(text);
+  let matches = false;
+  if (canonical.kind === 'argv') {
+    const program = (canonical.executable ?? '').split(/[\\/]/).at(-1)?.toLowerCase();
+    if (program === 'xcodebuild') matches = (canonical.args ?? []).some((arg) => /^(?:test|test-without-building)$/i.test(arg));
+    if (!matches) {
+      const wrapped = fixedShellWrapperCommand([canonical.executable ?? '', ...(canonical.args ?? [])]);
+      matches = Boolean(wrapped && /\bxcodebuild\b/i.test(wrapped) && isTestAction(wrapped));
+    }
+  } else {
+    const shell = canonical.shellCommand ?? '';
+    matches = /\bxcodebuild\b/i.test(shell) && isTestAction(shell);
+  }
+  if (!matches) return undefined;
+  return normalizeClaims([
+    claimWorkspaceRead(checkoutId),
+    claimBuildCacheWrite(repoId),
+    claimHostService('ios-simulator-test', 'write'),
+  ]);
+}
+
 function hostOnlyCommandClaims(command: string | readonly string[]): ResourceClaimSpec[] | undefined {
   const canonical = normalizeRepositoryCommand(command);
   if (canonical.kind === 'shell') {
@@ -208,6 +235,7 @@ function claimsForDeclaredCheckEffects(
   if (effects.git === 'refs') claims.push(claimGitRefs(repoId));
   if (effects.git === 'write') claims.push(claimWorkspaceWrite(checkoutId), claimGitIndex(checkoutId), claimGitRefs(repoId));
   if (effects.network) claims.push(claimNetwork(repoId, effects.network));
+  for (const service of effects.hostServices ?? []) claims.push(claimHostService(service, 'write'));
 
   return normalizeClaims(claims, { readOnly: claims.every((claim) => claim.mode === 'read') });
 }
@@ -323,6 +351,8 @@ export function claimsForRepositoryCommand(
   const classification = classifyRepositoryCommand(command, defaultBranch);
   const canonical = normalizeRepositoryCommand(command);
   const focused = isFocusedCheckCommand(command);
+  const iosSimulatorClaims = iosSimulatorTestCommandClaims(command, repoId, checkoutId);
+  if (iosSimulatorClaims) return iosSimulatorClaims;
   const hostClaims = hostOnlyCommandClaims(command);
   if (hostClaims) return hostClaims;
 

package/src/runtime/execution/process-runtime/runtime.ts

@@ -121,6 +121,21 @@ function safeProcessText(value: string): string {
   return redactSensitiveText(value).text;
 }
 
+function cleanupTerminalRunnerReceipts(record: ManagedProcessRecord): void {
+  if (!isManagedProcessTerminal(record) || record.terminalWritten !== true || record.leasesReleased !== true) return;
+  const exitReceiptPath = record.exitReceiptPath
+    ?? receiptPathFor(record.controllerHome, record.repoId, record.processId);
+  for (const path of [exitReceiptPath, `${exitReceiptPath}.started.json`]) {
+    if (!path || !existsSync(path)) continue;
+    try {
+      rmSync(path, { force: true });
+    } catch {
+      // Best-effort only. The durable terminal record is authoritative and
+      // fallback Process GC reconciles stale runner artifacts later.
+    }
+  }
+}
+
 function sanitizeTerminalProcessArtifacts(record: ManagedProcessRecord): ManagedProcessRecord {
   if (!isManagedProcessTerminal(record)) return record;
   let filesExamined = 0;
@@ -555,7 +570,9 @@ export function completeProcessFromEvidence(
   // already-terminal races (second caller still needs to clear leases once).
   const afterTerminal = completion.record ?? getProcessRecord(controllerHome, repoId, processId);
   if (afterTerminal && (completion.ok || completion.reason === 'already_terminal' || afterTerminal.terminalWritten === true)) {
-    return releaseProcessLeasesOnce(controllerHome, repoId, processId) ?? afterTerminal;
+    const released = releaseProcessLeasesOnce(controllerHome, repoId, processId) ?? afterTerminal;
+    cleanupTerminalRunnerReceipts(released);
+    return released;
   }
   return afterTerminal;
 }

package/src/runtime/execution/process-runtime/store.ts

@@ -1,7 +1,7 @@
 /**
  * Durable Managed Process records under controller-home repositories.
  * Layout: repositories/<repoId>/processes/<processId>.json
- * Index: repositories/<repoId>/processes/active-index.json
+ * Recovery membership authority: SQLite process_recovery_index/v2.
  */
 
 import { createHash } from 'crypto';
@@ -87,10 +87,6 @@ function checkExecutionBindingPath(controllerHome: string, repoId: string, scope
   return join(checkExecutionBindingsRoot(controllerHome, repoId), `${checkExecutionBindingKey(repoId, scopeKey, cacheKey)}.json`);
 }
 
-function indexPath(controllerHome: string, repoId: string): string {
-  return join(processesRoot(controllerHome, repoId), 'active-index.json');
-}
-
 interface ProcessRecoveryIndex {
   schemaVersion: 2;
   updatedAt: string;
@@ -118,18 +114,6 @@ function processRecoveryMembership(record: ManagedProcessRecord): { active: bool
   };
 }
 
-function projectRecoveryIndex(controllerHome: string, repoId: string, index: ProcessRecoveryIndex): void {
-  // Compatibility/readability projection only. SQLite is authoritative; the
-  // projection is never read by Process Runtime after v2 migration.
-  atomicWrite(indexPath(controllerHome, repoId), {
-    schemaVersion: 2,
-    source: 'sqlite_projection',
-    updatedAt: index.updatedAt,
-    processIds: index.activeProcessIds,
-    pendingLeaseReleaseIds: index.pendingLeaseReleaseIds,
-  });
-}
-
 function readRecoveryIndex(controllerHome: string, repoId: string): ProcessRecoveryIndex | undefined {
   return readOrImportControlPlaneRecord<ProcessRecoveryIndex>(controllerHome, {
     namespace: PROCESS_RECOVERY_INDEX_NAMESPACE,
@@ -163,7 +147,6 @@ function replaceRecoveryIndex(
       pendingLeaseReleaseIds: normalizedProcessIds(pendingLeaseReleaseIds),
     }),
   }).value;
-  projectRecoveryIndex(controllerHome, repoId, value);
   return value;
 }
 
@@ -224,7 +207,6 @@ function updateRecoveryIndexMembership(
       };
     },
   }).value;
-  projectRecoveryIndex(controllerHome, repoId, value);
   return value;
 }
 

package/src/runtime/execution/process-runtime/types.ts

@@ -248,6 +248,10 @@ export interface ManagedProcessRecord {
     /** Optional durable task identity consuming the same receipt. */
     issueId?: string;
     taskId?: string;
+    /** Internal structured result written by the persisted Check sidecar. */
+    checkResultReceiptPath?: string;
+    /** True when this Check executed in a Work-owned verification snapshot. */
+    workVerificationSnapshot?: boolean;
   };
   error?: { code: string; message: string };
   /** Sidecar exit receipt path written by wrapper (survives controller restart). */

package/src/runtime/execution/thin-harness/execution-router.ts

@@ -675,7 +675,6 @@ function durableSuggestion(operation: string): string {
   if (operation.includes('patch')) return 'repository_safe_patch_apply with apply_mode=async or Durable Work';
   if (operation.includes('command')) return 'repository_command_execute through Durable Work / Local Job';
   if (operation.includes('agent') || operation === 'quick_agent_session') return 'quick_agent_session / dispatch_task';
-  if (operation.includes('campaign')) return 'Campaign (opt-in long orchestration only)';
   return 'Durable Work (ExecutionJob path)';
 }
 

package/src/runtime/execution/thin-harness/fast-executor.ts

@@ -419,7 +419,7 @@ function ownershipOptionsFor(
 }
 
 /**
- * Execute one Fast Path operation without ExecutionJob / Local Job / Worker / Campaign.
+ * Execute one Fast Path operation without ExecutionJob / Local Job / Worker.
  */
 export async function executeFast(
   ctx: FastExecutorContext,

package/src/runtime/execution/thin-harness/lightweight-lanes.ts

@@ -157,7 +157,7 @@ function digest(value: unknown): string {
 }
 
 /**
- * Lightweight concurrent lanes without Campaign/Issue/worktree.
+ * Lightweight concurrent lanes without Issue/worktree.
  * Read lanes use async Fast primitives. Proposal lanes only validate conflicts (no Agent analysis).
  */
 export async function executeLightweightLanes(
@@ -429,7 +429,6 @@ export async function executeLightweightLanes(
     latency,
     appliedByIntegrator: false,
     createdIssue: false,
-    createdCampaign: false,
     createdWorktree: false,
     concurrent,
   };

package/src/runtime/execution/thin-harness/types.ts

@@ -295,7 +295,6 @@ export interface LightweightLanesResult {
   latency: LatencyBreakdown;
   appliedByIntegrator: false;
   createdIssue: false;
-  createdCampaign: false;
   createdWorktree: false;
   concurrent: boolean;
 }

package/src/runtime/execution/workers/executor.ts

@@ -22,7 +22,7 @@ import {
 import { markOperationDelegated } from '../jobs/receipt-store';
 import { assertAutomatedOperationAllowed } from '../../control-plane/governance/external-effects';
 import { recordCandidateFinding, updateCandidateFinding } from '../../workflow/findings/store';
-import { triggerWorkspaceAgent } from '../../workflow/campaigns/workspace-agent';
+import { triggerWorkspaceAgent } from '../workspace-agent';
 import { executeAssistantPluginAction } from '../../plugins/store';
 import { CONTROLLER_SCOPE_REPO_ID, controllerSystemRoot, repositoryControllerRoot } from '../../../cli/repositories/controller-home';
 import { writeExecutionArtifact } from '../../evidence/artifact-store';

package/src/runtime/gateway/mcp/execution-tools.ts

@@ -18,7 +18,7 @@ import { repositoryGitCommit, repositoryGitDeleteBranch, repositoryGitFinishWork
 import { previewRepositoryCommandExecution } from '../../../cli/repositories/command-executor';
 import { classifyRepositoryCommand } from '../../../cli/repositories/command-classifier';
 import { globMatches } from '../../../cli/mcp/paths';
-import { ensureManagedWorkspace } from '../../workflow/campaigns/workspace';
+import { ensureManagedWorkspace } from '../../execution/managed-workspace';
 import { listControllerChecks } from '../../../cli/controller/check-runner';
 import { readRepositoryAccessPolicy } from '../../control-plane/governance/access-policy';
 import { appendWorkEvidence, createWorkContract, getWorkContract, recordWorkCompletionReceipt, updateWorkContract, appendVerificationRecord } from '../../control-plane/facade/work-contract-store';