@moretea-labs/forge 1.5.1 → 1.6.0

package/src/runtime/control-plane/execution/validation.ts

@@ -32,6 +32,10 @@ function gitText(root: string, args: string[]): string | undefined {
     : undefined;
 }
 
+function gitSucceeds(root: string, args: string[]): boolean {
+  return spawnSync('git', ['-C', root, ...args], { stdio: 'ignore', timeout: 10_000 }).status === 0;
+}
+
 function fail(code: string, message: string): never {
   throw new Error(`${code}: ${message}`);
 }
@@ -44,7 +48,7 @@ export function assertWorkHandleLifecycle(handle: WorkHandleState, operation: 'i
   const allowed: Record<typeof operation, readonly WorkHandleState['state'][]> = {
     inspect: ['prepared', 'editing', 'validating', 'committed', 'merged', 'failed', 'failed_terminal_cleanup', 'cleaned'],
     execute: ['prepared', 'editing'],
-    validate: ['prepared', 'editing', 'validating', 'committed', 'merged'],
+    validate: ['prepared', 'editing', 'validating', 'committed', 'merged', 'failed'],
     finalize: ['prepared', 'editing', 'validating', 'committed', 'merged', 'failed_terminal_cleanup', 'cleaned', 'failed'],
   };
   if (!allowed[operation].includes(handle.state)) {
@@ -99,7 +103,16 @@ export function validateWorkHandle(
   const currentBranch = gitText(root, ['branch', '--show-current']);
   const currentHead = gitText(root, ['rev-parse', '--verify', 'HEAD']);
   if (currentBranch !== handle.branch) fail('WORK_HANDLE_BRANCH_CHANGED', `expected ${handle.branch}, found ${currentBranch ?? 'detached'}`);
-  if (handle.expectedHead && currentHead !== handle.expectedHead) fail('WORK_HANDLE_HEAD_CHANGED', `expected ${handle.expectedHead}, found ${currentHead ?? 'missing'}`);
+  const managedWorkProgress = (operation === 'validate' || operation === 'finalize')
+    && handle.managedWorktree
+    && Boolean(handle.expectedHead && currentHead)
+    && gitSucceeds(root, ['merge-base', '--is-ancestor', handle.expectedHead!, currentHead!]);
+  if (handle.expectedHead && currentHead !== handle.expectedHead && !managedWorkProgress) {
+    fail('WORK_HANDLE_HEAD_CHANGED', `expected ${handle.expectedHead}, found ${currentHead ?? 'missing'}`);
+  }
+  if (managedWorkProgress && currentHead !== handle.expectedHead) {
+    warnings.push('Managed Worktree HEAD advanced from the prepared revision by Work-owned descendant commits; validation/finalization will use the current Work state.');
+  }
 
   if (level === 'full') {
     const validation = validateRepository(repository.repoId, controllerHome);

package/src/runtime/control-plane/execution/work-terminal-cleanup.ts

@@ -544,6 +544,38 @@ export async function cleanupTerminalWork(input: TerminalWorkCleanupInput): Prom
   current = persist(input.controllerHome, current, receipt);
   if (receipt.blockers.length > 0) return { handle: current, receipt };
 
+  // A Work running in the selected/current checkout owns lifecycle and process
+  // leases, but it does not own the checkout/branch as disposable resources.
+  // Closing that Work therefore releases ownership without attempting git
+  // worktree removal, branch deletion, checkout-registry removal, or prune.
+  if (!current.managedWorktree) {
+    receipt.worktree.status = 'already_removed';
+    receipt.worktree.reason = 'Not applicable: Work did not create a managed worktree.';
+    receipt.branchCleanup.status = 'retained';
+    receipt.branchCleanup.reason = 'Current checkout branch is repository-owned, not Work-owned.';
+    receipt.checkoutRegistry.status = 'already_removed';
+    receipt.checkoutRegistry.reason = 'Not applicable: current checkout registration is retained.';
+    receipt.prune.status = 'done';
+    receipt.prune.reason = 'Not applicable: no managed worktree was removed.';
+    receipt.complete = true;
+    receipt.partial = false;
+    receipt.completedAt = receipt.completedAt ?? nowIso();
+    const finalization = {
+      ...current.finalization,
+      commit: current.finalization.commit === 'pending' ? 'skipped' as const : current.finalization.commit,
+      merge: current.finalization.merge === 'pending' ? 'skipped' as const : current.finalization.merge,
+      branchCleanup: 'skipped' as const,
+      worktreeCleanup: 'skipped' as const,
+      lastError: preservedFailure,
+    };
+    current = transitionWorkHandle(input.controllerHome, current, 'cleaned', {
+      failureReason: landed ? undefined : preservedFailure,
+      cleanupReceipt: receipt,
+      finalization,
+    });
+    return { handle: current, receipt };
+  }
+
   const target = selectTerminalCleanupTarget(repository, current);
   let registeredPath: string | undefined;
   try {

package/src/runtime/control-plane/execution/work-validation-reconciler.ts

@@ -98,10 +98,10 @@ export function projectWorkValidationOutcome(
   }
 
   transitionWorkContractPhase(options, contractId, {
-    phase: 'cleanup',
-    status: 'failed',
-    state: 'failed',
-    summary: summary ?? 'Validation infrastructure failed; terminal cleanup is required without treating this as an acceptance failure.',
+    phase: 'verification',
+    status: 'running',
+    state: 'blocked',
+    summary: summary ?? 'Validation infrastructure failed; retain the finite Work for retry without treating this as an acceptance failure.',
     evidenceRefs: contract.evidenceRefs,
   });
   updateWorkContract(options, contractId, {
@@ -127,8 +127,8 @@ function settleInfrastructureFailure(
  * Converge a persisted Work validation run from durable Process receipts.
  *
  * No command is launched here. Missing/running bindings stay pending; timeout,
- * cancellation, missing process state, or malformed receipt makes the Work
- * terminally failed for cleanup without classifying it as an acceptance failure.
+ * cancellation, missing process state, or malformed receipt makes the execution
+ * attempt retryable without classifying it as an acceptance failure or destroying Work.
  */
 export function reconcileWorkValidation(
   controllerHome: string,
@@ -173,7 +173,6 @@ export function reconcileWorkValidation(
         repoId: handle.repositoryId,
         checkoutId: handle.checkoutId,
         workId: handle.workId,
-        executionSessionId: handle.sessionId,
         checkId,
         processId: binding.processId,
         ...(currentIdentity ? {

package/src/runtime/control-plane/execution/work-verification-snapshot.ts

@@ -18,7 +18,7 @@ import { globMatches, normalizeMcpRelativePath } from '../../../cli/mcp/paths';
 import { sanitizeFileComponent } from '../../shared/json-files';
 
 const STALE_SNAPSHOT_MS = 6 * 60 * 60_000;
-const SNAPSHOT_MARKER = '.forge-work-verification-snapshot.json';
+const SNAPSHOT_MARKER = '.ai/harness/controller/work-verification-snapshot.json';
 
 export interface WorkVerificationSnapshotScope {
   workId: string;
@@ -156,6 +156,7 @@ export function materializeWorkVerificationSnapshot(input: {
       allowedPaths: [...input.scope.allowedPaths].sort(),
       forbiddenPaths: [...input.scope.forbiddenPaths].sort(),
     })).digest('hex');
+    mkdirSync(dirname(join(root, SNAPSHOT_MARKER)), { recursive: true });
     writeFileSync(join(root, SNAPSHOT_MARKER), `${JSON.stringify({ schemaVersion: 1, ...input.scope, sourceHead, includedPaths, excludedPaths, ownershipDigest }, null, 2)}\n`);
     return { root, sourceHead, includedPaths, excludedPaths, ownershipDigest };
   } catch (error) {

package/src/runtime/control-plane/facade/capability-registry.ts

@@ -150,7 +150,7 @@ const CORE_CAPABILITIES: CapabilityDescriptor[] = [
     risk: 'unknown',
     exposedVia: 'rh_work',
     schemaExposure: 'stable_static',
-    summary: 'Use typed browser target, snapshot, domain grant, and plugin actions when browser capability is configured.',
+    summary: 'Use typed HTTP(S) browser navigation, snapshot, and interaction actions when browser capability is configured.',
   },
   {
     capabilityId: 'platform.ios',

package/src/runtime/control-plane/facade/controller-session-store.ts

@@ -68,8 +68,10 @@ function claimedSession(
   const leaseExpiresAt = new Date(
     Date.parse(claimedAt) + Math.max(1_000, Math.min(input.leaseMs ?? 300_000, 3_600_000)),
   ).toISOString();
+  const previousPrincipal = previous?.principalId?.trim() || previous?.controllerId;
+  const inputPrincipal = input.principalId?.trim() || input.controllerId;
   const sameOwner = previous?.controllerId === input.controllerId
-    && previous.sessionId === input.sessionId
+    && previousPrincipal === inputPrincipal
     && (previous.controllerInstanceId ?? '') === (input.controllerInstanceId?.trim() ?? '');
   const claimGeneration = sameOwner
     ? Math.max(1, previous?.claimGeneration ?? 1)
@@ -116,6 +118,11 @@ export function getControllerSession(options: ControllerSessionStoreOptions, wor
   return activeSession(read(options), workId);
 }
 
+export function listControllerSessions(options: ControllerSessionStoreOptions): ControllerSession[] {
+  const at = Date.now();
+  return read(options).sessions.filter((session) => Date.parse(session.leaseExpiresAt) > at);
+}
+
 /**
  * Strict claim used for first ownership acquisition and explicit release/reclaim flows.
  * A live claim with any different controller or transport session remains fenced.
@@ -142,10 +149,10 @@ export function claimControllerSession(
 }
 
 /**
- * Resume a claim after transport replacement without allowing same-epoch stealing.
- * The authenticated principal must remain identical, and a different session id
- * is accepted only when the previous execution session is gone/invalidated or
- * belongs to a different Controller instance (the normal rollout boundary).
+ * Resume a claim after transport replacement. Durable Work ownership belongs to
+ * the authenticated principal/controller epoch, not to one MCP transport session.
+ * A same-principal session rotation therefore preserves ownership generation;
+ * a controller-epoch change is recovery and advances the generation fence.
  */
 export function resumeControllerSession(
   options: ControllerSessionStoreOptions,
@@ -172,14 +179,6 @@ export function resumeControllerSession(
       if (current.controllerId !== input.controllerId) {
         throw new Error(`WORK_ALREADY_CLAIMED: ${input.workId} is owned by ${current.controllerId}`);
       }
-      if (current.sessionId !== input.sessionId) {
-        const priorInstance = current.controllerInstanceId?.trim() || priorExecution?.controllerInstanceId?.trim();
-        const priorSessionUnavailable = !priorExecution || Boolean(priorExecution.invalidatedAt);
-        const crossedControllerEpoch = Boolean(priorInstance && priorInstance !== input.controllerInstanceId.trim());
-        if (!priorSessionUnavailable && !crossedControllerEpoch) {
-          throw new Error(`WORK_ALREADY_CLAIMED: ${input.workId} has an active session ${current.sessionId}`);
-        }
-      }
       return persistClaim(options, store, input, current);
     },
   );

package/src/runtime/control-plane/facade/goal-workloop-access.ts

@@ -161,9 +161,14 @@ export function runGoalWorkloop(
       secretAccess: args.secret_access === true,
       risk: typeof args.risk === 'string' ? args.risk as CapabilityRisk : undefined,
     },
-    requestedBy: args.requested_by === 'user' || args.requested_by === 'system' || args.requested_by === 'scheduler'
+    requestedBy: args.requested_by === 'chatgpt' || args.requested_by === 'user' || args.requested_by === 'system' || args.requested_by === 'scheduler'
       ? args.requested_by
-      : 'chatgpt',
+      : 'user',
+    relatedWorkId: typeof args.related_work_id === 'string' ? args.related_work_id : undefined,
+    workRelation: args.work_relation === 'continue' || args.work_relation === 'extend' || args.work_relation === 'parallel' || args.work_relation === 'new_goal'
+      ? args.work_relation
+      : undefined,
+    requirementId: typeof args.requirement_id === 'string' ? args.requirement_id : undefined,
     taskId: typeof args.task_id === 'string' ? args.task_id : undefined,
     issueId: typeof args.issue_id === 'string' ? args.issue_id : undefined,
     approvalConfirmed: args.approval_confirmed === true,

package/src/runtime/control-plane/facade/goal-workloop.ts

@@ -9,6 +9,7 @@ import {
   appendWorkHandoffRef,
   createWorkContract,
   getWorkContract,
+  listWorkContracts,
   summarizeWorkContract,
   transitionWorkContractPhase,
   updateWorkContract,
@@ -17,6 +18,7 @@ import {
 import {
   claimPlanStepForWork,
   completePlanStepForWork,
+  getPlanContract,
   type PlanContractStoreOptions,
 } from './plan-contract-store';
 import {
@@ -57,8 +59,11 @@ export interface GoalWorkloopContext {
   controllerInstanceId?: string;
   workspaceFingerprint?: string;
   now?: () => string;
+  materializeIsolatedWorkspace?: (input: { workId: string; title: string; baseRef?: string }) => { checkoutId: string; root: string; baseRevision?: string | null; managed: true };
 }
 
+export type WorkAdmissionRelation = 'continue' | 'extend' | 'parallel' | 'new_goal';
+
 export interface GoalWorkloopStartInput {
   objective: string;
   acceptanceCriteria?: string[];
@@ -68,6 +73,9 @@ export interface GoalWorkloopStartInput {
   constraints?: WorkContract['constraints'];
   modeInput: ExecutionModeSelectionInput;
   requestedBy?: WorkContract['requestedBy'];
+  relatedWorkId?: string;
+  workRelation?: WorkAdmissionRelation;
+  requirementId?: string;
   taskId?: string;
   issueId?: string;
   approvalConfirmed?: boolean;
@@ -280,11 +288,33 @@ export function routeWorkStart(
     selectedMode = selectExecutionMode({ ...effectiveModeInput, approvalConfirmed: true });
     policy = evaluateAccessPolicy(selectedMode);
   }
-  const mode = applyForcedMode(selectedMode);
+  let mode = applyForcedMode(selectedMode);
+
+  // Route Policy is the sole execution-depth authority. Existing Work is
+  // ownership context, not a reason to upgrade an otherwise Direct operation
+  // into Durable Work. Explicit Work/Plan ownership is resolved only after a
+  // durable route has already been selected; checkout writer conflicts affect
+  // placement, not semantic task identity.
 
   if (mode.mode === 'direct_control') {
     const available = ctx.availableChecks ?? [];
     const normalized = normalizeCheckIds(input.checks ?? [], available);
+    // Explicit ownership may annotate a Direct operation, but it never changes
+    // the RouteDecision. The actual repository mutation can pass this Work id
+    // to repository_safe_patch_apply / repository_command_execute for evidence
+    // attribution while staying on the Direct/Process path.
+    const directOwnershipCandidates = input.relatedWorkId || (input.planId && input.planStepId)
+      ? listWorkContracts({ ...ctx.workStore, status: 'active', limit: 100 })
+          .filter((candidate) => (candidate.lifecycleRole ?? 'primary') === 'primary')
+      : [];
+    const directPlan = input.planId && ctx.planStore ? getPlanContract(ctx.planStore, input.planId) : undefined;
+    const directPlanStep = directPlan && input.planStepId ? directPlan.steps.find((step) => step.id === input.planStepId) : undefined;
+    const directOwner = (input.relatedWorkId
+      ? directOwnershipCandidates.find((candidate) => candidate.workId === input.relatedWorkId)
+      : undefined)
+      ?? (directPlanStep?.workId
+        ? directOwnershipCandidates.find((candidate) => candidate.workId === directPlanStep.workId)
+        : undefined);
     const suggested = validateSuggestedNextActions([
       {
         label: 'Apply bounded direct edit',
@@ -315,6 +345,13 @@ export function routeWorkStart(
         directControlPreserved: true,
         objective: input.objective.slice(0, 1_000),
         normalizedChecks: normalized,
+        ...(directOwner ? {
+          ownership: {
+            workId: directOwner.workId,
+            relation: input.workRelation ?? 'continue',
+            executionDepthPreserved: true,
+          },
+        } : {}),
       },
       warnings: [...policy.warnings, ...normalized.warnings],
       suggestedNextActions: suggested,
@@ -437,12 +474,189 @@ export function startGoalWorkloop(
 ): FacadeResult {
   const at = nowIso(ctx);
   const available = ctx.availableChecks ?? [];
-  const normalized = normalizeCheckIds(input.checks ?? [], available);
   const workspaceMode = input.constraints?.workspaceMode ?? 'auto';
+  const activeWorks = listWorkContracts({ ...ctx.workStore, status: 'active', limit: 100 })
+    .filter((candidate) => (candidate.lifecycleRole ?? 'primary') === 'primary');
+  const workspaceOwner = ctx.checkoutId
+    ? activeWorks.find((candidate) => candidate.checkoutId === ctx.checkoutId
+      && candidate.worktreePolicy.required !== true
+      && !candidate.worktreeRef)
+    : undefined;
+  const explicitRelatedWork = input.relatedWorkId
+    ? activeWorks.find((candidate) => candidate.workId === input.relatedWorkId)
+    : undefined;
+  const plan = input.planId && ctx.planStore ? getPlanContract(ctx.planStore, input.planId) : undefined;
+  const planStep = plan && input.planStepId ? plan.steps.find((step) => step.id === input.planStepId) : undefined;
+  const sameStringSet = (provided: string[] | undefined, frozen: string[]): boolean => {
+    if (provided === undefined) return true;
+    const actual = [...new Set(provided)].sort();
+    const expected = [...new Set(frozen)].sort();
+    return actual.length === expected.length && actual.every((value, index) => value === expected[index]);
+  };
+  if (planStep) {
+    const mismatches = [
+      !sameStringSet(input.acceptanceCriteria, planStep.acceptanceCriteria) && 'acceptance_criteria',
+      !sameStringSet(input.allowedPaths, planStep.allowedPaths) && 'allowed_paths',
+      !sameStringSet(input.forbiddenPaths, planStep.forbiddenPaths) && 'forbidden_paths',
+      !sameStringSet(input.checks, planStep.checks) && 'check_ids',
+    ].filter((value): value is string => Boolean(value));
+    if (mismatches.length > 0) {
+      return buildFacadeResult({
+        status: 'blocked',
+        summary: `PLAN_STEP_WORK_CONTRACT_MISMATCH: ${input.planId}/${input.planStepId} conflicts with frozen Plan step field(s): ${mismatches.join(', ')}. Replan instead of widening or narrowing Work admission.`,
+        data: { executionStarted: false, workContractCreated: false, planId: input.planId, planStepId: input.planStepId, mismatches },
+      });
+    }
+  }
+  const effectiveAcceptanceCriteria = planStep?.acceptanceCriteria ?? input.acceptanceCriteria ?? [];
+  const effectiveAllowedPaths = planStep?.allowedPaths ?? input.allowedPaths ?? [];
+  const effectiveForbiddenPaths = planStep?.forbiddenPaths ?? input.forbiddenPaths ?? [];
+  const effectiveChecks = planStep?.checks ?? input.checks ?? [];
+  const normalized = normalizeCheckIds(effectiveChecks, available);
+  const planStepWork = planStep?.workId ? activeWorks.find((candidate) => candidate.workId === planStep.workId) : undefined;
+  const requirementWorks = input.requirementId
+    ? activeWorks.filter((candidate) => candidate.requirementId === input.requirementId)
+    : [];
+  const deterministicTarget = explicitRelatedWork ?? planStepWork ?? (requirementWorks.length === 1 ? requirementWorks[0] : undefined);
+  const requestedRelation = input.workRelation ?? (input.modeInput.requiresParallelism === true ? 'parallel' : undefined);
+  // Only strong semantic bindings participate in ownership resolution. An
+  // unrelated active Work or a checkout writer is a placement fact, not a
+  // semantic candidate for continue/extend/parallel/new_goal.
+  const candidateWorks = [...new Map(
+    [explicitRelatedWork, planStepWork, ...requirementWorks]
+      .filter((candidate): candidate is WorkContract => Boolean(candidate))
+      .map((candidate) => [candidate.workId, candidate]),
+  ).values()].slice(0, 8);
+
+  const resolutionRequired = (reason: string, target = deterministicTarget): FacadeResult => buildFacadeResult({
+    status: 'ok',
+    summary: reason,
+    data: {
+      executionStarted: false,
+      workContractCreated: false,
+      admissionDecision: 'resolution_required',
+      resolutionRequired: true,
+      requestedBy: input.requestedBy ?? 'chatgpt',
+      ...(target ? { recommendedWork: summarizeWorkContract(target) } : {}),
+      candidates: candidateWorks.map(summarizeWorkContract),
+      allowedRelations: ['continue', 'extend', 'parallel', 'new_goal'],
+    },
+    evidenceRefs: target?.evidenceRefs ?? [],
+    suggestedNextActions: target
+      ? [{
+          label: 'Continue existing Work',
+          tool: 'rh_work',
+          operation: 'continue',
+          payload: { work_id: target.workId },
+          risk: 'readonly',
+          confidence: planStepWork || explicitRelatedWork ? 'high' : 'medium',
+          reason: 'Resolve intent before execution; do not create a second Work until the relationship is explicit.',
+        }]
+      : [],
+    rawAvailable: false,
+  });
+
+  if ((input.requestedBy ?? 'chatgpt') === 'scheduler') {
+    return resolutionRequired(
+      deterministicTarget
+        ? `SCHEDULER_CONTINUATION_REQUIRED: scheduler-triggered execution must continue its bound Work ${deterministicTarget.workId}; it must not create a new durable Work.`
+        : 'SCHEDULER_WORK_BINDING_REQUIRED: scheduler-triggered execution must bind and wake an existing durable Work; it must not invent a new Work from a prompt.',
+    );
+  }
+
+  if (planStepWork && !requestedRelation) {
+    return buildFacadeResult({
+      status: 'ok',
+      summary: `PLAN_STEP_REUSES_ACTIVE_WORK: ${input.planId}/${input.planStepId} already executes as ${planStepWork.workId}; reuse that Work instead of creating another.`,
+      data: {
+        executionStarted: false,
+        workContractCreated: false,
+        admissionDecision: 'reuse_existing',
+        resolutionRequired: false,
+        work: summarizeWorkContract(planStepWork),
+      },
+      evidenceRefs: planStepWork.evidenceRefs,
+      suggestedNextActions: [{ label: 'Continue existing Work', tool: 'rh_work', operation: 'continue', payload: { work_id: planStepWork.workId }, risk: 'readonly', confidence: 'high' }],
+      rawAvailable: false,
+    });
+  }
+
+  if (requestedRelation === 'continue' || requestedRelation === 'extend') {
+    if (!deterministicTarget) {
+      return resolutionRequired(`${requestedRelation.toUpperCase()}_TARGET_REQUIRED: select related_work_id or bind the request to an active Plan/Requirement before execution.`);
+    }
+    if (requestedRelation === 'extend' && deterministicTarget.planId) {
+      return resolutionRequired(
+        `PLAN_EXTENSION_REQUIRES_REPLAN: Work ${deterministicTarget.workId} is governed by Plan ${deterministicTarget.planId}; extend the authoritative Plan/Requirement before continuing rather than silently widening Work scope.`,
+        deterministicTarget,
+      );
+    }
+    const selected = requestedRelation === 'extend'
+      ? updateWorkContract(ctx.workStore, deterministicTarget.workId, {
+          acceptanceCriteria: [...new Set([...deterministicTarget.acceptanceCriteria, ...(input.acceptanceCriteria ?? [])])].slice(0, 30),
+          allowedPaths: [...new Set([...deterministicTarget.allowedPaths, ...(input.allowedPaths ?? [])])].slice(0, 50),
+          forbiddenPaths: [...new Set([...deterministicTarget.forbiddenPaths, ...(input.forbiddenPaths ?? [])])].slice(0, 50),
+          checks: [...new Set([...deterministicTarget.checks, ...normalized.validCheckIds])].slice(0, 30),
+          scopeSummary: `Extended serially: ${input.objective}`.slice(0, 500),
+          continuationPrompt: `Continue work ${ctx.repoId}: ${deterministicTarget.objective.slice(0, 160)}. Additional requested scope: ${input.objective.slice(0, 500)}`,
+        })
+      : deterministicTarget;
+    return buildFacadeResult({
+      status: 'ok',
+      summary: `${requestedRelation === 'extend' ? 'Existing Work extended' : 'Existing Work selected'}: ${selected.workId}. No new WorkContract was created.`,
+      data: {
+        executionStarted: false,
+        workContractCreated: false,
+        admissionDecision: requestedRelation === 'extend' ? 'extend_existing' : 'reuse_existing',
+        resolutionRequired: false,
+        work: summarizeWorkContract(selected),
+      },
+      evidenceRefs: selected.evidenceRefs,
+      suggestedNextActions: [{ label: 'Continue existing Work', tool: 'rh_work', operation: 'continue', payload: { work_id: selected.workId }, risk: 'readonly', confidence: 'high' }],
+      rawAvailable: false,
+    });
+  }
+
+  if (!requestedRelation && candidateWorks.length > 0) {
+    return resolutionRequired(
+      `WORK_ADMISSION_RESOLUTION_REQUIRED: ${candidateWorks.length} active Work candidate(s) exist. Classify this request as continue, extend, parallel, or new_goal before any durable Work is created.`,
+    );
+  }
+
+  const placementConflict = Boolean(workspaceOwner);
   const needsWorktree = executionMode === 'goal_workloop' && (input.constraints?.requireWorktree
     ?? (workspaceMode === 'isolated'
+      || placementConflict
       || (workspaceMode === 'auto' && routeDecision.requiresIsolation === true)));
+  if (!needsWorktree && workspaceOwner) {
+    return buildFacadeResult({
+      status: 'blocked',
+      summary: `WORKSPACE_OWNERSHIP_INVARIANT: unresolved admission reached checkout ${ctx.checkoutId} while active Work ${workspaceOwner.workId} owns it. This is an internal routing invariant, not a normal fallback path.`,
+      data: {
+        executionStarted: false,
+        workContractCreated: false,
+        conflictType: 'workspace_single_writer_invariant',
+        existingWork: summarizeWorkContract(workspaceOwner),
+      },
+      evidenceRefs: workspaceOwner.evidenceRefs,
+      rawAvailable: false,
+    });
+  }
   const generatedWorkId = workIdFor(input.objective);
+  let isolatedWorkspace: ReturnType<NonNullable<GoalWorkloopContext['materializeIsolatedWorkspace']>> | undefined;
+  if (needsWorktree) {
+    if (!ctx.materializeIsolatedWorkspace) {
+      return buildFacadeResult({ status: 'blocked', summary: 'ISOLATED_WORKSPACE_MATERIALIZER_REQUIRED: isolated Work cannot enter running state without a concrete managed checkout.', data: { executionStarted: false, workContractCreated: false, worktreeRequired: true } });
+    }
+    try {
+      isolatedWorkspace = ctx.materializeIsolatedWorkspace({ workId: generatedWorkId, title: input.objective, baseRef: ctx.sourceRevision });
+      if (!isolatedWorkspace.checkoutId || !isolatedWorkspace.root || isolatedWorkspace.checkoutId === ctx.checkoutId) {
+        throw new Error('ISOLATED_WORKSPACE_NOT_DISTINCT');
+      }
+    } catch (error) {
+      return buildFacadeResult({ status: 'blocked', summary: error instanceof Error ? `ISOLATED_WORKSPACE_MATERIALIZATION_FAILED: ${error.message}` : 'ISOLATED_WORKSPACE_MATERIALIZATION_FAILED', data: { executionStarted: false, workContractCreated: false, worktreeRequired: true } });
+    }
+  }
   if (input.planId || input.planStepId) {
     if (!input.planId || !input.planStepId || !ctx.planStore || !ctx.sourceRevision) {
       return buildFacadeResult({ status: 'blocked', summary: 'PLAN_CONTEXT_REQUIRED: plan_id, plan_step_id and a current source revision are required.', data: { executionStarted: false } });
@@ -473,28 +687,32 @@ export function startGoalWorkloop(
   const work = createWorkContract(ctx.workStore, {
     workId: generatedWorkId,
     repoId: ctx.repoId,
-    checkoutId: ctx.checkoutId,
+    checkoutId: isolatedWorkspace?.checkoutId ?? ctx.checkoutId,
     principalId: ctx.principalId,
     controllerInstanceId: ctx.controllerInstanceId,
-    baseRevision: ctx.sourceRevision,
-    workspaceFingerprint: ctx.workspaceFingerprint,
+    baseRevision: isolatedWorkspace?.baseRevision ?? ctx.sourceRevision,
+    workspaceFingerprint: isolatedWorkspace ? undefined : ctx.workspaceFingerprint,
     routeDecisionFingerprint: routeDecision.inputFingerprint,
     routeDecision,
     mode: executionMode,
     objective: input.objective,
-    acceptanceCriteria: input.acceptanceCriteria ?? [],
+    acceptanceCriteria: effectiveAcceptanceCriteria,
     constraints: input.constraints ?? { requireHandoffOnAmbiguity: true },
     risk: workRiskFor(input),
+    workKind: input.modeInput.requiresExternalEffect === true && input.modeInput.remoteWrite === true
+      ? 'remote_effect'
+      : undefined,
     status: 'running',
     phase: 'implementation',
     issueId: input.issueId,
     taskId: input.taskId,
+    requirementId: input.requirementId,
     planId: input.planId,
     planStepId: input.planStepId,
     planSourceRevision: input.planId ? ctx.sourceRevision : undefined,
     scopeSummary: input.modeInput.scopeClear ? 'scope declared at start' : 'scope incomplete',
-    allowedPaths: input.allowedPaths ?? [],
-    forbiddenPaths: input.forbiddenPaths ?? [],
+    allowedPaths: effectiveAllowedPaths,
+    forbiddenPaths: effectiveForbiddenPaths,
     checks: normalized.validCheckIds,
     driver: {
       preferred: executionMode === 'direct_control'
@@ -509,6 +727,7 @@ export function startGoalWorkloop(
         ? 'Isolation was explicitly requested or required for parallel execution.'
         : 'Current workspace is the stability-first default; isolation remains opt-in.',
     },
+    worktreeRef: isolatedWorkspace?.root,
     evidencePolicy: {
       defaultDetailLevel: 'summary',
       allowRawOptIn: true,
@@ -1115,6 +1334,9 @@ export function stopGoalWorkloop(ctx: GoalWorkloopContext, input: GoalWorkloopSt
     // cleanup handler verifies ownership, cleanliness and successful removal.
     worktreeRef: work.worktreeRef,
   });
+  const plan = updated.planId && updated.planStepId && ctx.planStore
+    ? completePlanStepForWork(ctx.planStore, { planId: updated.planId, stepId: updated.planStepId, work: updated })
+    : undefined;
 
   return buildFacadeResult({
     status: 'ok',
@@ -1126,6 +1348,7 @@ export function stopGoalWorkloop(ctx: GoalWorkloopContext, input: GoalWorkloopSt
       worktreeDeleted: false,
       cleanupPending: destructiveCleanup && Boolean(work.worktreeRef),
       destructiveCleanupAuthorized: destructiveCleanup,
+      ...(plan ? { plan } : {}),
     },
     evidenceRefs: work.evidenceRefs.slice(0, 5),
     suggestedNextActions: [

package/src/runtime/control-plane/facade/plan-contract-store.ts

@@ -376,28 +376,48 @@ export function completePlanStepForWork(
     if (stepIndex < 0) throw new Error(`PLAN_STEP_NOT_FOUND: ${input.stepId}`);
     const step = current.steps[stepIndex];
     if (step.workId !== input.work.workId) throw new Error(`PLAN_STEP_WORK_MISMATCH: ${input.stepId}`);
-    const completed = input.work.status === 'completed'
+    if (step.status === 'completed') return current;
+    const delivered = input.work.status === 'completed'
       && input.work.phase === 'cleanup'
       && input.work.evidenceState === 'valid'
       && Boolean(input.work.completionOutcome && input.work.completionOutcome !== 'superseded')
       && Boolean(input.work.completionReceipt);
     const failed = input.work.status === 'failed' || input.work.status === 'cancelled';
-    if (!completed && !failed) throw new Error(`PLAN_STEP_WORK_NOT_TERMINAL: ${input.work.workId}`);
+    if (!delivered && !failed) throw new Error(`PLAN_STEP_WORK_NOT_TERMINAL: ${input.work.workId}`);
     const at = nowIso(options);
     const steps = [...current.steps];
     steps[stepIndex] = {
       ...step,
-      status: completed ? 'completed' : 'validating',
-      evidenceRefs: input.work.evidenceRefs.length > 0
-        ? input.work.evidenceRefs.slice(0, 20)
-        : step.evidenceRefs,
+      // Work completion proves machine delivery only. The Plan step remains in
+      // semantic validation until an explicit Controller acceptance records it.
+      // Failed/cancelled Work returns the slice to ready for replanning.
+      status: delivered ? 'validating' : 'ready',
+      evidenceRefs: input.work.evidenceRefs.length > 0 ? input.work.evidenceRefs.slice(0, 20) : step.evidenceRefs,
     };
-    const allCompleted = steps.every((candidate) => candidate.status === 'completed');
-    return {
-      ...current,
-      status: completed ? (allCompleted ? 'ready_to_finalize' : 'executing') : 'replanning',
-      steps,
-      updatedAt: at,
+    return { ...current, status: delivered ? 'verifying' : 'replanning', steps, updatedAt: at };
+  });
+}
+
+export function acceptPlanStepEvidence(
+  options: PlanContractStoreOptions,
+  input: { planId: string; stepId: string; reviewer: string; rationale: string },
+): PlanContract {
+  const reviewer = input.reviewer.trim();
+  const rationale = input.rationale.trim();
+  if (!reviewer || !rationale) throw new Error('PLAN_STEP_SEMANTIC_ACCEPTANCE_METADATA_REQUIRED');
+  return updatePlanContract(options, input.planId, (current) => {
+    const stepIndex = current.steps.findIndex((step) => step.id === sanitizeFileComponent(input.stepId));
+    if (stepIndex < 0) throw new Error(`PLAN_STEP_NOT_FOUND: ${input.stepId}`);
+    const step = current.steps[stepIndex];
+    if (step.status === 'completed') return current;
+    if (step.status !== 'validating') throw new Error(`PLAN_STEP_NOT_READY_FOR_SEMANTIC_ACCEPTANCE: ${step.id} is ${step.status}`);
+    const steps = [...current.steps];
+    steps[stepIndex] = {
+      ...step,
+      status: 'completed',
+      evidenceRefs: [{ title: 'semantic acceptance', summary: `${reviewer}: ${rationale}`, detailLevel: 'summary' as const }, ...step.evidenceRefs].slice(0, 20),
     };
+    const allCompleted = steps.every((candidate) => candidate.status === 'completed');
+    return { ...current, status: allCompleted ? 'finalized' : 'executing', steps, updatedAt: nowIso(options) };
   });
 }