@moretea-labs/forge 1.8.0 → 1.8.1

package/src/runtime/control-plane/facade/work-task-projection.ts

@@ -1,66 +0,0 @@
-import type { ControllerTask, TaskStatus } from '../../../cli/controller/types';
-import { isRepositoryCompletionReceipt, type WorkContract, type WorkRisk } from './types';
-
-/**
- * Legacy Task statuses are a read-model vocabulary. They are intentionally
- * derived from Work and never fed back into Work or Requirement state.
- */
-export function taskStatusFromWork(work: Pick<WorkContract, 'status' | 'phase'>): TaskStatus {
-  if (work.status === 'completed') return 'done';
-  if (work.status === 'cancelled') return 'cancelled';
-  if (work.status === 'failed') return 'changes_requested';
-  if (work.status === 'blocked') return 'blocked';
-  if (work.status === 'running') {
-    return work.phase === 'verification' ? 'verifying' : work.phase === 'delivery' ? 'integrating' : work.phase === 'cleanup' ? 'cleanup_pending' : 'running';
-  }
-  if (work.status === 'ready') return 'ready_to_integrate';
-  return 'planned';
-}
-
-function workRiskToTaskRisk(risk: WorkRisk): ControllerTask['risk'] {
-  return risk;
-}
-
-/**
- * Project one Work into the old ControllerTask shape for compatibility UIs and
- * readers. The source Task object is not mutated and its duplicated contract
- * fields are never consulted by this projection.
- */
-export function projectControllerTaskFromWork(
-  task: ControllerTask,
-  work: WorkContract,
-): ControllerTask {
-  const projected: ControllerTask = {
-    ...task,
-    workId: work.workId,
-    objective: work.objective,
-    allowedPaths: [...work.allowedPaths],
-    forbiddenPaths: [...work.forbiddenPaths],
-    checks: [...work.checks],
-    acceptanceCriteria: [...work.acceptanceCriteria],
-    risk: workRiskToTaskRisk(work.risk),
-    // A reviewed legacy outcome is user-facing evidence. Historical failed or
-    // cancelled execution facts cannot move it backwards.
-    status: task.status === 'done' && work.status !== 'completed' ? 'done' : taskStatusFromWork(work),
-  };
-  if (work.completionReceipt && projected.verification && isRepositoryCompletionReceipt(work.completionReceipt)) {
-    projected.verification = {
-      ...projected.verification,
-      completionReceipt: work.completionReceipt,
-    };
-  }
-  return projected;
-}
-
-export function taskExecutionContractFromWork(work: WorkContract): Pick<ControllerTask, 'workId' | 'objective' | 'allowedPaths' | 'forbiddenPaths' | 'checks' | 'acceptanceCriteria' | 'risk' | 'status'> {
-  return {
-    workId: work.workId,
-    objective: work.objective,
-    allowedPaths: [...work.allowedPaths],
-    forbiddenPaths: [...work.forbiddenPaths],
-    checks: [...work.checks],
-    acceptanceCriteria: [...work.acceptanceCriteria],
-    risk: workRiskToTaskRisk(work.risk),
-    status: taskStatusFromWork(work),
-  };
-}

package/src/runtime/control-plane/routing/index.ts

@@ -1 +0,0 @@
-export * from './route-policy';

package/src/runtime/control-plane/routing/route-policy.ts

@@ -1,401 +0,0 @@
-import { createHash } from 'crypto';
-
-export const ROUTE_POLICY_VERSION = 'route-policy-v5' as const;
-
-export type RouteExecutionMode = 'direct_control' | 'goal_workloop' | 'handoff_only';
-export type RouteWorkMode = 'direct_edit' | 'bounded_work' | 'quick_agent' | 'issue_task';
-export type RouteExecutionPath = 'fast' | 'durable';
-export type RouteExecutorKind = 'direct_edit' | 'local_cli' | 'remote_api' | 'cloud_agent' | 'external_controller' | 'handoff_only';
-export type RouteApprovalState = 'approval_not_required' | 'normal_authorization_required' | 'strong_confirmation_required' | 'blocked_by_policy';
-export type ExplicitTaskMode = 'direct' | 'plan' | 'debug' | 'review' | 'release' | 'scale';
-
-export interface RouteReason {
-  code: string;
-  message: string;
-}
-
-export interface RouteContextHints {
-  preferredProviderId?: string;
-  allowedProviderIds?: readonly string[];
-  forbiddenProviderIds?: readonly string[];
-}
-
-export interface RouteProviderSnapshot {
-  providerId: string;
-  kind: 'direct_edit' | 'local_cli' | 'remote_api' | 'cloud_agent' | 'handoff_only';
-  status: string;
-  capabilities: readonly string[];
-  directDispatch: boolean;
-}
-
-export interface RoutePolicyInput {
-  intent: {
-    objective: string;
-    scopeClear: boolean;
-    mutation?: boolean;
-    taskIntent?: string;
-    expectedFiles?: number;
-    expectedChangedLines?: number;
-    requiresInvestigation?: boolean;
-    requiresLongRunningChecks?: boolean;
-    requiresParallelism?: boolean;
-    needsDependencies?: boolean;
-    requiresIndependentDeliverables?: boolean;
-    independentTaskCount?: number;
-    agentRequested?: boolean;
-    /** Explicit operator mode. It overrides heuristic topology, never policy gates. */
-    explicitMode?: ExplicitTaskMode;
-    preferredProviderId?: string;
-    allowedProviderIds?: readonly string[];
-    forbiddenProviderIds?: readonly string[];
-    lastProviderId?: string;
-    lastFailureClass?: string;
-  };
-  workspace: {
-    knownPaths?: readonly string[];
-    dirty?: boolean;
-    checkoutId?: string;
-    fingerprint?: string;
-    /** Canonical typed placement constraint resolved before routing. */
-    placement?: 'current' | 'isolated' | 'auto';
-    /** Admission fence: Direct Control/current-main mutation is not permitted. */
-    directMainProhibited?: boolean;
-  };
-  policy: {
-    risk?: string;
-    policyBlocked?: boolean;
-    requiresApproval?: boolean;
-    requiresUserApproval?: boolean;
-    approvalConfirmed?: boolean;
-    destructive?: boolean;
-    remoteWrite?: boolean;
-    secretAccess?: boolean;
-  };
-  capabilities: {
-    requiresWorker?: boolean;
-    requiresExternalEffect?: boolean;
-    requiredProviderCapabilities?: readonly string[];
-    providers?: readonly RouteProviderSnapshot[];
-    routingOrders?: Readonly<Record<string, readonly string[] | undefined>>;
-    defaultProviders?: Readonly<Record<string, string | undefined>>;
-  };
-  recovery: {
-    required?: boolean;
-    isolationRequired?: boolean;
-  };
-}
-
-export interface RouteDecision {
-  executionMode: RouteExecutionMode;
-  executorKind: RouteExecutorKind;
-  selectedProviderId: string | null;
-  workMode: RouteWorkMode;
-  executionPath: RouteExecutionPath;
-  requiresWork: boolean;
-  requiresApproval: boolean;
-  requiresIsolation: boolean;
-  requiresRecovery: boolean;
-  createHandoff: boolean;
-  waitForUser: boolean;
-  approvalState: RouteApprovalState;
-  alternatives: string[];
-  reasons: RouteReason[];
-  inputFingerprint: string;
-  policyVersion: typeof ROUTE_POLICY_VERSION;
-}
-
-const PROTECTED_PATH = /(^|\/)(\.github|\.git|.*\.xcodeproj|.*\.xcworkspace)(\/|$)/;
-
-function canonical(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(canonical);
-  if (!value || typeof value !== 'object') return value;
-  return Object.fromEntries(Object.entries(value as Record<string, unknown>)
-    .filter(([, item]) => item !== undefined)
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([key, item]) => [key, canonical(item)]));
-}
-
-export function routePolicyInputFingerprint(input: RoutePolicyInput): string {
-  return createHash('sha256').update(JSON.stringify(canonical(input))).digest('hex');
-}
-
-export function applyRouteContextHints(input: RoutePolicyInput, hints: RouteContextHints | undefined): RoutePolicyInput {
-  if (!hints) return input;
-  return {
-    ...input,
-    intent: {
-      ...input.intent,
-      preferredProviderId: input.intent.preferredProviderId ?? hints.preferredProviderId,
-      allowedProviderIds: input.intent.allowedProviderIds ?? hints.allowedProviderIds,
-      forbiddenProviderIds: input.intent.forbiddenProviderIds ?? hints.forbiddenProviderIds,
-    },
-  };
-}
-
-function ready(provider: RouteProviderSnapshot, required: readonly string[]): boolean {
-  return provider.directDispatch
-    && provider.status === 'ready'
-    && provider.kind !== 'handoff_only'
-    && provider.providerId !== 'chatgpt_handoff'
-    && required.every((capability) => provider.capabilities.includes(capability));
-}
-
-function routingKey(input: RoutePolicyInput): string {
-  const taskIntent = input.intent.taskIntent ?? 'implementation';
-  const failure = input.intent.lastFailureClass;
-  const repair = taskIntent === 'code_repair'
-    || taskIntent === 'verification_repair'
-    || failure === 'test_failure'
-    || failure === 'typecheck_failure'
-    || failure === 'source_defect'
-    || (input.intent.lastProviderId === 'codex_cli' && (failure === 'provider_unavailable' || failure === 'unknown'));
-  if (taskIntent === 'deterministic_edit') return 'deterministic_edit';
-  if (repair) return 'repair';
-  if (taskIntent === 'architecture_planning') return 'planning';
-  if (taskIntent === 'review') return 'review';
-  if (taskIntent === 'browser_automation') return 'browser_planning';
-  if (taskIntent === 'ios_build_or_sim') return 'ios_analysis';
-  return 'implementation';
-}
-
-const KIND_RANK: Record<RouteProviderSnapshot['kind'], number> = {
-  direct_edit: 0,
-  local_cli: 10,
-  remote_api: 20,
-  cloud_agent: 30,
-  handoff_only: 90,
-};
-
-const PREFERRED_CAPABILITY: Record<string, string | undefined> = {
-  deterministic_edit: 'code_patch',
-  implementation: 'code_patch',
-  repair: 'test_failure_repair',
-  planning: 'architecture_planning',
-  review: 'code_review',
-  browser_planning: 'browser_planning',
-  ios_analysis: 'ios_log_analysis',
-};
-
-function providerOrder(input: RoutePolicyInput, key: string, providers: readonly RouteProviderSnapshot[]): string[] {
-  const configured = input.capabilities.routingOrders?.[key];
-  let order = configured?.length
-    ? [...configured]
-    : providers
-      .map((provider, index) => ({ provider, index }))
-      .filter(({ provider }) => provider.kind !== 'handoff_only' && provider.providerId !== 'chatgpt_handoff')
-      .filter(({ provider }) => key === 'deterministic_edit' || provider.kind !== 'direct_edit')
-      .sort((left, right) => {
-        const preferred = PREFERRED_CAPABILITY[key];
-        const leftSupports = preferred ? left.provider.capabilities.includes(preferred) : true;
-        const rightSupports = preferred ? right.provider.capabilities.includes(preferred) : true;
-        if (leftSupports !== rightSupports) return leftSupports ? -1 : 1;
-        return KIND_RANK[left.provider.kind] - KIND_RANK[right.provider.kind]
-          || left.index - right.index
-          || left.provider.providerId.localeCompare(right.provider.providerId);
-      })
-      .map(({ provider }) => provider.providerId);
-  const configuredDefault = input.capabilities.defaultProviders?.[key];
-  if (configuredDefault && configuredDefault !== 'chatgpt_handoff') {
-    order = [configuredDefault, ...order.filter((providerId) => providerId !== configuredDefault)];
-  }
-  if (input.intent.preferredProviderId) {
-    order = [input.intent.preferredProviderId, ...order.filter((providerId) => providerId !== input.intent.preferredProviderId)];
-  }
-  if (key === 'repair' && input.intent.lastProviderId) {
-    order = [...order.filter((providerId) => providerId !== input.intent.lastProviderId), input.intent.lastProviderId];
-  }
-  return [...new Set([...order, 'chatgpt_handoff'])];
-}
-
-function selectProvider(input: RoutePolicyInput): { provider: RouteProviderSnapshot | null; alternatives: string[]; key: string } {
-  const providers = input.capabilities.providers;
-  if (!providers) return { provider: null, alternatives: [], key: routingKey(input) };
-  const required = input.capabilities.requiredProviderCapabilities ?? [];
-  const allowed = new Set(input.intent.allowedProviderIds ?? []);
-  const forbidden = new Set(input.intent.forbiddenProviderIds ?? []);
-  const alternatives = providers
-    .filter((provider) => ready(provider, required))
-    .filter((provider) => !forbidden.has(provider.providerId))
-    .filter((provider) => allowed.size === 0 || allowed.has(provider.providerId))
-    .map((provider) => provider.providerId)
-    .sort();
-  const key = routingKey(input);
-  const byId = new Map(providers.map((provider) => [provider.providerId, provider]));
-  for (const providerId of providerOrder(input, key, providers)) {
-    if (providerId === 'chatgpt_handoff' || forbidden.has(providerId)) continue;
-    if (allowed.size > 0 && !allowed.has(providerId)) continue;
-    const provider = byId.get(providerId);
-    if (provider && ready(provider, required)) return { provider, alternatives, key };
-  }
-  const fallback = input.capabilities.routingOrders?.fallback ?? [];
-  for (const providerId of fallback) {
-    if (forbidden.has(providerId) || (allowed.size > 0 && !allowed.has(providerId))) continue;
-    const provider = byId.get(providerId);
-    if (provider && ready(provider, required)) return { provider, alternatives, key: 'fallback' };
-  }
-  return { provider: null, alternatives, key };
-}
-
-function decisionBase(input: RoutePolicyInput, reasons: RouteReason[]): Pick<RouteDecision, 'inputFingerprint' | 'policyVersion' | 'reasons'> {
-  return { inputFingerprint: routePolicyInputFingerprint(input), policyVersion: ROUTE_POLICY_VERSION, reasons };
-}
-
-export function decideRoute(input: RoutePolicyInput): RouteDecision {
-  const reasons: RouteReason[] = [];
-  const objective = input.intent.objective.trim();
-  const paths = [...new Set((input.workspace.knownPaths ?? []).map((path) => path.trim()).filter(Boolean))].sort();
-  const expectedFiles = Math.max(0, Math.trunc(input.intent.expectedFiles ?? paths.length));
-  const expectedChangedLines = Math.max(0, Math.trunc(input.intent.expectedChangedLines ?? 0));
-  const independentTaskCount = Math.max(0, Math.trunc(input.intent.independentTaskCount ?? 0));
-  const risk = input.policy.risk ?? (input.intent.mutation === false ? 'readonly' : 'local_repo_write');
-  const mutation = input.intent.mutation ?? risk !== 'readonly';
-  const destructive = input.policy.destructive === true || risk === 'destructive' || risk === 'destructive_remote';
-  const remoteWrite = input.policy.remoteWrite === true || risk === 'remote_write' || risk === 'destructive_remote';
-  const secretAccess = input.policy.secretAccess === true || risk === 'raw_secret_config';
-  const approvalRequired = input.policy.requiresApproval === true || input.policy.requiresUserApproval === true || destructive || remoteWrite || secretAccess;
-  const approvalConfirmed = input.policy.approvalConfirmed === true;
-  const protectedPath = paths.some((path) => PROTECTED_PATH.test(path));
-  const explicitMode = input.intent.explicitMode;
-  const explicitParallelMode = explicitMode === 'scale';
-  const placementIsolationRequired = input.workspace.placement === 'isolated'
-    || input.workspace.directMainProhibited === true;
-  const requiresIsolation = placementIsolationRequired
-    || input.recovery.isolationRequired === true
-    || explicitParallelMode;
-  const requiresRecovery = input.recovery.required === true
-    || explicitMode === 'release'
-    || explicitMode === 'scale';
-  const coordinationRequired = explicitParallelMode || input.intent.requiresIndependentDeliverables === true
-    || independentTaskCount >= 3;
-
-  if (input.policy.policyBlocked === true) {
-    reasons.push({ code: 'policy_blocked', message: 'Policy blocks execution until authorization or scope changes.' });
-    return {
-      executionMode: 'handoff_only', executorKind: 'handoff_only', selectedProviderId: null,
-      workMode: 'direct_edit', executionPath: 'durable', requiresWork: false, requiresApproval: true,
-      requiresIsolation, requiresRecovery, createHandoff: true, waitForUser: true,
-      approvalState: 'blocked_by_policy', alternatives: [], ...decisionBase(input, reasons),
-    };
-  }
-  if (!objective) {
-    reasons.push({ code: 'objective_missing', message: 'A non-empty objective is required before execution.' });
-    return {
-      executionMode: 'handoff_only', executorKind: 'handoff_only', selectedProviderId: null,
-      workMode: 'direct_edit', executionPath: 'durable', requiresWork: false, requiresApproval: false,
-      requiresIsolation, requiresRecovery, createHandoff: true, waitForUser: true,
-      approvalState: 'approval_not_required', alternatives: [], ...decisionBase(input, reasons),
-    };
-  }
-  if (input.policy.requiresUserApproval === true && !approvalConfirmed) {
-    reasons.push({ code: 'user_decision_required', message: 'The architecture or execution strategy change requires an explicit user decision.' });
-    return {
-      executionMode: 'handoff_only', executorKind: 'handoff_only', selectedProviderId: null,
-      workMode: 'direct_edit', executionPath: 'durable', requiresWork: false, requiresApproval: true,
-      requiresIsolation, requiresRecovery, createHandoff: true, waitForUser: true,
-      approvalState: 'normal_authorization_required', alternatives: [], ...decisionBase(input, reasons),
-    };
-  }
-  if ((!input.intent.scopeClear && (destructive || remoteWrite || secretAccess)) || (approvalRequired && !approvalConfirmed)) {
-    reasons.push({
-      code: !input.intent.scopeClear ? 'high_risk_scope_incomplete' : 'authorization_required',
-      message: !input.intent.scopeClear
-        ? 'High-risk work requires a complete scope before execution.'
-        : 'The requested side effect requires explicit authorization before execution.',
-    });
-    return {
-      executionMode: 'handoff_only', executorKind: 'handoff_only', selectedProviderId: null,
-      workMode: 'direct_edit', executionPath: 'durable', requiresWork: false, requiresApproval: true,
-      requiresIsolation, requiresRecovery, createHandoff: true, waitForUser: true,
-      approvalState: destructive || secretAccess ? 'strong_confirmation_required' : 'normal_authorization_required',
-      alternatives: [], ...decisionBase(input, reasons),
-    };
-  }
-
-  if (input.workspace.dirty && mutation) {
-    reasons.push({
-      code: 'dirty_workspace_preserve_existing_changes',
-      message: 'The checkout is already dirty; preserve unrelated changes and treat inspected/actual scope as evidence instead of creating Work solely for adoption.',
-    });
-  }
-  if (explicitMode) reasons.push({ code: `explicit_${explicitMode}`, message: `Explicit -${explicitMode} mode overrides automatic work topology while policy gates remain authoritative.` });
-  if (protectedPath) reasons.push({ code: 'protected_path', message: 'The predicted scope includes a protected or release-sensitive path.' });
-  if (requiresRecovery) reasons.push({ code: 'recovery_required', message: 'The operation needs resumable Work and bounded recovery.' });
-  if (input.workspace.placement === 'isolated') reasons.push({ code: 'placement_isolated', message: 'Typed Work admission requires an isolated workspace.' });
-  if (input.workspace.directMainProhibited === true) reasons.push({ code: 'direct_main_prohibited', message: 'Typed Work admission forbids the Direct Control/current-main mutation lane.' });
-  if (requiresIsolation) reasons.push({ code: 'isolation_required', message: 'The operation requires an isolated checkout or serialized lane.' });
-  if (input.intent.requiresLongRunningChecks) reasons.push({ code: 'long_checks', message: 'Long-running checks may use a lightweight handle; duration alone does not require durable Work.' });
-  if (input.intent.requiresInvestigation) reasons.push({ code: 'investigation', message: 'Investigation is required before or during implementation.' });
-  if (input.intent.needsDependencies) reasons.push({ code: 'dependencies', message: 'Dependency ordering requires durable Work.' });
-  if (coordinationRequired) reasons.push({ code: 'independent_deliverables', message: 'Multiple independent deliverables require durable PlanContract/Work coordination.' });
-
-  const explicitBoundedMode = explicitMode === 'plan'
-    || explicitMode === 'release';
-  const directModeCanRemainFast = explicitMode === 'direct'
-    && !requiresIsolation
-    && !requiresRecovery
-    && !coordinationRequired;
-  const complex = directModeCanRemainFast
-    ? false
-    : coordinationRequired
-    || explicitBoundedMode
-    || requiresRecovery
-    || requiresIsolation
-    || input.intent.agentRequested === true
-    || input.capabilities.requiresWorker === true
-    || input.capabilities.requiresExternalEffect === true
-    || input.intent.needsDependencies === true
-    || destructive
-    || remoteWrite
-    || secretAccess;
-  const executionMode: RouteExecutionMode = complex ? 'goal_workloop' : 'direct_control';
-  // Work topology is independent from executor/provider choice. Independent or
-  // parallel deliverables stay in the durable Goal Workloop and are decomposed by
-  // PlanContract/Work rather than introducing another project-level lifecycle.
-  const workMode: RouteWorkMode = directModeCanRemainFast
-    ? 'direct_edit'
-    : coordinationRequired
-    ? 'bounded_work'
-    : input.intent.agentRequested
-      ? expectedFiles > 10 || expectedChangedLines > 1_500 ? 'issue_task' : 'quick_agent'
-      : complex
-        ? 'bounded_work'
-        : 'direct_edit';
-  const executionPath: RouteExecutionPath = complex ? 'durable' : 'fast';
-  const providerSelection = selectProvider(input);
-  const providersWereSupplied = input.capabilities.providers !== undefined;
-  if (providersWereSupplied && !providerSelection.provider) {
-    reasons.push({ code: 'provider_unavailable', message: 'No allowed provider with the required capabilities is ready.' });
-    return {
-      executionMode: 'handoff_only', executorKind: 'handoff_only', selectedProviderId: 'chatgpt_handoff',
-      workMode, executionPath: 'durable', requiresWork: mutation || requiresRecovery, requiresApproval: false,
-      requiresIsolation, requiresRecovery, createHandoff: true, waitForUser: false,
-      approvalState: 'approval_not_required', alternatives: providerSelection.alternatives,
-      ...decisionBase(input, reasons),
-    };
-  }
-  const selectedProvider = providerSelection.provider;
-  const executorKind: RouteExecutorKind = selectedProvider?.kind
-    ?? (input.capabilities.requiresWorker ? 'external_controller' : 'direct_edit');
-  if (selectedProvider) reasons.push({ code: 'provider_selected', message: `Selected ${selectedProvider.providerId} using ${providerSelection.key} order.` });
-  if (reasons.length === 0) reasons.push({ code: executionMode === 'direct_control' ? 'bounded_direct' : 'durable_work', message: executionMode === 'direct_control' ? 'Bounded supervised work stays on Direct Control.' : 'The operation requires a durable Goal Workloop.' });
-
-  return {
-    executionMode,
-    executorKind,
-    selectedProviderId: selectedProvider?.providerId ?? null,
-    workMode,
-    executionPath,
-    // Direct Control is intentionally contract-free. Persistence belongs to
-    // Goal Workloop/Agent tiers; bounded direct edits rely on the
-    // existing permission, patch, Process, and evidence boundaries instead.
-    requiresWork: executionMode !== 'direct_control',
-    requiresApproval: approvalRequired,
-    requiresIsolation,
-    requiresRecovery,
-    createHandoff: false,
-    waitForUser: false,
-    approvalState: 'approval_not_required',
-    alternatives: providerSelection.alternatives,
-    ...decisionBase(input, reasons),
-  };
-}

package/src/runtime/control-plane/routing/workspace-admission.ts

@@ -1,70 +0,0 @@
-export type WorkspacePlacementMode = 'current' | 'isolated' | 'auto';
-
-export interface WorkspaceAdmissionConstraintInput {
-  workspaceMode?: WorkspacePlacementMode;
-  requireWorktree?: boolean;
-  /**
-   * Forbid repository mutation through the current/direct-main lane. This is
-   * an admission constraint, not a routing hint: callers must never silently
-   * downgrade it to Direct Control.
-   */
-  directMainProhibited?: boolean;
-}
-
-export interface WorkspaceAdmissionConstraint {
-  workspaceMode: WorkspacePlacementMode;
-  requireWorktree: boolean;
-  directMainProhibited: boolean;
-  requiresIsolation: boolean;
-}
-
-export type WorkspaceAdmissionResolution =
-  | { ok: true; constraint: WorkspaceAdmissionConstraint }
-  | { ok: false; code: 'WORKSPACE_PLACEMENT_CONSTRAINT_CONFLICT'; message: string };
-
-/**
- * Canonicalize Work placement before Route Policy runs. Placement is a policy
- * fence: explicit isolation / direct-main prohibition has precedence over an
- * operator request for the fast Direct Control topology.
- */
-export function resolveWorkspaceAdmissionConstraint(
-  input: WorkspaceAdmissionConstraintInput = {},
-): WorkspaceAdmissionResolution {
-  const workspaceMode = input.workspaceMode ?? 'auto';
-  const directMainProhibited = input.directMainProhibited === true;
-
-  if (workspaceMode === 'current' && input.requireWorktree === true) {
-    return {
-      ok: false,
-      code: 'WORKSPACE_PLACEMENT_CONSTRAINT_CONFLICT',
-      message: 'workspaceMode=current conflicts with requireWorktree=true.',
-    };
-  }
-  if (workspaceMode === 'isolated' && input.requireWorktree === false) {
-    return {
-      ok: false,
-      code: 'WORKSPACE_PLACEMENT_CONSTRAINT_CONFLICT',
-      message: 'workspaceMode=isolated conflicts with requireWorktree=false.',
-    };
-  }
-  if (workspaceMode === 'current' && directMainProhibited) {
-    return {
-      ok: false,
-      code: 'WORKSPACE_PLACEMENT_CONSTRAINT_CONFLICT',
-      message: 'workspaceMode=current conflicts with directMainProhibited=true because the current lane cannot prove a non-main placement at admission time.',
-    };
-  }
-
-  const requiresIsolation = workspaceMode === 'isolated'
-    || input.requireWorktree === true
-    || directMainProhibited;
-  return {
-    ok: true,
-    constraint: {
-      workspaceMode: requiresIsolation ? 'isolated' : workspaceMode,
-      requireWorktree: requiresIsolation,
-      directMainProhibited,
-      requiresIsolation,
-    },
-  };
-}