@claudexor/orchestrator 3.10.4 → 3.11.0

package/dist/orchestrator.js

@@ -1,3 +1,6 @@
+import { delegationBeltFor } from "./delegationBelt.js";
+import { bindProcessingAdmission, processingAdmissionForLease, updateProcessingStreamHold, ProcessingBudgetAdmissionError, } from "./processing-dispatch.js";
+import { cancelledCandidatesResult, emptyCandidateResult, failedCandidatesResult, } from "./candidateTerminals.js";
 import { existsSync } from "node:fs";
 import { effectiveAuthPreference, observeNativeSessionEvent, resumeSessionForProfile, rotateSpecOnTypedLimit, selectedProfileAvailability, } from "./credential-profiles.js";
 import { OrchestratorCredentials, reviewerProfileResolver, rotatedSpecInLaneHome, } from "./orchestrator-credentials.js";
@@ -5,17 +8,18 @@ import { accountPoolRows } from "./account-pool.js";
 import { writeRunTelemetryArtifact } from "./runTelemetryWriter.js";
 import { buildFileBackedSynthesisInput, materializeWinnerOutputs, stageFileBackedContext, writeCandidateAttemptArtifacts, } from "./candidateOutputs.js";
 import { processAttemptUsage } from "./attemptUsage.js";
+import { captureDirectoryCandidate, directoryHasOutput, directoryCandidateStable, observeDirectoryPaths, publishDirectoryCandidate, } from "./directoryCandidate.js";
 import { appliedAttemptFacts, assertDelegatedEvidence, isMutatingAccess, outerBoundaryNotice, scopedHarnessHome, } from "./delegatedHome.js";
 import * as AC from "./attemptUsageCost.js";
-import { candidateRoster, convergenceOutcomeFacts, isWorkingCandidate, partitionCandidates, toCandidateEvidence, unanimousDeclaredFailure, } from "./candidateEvidence.js";
+import { candidateRoster, candidateStatuses, convergenceOutcomeFacts, isWorkingCandidate, partitionCandidates, toCandidateEvidence, } from "./candidateEvidence.js";
 import { capabilityIntents } from "@claudexor/gateway";
-import { policyFindings } from "./policyFindings.js";
 import { reviewCandidateRuns, resolveEngineReview, unreviewedCandidateEvidence, evaluateUnreviewedConvergence, } from "./candidateReview.js";
 import { join } from "node:path";
 import { finalizePlanRun, runCouncilPlan, writePlanHarnessFailure, } from "./planRun.js";
 import { runPlannerAttempt as executePlannerAttempt, } from "./plannerAttempt.js";
 import { HarnessRunSpec, ModeKind as ModeKindSchema, QuotaSnapshot as QuotaSnapshotSchema, isBlocking, makeOutcomeFacts, reviewAllowsApply, workStateVetoes, strictifyOutputSchema, estimateEffectiveAuthRoute, } from "@claudexor/schema";
 import { globalConfigDir, loadConfig } from "@claudexor/config";
+import { prepareRoutedProcessing, processingCostEvidence, prepareReviewerProcessing, } from "./processing-routing.js";
 import { acceptedTryOutput, AccessProfileIncompatibleError, AnswerAssembly, CLAUDEXOR_BROWSER_ARTIFACT_SUBDIR, countsAsAgentProgress, HarnessUnavailableError, summarizeDiffPaths as diffStats, withInactivityWatchdog, } from "@claudexor/core";
 import { assertRouteModelsAllowed, runModelGovernedRoute } from "./modelGovernance.js";
 import { authModeForCredentialRoute, authModeForPreference } from "./auth-route-classification.js";
@@ -29,7 +33,7 @@ import { planPrompt } from "./plan-prompt.js";
 import { verifiedPlanBrief, withPlanBrief } from "./planBrief.js";
 import { resolveRunInputDefaults } from "./run-input-resolution.js";
 import { beginAnnouncedRun } from "./runEventLog.js";
-import { arbitrationBudgetOptions, decisionBudgetSummary } from "./decisionBudget.js";
+import { arbitrationBudgetOptions } from "./decisionBudget.js";
 import { buildRevisePrompt } from "./revisePrompt.js";
 import { cancelledResult, declaredFailure, failTerminally, guardAnnouncedRun, writeFailure, cancelReasonFromSignalToken, } from "./runTerminals.js";
 import { budgetFailureRecord, classifyBudgetFailure } from "./budgetFailure.js";
@@ -39,7 +43,7 @@ import { dropDeltaPastBudget, emitPlanProgress, emitTransientExhausted, emitTran
 import { promptWithEngineConstraints, sleep, redactHarnessEvent, harnessEventPayload, safeErrorMessage, renderSummary, observeBudgetSignals, rotateOnStall, recordCleanAttemptMetrics, envInheritance, transientRetryPolicy, reviewerTimeoutMs, harnessInactivityTimeoutMs, observeAuthSwitch, emitPrimaryDivergence, emitPoolDegraded, deliveryRefusalFailure, winnerNeedsHuman, writeRaceDeliveryDecision, } from "./runSupport.js";
 import { candidateStatusInRouteContext, resolveReadOnlyRouteContext, } from "./routeContext.js";
 import { resolveAutoReviewerPanel, resolveExplicitReviewerPanel } from "./reviewerPanel.js";
-import { ensureWriteModeGitBoundary } from "./git-precondition.js";
+import { ensureClaudeBridgeForRun, ensureWriteModeGitBoundary } from "./git-precondition.js";
 import { buildContinuation, } from "./continuity.js";
 import { activePlanPointer, resolveContinuitySummary, workspaceAnchor, } from "./continuity-facts.js";
 import { runDiffReview } from "./diffReview.js";
@@ -56,14 +60,14 @@ import { gateSpecsFromContract, renderTestsEvidence } from "./contract-gates.js"
 import { buildTaskContract } from "./task-contract-builder.js";
 import { ArtifactStore } from "@claudexor/artifact-store";
 import { buildContextPack, rawContextForEnvelope, preflightEvidence, writeEvidencePacket, } from "@claudexor/context";
-import { WorkspaceManager, captureRawPatchEnvelope, createRevertAnchorFromPatchOrNull, createRevertAnchorOrNull, ensureClaudeBridge, consumeRawPatchEnvelope, snapshotTree, } from "@claudexor/workspace";
-import { blockedDecisionOverride, finalVerifyBlocks, finalVerifyPatch, verifyAndDeliver, } from "@claudexor/delivery";
+import { WorkspaceManager, captureRawPatchEnvelope, createRevertAnchorFromPatchOrNull, createRevertAnchorOrNull, consumeRawPatchEnvelope, snapshotTree, } from "@claudexor/workspace";
+import { blockedDecisionOverride, finalVerifyBlocks, finalVerifyPatch, finalVerifyFiles, verifyAndDeliverFiles, verifyAndDeliver, } from "@claudexor/delivery";
 import { HarnessGateway } from "@claudexor/gateway";
-import { ReadinessLedger, evaluateConvergence, failureSignature, gatesPassed, reviewCandidate, revalidateFindings, runGates, } from "@claudexor/review";
+import { ReadinessLedger, evaluateConvergence, failureSignature, gatesPassed, reviewCandidate, runGates, } from "@claudexor/review";
 import { arbitrate } from "@claudexor/arbitration";
 import { buildSynthesisPlan, decideSynthesis } from "@claudexor/synthesis";
-import { attemptCostEvidence, attemptUsageCostSettlement, BudgetLedger, isBudgetTerminal, explainRanking, loadHarnessMetrics, promptFingerprint, rankHarnesses, reviewUsageCostSettlement, } from "@claudexor/budget";
-import { readTextSafe, appendLine, assertNoInlineSecretValues, DELEGATION_ENV, hashJson, newId, noProjectRepoRoot, redactSecrets, safeInvoke, sha256, userConfigDir, writeText, } from "@claudexor/util";
+import { attemptCostEvidence, billingKnowledgeForAuthRoute, attemptUsageCostSettlement, BudgetLedger, isBudgetTerminal, explainRanking, loadHarnessMetrics, promptFingerprint, rankHarnesses, } from "@claudexor/budget";
+import { readTextSafe, appendLine, assertNoInlineSecretValues, hashJson, newId, noProjectRepoRoot, redactSecrets, safeInvoke, sha256, userConfigDir, } from "@claudexor/util";
 const LABELS = "ABCDEFGHIJ".split("");
 const NO_PROJECT_ROOT = noProjectRepoRoot();
 /** Concurrency cap for parallel candidates/explorers (locked decision: min(n, 4)). */
@@ -228,7 +232,11 @@ export class Orchestrator {
         try {
             // Auto-panel dropped knobs (reviewerEfforts) → ignored-settings channel (QA-070):
             const warn = (d) => void log.emit("review.preflight", { ignored_settings: [d] });
-            return { reviewers: await this.resolveReviewers(input.repoRoot, input.authPreference, warn) };
+            const config = this.config(input.repoRoot).global;
+            const reviewers = await this.resolveReviewers(input.repoRoot, input.authPreference, warn);
+            return {
+                reviewers: await prepareReviewerProcessing(reviewers, input, config, input.paidBudget ?? this.deps.paidBudget ?? config.budget.paid_budget_per_run),
+            };
         }
         catch (err) {
             const message = safeErrorMessage(err);
@@ -664,6 +672,7 @@ export class Orchestrator {
                     }),
                     effortLevels: manifest.capabilities.effort_levels,
                     knownModels: manifest.capabilities.known_models,
+                    modelInventoryRoutes: manifest.capabilities.model_inventory_routes,
                     // A selected profile's credential_kind IS the route (round-18 #2);
                     // the default store's sources apply only to profile-less runs.
                     authRouteEstimate: this.credentials.profileAuthRoute(input, id) ??
@@ -751,6 +760,8 @@ export class Orchestrator {
         }
         for (const { routed, error } of quotaRefusals)
             dropLane(routed.adapter.id, "credential", safeErrorMessage(error));
+        const processingConfig = this.config(input.repoRoot).global;
+        await prepareRoutedProcessing(quotaPreparedPool, input, this.execRootOf(input), processingConfig, input.paidBudget ?? this.deps.paidBudget ?? processingConfig.budget.paid_budget_per_run, (id) => (routeContext ? (routeContext.envForHarness?.(id) ?? routeContext.env) : undefined));
         const ordered = this.orderPool(quotaPreparedPool, input, intent, statusById, ledger, runId);
         if (ordered.length === 0) {
             if (primaryQuotaRefusal)
@@ -873,6 +884,7 @@ export class Orchestrator {
                 // reading as unknown/paid. Absent (unknown route) falls back to the
                 // metric-derived billingKnowledge below.
                 const authRoute = this.authRouteEvidenceFor(authMode, status?.authSources ?? []);
+                const processingCost = processingCostEvidence(r.processing, authRoute ? billingKnowledgeForAuthRoute(authRoute) : "unknown", [`harness:${r.adapter.id}`, `profile:${credentialSubjectId ?? "default"}`]);
                 return {
                     harnessId: r.adapter.id,
                     available: true,
@@ -882,7 +894,12 @@ export class Orchestrator {
                         config.harnesses[r.adapter.id]?.effort ??
                         undefined,
                     billingKnowledge: authMode === "api_key" ? "metered" : "unknown",
-                    incrementalCostUsd: authMode === "api_key" ? (metric?.avg_cost_usd ?? null) : null,
+                    costEvidence: processingCost,
+                    incrementalCostUsd: processingCost
+                        ? processingCost.estimatedUsd
+                        : authMode === "api_key"
+                            ? (metric?.avg_cost_usd ?? null)
+                            : null,
                     credentialRoute: r.quotaAdmission.route ??
                         (authMode === "api_key"
                             ? "managed_api_key"
@@ -1068,11 +1085,6 @@ export class Orchestrator {
             routingGoal: this.deps.routingGoal,
         });
     }
-    /**
-     * Per-harness settings applied to one route's run spec (model/effort/web
-     * defaults, max_turns, tool lists). Knobs the manifest does not support are
-     * RETURNED as ignored reasons (disclosed by the caller), never silently sent.
-     */
     /**
      * The HarnessRunSpec fields every TASK-PRODUCING lane shares (primary,
      * candidate, planner, explorer, orchestrate-planner). Extracting the identical
@@ -1083,43 +1095,6 @@ export class Orchestrator {
      * execution — owner Quiz-5a); reviewers and the auth smoke build their own
      * specs and never call this.
      */
-    /** The extra MCP servers injected into one agent lane's sandbox. Today only
-     * the delegation belt (D32): present when `--delegate` is on, the daemon built
-     * a belt descriptor, the lane's adapter can inject MCP servers, and the lane is
-     * a WRITING agent intent (the delegator integrates results in its workspace;
-     * read lanes and reviewers have nothing to delegate). */
-    delegationBeltFor(input, intent, routed, resolvedBudget) {
-        if (!input?.delegate ||
-            !input.delegationBelt ||
-            !input.delegationParentRunId ||
-            !routed.delegationRequirement.effective)
-            return [];
-        // A lane that sandbox-cancels the belt below full access (codex) must NOT
-        // receive a belt it cannot use. Per-lane requirement resolution records the
-        // typed degradation, while a mixed pool keeps the belt on lanes that can
-        // host it.
-        if (routed.mcpInjectionRequiresFullAccess && !isFullAccess(routed.adapterAccess))
-            return [];
-        const writingIntents = ["implement", "create_from_scratch", "repair"];
-        if (!writingIntents.includes(intent))
-            return [];
-        // The CLI built the descriptor from the RAW request budget (undefined when
-        // the caller relied on a config/dep default), which would leave the belt
-        // unlimited while the real run is capped. Rebind the belt's parent-budget
-        // env to the RESOLVED budget (resolvePaidBudget output) so sub-run draws are
-        // bounded by the same headroom the parent run enforces — one budget owner.
-        return [
-            {
-                ...input.delegationBelt,
-                env: {
-                    ...input.delegationBelt.env,
-                    [DELEGATION_ENV.parentRunId]: input.delegationParentRunId,
-                    [DELEGATION_ENV.repoRoot]: input.repoRoot,
-                    [DELEGATION_ENV.budget]: JSON.stringify(resolvedBudget),
-                },
-            },
-        ];
-    }
     harnessSpecKnobs(contract, knobs, intent) {
         return {
             external_context_policy: knobs.webPolicy,
@@ -1130,6 +1105,10 @@ export class Orchestrator {
             },
             model_hint: knobs.model,
             effort_hint: knobs.effort,
+            processing_preference: contract.processing_preference,
+            processing: knobs.processing?.receipt,
+            processing_cost_basis: knobs.processing?.costBasis,
+            processing_allow_paid: knobs.processingAllowPaid,
             max_turns: knobs.maxTurns,
             ...(intent === "synthesize" ? {} : { instructions: contract.instructions }),
             // The user's answer contract rides every answer-producing lane INCLUDING
@@ -1221,6 +1200,8 @@ export class Orchestrator {
         return {
             model,
             effort,
+            processing: routed.processing,
+            processingAllowPaid: routed.processingAllowPaid,
             webPolicy,
             maxTurns,
             toolsAllow,
@@ -1237,7 +1218,7 @@ export class Orchestrator {
      * Returns null (no packet, no pointer) for native resume, a fresh thread, or
      * a non-thread run. Never throws: continuity failure degrades to no packet.
      */
-    async resolveContinuity(runInput, harnessId, resolvedProfileId, nativeResumeAvailable, sessionFields, store, paths, repoRoot, log) {
+    async resolveContinuity(runInput, harnessId, resolvedProfileId, nativeResumeAvailable, sessionFields, store, paths, repoRoot, log, processing, processingAdmission, physicalDispatchStarted) {
         const ctx = runInput.threadContinuity;
         if (!runInput.threadId || !ctx)
             return null;
@@ -1286,6 +1267,9 @@ export class Orchestrator {
                 laneEnv: this.laneHomeEnvFor(runInput, harnessId, profileId) ?? {},
                 envInheritance: envInheritance(this.config(runInput.repoRoot)),
                 signal: runInput.signal,
+                processing,
+                processingAdmission,
+                physicalDispatchStarted,
             });
             const result = buildContinuation(req);
             // Disclose on every lane and stamp the turn (INV-137: never silent).
@@ -1343,7 +1327,7 @@ export class Orchestrator {
         // Refuses (never silently degrades) when a delegated run cannot be confined.
         return scopedHarnessHome(wsm, envelope, envelope.worktree_path === envelope.repo_root, runInput?.delegated === true, routed.adapterAccess);
     }
-    async runCandidateInEnvelope(routed, envelope, attemptId, label, contract, prompt, store, paths, wsm, ledger, access, onHarnessEvent, signal, modelHint, effortHint, intent, log, effectiveWebMode, interaction, budgetGuard, runInput, streamDeltas, fileBackedContext, 
+    async runCandidateInEnvelope(routed, envelope, attemptId, label, contract, prompt, store, paths, wsm, ledger, processingLease, access, onHarnessEvent, signal, modelHint, effortHint, intent, log, effectiveWebMode, interaction, budgetGuard, runInput, streamDeltas, fileBackedContext, 
     /** D-16d: when set, the mechanical continuation checkpoint pointer for a
      * one-shot fresh-session continuation — appended to the prompt so the model
      * (and the offline fake) re-grounds in the exhausted attempt's partial work. */
@@ -1353,21 +1337,33 @@ export class Orchestrator {
      * must record what it ran under, not just why it stopped. REQUIRED (no
      * default): a silent fallback here would spawn a delegated attempt on the
      * operator's real home while the record still claimed scoped state. */
-    harnessHome) {
+    harnessHome, observedPaths = new Set()) {
         const adapter = routed.adapter;
         const knobs = this.routeSpecKnobs(routed, contract, modelHint, effortHint);
         // Isolated scoped-home sessions are never retained after disposal.
         const inPlaceEnvelope = envelope.worktree_path === envelope.repo_root;
+        const directory = envelope.workspace_kind === "directory";
+        let directoryCapture = {};
+        const captureDirectory = async () => (directoryCapture = await captureDirectoryCandidate({
+            manager: wsm,
+            envelope,
+            artifactRoot: join(paths.attemptsDir, attemptId),
+            sourceRoot: contract.repo.root,
+            observedPaths: [...observedPaths],
+        }));
         const rawContextPacket = await rawContextForEnvelope(routed.implementationTransport, envelope);
         const sessionFields = runInput
             ? await this.sessionSpecFields(runInput, adapter.id, knobs.model, log, routed.authRouteEstimate, routed.quotaAdmission)
             : undefined;
-        // Continuity (INV-137): once the lane (harness + resolved profile) is known,
-        // build the continuation packet, materialize context/THREAD.md, and point
-        // the prompt at it — never embed the packet body in the prompt. Replaces the
-        // old static session.rebound "not_portable" phrase with a real disclosure.
+        const processingAdmission = processingAdmissionForLease(ledger, processingLease.id, adapter.id, attemptId, processingLease.onDenied);
+        const capturedProcessing = {
+            processing_preference: contract.processing_preference,
+            processing: knobs.processing?.receipt,
+            processing_cost_basis: knobs.processing?.costBasis,
+            processing_allow_paid: knobs.processingAllowPaid,
+        };
         const laneContinuity = runInput
-            ? await this.resolveContinuity(runInput, adapter.id, sessionFields?.credential_profile?.profile_id ?? runInput.credentialProfileId ?? null, inPlaceEnvelope && !!sessionFields?.resume_session_id, sessionFields, store, paths, envelope.repo_root, log)
+            ? await this.resolveContinuity(runInput, adapter.id, sessionFields?.credential_profile?.profile_id ?? runInput.credentialProfileId ?? null, inPlaceEnvelope && !!sessionFields?.resume_session_id, sessionFields, store, paths, envelope.repo_root, log, capturedProcessing, processingAdmission, () => ledger.markPhysicalDispatchStarted(processingLease.id))
             : null;
         const artifactRelativeDir = routed.browserRequirement.effective
             ? (wsm.ensureArtifactDirectory(envelope), wsm.ownedArtifactRelativeDirectory(envelope))
@@ -1392,7 +1388,7 @@ export class Orchestrator {
             artifactRelativeDir === null
                 ? ""
                 : join(envelope.worktree_path, artifactRelativeDir, CLAUDEXOR_BROWSER_ARTIFACT_SUBDIR)),
-            extra_mcp_servers: this.delegationBeltFor(runInput, intent, routed, contract.budget.paid_budget),
+            extra_mcp_servers: delegationBeltFor(runInput, intent, routed, contract.budget.paid_budget),
             cwd: envelope.worktree_path,
             access: routed.adapterAccess,
             ...this.harnessSpecKnobs(contract, knobs, intent),
@@ -1406,18 +1402,22 @@ export class Orchestrator {
             ...(inPlaceEnvelope && sessionFields?.resume_session_id
                 ? { resume_session_id: sessionFields.resume_session_id }
                 : {}),
-            // Scoped harness home for isolated envelopes AND for every delegated run;
-            // an ordinary in-place run keeps the native environment so the resumed
-            // vendor session is reachable. See scopedHarnessHome for the cost a
-            // delegated in-place attempt pays for that scoped state.
             ...(harnessHome.env ? { env: harnessHome.env } : {}),
             raw_context_packet: rawContextPacket,
             stream_deltas: streamDeltas,
         });
+        bindProcessingAdmission(spec, ledger, processingLease.id, adapter.id, attemptId, processingLease.onDenied, processingAdmission);
+        const billingInput = runInput ?? { repoRoot: contract.repo.root };
+        // Keep billing route-bound until admission observes the actual prepared
+        // profile. The resolver is evaluated per physical dispatch; preparedCost
+        // gives an actual profile precedence over this pool fallback.
+        spec.extra["routeBillingKnowledge"] = (actual) => actual.credential_profile?.credential_kind === "api_key"
+            ? "metered"
+            : actual.credential_profile
+                ? "subscription_entitlement"
+                : this.routeBillingKnowledge(billingInput, adapter.id);
         if (interaction)
             spec.extra["interactionChannel"] = interaction;
-        // D-16: compile the WorkReport envelope onto the spec (overriding the plain
-        // caller-schema transport) and keep the mode for the answer unwrap.
         const workEnvelope = this.workReportEnvelopeFor(routed, contract, Boolean(interaction));
         const workReportMode = this.applyWorkEnvelope(spec, workEnvelope);
         const inactivityMs = harnessInactivityTimeoutMs(this.config(contract.repo.root));
@@ -1434,6 +1434,7 @@ export class Orchestrator {
         let cost = 0;
         let costEstimated = false;
         let harnessErrored = false;
+        let processingRefusal = null;
         let poolExhausted = null; // A5: typed pool-exhausted refusal
         const deltaFlood = { count: 0, disclosed: false }; // W-C4 per-attempt delta budget
         // QA-024: emit the belt-failure disclosure event at most once per attempt.
@@ -1509,6 +1510,8 @@ export class Orchestrator {
                         if (ev.type === "patch_produced")
                             continue;
                         const safeEv = redactHarnessEvent(ev);
+                        if (directory)
+                            observeDirectoryPaths(observedPaths, safeEv, envelope.worktree_path);
                         if (dropDeltaPastBudget(safeEv, deltaFlood, Orchestrator.MAX_DELTAS_PER_ATTEMPT, (t, p) => log?.emit(t, p), adapter.id, attemptId))
                             continue;
                         safeInvoke(onHarnessEvent, safeEv);
@@ -1586,6 +1589,10 @@ export class Orchestrator {
                     // gate and required-actions read a typed category, not a bare boolean.
                     harnessErrored = true;
                     errors.push(safeErrorMessage(err));
+                    if (err instanceof ProcessingBudgetAdmissionError) {
+                        processingRefusal = err;
+                        break;
+                    }
                     telemetry.transientFailures.push(classifyAdapterThrow({ errorName: err instanceof Error ? err.name : null }));
                 }
                 finally {
@@ -1596,8 +1603,13 @@ export class Orchestrator {
                 // #31: the centralized retry gate reads the classified `retryable` verdict.
                 const sawRetryable = newTransients.some((f) => f.retryable);
                 const sawTypedLimit = telemetry.rateLimits.length > rateLimitStart;
-                const currentDiff = await wsm.diff(envelope);
-                const deliverableEmpty = currentDiff.trim().length === 0 && answer.text().length === 0;
+                if (directory)
+                    await captureDirectory();
+                const currentDiff = directory ? "" : await wsm.diff(envelope);
+                const workspaceUnchanged = directory
+                    ? directoryCapture.files?.noChanges === true
+                    : currentDiff.trim().length === 0;
+                const deliverableEmpty = workspaceUnchanged && answer.text().length === 0;
                 // W5.4 + A2 failover: a typed-limit hit OR a structural pre-progress
                 // death rebuilds the spec on a NEW session under the next profile.
                 if (harnessErrored && runInput && !signal?.aborted) {
@@ -1618,9 +1630,8 @@ export class Orchestrator {
                         // Rotation evidence reads the POLICY-accepted try output: refusal
                         // prose arriving as mid-stream MESSAGE events (claude org-disabled)
                         // is no deliverable; the transient gate keeps RAW deliverableEmpty.
-                        deliverableEmpty: currentDiff.trim().length === 0 &&
-                            acceptedTryOutput(answer, harnessErrored).length === 0,
-                        workspaceDiffNonEmpty: currentDiff.trim().length > 0,
+                        deliverableEmpty: workspaceUnchanged && acceptedTryOutput(answer, harnessErrored).length === 0,
+                        workspaceDiffNonEmpty: !workspaceUnchanged,
                         lastLimit: telemetry.rateLimits.at(-1) ?? null,
                         emit: (type, payload) => log?.emit(type, payload),
                         newSessionId: () => newId("ses"),
@@ -1663,7 +1674,7 @@ export class Orchestrator {
         }
         // A pool-exhausted terminal is rotation's verdict, not the transient
         // machinery's — no `route.transient.exhausted` rides along with it.
-        if (harnessErrored && !poolExhausted) {
+        if (harnessErrored && !poolExhausted && !processingRefusal) {
             emitTransientExhausted((t, p) => log?.emit(t, p), adapter.id, attemptId, telemetry, retryPolicy.maxRetries);
         }
         const attemptStreamEndedMs = Date.now();
@@ -1675,10 +1686,14 @@ export class Orchestrator {
         const unwrapped = unwrapWorkReportEnvelope(acceptedTryOutput(answer, harnessErrored), workReportMode, { sideToolReport: telemetry.sideToolWorkReport ?? undefined });
         const redacted = redactSecrets(unwrapped.deliverable);
         const candidateAnswer = redacted.trim().length > 0 ? redacted : undefined;
-        const { diff, refusal: secretDiffRefusal } = await secretDiff.quarantineCandidateWorkspace(wsm, envelope, inPlaceEnvelope, candidateAnswer);
+        if (directory)
+            await captureDirectory();
+        const { diff, refusal: secretDiffRefusal } = directory
+            ? { diff: "", refusal: directoryCapture.refusal }
+            : await secretDiff.quarantineCandidateWorkspace(wsm, envelope, inPlaceEnvelope, candidateAnswer);
         harnessErrored = secretDiff.recordSecretDiffRefusal(secretDiffRefusal, errors, harnessErrored);
         const answerText = secretDiffRefusal ? undefined : candidateAnswer;
-        const deliverableEvidence = diff.trim().length > 0 || Boolean(answerText);
+        const deliverableEvidence = diff.trim().length > 0 || Boolean(answerText) || directoryHasOutput(directoryCapture.files);
         // Cancelled attempts skip gates: running a 600s-per-gate suite delays the ack
         // and burns compute on a result nobody will adopt. Diff/attempt.yaml
         // still land, so partial work stays inspectable.
@@ -1757,8 +1772,8 @@ export class Orchestrator {
             worktreePath: envelope.worktree_path,
             artifactRelativeDir,
             diff,
-            persistPatch: secretDiffRefusal === undefined && isMutatingAccess(access),
-            persistProducedMedia: secretDiffRefusal === undefined,
+            persistPatch: !directory && secretDiffRefusal === undefined && isMutatingAccess(access),
+            persistProducedMedia: !directory && secretDiffRefusal === undefined,
             answerText,
             record: {
                 attempt_id: attemptId,
@@ -1773,6 +1788,15 @@ export class Orchestrator {
                 ...(secretDiffRefusal ? { secret_diff_refusal: secretDiffRefusal } : {}),
                 gates: gates.map((g) => ({ id: g.id, status: g.status })),
                 branch: envelope.branch_name,
+                ...(directoryCapture.files
+                    ? {
+                        files_manifest: directoryCapture.files.manifestPath,
+                        manifest_sha256: directoryCapture.files.manifestSha256,
+                        source_root: contract.repo.root,
+                        execution_root: envelope.worktree_path,
+                        no_changes: directoryCapture.files.noChanges,
+                    }
+                    : {}),
                 // Applied facts, not promises: historical proofs stay readable and
                 // current delegated runs state deliberate outer-boundary absence.
                 // Built by the SAME shape the failure path writes.
@@ -1788,6 +1812,7 @@ export class Orchestrator {
             harnessId: adapter.id,
             label,
             diff,
+            ...(directoryCapture.files ? { files: directoryCapture.files } : {}),
             answerText,
             reviewCwd: envelope.worktree_path,
             baseSha: envelope.base_sha ?? undefined,
@@ -1800,7 +1825,9 @@ export class Orchestrator {
             telemetry,
             ...(secretDiffRefusal ? { secretDiffRefusal } : {}),
             // A5: the typed refusal survives NORMAL attempt finalization (no throw).
-            ...(poolExhausted ? { declaredFailure: declaredFailure(poolExhausted) } : {}),
+            ...(poolExhausted || processingRefusal
+                ? { declaredFailure: declaredFailure(processingRefusal ?? poolExhausted) }
+                : {}),
             outcomeClass: finalized.outcomeClass,
             applied,
         };
@@ -1812,41 +1839,6 @@ export class Orchestrator {
         // Thin delegate — the channel mechanics live in interaction.ts.
         return interactionChannelFor(input, log, runId, taskId, attemptId, harnessId, supportsInteractive, DEFAULT_INTERACTION_TIMEOUT_MS);
     }
-    /**
-     * D-14 layer 3 (AGENTS.md unification, INV-113): the ONE new live-tree write.
-     * When the PROJECT root has `AGENTS.md` and no `CLAUDE.md`, drop a thin
-     * `CLAUDE.md` (`@AGENTS.md` import + Claudexor ownership marker) so a Claude
-     * Code route reads the same instruction file codex/cursor read natively.
-     *
-     * The project-root bridge has its own narrower fence: read-only modes never
-     * reach this run-prep stage and `--in-place` stateful targets are left
-     * untouched. Git admission is independently owned by `runStartRequiresGit`.
-     * The write targets the PROJECT root (`repoRoot`), never a worktree envelope.
-     * The workspace helper adds exclusive-create + no-follow +
-     * idempotency, so a hand-written or symlinked `CLAUDE.md` is never overwritten
-     * and a concurrent/second prep is a no-op. Announced via a typed
-     * `project.claude_bridge.created` event on an actual create only — the git-init
-     * pattern. A bridge is a convenience, not a precondition: any failure is
-     * swallowed so it can never fail an otherwise-valid write run.
-     */
-    ensureClaudeBridgeForRun(repoRoot, inPlace, log) {
-        if (repoRoot === NO_PROJECT_ROOT || inPlace)
-            return;
-        let result;
-        try {
-            result = ensureClaudeBridge(repoRoot);
-        }
-        catch {
-            return;
-        }
-        if (result.created) {
-            log.emit("project.claude_bridge.created", {
-                project_root: repoRoot,
-                path: "CLAUDE.md",
-                source: "AGENTS.md",
-            });
-        }
-    }
     async runRace(input, mode, announce) {
         const taskId = input.taskId ?? newId("task");
         const runId = input.runId ?? newId("run");
@@ -1885,7 +1877,7 @@ export class Orchestrator {
         // directory, a filesystem root, or one that cannot be classified), which
         // gets a typed refusal BEFORE any mutation (INV-075). For an isolated
         // thread the execution root is already a git worktree: a no-op there.
-        if (mutatingRun) {
+        if (mutatingRun && input.workspaceKind !== "directory") {
             const gitPreconditionError = await ensureWriteModeGitBoundary(execRoot, log, store, paths, runId, mode);
             if (gitPreconditionError) {
                 return {
@@ -1903,14 +1895,14 @@ export class Orchestrator {
         }
         // Same run-prep stage as the git boundary: if the PROJECT root uses AGENTS.md
         // with no CLAUDE.md, bridge it so a Claude Code candidate reads it (INV-113).
-        if (mutatingRun) {
-            this.ensureClaudeBridgeForRun(input.repoRoot, input.inPlace === true, log);
+        if (mutatingRun && input.workspaceKind !== "directory") {
+            ensureClaudeBridgeForRun(input.repoRoot, input.inPlace === true, log);
         }
         // Pre-turn snapshot of the live tree for in-place runs: the revert restore
         // target (server-owned revertInPlace). A snapshot failure must never fail the
         // run — revert is simply unavailable then.
         let preTurnSha = null;
-        if (mutatingRun && input.inPlace === true) {
+        if (mutatingRun && input.inPlace === true && input.workspaceKind !== "directory") {
             try {
                 preTurnSha = await snapshotTree(execRoot);
             }
@@ -1983,7 +1975,7 @@ export class Orchestrator {
                 attemptId,
                 intent: this.candidateIntent(input),
                 harnessId: routed.adapter.id,
-                cost: attemptCostEvidence(routed.adapter.id, attemptId, this.reservationEstimateUsd(input, i > 0), this.routeBillingKnowledge(input, routed.adapter.id)),
+                cost: attemptCostEvidence(routed.adapter.id, attemptId, this.reservationEstimateUsd(input, i > 0), this.routeBillingKnowledge(input, routed.adapter.id), processingCostEvidence(routed.processing, this.routeBillingKnowledge(input, routed.adapter.id), [`harness:${routed.adapter.id}`])),
             });
             log.emit("budget.lease.created", {
                 granted: lease.granted,
@@ -2079,6 +2071,8 @@ export class Orchestrator {
                     baseRef: contract.repo.base_ref,
                     dirtyPolicy: "snapshot",
                     accessProfile: candidateAccess,
+                    workspaceKind: input.workspaceKind,
+                    scopePaths: input.scopePaths,
                     // Direct-workspace singletons run in place. Races and patch-envelope
                     // transports stay isolated and adopt through the delivery service.
                     inPlace: !mutatingRun ||
@@ -2087,7 +2081,13 @@ export class Orchestrator {
                             slot.routed.implementationTransport !== "git_patch_envelope"),
                 });
                 harnessHome = this.harnessHomeFor(wsm, envelope, slot.routed, input);
-                const run = await this.runCandidateInEnvelope(slot.routed, envelope, slot.attemptId, slot.label, contract, input.prompt, store, paths, wsm, ledger, candidateAccess, (ev) => {
+                const run = await this.runCandidateInEnvelope(slot.routed, envelope, slot.attemptId, slot.label, contract, input.prompt, store, paths, wsm, ledger, {
+                    id: slot.leaseId,
+                    onDenied: (denial) => {
+                        budgetStopped = true;
+                        budgetDenial ??= denial;
+                    },
+                }, candidateAccess, (ev) => {
                     const safeEv = redactHarnessEvent(ev);
                     safeInvoke(input.onHarnessEvent, safeEv);
                     log.emit("harness.event", harnessEventPayload(adapter.id, slot.attemptId, safeEv));
@@ -2145,7 +2145,7 @@ export class Orchestrator {
                             attemptId: contAttemptId,
                             intent: this.candidateIntent(input),
                             harnessId: adapter.id,
-                            cost: attemptCostEvidence(adapter.id, contAttemptId, this.estimateUsdFloor(input.repoRoot), this.routeBillingKnowledge(input, adapter.id)),
+                            cost: attemptCostEvidence(adapter.id, contAttemptId, this.estimateUsdFloor(input.repoRoot), this.routeBillingKnowledge(input, adapter.id), processingCostEvidence(slot.routed.processing, this.routeBillingKnowledge(input, slot.routed.adapter.id), [`harness:${adapter.id}`])),
                         });
                         if (contLease.granted) {
                             candidateContinuationCount += 1; // claim the one-shot only once it launches
@@ -2164,7 +2164,13 @@ export class Orchestrator {
                             });
                             const contLeaseId = contLease.lease?.lease_id ?? "";
                             try {
-                                const contRun = await this.runCandidateInEnvelope(slot.routed, envelope, contAttemptId, slot.label, contract, input.prompt, store, paths, wsm, ledger, candidateAccess, (ev) => {
+                                const contRun = await this.runCandidateInEnvelope(slot.routed, envelope, contAttemptId, slot.label, contract, input.prompt, store, paths, wsm, ledger, {
+                                    id: contLeaseId,
+                                    onDenied: (denial) => {
+                                        budgetStopped = true;
+                                        budgetDenial ??= denial;
+                                    },
+                                }, candidateAccess, (ev) => {
                                     const safeEv = redactHarnessEvent(ev);
                                     safeInvoke(input.onHarnessEvent, safeEv);
                                     log.emit("harness.event", harnessEventPayload(adapter.id, contAttemptId, safeEv));
@@ -2263,18 +2269,18 @@ export class Orchestrator {
         // Fail-closed terminal: a delegated mutating run whose attempts state
         // neither historical proof nor deliberate absence refuses instead of passing.
         assertDelegatedEvidence(input.delegated === true, candidateAccess, runs);
-        const cancelledCandidates = () => runs.map((r) => ({
-            attemptId: r.attemptId,
-            harnessId: r.harnessId,
-            // gatesPassed([]) is vacuously true: a successful zero-gate run is a
-            // legitimate green STATUS (never a "gates passed" claim — the label
-            // surfaces render that honestly as n/a).
-            status: gatesPassed(r.gates) && !r.errored ? "green" : "red",
-        }));
-        /** The one cancellation terminal this race can reach, from any of its three
-         * abort checks. Every argument is re-read at call time, exactly as it was
-         * when each check spelled the whole call out for itself. */
-        const cancelledRaceResult = () => cancelledResult(log, runId, taskId, mode, paths.root, cancelledCandidates(), () => this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, candidateRoster(runs), null), ledger.spend(), input.signal, store);
+        const cancelledRaceResult = () => cancelledCandidatesResult({
+            store,
+            paths,
+            log,
+            runId,
+            taskId,
+            mode,
+            ledger,
+            runs,
+            signal: input.signal,
+            writeTelemetry: () => this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, candidateRoster(runs), null),
+        });
         // Revert divergence fence for the single-candidate in-place path: the
         // candidate mutated the LIVE tree during execution above, so the post-turn
         // snapshot must be taken NOW — before review/synthesis/arbitration, which can
@@ -2283,6 +2289,7 @@ export class Orchestrator {
         // into the revert target and let a later revert clobber them.
         let earlyPostTurnSha = null;
         if (mutatingRun &&
+            input.workspaceKind !== "directory" &&
             input.inPlace &&
             requestedSingleCandidate &&
             runs.every((run) => !run.secretDiffRefusal)) {
@@ -2301,7 +2308,19 @@ export class Orchestrator {
         if (failedDelegation) {
             const failure = delegateFailure.candidateFailureTerminal(failedDelegation, "race");
             await disposeReviewEnvelopes();
-            if (mutatingRun) {
+            if (mutatingRun && failedDelegation.files) {
+                await publishDirectoryCandidate({
+                    files: failedDelegation.files,
+                    store,
+                    paths,
+                    taskId,
+                    attemptId: failedDelegation.attemptId,
+                    harnessId: failedDelegation.harnessId,
+                    facts: makeOutcomeFacts("failed", { noChanges: failedDelegation.files.noChanges }),
+                    log,
+                });
+            }
+            else if (mutatingRun && input.workspaceKind !== "directory") {
                 await delegateFailure.persistFailedInPlaceWorkProduct({
                     ...{ store, log, paths, execRoot, preTurnSha, taskId, mode },
                     live: input.inPlace === true && failedDelegation.reviewCwd === execRoot,
@@ -2313,63 +2332,18 @@ export class Orchestrator {
             this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, candidateRoster(runs), null);
             return failTerminally(log, store, paths, runId, taskId, mode, failure.phase, failure.error, ledger.spend(), failure.metadata);
         }
-        if (runs.length === 0) {
-            const budgetReason = ledger.terminal();
-            // QA-050: when the zero-candidate cause is a budget refusal, the shared
-            // classifier owns the typed code, the refused route/slot, and actionable
-            // budget remediation (previously an empty nextActions array).
-            const agentBudgetMapping = budgetStopped || budgetReason
-                ? classifyBudgetFailure({ denial: budgetDenial, terminal: budgetReason })
-                : null;
-            const facts = makeOutcomeFacts("failed", {
-                reason: agentBudgetMapping?.reason ?? (budgetStopped ? "budget_exhausted" : "harness_failed"),
-                noChanges: true,
-            });
-            const why = agentBudgetMapping?.safeMessage ?? "no candidates produced";
-            store.writeYaml(join(paths.arbitrationDir, "decision.yaml"), {
-                winner: null,
-                facts,
-                why_winner: why,
-                evidence_facts: ["no candidates were produced"],
-                apply_recommendation: "continue",
-                budget_summary: decisionBudgetSummary(ledger),
-            });
-            store.writeText(join(paths.finalDir, "summary.md"), `# Run ${runId} (${mode})\n\n- Lifecycle: ${facts.lifecycle}${facts.reason ? ` (${facts.reason})` : ""}\n- Phase: ${agentBudgetMapping ? "budget" : "executor"}\n\n${why}\n`);
-            if (agentBudgetMapping) {
-                writeFailure(store, paths, budgetFailureRecord(agentBudgetMapping, { runDir: paths.root }));
-            }
-            else {
-                writeFailure(store, paths, {
-                    phase: "executor",
-                    category: "internal",
-                    safeMessage: why,
-                    runDir: paths.root,
-                    nextActions: ["Open diagnostics", "Retry the run"],
-                });
-            }
-            log.emit("output.ready", { kind: "summary", path: "final/summary.md", state: "diagnostic" });
-            log.emit("run.failed", {
-                lifecycle: facts.lifecycle,
-                facts,
-                reason: facts.reason,
-                phase: agentBudgetMapping ? "budget" : "executor",
-                ...(agentBudgetMapping?.harnessId ? { harness_id: agentBudgetMapping.harnessId } : {}),
-                error: why,
-                failure_ref: "final/failure.yaml",
-            });
-            return {
+        if (runs.length === 0)
+            return emptyCandidateResult({
+                ledger,
+                budgetStopped,
+                budgetDenial,
+                mode,
+                store,
+                paths,
+                log,
                 runId,
                 taskId,
-                mode,
-                lifecycle: facts.lifecycle,
-                facts,
-                winner: null,
-                runDir: paths.root,
-                summary: why,
-                candidates: [],
-                spendUsd: ledger.spend(),
-            };
-        }
+            });
         // Reviewers, synthesis, and arbitration only ever see candidates WITH
         // work (a real diff or a completed stream). Attempts that died before
         // producing anything are corpses: reviewing "(empty diff)" spends real
@@ -2378,72 +2352,18 @@ export class Orchestrator {
         const workingRuns = partitionCandidates(runs).working;
         if (workingRuns.length === 0) {
             await disposeReviewEnvelopes();
-            const first = runs[0];
-            const phase = first.secretDiffRefusal ? "artifact_security" : (first.infraPhase ?? "harness");
-            const { facts, why: rootCause } = partitionCandidates(runs);
-            store.writeYaml(join(paths.arbitrationDir, "decision.yaml"), {
-                winner: null,
-                facts,
-                why_winner: rootCause,
-                evidence_facts: runs.map((r) => `${r.attemptId} produced no work: ${r.errors[0] ?? "unknown"}`),
-                apply_recommendation: "continue",
-                budget_summary: decisionBudgetSummary(ledger),
-            });
-            this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, candidateRoster(runs), null);
-            store.writeText(join(paths.finalDir, "summary.md"), `# Run ${runId} (${mode})\n\n- Lifecycle: ${facts.lifecycle}\n- Phase: ${phase}\n\n${rootCause}\n`);
-            const existingEventRefs = runs
-                .map((r) => `attempts/${r.attemptId}/events.jsonl`)
-                .filter((rel) => existsSync(join(paths.root, rel)));
-            // #31: auth guidance only on a classified auth failure; every other
-            // harness cause (timeout, rate limit, crash, config) gets remediation that
-            // fits it, instead of a doomed "Check harness authentication".
-            const harnessCategory = dominantHarnessFailureCategory(first.telemetry.transientFailures);
-            // A run speaks with a candidate's TYPED refusal only when EVERY candidate
-            // died of the same one (candidateEvidence owns that rule); mixed causes
-            // keep the honest harness terminal.
-            const unanimous = unanimousDeclaredFailure(runs);
-            writeFailure(store, paths, {
-                phase,
-                category: unanimous?.category ?? (phase === "workspace" ? "project" : "harness_error"),
-                code: unanimous?.code ?? null,
-                harnessId: first.harnessId,
-                attemptId: first.attemptId,
-                safeMessage: rootCause,
-                rawDetailRef: `attempts/${first.attemptId}/attempt.yaml`,
-                eventRefs: existingEventRefs,
-                runDir: paths.root,
-                resetsAt: unanimous?.resetsAt ?? null,
-                nextActions: first.secretDiffRefusal
-                    ? secretDiff.secretDiffNextActions(first.secretDiffRefusal)
-                    : phase === "workspace"
-                        ? ["Check the project folder", "Open diagnostics", "Retry the run"]
-                        : harnessFailureNextActions(harnessCategory),
-            });
-            log.emit("output.ready", { kind: "summary", path: "final/summary.md", state: "diagnostic" });
-            log.emit("run.failed", {
-                lifecycle: facts.lifecycle,
-                facts,
-                reason: facts.reason,
-                phase,
-                error: rootCause,
-                failure_ref: "final/failure.yaml",
-            });
-            return {
+            return failedCandidatesResult({
+                store,
+                paths,
+                log,
                 runId,
                 taskId,
                 mode,
-                lifecycle: facts.lifecycle,
-                facts,
-                winner: null,
-                runDir: paths.root,
-                summary: rootCause,
-                candidates: runs.map((r) => ({
-                    attemptId: r.attemptId,
-                    harnessId: r.harnessId,
-                    status: "red",
-                })),
-                spendUsd: ledger.spend(),
-            };
+                ledger,
+                runs,
+                budgetDenial,
+                writeTelemetry: () => this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, candidateRoster(runs), null),
+            });
         }
         // QA-025: only announce that review STARTED when the panel will actually
         // run. A candidate that changed no files is skipped inside reviewRuns; a
@@ -2452,7 +2372,7 @@ export class Orchestrator {
         // real verification). Compute the reviewable set first and emit a typed
         // `review.skipped` when nothing is reviewable, so every start has a matching
         // terminal and the no-diff path records `not_run` consistently.
-        const reviewableRuns = workingRuns.filter((r) => r.diff.trim().length > 0);
+        const reviewableRuns = workingRuns.filter((r) => r.files ? r.files.noChanges !== true : r.diff.trim().length > 0);
         const configuredFamilies = new Set(reviewers.map((r) => r.providerFamily)).size;
         if (reviewableRuns.length === 0 || reviewers.length === 0) {
             log.emit("review.skipped", {
@@ -2511,7 +2431,7 @@ export class Orchestrator {
                 attemptId: "synth",
                 intent: "synthesize",
                 harnessId: synthRouted.adapter.id,
-                cost: attemptCostEvidence(synthRouted.adapter.id, "synth", this.reservationEstimateUsd(input), this.routeBillingKnowledge(input, synthRouted.adapter.id)),
+                cost: attemptCostEvidence(synthRouted.adapter.id, "synth", this.reservationEstimateUsd(input), this.routeBillingKnowledge(input, synthRouted.adapter.id), processingCostEvidence(synthRouted.processing, this.routeBillingKnowledge(input, synthRouted.adapter.id), [`harness:${synthRouted.adapter.id}`])),
             });
             if (lease.granted) {
                 let envelope;
@@ -2533,9 +2453,17 @@ export class Orchestrator {
                         baseRef: contract.repo.base_ref,
                         dirtyPolicy: "snapshot",
                         accessProfile: candidateAccess,
+                        workspaceKind: input.workspaceKind,
+                        scopePaths: input.scopePaths,
                     });
                     const synthHome = this.harnessHomeFor(wsm, envelope, synthRouted, input);
-                    const run = await this.runCandidateInEnvelope(synthRouted, envelope, "synth", "Synthesis", contract, synthesisInput.prompt, store, paths, wsm, ledger, candidateAccess, (ev) => {
+                    const run = await this.runCandidateInEnvelope(synthRouted, envelope, "synth", "Synthesis", contract, synthesisInput.prompt, store, paths, wsm, ledger, {
+                        id: lease.lease.lease_id,
+                        onDenied: (denial) => {
+                            budgetStopped = true;
+                            budgetDenial ??= denial;
+                        },
+                    }, candidateAccess, (ev) => {
                         const safeEv = redactHarnessEvent(ev);
                         safeInvoke(input.onHarnessEvent, safeEv);
                         log.emit("harness.event", harnessEventPayload(synthAdapter.id, "synth", safeEv));
@@ -2553,7 +2481,7 @@ export class Orchestrator {
                             workingRuns.push(run);
                         }
                         if (input.signal?.aborted) {
-                            return cancelledResult(log, runId, taskId, mode, paths.root, cancelledCandidates(), () => this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, candidateRoster(runs), null), ledger.spend(), input.signal, store);
+                            return cancelledResult(log, runId, taskId, mode, paths.root, candidateStatuses(runs), () => this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, candidateRoster(runs), null), ledger.spend(), input.signal, store);
                         }
                     }
                     finally {
@@ -2613,6 +2541,12 @@ export class Orchestrator {
             ? (evidences.find((e) => e.attemptId === winnerRun.attemptId)?.reviewVerified ?? false)
             : evidences.length > 0 && evidences.every((e) => e.reviewVerified);
         let facts = result.decision.facts;
+        if (winnerRun?.files)
+            facts = {
+                ...facts,
+                noChanges: winnerRun.files.noChanges,
+                reason: facts.reason === "no_changes" && winnerRun.files.noChanges !== true ? null : facts.reason,
+            };
         // A reviewer NEEDS_HUMAN escalation forces the REVIEW axis to blocked (a
         // needs-decision terminal), unless the decision is already applyable-clean.
         if (needsHuman && facts.lifecycle === "succeeded" && facts.review !== "blocked") {
@@ -2633,27 +2567,24 @@ export class Orchestrator {
         let finalVerifyFailed = false;
         let deliveryFailureReason = null;
         let raceDeliveryReceipt = null;
-        // A single in-place turn already mutated its execution tree; race adoption
-        // instead defers verification until immediately before delivery.
+        let directoryDeliveryReceipt = false;
         const inPlaceWinner = winnerRun?.reviewCwd === execRoot;
         const deferredRaceVerify = input.inPlace === true && !inPlaceWinner;
         if (mutatingRun &&
             winnerRun &&
             !inPlaceWinner &&
             !deferredRaceVerify &&
-            winnerRun.diff.trim().length > 0 &&
+            (winnerRun.files ? winnerRun.files.noChanges !== true : winnerRun.diff.trim().length > 0) &&
             facts.lifecycle === "succeeded" &&
             facts.review !== "blocked" &&
             !input.signal?.aborted) {
-            finalVerify = await finalVerifyPatch(execRoot, winnerRun, gateSpecsFromContract(contract), log);
-            // Verify errors block like proven failures; accept_risk stays available.
-            // A failed fresh verify lands on the CHECKS axis (a needs-decision block).
+            finalVerify = winnerRun.files
+                ? await finalVerifyFiles(winnerRun.files, undefined, gateSpecsFromContract(contract), log)
+                : await finalVerifyPatch(execRoot, winnerRun, gateSpecsFromContract(contract), log);
             finalVerifyFailed = finalVerifyBlocks(finalVerify);
             if (finalVerifyFailed)
                 facts = { ...facts, checks: "failed", reason: "checks_failed" };
         }
-        // A needs-decision terminal (review blocked or checks failed) overrides the
-        // persisted green arbitration fields; otherwise the facts pass through.
         const needsDec = facts.review === "blocked" || facts.checks === "failed";
         store.writeYaml(join(paths.arbitrationDir, "decision.yaml"), {
             ...result.decision,
@@ -2674,17 +2605,9 @@ export class Orchestrator {
                 log.emit("output.ready", { kind: "artifact", path });
             }
             const winnerAnswer = winnerRun.answerText ?? "";
-            // The winner's final MESSAGE is the human-facing answer and materializes
-            // for diff-ful runs too: the chat renders final/answer.md (the projection
-            // prefers it), never the arbitration summary — "Run … Winner: a01 …" is
-            // machine telemetry, not what the agent said. The diff stays in the
-            // Diff tab; summary.md remains a diagnostics artifact.
             if (winnerAnswer.length > 0) {
                 store.writeText(join(paths.finalDir, "answer.md"), winnerAnswer + "\n");
             }
-            // The run's structured-output contract: ONE engine validator, called on
-            // the winner's answer regardless of diff presence (a non-conformant
-            // answer stays success-with-warnings; the receipt is the truth).
             if (contract.output_schema) {
                 finalizeStructuredOutput({
                     store,
@@ -2694,7 +2617,48 @@ export class Orchestrator {
                     answerText: winnerAnswer,
                 });
             }
-            if (mutatingRun) {
+            if (mutatingRun && winnerRun.files) {
+                let directoryDelivery;
+                const directoryAdoptable = facts.lifecycle === "succeeded" &&
+                    reviewAllowsApply(facts) &&
+                    facts.checks !== "failed" &&
+                    !workStateVetoes(facts);
+                if (input.inPlace === true && !inPlaceWinner && directoryAdoptable) {
+                    const delivered = await verifyAndDeliverFiles(execRoot, winnerRun.files, {}, gateSpecsFromContract(contract), (freshVerify) => finalVerifyBlocks(freshVerify)
+                        ? (freshVerify.reason ?? "final verify failed before directory race adoption")
+                        : null, log);
+                    store.writeYaml(join(paths.finalDir, "delivery_receipt.yaml"), delivered);
+                    directoryDeliveryReceipt = true;
+                    directoryDelivery = delivered;
+                    finalVerify = delivered.finalVerify;
+                    if (finalVerifyBlocks(finalVerify))
+                        finalVerifyFailed = true;
+                    if (!delivered.applied) {
+                        deliveryFailureReason = delivered.detail ?? "directory race adoption was refused";
+                        facts = { ...facts, checks: "failed", reason: "checks_failed" };
+                    }
+                    writeRaceDeliveryDecision(store, decisionPath, {
+                        decision: result.decision,
+                        facts,
+                        reviewVerified: actualReviewVerified,
+                        finalVerify,
+                        deliveryFailureReason,
+                        deliveryReceiptPath: "final/delivery_receipt.yaml",
+                    });
+                }
+                await publishDirectoryCandidate({
+                    files: winnerRun.files,
+                    store,
+                    paths,
+                    taskId,
+                    attemptId: winnerRun.attemptId,
+                    harnessId: winnerRun.harnessId,
+                    facts,
+                    log,
+                    delivery: directoryDelivery,
+                });
+            }
+            else if (mutatingRun) {
                 secretDiff.assertNoSecretLikeTokens("final patch diff", winnerRun.diff);
                 const patchSha256 = sha256(winnerRun.diff);
                 store.writeText(join(paths.finalDir, "patch.diff"), winnerRun.diff);
@@ -2771,7 +2735,7 @@ export class Orchestrator {
                     reviewVerified: actualReviewVerified,
                     finalVerify,
                     deliveryFailureReason,
-                    deliveryReceiptPath: raceDeliveryReceipt ? "final/delivery_receipt.yaml" : null,
+                    deliveryReceiptPath: raceDeliveryReceipt || directoryDeliveryReceipt ? "final/delivery_receipt.yaml" : null,
                 });
                 if (inPlaceWinner && requestedSingleCandidate && adopted === true) {
                     revertAnchorId = await createRevertAnchorOrNull(execRoot, preTurnSha, postTurnSha);
@@ -2781,7 +2745,7 @@ export class Orchestrator {
                     kind: input.create === true ? "new_repo" : "patch",
                     source_task_id: taskId,
                     producer_attempt_id: winnerRun.attemptId,
-                    ...(raceDeliveryReceipt
+                    ...(raceDeliveryReceipt || directoryDeliveryReceipt
                         ? { files: { delivery_receipt: "final/delivery_receipt.yaml" } }
                         : {}),
                     meta: {
@@ -2948,20 +2912,12 @@ export class Orchestrator {
             winner: result.decision.winner,
             runDir: paths.root,
             summary: result.decision.why_winner,
-            candidates: runs.map((r) => ({
-                attemptId: r.attemptId,
-                harnessId: r.harnessId,
-                // gatesPassed([]) is vacuously true: a successful zero-gate run is a
-                // legitimate green STATUS (never a "gates passed" claim — the label
-                // surfaces render that honestly as n/a).
-                status: gatesPassed(r.gates) && !r.errored ? "green" : "red",
-            })),
+            candidates: candidateStatuses(runs),
             decisionPath,
             reviewVerified: actualReviewVerified,
             spendUsd: ledger.spend(),
         };
     }
-    /** Single-owner telemetry artifact (final/telemetry.yaml); surfaces project it, never recompute. */
     writeRunTelemetry(store, paths, contract, runId, taskId, mode, attempts, finalAttemptId, deepScanSynthesis) {
         // QA-034: attach the routing rationale recorded at pool ordering (if this
         // run computed one), then clear it — telemetry is written once at terminal.
@@ -2981,7 +2937,6 @@ export class Orchestrator {
             resolveAuthPreference: (harnessId) => this.authPreferenceForHarness(contract.repo.root, harnessId, contract.auth_preference),
         });
     }
-    /** Review a set of runs and return their evidence (with finalReviewClean + review_verified caveat). */
     /**
      * SINGLE funnel for every reviewer-panel invocation: run it inside a per-review
      * scoped harness HOME (Bible §6) so reviewer scratch state and injected auth
@@ -2998,7 +2953,7 @@ export class Orchestrator {
             transientRetryPolicy: input.transientRetryPolicy ?? transientRetryPolicy(this.config(input.cwd)),
         });
     }
-    async reviewRuns(runs, reviewers, reviewVerified, reviewDir, cwd, contract, store, paths, log, ledger, taskId, signal, reservationEstimateUsd) {
+    async reviewRuns(runs, reviewers, reviewVerified, reviewDir, cwd, contract, store, paths, log, ledger, taskId, signal, reservationEstimateUsd, reviewUnchanged = false) {
         return reviewCandidateRuns({
             runs,
             reviewers,
@@ -3013,6 +2968,7 @@ export class Orchestrator {
             taskId,
             signal,
             reservationEstimateUsd,
+            reviewUnchanged,
         }, {
             prepareReviewEvidenceDir: this.prepareReviewEvidenceDir.bind(this),
             recordReviewEvidenceCleanup: this.recordReviewEvidenceCleanup.bind(this),
@@ -3087,9 +3043,9 @@ export class Orchestrator {
         const wsm = new WorkspaceManager(execRoot);
         const readiness = new ReadinessLedger();
         store.writeYaml(join(paths.contextDir, "task.yaml"), contract);
-        // Live (in-place) isolation deliberately tolerates non-git stateful
-        // environments; only envelope isolation needs the git boundary.
-        if (!input.inPlace) {
+        // Legacy Git envelopes need their boundary; explicit directory execution
+        // keeps the requested strategy without initializing the selected folder.
+        if (!input.inPlace && input.workspaceKind !== "directory") {
             const gitPreconditionError = await ensureWriteModeGitBoundary(execRoot, log, store, paths, runId, mode);
             if (gitPreconditionError) {
                 return {
@@ -3109,7 +3065,7 @@ export class Orchestrator {
             // exclusion — we are inside that branch, so inPlace is false here): bridge
             // an AGENTS.md-only PROJECT root so a Claude Code convergence attempt reads
             // it (INV-113).
-            this.ensureClaudeBridgeForRun(input.repoRoot, false, log);
+            ensureClaudeBridgeForRun(input.repoRoot, false, log);
         }
         const reviewDir = join(paths.root, "review-evidence");
         if (contract.review_requested !== false)
@@ -3198,6 +3154,7 @@ export class Orchestrator {
         let attempt = 0;
         let converged = false;
         let exhausted = false;
+        let processingBudgetDenial = null;
         let interrupted = false; // D-16 r8: terminalizes the run interrupted
         let lastFindings = [];
         let lastRun = null;
@@ -3223,12 +3180,13 @@ export class Orchestrator {
         const allCooledDown = () => adapterPool.every((a) => convergenceQuotaLedger.cooldownActive(a.adapter.id));
         const attemptTelemetries = [];
         let lastDiffStable = true;
+        const observedPaths = new Set();
         try {
             // The contract's ENGINE-COMPUTED effective profile drives the envelope and
             // every attempt spec (parity with runRace); telemetry must never claim an
             // access level the envelope did not actually run with.
             const convergenceAccess = contract.access.effective_profile;
-            if (input.inPlace === true) {
+            if (input.inPlace === true && input.workspaceKind !== "directory") {
                 try {
                     preTurnSha = await snapshotTree(execRoot);
                 }
@@ -3243,6 +3201,8 @@ export class Orchestrator {
                 dirtyPolicy: "snapshot",
                 inPlace: input.inPlace ?? false,
                 accessProfile: convergenceAccess,
+                workspaceKind: input.workspaceKind,
+                scopePaths: input.scopePaths,
             });
             for (;;) {
                 if (input.signal?.aborted)
@@ -3277,7 +3237,7 @@ export class Orchestrator {
                     attemptId,
                     intent: "repair",
                     harnessId: adapter.id,
-                    cost: attemptCostEvidence(adapter.id, attemptId, this.reservationEstimateUsd(input), this.routeBillingKnowledge(input, adapter.id)),
+                    cost: attemptCostEvidence(adapter.id, attemptId, this.reservationEstimateUsd(input), this.routeBillingKnowledge(input, adapter.id), processingCostEvidence(routed.processing, this.routeBillingKnowledge(input, routed.adapter.id), [`harness:${adapter.id}`])),
                 });
                 if (!lease.granted) {
                     exhausted = true;
@@ -3295,7 +3255,13 @@ export class Orchestrator {
                         external_context_policy: knobs.webPolicy,
                         ...(knobs.ignored.length > 0 ? { ignored_settings: knobs.ignored } : {}),
                     });
-                    run = await this.runCandidateInEnvelope(routed, envelope, attemptId, `Attempt ${attempt}`, contract, prompt, store, paths, wsm, ledger, convergenceAccess, (ev) => {
+                    run = await this.runCandidateInEnvelope(routed, envelope, attemptId, `Attempt ${attempt}`, contract, prompt, store, paths, wsm, ledger, {
+                        id: lease.lease.lease_id,
+                        onDenied: (denial) => {
+                            exhausted = true;
+                            processingBudgetDenial ??= denial;
+                        },
+                    }, convergenceAccess, (ev) => {
                         const safeEv = redactHarnessEvent(ev);
                         safeInvoke(input.onHarnessEvent, safeEv);
                         log.emit("harness.event", harnessEventPayload(adapter.id, attemptId, safeEv));
@@ -3303,7 +3269,7 @@ export class Orchestrator {
                         ledger.updateHold(lease.lease?.lease_id ?? "", streamedUsd);
                         return ledger.tier() === "hard";
                     }, input, true, // convergence runs one candidate: live deltas on (W-C4)
-                    undefined, undefined, harnessHome);
+                    undefined, undefined, harnessHome, observedPaths);
                     ledger.settle(lease.lease?.lease_id ?? "", attemptUsageCostSettlement(run.cost, run.costEstimated, run.attemptId, run.harnessId, run.telemetry.authMode, run.telemetry.usageCost));
                     log.emit("harness.completed", {
                         harness_id: adapter.id,
@@ -3343,6 +3309,17 @@ export class Orchestrator {
                         ...(declared.code ? { declaredFailure: declared } : {}),
                         telemetry: createAttemptTelemetry(knobs.webPolicy, contract.external_context.web_required, effectiveWeb, [routed.browserRequirement, routed.denyRequirement, routed.delegationRequirement], knobs.model),
                     };
+                    if (envelope.workspace_kind === "directory") {
+                        const captured = await captureDirectoryCandidate({
+                            manager: wsm,
+                            envelope,
+                            artifactRoot: join(paths.attemptsDir, attemptId),
+                            sourceRoot: contract.repo.root,
+                            observedPaths: [...observedPaths],
+                        });
+                        run.files = captured.files;
+                        run.secretDiffRefusal = captured.refusal;
+                    }
                 }
                 lastRun = run;
                 // Fail-closed twin of the candidate lane's gate: this loop terminalizes
@@ -3350,20 +3327,47 @@ export class Orchestrator {
                 assertDelegatedEvidence(input.delegated === true, convergenceAccess, [run]);
                 attemptTelemetries.push({ attemptId, harnessId: adapter.id, telemetry: run.telemetry });
                 // Cancellation/deadline keeps priority over a belt failure finalized concurrently.
-                if (input.signal?.aborted)
+                if (input.signal?.aborted || processingBudgetDenial)
                     break;
                 if (delegateFailure.candidateFailureKind(run)) {
                     const failure = delegateFailure.candidateFailureTerminal(run, "convergence");
-                    await delegateFailure.persistFailedInPlaceWorkProduct({
-                        ...{ store, log, paths, execRoot, preTurnSha, taskId, mode },
-                        live: input.inPlace === true,
-                        run,
-                        kind: input.create === true ? "new_repo" : "patch",
-                        attempts: attempt,
-                    });
+                    if (run.files) {
+                        await publishDirectoryCandidate({
+                            files: run.files,
+                            store,
+                            paths,
+                            taskId,
+                            attemptId,
+                            harnessId: run.harnessId,
+                            facts: makeOutcomeFacts("failed", { noChanges: run.files.noChanges }),
+                            log,
+                        });
+                    }
+                    else if (input.workspaceKind !== "directory") {
+                        await delegateFailure.persistFailedInPlaceWorkProduct({
+                            ...{ store, log, paths, execRoot, preTurnSha, taskId, mode },
+                            live: input.inPlace === true,
+                            run,
+                            kind: input.create === true ? "new_repo" : "patch",
+                            attempts: attempt,
+                        });
+                    }
                     this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, attemptTelemetries, null);
                     return failTerminally(log, store, paths, runId, taskId, mode, failure.phase, failure.error, ledger.spend(), failure.metadata);
                 }
+                if (input.workspaceKind === "directory" && run.secretDiffRefusal) {
+                    return failedCandidatesResult({
+                        ledger,
+                        mode,
+                        store,
+                        paths,
+                        log,
+                        runId,
+                        taskId,
+                        runs: [run],
+                        writeTelemetry: () => this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, attemptTelemetries, null),
+                    });
+                }
                 // D-16 r8: interrupted (errored===false) would CONVERGE a partial diff
                 // as clean — break BEFORE review; a harness error still gate-retries.
                 if (run.outcomeClass === "interrupted") {
@@ -3373,7 +3377,7 @@ export class Orchestrator {
                 // Post-mutation fence for in-place: snapshot the live tree NOW (after the
                 // harness mutated it, before this attempt's review). The last attempt's
                 // value is the revert target persisted into work_product.yaml.
-                if (input.inPlace === true) {
+                if (input.inPlace === true && input.workspaceKind !== "directory") {
                     try {
                         lastPostTurnSha = await snapshotTree(execRoot);
                     }
@@ -3394,148 +3398,43 @@ export class Orchestrator {
                             log.emit("review.skipped", { reason: "not_requested", attempt_id: attemptId });
                             return evaluateUnreviewedConvergence(evidence, contract);
                         }
-                        const candidateReviewCwd = run.reviewCwd ?? input.repoRoot;
-                        const candidateReviewEvidenceDir = this.prepareReviewEvidenceDir(reviewDir, candidateReviewCwd);
-                        try {
-                            writeText(join(candidateReviewEvidenceDir, "TESTS.txt"), renderTestsEvidence(contract, run.gates).trim() + "\n");
-                            // Reviewer panels spend real money in convergence too: reserve before,
-                            // settle the observed cost, and surface it as a budget observation
-                            // (parity with the race path's reviewRuns metering).
-                            const reviewLease = reviewers.length > 0
-                                ? ledger.reserve({
-                                    taskId,
-                                    attemptId,
-                                    intent: "review",
-                                    harnessId: "review-panel",
-                                    cost: attemptCostEvidence("review-panel", attemptId, this.reservationEstimateUsd(input)),
-                                })
-                                : null;
-                            const reviewResult = reviewers.length > 0 && (reviewLease?.granted ?? false)
-                                ? await this.reviewScoped({
-                                    candidateLabel: `Attempt ${attempt}`,
-                                    diff: run.diff,
-                                    evidenceDir: candidateReviewEvidenceDir,
-                                    artifactsDir: join(paths.reviewsDir, `${attemptId}-reviewers`),
-                                    cwd: candidateReviewCwd,
-                                    reviewers,
-                                    envInheritance: envInheritance(this.config(input.repoRoot)),
-                                    signal: input.signal,
-                                    onReviewerEvent: (event) => log.emit(event.type, { ...event }),
-                                })
-                                : {
-                                    findings: [],
-                                    routeProofs: [],
-                                    reviewerRequests: [],
-                                    crossFamilyHealthy: false,
-                                    healthyProviders: [],
-                                    crossFamilyVerified: false,
-                                    distinctProviders: [],
-                                    reviewSpendUsd: 0,
-                                    reviewSpendEstimated: false,
-                                    reviewCashUsd: 0,
-                                    reviewCashKnowledge: "unknown",
-                                    reviewValuationUsd: 0,
-                                    reviewValuationKnowledge: "unknown",
-                                    reviewUnknownUsd: 0,
-                                };
-                            if (reviewLease?.granted) {
-                                ledger.settle(reviewLease.lease?.lease_id ?? "", reviewUsageCostSettlement(reviewResult.reviewCashUsd, reviewResult.reviewValuationUsd, {
-                                    cash: reviewResult.reviewCashKnowledge,
-                                    valuation: reviewResult.reviewValuationKnowledge,
-                                }, [`attempt:${attemptId}`, "review:panel"], reviewResult.reviewUnknownUsd));
-                                if ((reviewResult.reviewSpendUsd ?? 0) > 0) {
-                                    log.emit("budget.observation", {
-                                        harness_id: "review-panel",
-                                        attempt_id: attemptId,
-                                        kind: "spend",
-                                        usd: reviewResult.reviewSpendUsd,
-                                        cash_usd: reviewResult.reviewCashUsd,
-                                        valuation_usd: reviewResult.reviewValuationUsd,
-                                        unknown_usd: reviewResult.reviewUnknownUsd,
-                                        estimated: reviewResult.reviewSpendEstimated === true,
-                                    });
-                                }
-                            }
-                            else if (reviewLease && !reviewLease.granted) {
-                                log.emit("budget.lease.created", {
-                                    granted: false,
-                                    reason: reviewLease.reason,
-                                    attempt_id: attemptId,
-                                    harness_id: "review-panel",
-                                });
-                            }
-                            actualReviewVerified =
-                                reviewVerified &&
-                                    reviewResult.crossFamilyHealthy &&
-                                    reviewResult.crossFamilyVerified;
-                            const revalidated = await revalidateFindings(reviewResult.findings, {
-                                candidateRoot: candidateReviewCwd,
-                                evidenceDir: candidateReviewEvidenceDir,
-                            });
-                            // Typed policy gate (risk + protected paths) merges with reviewer findings.
-                            const policy = policyFindings(run, actualReviewVerified, contract.constraints.protected_paths, contract.constraints.auto_protected_paths, contract.constraints.protected_path_approvals, contract.constraints.deny_paths);
-                            const allFindings = [...policy.findings, ...revalidated];
-                            lastFindings = allFindings;
-                            const inconclusive = allFindings.some((f) => f.severity === "INSUFFICIENT_EVIDENCE" || f.status === "insufficient_evidence");
-                            const finalReviewClean = reviewResult.crossFamilyHealthy &&
-                                reviewResult.crossFamilyVerified &&
-                                !inconclusive &&
-                                !allFindings.some((f) => isBlocking(f));
-                            store.writeYaml(join(paths.reviewsDir, `${attemptId}.yaml`), {
-                                attempt_id: attemptId,
-                                review_verified: actualReviewVerified,
-                                final_review_clean: finalReviewClean,
-                                cross_family_healthy: reviewResult.crossFamilyHealthy,
-                                cross_family_verified: reviewResult.crossFamilyVerified,
-                                healthy_providers: reviewResult.healthyProviders,
-                                verified_providers: reviewResult.distinctProviders,
-                                reviewer_requests: reviewResult.reviewerRequests,
-                                risk: policy.risk,
-                                findings: allFindings,
-                                route_proofs: reviewResult.routeProofs,
-                            });
-                            lastFinalReviewClean = finalReviewClean;
-                            // Measure diff stability instead of asserting it: the tree must not have
-                            // changed between the candidate diff capture and the end of review.
-                            const postReviewDiff = await wsm.diff(envelope);
-                            const diffStableAfterReview = sha256(postReviewDiff) === sha256(run.diff);
-                            lastDiffStable = diffStableAfterReview;
-                            const evaluated = evaluateConvergence({
-                                predicate: contract.convergence,
-                                gates: run.errored
-                                    ? [
-                                        ...run.gates,
-                                        {
-                                            id: "harness",
-                                            command: "harness",
-                                            exit_code: 1,
-                                            status: "failed",
-                                            duration_ms: 0,
-                                            required: true,
-                                            stdout_tail: null,
-                                            stderr_tail: null,
-                                            output_truncated: false,
-                                        },
-                                    ]
-                                    : run.gates,
-                                findings: allFindings,
-                                finalReviewClean,
-                                diffStableAfterReview,
-                            });
-                            log.emit("finding.revalidated", {
-                                attempt_id: attemptId,
-                                converged: evaluated.converged,
-                                reasons: evaluated.reasons,
-                                diff_stable_after_review: diffStableAfterReview,
-                            });
-                            return evaluated;
-                        }
-                        finally {
-                            this.recordReviewEvidenceCleanup(store, join(paths.reviewsDir, `${attemptId}-evidence-cleanup.yaml`), attemptId, candidateReviewEvidenceDir, candidateReviewCwd);
-                        }
+                        const [evidence] = await this.reviewRuns([run], reviewers, reviewVerified, reviewDir, input.repoRoot, contract, store, paths, log, ledger, taskId, input.signal, this.reservationEstimateUsd(input), true);
+                        if (!evidence)
+                            throw new Error("Convergence review produced no evidence");
+                        lastFindings = evidence.findings;
+                        lastFinalReviewClean = evidence.finalReviewClean;
+                        actualReviewVerified = evidence.reviewVerified ?? false;
+                        lastDiffStable = run.files
+                            ? await directoryCandidateStable(wsm, envelope, run.files)
+                            : sha256(await wsm.diff(envelope)) === sha256(run.diff);
+                        const evaluated = evaluateConvergence({
+                            predicate: contract.convergence,
+                            gates: evidence.gates,
+                            findings: evidence.findings,
+                            finalReviewClean: evidence.finalReviewClean,
+                            diffStableAfterReview: lastDiffStable,
+                        });
+                        log.emit("finding.revalidated", {
+                            attempt_id: attemptId,
+                            converged: evaluated.converged,
+                            reasons: evaluated.reasons,
+                            diff_stable_after_review: lastDiffStable,
+                        });
+                        return evaluated;
                     })();
                 }
                 catch (err) {
+                    if (run.files)
+                        await publishDirectoryCandidate({
+                            files: run.files,
+                            store,
+                            paths,
+                            taskId,
+                            attemptId,
+                            harnessId: run.harnessId,
+                            facts: makeOutcomeFacts("failed", { noChanges: run.files.noChanges }),
+                            log,
+                        });
                     return failTerminally(log, store, paths, runId, taskId, mode, "review", err, ledger.spend());
                 }
                 if (conv.converged) {
@@ -3543,13 +3442,17 @@ export class Orchestrator {
                     break;
                 }
                 const requiredGateFailing = run.gates.length > 0 && !gatesPassed(run.gates);
-                const diffHash = sha256(run.diff);
-                if (requiredGateFailing && diffHash === lastFailingGateDiffHash) {
+                const diffHash = run.files
+                    ? run.files.manifestSha256
+                    : input.workspaceKind === "directory"
+                        ? null
+                        : sha256(run.diff);
+                if (requiredGateFailing && diffHash !== null && diffHash === lastFailingGateDiffHash) {
                     sameFailingGateDiffs += 1;
                 }
                 else {
                     sameFailingGateDiffs = requiredGateFailing ? 1 : 0;
-                    lastFailingGateDiffHash = requiredGateFailing ? diffHash : "";
+                    lastFailingGateDiffHash = requiredGateFailing ? (diffHash ?? "") : "";
                 }
                 if (sameFailingGateDiffs >= 2) {
                     stuckNoProgress = true;
@@ -3565,7 +3468,10 @@ export class Orchestrator {
                     });
                     break;
                 }
-                const sig = failureSignature(conv.reasons);
+                const sig = failureSignature([
+                    ...conv.reasons,
+                    ...(run.files ? [`files_manifest:${run.files.manifestSha256}`] : []),
+                ]);
                 readiness.recordRound(sig, conv.reasons.join("; "));
                 if (sig !== lastSig) {
                     triedSinceProgress = new Set();
@@ -3648,6 +3554,12 @@ export class Orchestrator {
                 facts = decision.facts;
             }
         }
+        if (lastRun?.files)
+            facts = {
+                ...facts,
+                noChanges: lastRun.files.noChanges,
+                reason: facts.reason === "no_changes" && lastRun.files.noChanges !== true ? null : facts.reason,
+            };
         // A budget terminal turns a succeeded lifecycle into a failed one (D8).
         const convBudgetTerminal = ledger.terminal();
         if (facts.lifecycle === "succeeded" && convBudgetTerminal) {
@@ -3671,11 +3583,13 @@ export class Orchestrator {
         let convFinalVerify = null;
         if (input.inPlace !== true &&
             lastRun &&
-            lastRun.diff.trim().length > 0 &&
+            (lastRun.files ? lastRun.files.noChanges !== true : lastRun.diff.trim().length > 0) &&
             facts.lifecycle === "succeeded" &&
             facts.review !== "blocked" &&
             !input.signal?.aborted) {
-            convFinalVerify = await finalVerifyPatch(execRoot, lastRun, gateSpecsFromContract(contract), log);
+            convFinalVerify = lastRun.files
+                ? await finalVerifyFiles(lastRun.files, undefined, gateSpecsFromContract(contract), log)
+                : await finalVerifyPatch(execRoot, lastRun, gateSpecsFromContract(contract), log);
             if (finalVerifyBlocks(convFinalVerify))
                 facts = { ...facts, checks: "failed", reason: "checks_failed" };
         }
@@ -3694,51 +3608,68 @@ export class Orchestrator {
         }
         this.writeRunTelemetry(store, paths, contract, runId, taskId, mode, attemptTelemetries, lastRun?.attemptId ?? null);
         // Deliver the converged/last work to final/ so `apply` and `inspect` can
-        // use it. D-16 r8: an INTERRUPTED envelope run delivers no applyable
-        // work_product (its partial patch.diff stays diagnostic via attempts/);
-        // in-place keeps the product so the honest Revert offer survives.
-        if (lastRun && (!interrupted || input.inPlace === true)) {
-            secretDiff.assertNoSecretLikeTokens("final patch diff", lastRun.diff);
-            const patchSha256 = sha256(lastRun.diff);
-            store.writeText(join(paths.finalDir, "patch.diff"), lastRun.diff);
-            // Honest apply-state (parity with runRace single-candidate in-place): a
-            // convergence run with inPlace mutated the live tree directly across its
-            // attempts, so it is "applied" even when review blocked (Revert offered).
-            const convHasDiff = lastRun.diff.trim().length > 0;
+        // use it. Directory results retain complete partial files with their actual
+        // lifecycle; direct effects are already applied and promise no rollback.
+        if (lastRun && (lastRun.files || !interrupted || input.inPlace === true)) {
             const convAdoptable = facts.lifecycle === "succeeded" &&
                 reviewAllowsApply(facts) &&
                 facts.checks !== "failed" &&
                 !workStateVetoes(facts);
-            const convAdopted = input.inPlace === true && convHasDiff ? true : null;
-            const convApplyState = convAdopted === true
-                ? convAdoptable
-                    ? "applied"
-                    : "applied_review_blocked"
-                : "not_applied";
-            const revertAnchorId = convAdopted === true
-                ? await createRevertAnchorOrNull(execRoot, preTurnSha, lastPostTurnSha)
-                : null;
-            store.writeYaml(join(paths.finalDir, "work_product.yaml"), {
-                id: newId("wp"),
-                kind: "patch",
-                source_task_id: taskId,
-                producer_attempt_id: lastRun.attemptId,
-                meta: {
-                    harness_id: lastRun.harnessId,
-                    result_kind: "patch",
-                    mode,
-                    attempts: attempt,
-                    lifecycle: facts.lifecycle,
-                    outcome_facts: facts,
-                    review_verified: actualReviewVerified,
-                    patch_sha256: patchSha256,
-                    adopted: convAdopted,
-                    apply_state: convApplyState,
-                    pre_turn_sha: convAdopted === true ? preTurnSha : null,
-                    post_turn_sha: convAdopted === true ? lastPostTurnSha : null,
-                    revert_anchor_id: revertAnchorId,
-                },
-            });
+            if (lastRun.files) {
+                await publishDirectoryCandidate({
+                    files: lastRun.files,
+                    store,
+                    paths,
+                    taskId,
+                    attemptId: lastRun.attemptId,
+                    harnessId: lastRun.harnessId,
+                    facts,
+                    log,
+                });
+                if (lastRun.answerText) {
+                    store.writeText(join(paths.finalDir, "answer.md"), lastRun.answerText);
+                    log.emit("output.ready", { kind: "answer", path: "final/answer.md" });
+                }
+            }
+            else {
+                secretDiff.assertNoSecretLikeTokens("final patch diff", lastRun.diff);
+                const patchSha256 = sha256(lastRun.diff);
+                store.writeText(join(paths.finalDir, "patch.diff"), lastRun.diff);
+                // Honest apply-state (parity with runRace single-candidate in-place): a
+                // convergence run with inPlace mutated the live tree directly across its
+                // attempts, so it is "applied" even when review blocked (Revert offered).
+                const convHasDiff = lastRun.diff.trim().length > 0;
+                const convAdopted = input.inPlace === true && convHasDiff ? true : null;
+                const convApplyState = convAdopted === true
+                    ? convAdoptable
+                        ? "applied"
+                        : "applied_review_blocked"
+                    : "not_applied";
+                const revertAnchorId = convAdopted === true
+                    ? await createRevertAnchorOrNull(execRoot, preTurnSha, lastPostTurnSha)
+                    : null;
+                store.writeYaml(join(paths.finalDir, "work_product.yaml"), {
+                    id: newId("wp"),
+                    kind: "patch",
+                    source_task_id: taskId,
+                    producer_attempt_id: lastRun.attemptId,
+                    meta: {
+                        harness_id: lastRun.harnessId,
+                        result_kind: "patch",
+                        mode,
+                        attempts: attempt,
+                        lifecycle: facts.lifecycle,
+                        outcome_facts: facts,
+                        review_verified: actualReviewVerified,
+                        patch_sha256: patchSha256,
+                        adopted: convAdopted,
+                        apply_state: convApplyState,
+                        pre_turn_sha: convAdopted === true ? preTurnSha : null,
+                        post_turn_sha: convAdopted === true ? lastPostTurnSha : null,
+                        revert_anchor_id: revertAnchorId,
+                    },
+                });
+            }
             store.writeText(join(paths.finalDir, "summary.md"), `# Run ${runId} (${mode})\n\n- Lifecycle: ${facts.lifecycle}${facts.reason ? ` (${facts.reason})` : ""}\n- Attempts: ${attempt}\n- Winner: ${lastRun.attemptId}\n- Review verified (cross-family): ${actualReviewVerified}\n- Apply recommendation: ${decision?.apply_recommendation ?? "inspect"}${stuckNoProgressReason ? `\n- No-progress reason: ${stuckNoProgressReason}` : ""}\n`);
             // Lifecycle invariant (all modes): output.ready precedes the terminal
             // event so a client that applied the terminal event has the output.
@@ -3757,6 +3688,9 @@ export class Orchestrator {
             const convDeclared = !convNeedsDecision && facts.lifecycle === "failed" && !isBudgetTerminal(facts.reason)
                 ? lastRun?.declaredFailure
                 : undefined;
+            const processingBudgetMapping = processingBudgetDenial
+                ? classifyBudgetFailure({ denial: processingBudgetDenial, terminal: ledger.terminal() })
+                : null;
             writeFailure(store, paths, {
                 phase: convNeedsDecision ? "review" : "convergence",
                 category: isBudgetTerminal(facts.reason)
@@ -3766,7 +3700,7 @@ export class Orchestrator {
                         : convNeedsDecision
                             ? "policy"
                             : (convDeclared?.category ?? "internal"),
-                code: convDeclared?.code ?? null,
+                code: processingBudgetMapping?.code ?? convDeclared?.code ?? null,
                 resetsAt: convDeclared?.resetsAt ?? null,
                 safeMessage: convNeedsDecision
                     ? `review escalated to a human decision after ${attempt} attempt(s)`
@@ -3799,12 +3733,15 @@ export class Orchestrator {
                                 "Inspect latest patch and review findings",
                                 "Retry with more attempts or a narrower prompt",
                             ],
+                ...(processingBudgetMapping
+                    ? budgetFailureRecord(processingBudgetMapping, { runDir: paths.root })
+                    : {}),
             });
             // D-16 r8/r9: an INTERRUPTED envelope run still gets its diagnostic
             // summary + output.ready (only patch/work_product are withheld) — the
             // ARCHITECTURE event contract guarantees output.ready precedes the
             // terminal in every mode.
-            if (!lastRun || (interrupted && input.inPlace !== true)) {
+            if (!lastRun || (interrupted && input.inPlace !== true && !lastRun.files)) {
                 store.writeText(join(paths.finalDir, "summary.md"), `# Run ${runId} (${mode})\n\n- Lifecycle: ${facts.lifecycle}${facts.reason ? ` (${facts.reason})` : ""}\n- Attempts: ${attempt}\n`);
                 log.emit("output.ready", {
                     kind: "summary",
@@ -3814,7 +3751,7 @@ export class Orchestrator {
             }
         }
         // work_product.emitted only when a product was actually written (r9).
-        if (lastRun && (!interrupted || input.inPlace === true)) {
+        if (lastRun && (lastRun.files || !interrupted || input.inPlace === true)) {
             log.emit("work_product.emitted", { winner: lastRun.attemptId });
         }
         if (!convIsFailureTerminal) {
@@ -4226,16 +4163,19 @@ export class Orchestrator {
         // A selected profile's credential_kind decides billing (round-18 #2).
         const profileRoute = this.credentials.profileAuthRoute(input, harnessId);
         if (profileRoute)
-            return profileRoute === "api_key" ? "metered" : "unknown";
+            return profileRoute === "api_key" ? "metered" : "subscription_entitlement";
         // Deps-closure site: no selected route exists yet, so the RESOLVED
         // preference (per-run > per-harness config > global) speaks — never the
         // raw run input (#121).
         const mode = authModeForPreference(this.authPreferenceForHarness(input.repoRoot, harnessId, input.authPreference));
         if (mode)
-            return mode === "api_key" ? "metered" : "unknown";
-        return loadHarnessMetrics(globalConfigDir())[harnessId]?.last_auth_mode === "api_key"
+            return mode === "api_key" ? "metered" : "subscription_entitlement";
+        const lastAuth = loadHarnessMetrics(globalConfigDir())[harnessId]?.last_auth_mode;
+        return lastAuth === "api_key"
             ? "metered"
-            : "unknown";
+            : lastAuth === "local_session"
+                ? "subscription_entitlement"
+                : "unknown";
     }
     /**
      * #27 / D-6: build the engine-side deps closure for the deep-scan bounded
@@ -4247,11 +4187,13 @@ export class Orchestrator {
     deepScanReducerDeps(input, contract, log) {
         return {
             newReadOnlyHome: () => resolveReadOnlyRouteContext(this.execRootOf(input)),
-            costEvidence: (harnessId, attemptId) => 
+            costEvidence: (harnessId, attemptId, routed) => 
             // The reducer admits under a finite estimate floor (mirror of the n>1
             // scout reserve) so a subscription route is not refused for lacking a
             // cash quote.
-            attemptCostEvidence(harnessId, attemptId, this.estimateUsdFloor(input.repoRoot), this.routeBillingKnowledge(input, harnessId)),
+            attemptCostEvidence(harnessId, attemptId, this.estimateUsdFloor(input.repoRoot), this.routeBillingKnowledge(input, harnessId), processingCostEvidence(routed?.processing, this.routeBillingKnowledge(input, harnessId), [
+                `harness:${harnessId}`,
+            ])),
             buildSpec: async (routed, homeEnv, prompt, attemptId) => {
                 const knobs = this.routeSpecKnobs(routed, contract, undefined, input.effort);
                 const effectiveWeb = this.discloseWebUpgrade(log, routed, knobs.webPolicy, attemptId);
@@ -4434,7 +4376,7 @@ export class Orchestrator {
                 // (mirror of the candidate loop): the first top-level scout reserves
                 // without a floor; later scouts and every real Delegate child pass the
                 // repo floor because they overlap an existing family unit.
-                cost: attemptCostEvidence(adapter.id, attemptId, this.reservationEstimateUsd(input, opts.deepScan && idx > 0), this.routeBillingKnowledge(input, adapter.id)),
+                cost: attemptCostEvidence(adapter.id, attemptId, this.reservationEstimateUsd(input, opts.deepScan && idx > 0), this.routeBillingKnowledge(input, adapter.id), processingCostEvidence(routed.processing, this.routeBillingKnowledge(input, routed.adapter.id), [`harness:${adapter.id}`])),
             });
             if (!lease.granted) {
                 log.emit("budget.lease.created", {
@@ -4580,6 +4522,10 @@ export class Orchestrator {
             const { knobs, spec: preparedSpec, reportAbort, reportInteraction, readonlyWorkMode, attemptEventsPath, telemetry, } = preparation.value;
             let { answer } = preparation.value;
             let spec = preparedSpec;
+            bindProcessingAdmission(spec, ledger, lease.lease.lease_id, adapter.id, attemptId, (denial) => {
+                budgetStopped = true;
+                budgetDenial ??= denial;
+            });
             const retryPolicy = transientRetryPolicy(this.config(input.repoRoot));
             let activeSessionId = spec.session_id;
             const onAbort = () => {
@@ -4594,6 +4540,8 @@ export class Orchestrator {
             let cost = 0;
             let costEstimated = false;
             let harnessError = null;
+            let streamBudgetDenied = false;
+            let processingRefusal = null;
             let poolExhausted = null; // A5: typed pool-exhausted refusal
             try {
                 const triedProfiles = new Set(); // W5.4 failover: each profile at most once
@@ -4659,6 +4607,15 @@ export class Orchestrator {
                             const spend = observeReadonlySpend(safeEv, (t, p) => log.emit(t, p), adapter.id, attemptId);
                             cost += spend.costUsd;
                             costEstimated ||= spend.estimated;
+                            const streamDenial = updateProcessingStreamHold(runSpec, telemetry.usageCost, ledger, lease.lease.lease_id, adapter.id, attemptId);
+                            if (streamDenial) {
+                                budgetStopped = streamBudgetDenied = true;
+                                budgetDenial ??= streamDenial;
+                                harnessError = streamDenial.reason;
+                                reportAbort.abort();
+                                void adapter.cancel?.(activeSessionId)?.catch(() => { });
+                                break;
+                            }
                             // A TYPED final message wins verbatim over joined narration.
                             answer.observe(safeEv);
                             if (safeEv.type === "error")
@@ -4669,9 +4626,15 @@ export class Orchestrator {
                     }
                     catch (err) {
                         harnessError = safeErrorMessage(err);
+                        if (err instanceof ProcessingBudgetAdmissionError) {
+                            processingRefusal = err;
+                            break;
+                        }
                         // #31: classify the throw (watchdog timeout vs process crash) as typed.
                         telemetry.transientFailures.push(classifyAdapterThrow({ errorName: err instanceof Error ? err.name : null }));
                     }
+                    if (streamBudgetDenied)
+                        break;
                     const newTransients = telemetry.transientFailures.slice(transientStart);
                     const transient = newTransients.at(-1) ?? null;
                     const sawRetryable = newTransients.some((f) => f.retryable);
@@ -4748,7 +4711,7 @@ export class Orchestrator {
                     preStreamFailureSource: "readonly-pre-stream",
                 });
             }
-            if (harnessError && !poolExhausted) {
+            if (harnessError && !poolExhausted && !processingRefusal) {
                 emitTransientExhausted((t, p) => log.emit(t, p), adapter.id, attemptId, telemetry, retryPolicy.maxRetries);
             }
             attemptTelemetries.push({ attemptId, harnessId: adapter.id, telemetry });
@@ -4809,7 +4772,9 @@ export class Orchestrator {
                     report,
                     error: harnessError,
                     telemetry,
-                    ...(poolExhausted ? { declaredFailure: declaredFailure(poolExhausted) } : {}),
+                    ...(poolExhausted || processingRefusal
+                        ? { declaredFailure: declaredFailure(processingRefusal ?? poolExhausted) }
+                        : {}),
                 });
                 if (opts.deepScan) {
                     store.writeText(join(paths.findingsDir, `${attemptId}-error.md`), `# Explorer ${attemptId} failed\n\n${harnessError}\n`);
@@ -5062,7 +5027,7 @@ export class Orchestrator {
             });
             const terminalFacts = makeOutcomeFacts(roTerminal.lifecycle, {
                 ...(roTerminal.review ? { review: roTerminal.review } : {}),
-                reason: roTerminal.reason,
+                reason: budgetMapping?.reason ?? roTerminal.reason,
             });
             const terminalHarnessId = budgetMapping?.harnessId ?? last?.harnessId;
             store.writeText(join(paths.finalDir, "summary.md"), `# Run ${runId} (${opts.mode})\n\n- Harness: ${terminalHarnessId ?? "none"}\n- Lifecycle: ${terminalFacts.lifecycle}${terminalFacts.reason ? ` (${terminalFacts.reason})` : ""}\n\n${singleError}\n`);
@@ -5254,19 +5219,12 @@ export class Orchestrator {
             });
             store.writeText(join(paths.finalDir, "omissions.md"), `# Omissions\n\n${unsuccessful.map((a) => `- ${a.attemptId} / ${a.harnessId} (${a.status}): ${a.error}`).join("\n") || "- None recorded by the runner. Synthesis claims still require evidence checks."}\n`);
         }
-        // A read-only report (ask / deep-scan) has no live-tree work; the only
-        // non-clean terminal is an aggregate paid-budget stop.
         let terminalFacts = makeOutcomeFacts("succeeded");
         const reportBudgetTerminal = ledger.terminal();
         if (reportBudgetTerminal) {
             terminalFacts = makeOutcomeFacts("failed", { reason: reportBudgetTerminal });
         }
         else if (!opts.deepScan) {
-            // D-16: fold the winning read-only attempt's work_state into the terminal.
-            // A terminal context exhaustion with no completed report ⇒ interrupted;
-            // a needs_input/incomplete report ⇒ a succeeded run whose work_state
-            // vetoes applyability and a clean exit (INV-116). answer.md was already
-            // persisted from the unwrapped OUTPUT.
             const winnerTelemetry = succeeded[0]?.telemetry;
             const winnerWorkState = winnerTelemetry?.outcome?.workState;
             if (winnerTelemetry?.contextExhausted && winnerWorkState?.state !== "completed") {
@@ -5327,9 +5285,6 @@ export class Orchestrator {
             });
         }
         else if (workVetoed) {
-            // D-16: a succeeded lifecycle whose work_state vetoes is a needs-me
-            // terminal — run.blocked (not run.completed); the outcome-aware exit
-            // projection returns non-zero from the same facts.
             log.emit("run.blocked", {
                 lifecycle: terminalFacts.lifecycle,
                 facts: terminalFacts,