@dsh-enhanced/plugin-control-plane 0.1.66 → 0.1.68

package/lib/service.js

@@ -2,17 +2,20 @@ import { cleanedLinuxSourceBuildFailure, cleanedLinuxSourcePreflight, consumeCle
 import { AdoptionCoordinatorRuntime, validateAdoptionCoordinatorConfig } from './adoption-coordinator.js';
 import { CreationCapabilityJournal, creationCapabilityAuthorityDigest, creationCapabilityPublicKey, validateCreationCapabilityConfig } from './creation-capability-journal.js';
 import { CreationCapabilityRuntime } from './creation-capability-runtime.js';
-import { inspectCreationCapabilityAvailabilityAttribution, inspectCreationCapabilityOrdinaryUseReport, inspectCreationCapabilityOrdinaryUseTrend, inspectCreationCapabilityTaskAssociations } from './creation-capability-feedback.js';
+import { RevisionCapabilityJournal, revisionCapabilityAuthorityDigest, revisionCapabilityPublicKey, validateRevisionCapabilityConfig } from './revision-capability-journal.js';
+import { RevisionCapabilityRuntime } from './revision-capability-runtime.js';
+import { inspectCreationCapabilityAvailabilityAttribution, inspectCreationCapabilityBenefitWindow, inspectCreationCapabilityOrdinaryUseReport, inspectCreationCapabilityOrdinaryUseTrend, inspectCreationCapabilityTaskAssociations } from './creation-capability-feedback.js';
+import { autoRollbackInferiorRevision, evaluateRevisionBenefitEvidence, inspectRevisionBenefitTerminal, inspectRevisionCapabilityBenefitWindow, mergeRevisionBenefitWindows, revisionBenefitObservationDeadline, revisionBenefitPairedWindows } from './revision-capability-feedback.js';
 import { captureCreationCapabilitySource } from './creation-capability-source.js';
 import { lstat, readFile, realpath } from 'node:fs/promises';
 import { realpathSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 import { createHash, createPublicKey, randomBytes } from 'node:crypto';
-import { isSourceOwnerContinuation, anySourceGrowthRunDigest as sourceGrowthRunDigest, validateAnySourceGrowthRunBinding as validateSourceGrowthRunBinding, validateWorkItemGrowthAuthorityPins, validateCreationAcceptanceAuthorityRef, verifyPluginCreationVerificationCertificate, validateRevisionAcceptanceAuthorityRef, verifyPluginRevisionVerificationCertificate, validateRevisionRegressionAcceptanceAuthorityRef, verifyPluginRevisionRegressionCertificate } from '@dsh-enhanced/assistant-growth-contract';
+import { isSourceOwnerContinuation, isPluginRevisionTaskSource, anySourceGrowthRunDigest as sourceGrowthRunDigest, validateAnySourceGrowthRunBinding as validateSourceGrowthRunBinding, validateWorkItemGrowthAuthorityPins, validateCreationAcceptanceAuthorityRef, verifyPluginCreationVerificationCertificate, validateRevisionAcceptanceAuthorityRef, verifyPluginRevisionVerificationCertificate, validateRevisionRegressionAcceptanceAuthorityRef, verifyPluginRevisionRegressionCertificate, validateWorkItemRevisionAuthorityPins, revisionBenefitContractDigest } from '@dsh-enhanced/assistant-growth-contract';
 import { TaskObservationRuntime, validateTaskObservationConfig } from './task-observation-runtime.js';
 import { LiveQualificationRuntime, validateLiveQualificationConfig } from './live-qualification-runtime.js';
 import { rollbackPluginWatch } from './cli.js';
-import { assertWorkItemRunReference, inertCreationData, WORK_ITEM_ENGINEERING_PROTOCOL } from './work-item-creation-contract.js';
+import { assertWorkItemRunReference, assertWorkItemRevisionRunReference, inertCreationData, WORK_ITEM_ENGINEERING_PROTOCOL } from './work-item-creation-contract.js';
 import { OwnerTaskFailureGaps } from './owner-task-gaps.js';
 import { Context, Service } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
@@ -26,8 +29,8 @@ import { Ed25519SourceReleaseAuthorizationAuthority } from './release.js';
 import { advanceSourceRelease, sourceReleaseAuthorities, validateSourceReleaseExecutionConfig } from './source-release-runner.js';
 import { adoptSourceRelease, validateSourceAdoptionConfig } from './source-adoption-runner.js';
 import { Ed25519ApprovalAuthority } from './approval.js';
-import { ControlPlaneStore, MODIFY_GENERATOR_DIGEST, controlPlaneDigest } from './store.js';
-import { runDockerPreparedChecks, validateSourceBuildConfig } from './source-build.js';
+import { ControlPlaneStore, MODIFY_GENERATOR_DIGEST, controlPlaneDigest, createOwnerInstructionReviewFreeze } from './store.js';
+import { validateSourceBuildConfig } from './source-build.js';
 import { runNativePreparedChecks } from './native-source-build.js';
 import { LINUX_PREPARED_SOURCE_BUILD_SCRIPT, LINUX_SOURCE_PACK_PATH, runLinuxPreparedChecks } from './linux-source-build.js';
 import { LinuxRepositoryRunner, NativeMacVerifierRunner, linuxRuntimeDigest, verifyLinuxRuntime } from '@dsh-enhanced/assistant-isolation';
@@ -38,7 +41,8 @@ import { inspectSourceCreationContext, prepareCreatedPluginWorkspace, validateSo
 import { resolveSourceBaseline } from './source-baseline.js';
 import { inheritedEnvironment, loadTrustConfig, resolveTrustKey } from './trust.js';
 import { registerPluginControlTools } from './tools.js';
-import { SourceGrowthRunUnavailableError, SourceJobRuntime, normalizeSourceJobsConfig } from './source-jobs.js';
+import { SourceGrowthRunUnavailableError, SourceJobRuntime, normalizeSourceJobsConfig, instructionReviewWindowFor } from './source-jobs.js';
+import { drainOwnerInstructionRequests as drainPendingOwnerInstructionRequests, OWNER_INSTRUCTION_CLAIM_TIMEOUT_MS } from './owner-instruction-drain.js';
 import { installRuntimeObserver, validateRuntimeObserverConfig } from './runtime-observer.js';
 import { installReplayEndpoint, validateReplayEndpointConfig } from './replay-endpoint.js';
 import { readPrivateRuntimeObserverKey } from './runtime-observer-protocol.js';
@@ -57,6 +61,7 @@ const schema = Schema.object({
     revisionVerifications: Schema.any(),
     revisionRegressions: Schema.any(),
     creationCapabilities: Schema.any(),
+    revisionCapabilities: Schema.any(),
     sourceApprovals: Schema.any(),
     sourceReleases: Schema.any(),
     sourceReleaseExecution: Schema.any(),
@@ -149,7 +154,8 @@ export function normalizeControlPlaneConfig(input) {
     if (config.sourceBuild !== undefined && 'backend' in config.sourceBuild && config.sourceBuild.backend === 'linux-native') {
         if (!config.sourceJobs)
             throw new Error('plugin-control-plane: Linux repository preparation requires durable sourceJobs');
-        if ((config.creationVerifications || config.creationCapabilities || config.revisionVerifications || config.revisionRegressions)
+        if ((config.creationVerifications || config.creationCapabilities || config.revisionVerifications || config.revisionRegressions
+            || config.revisionCapabilities)
             && (!config.sourceBuild.userNamespace || !config.sourceBuild.systemSnapshot)) {
             throw new Error('plugin-control-plane: Linux independent verification requires the dual-UID repository boundary');
         }
@@ -246,9 +252,15 @@ export function normalizeControlPlaneConfig(input) {
         const verification = config.creationVerifications;
         const jobs = config.sourceJobs;
         const build = config.sourceBuild;
-        const buildBackend = build && 'backend' in build ? build.backend : 'docker';
-        const adoptionBackend = 'backend' in capability.runner ? capability.runner.backend : 'docker';
-        if (!build || buildBackend !== adoptionBackend) {
+        if (!build || !('backend' in build)) {
+            throw new Error('plugin-control-plane: creation build requires a native execution backend');
+        }
+        const buildBackend = build.backend;
+        if (!('backend' in capability.runner)) {
+            throw new Error('plugin-control-plane: creation adoption runner requires a native execution backend');
+        }
+        const adoptionBackend = capability.runner.backend;
+        if (buildBackend !== adoptionBackend) {
             throw new Error('plugin-control-plane: creation build, verification and adoption require matching execution backends');
         }
         if (!verification || !jobs?.creation || capability.namePrefix !== jobs.creation.namePrefix
@@ -262,6 +274,39 @@ export function normalizeControlPlaneConfig(input) {
         if (adoptionKey.equals(verificationKey))
             throw new Error('plugin-control-plane: adoption and verification signing keys must be separate');
     }
+    if (config.revisionCapabilities !== undefined) {
+        validateRevisionCapabilityConfig(config.revisionCapabilities);
+        const capability = config.revisionCapabilities;
+        const creation = config.creationCapabilities;
+        const verification = config.revisionVerifications;
+        const jobs = config.sourceJobs;
+        const build = config.sourceBuild;
+        if (!creation || !verification || !jobs?.revision || !build) {
+            throw new Error('plugin-control-plane: revision adoption requires creation capabilities, revision verification and finite revision source');
+        }
+        const buildBackend = 'backend' in build ? build.backend : 'docker';
+        const runnerBackend = 'backend' in creation.runner ? creation.runner.backend : 'docker';
+        if (buildBackend !== runnerBackend
+            || capability.namePrefix !== creation.namePrefix || capability.namePrefix !== jobs.revision.namePrefix
+            || controlPlaneDigest(capability.owner) !== controlPlaneDigest(creation.owner)
+            || capability.expiresAt > creation.expiresAt) {
+            throw new Error('plugin-control-plane: revision adoption authority does not match its authenticated creation lane');
+        }
+        if (capability.authorityId === creation.authorityId || capability.authorityId === verification.authority.authorityId
+            || capability.rollback.authorityId === capability.authorityId || capability.rollback.authorityId === creation.authorityId
+            || capability.rollback.authorityId === verification.authority.authorityId) {
+            throw new Error('plugin-control-plane: revision adoption, rollback, verification and creation authorities must be separate');
+        }
+        if (capability.keyId === creation.keyId || capability.keyId === verification.authority.keyId) {
+            throw new Error('plugin-control-plane: revision adoption signing key must differ from acceptance and creation keys');
+        }
+        const revisionKey = createPublicKey(revisionCapabilityPublicKey(capability)).export({ format: 'der', type: 'spki' });
+        const creationKey = createPublicKey(creationCapabilityPublicKey(creation)).export({ format: 'der', type: 'spki' });
+        const verificationKey = createPublicKey(verification.publicKey).export({ format: 'der', type: 'spki' });
+        if (revisionKey.equals(creationKey) || revisionKey.equals(verificationKey)) {
+            throw new Error('plugin-control-plane: revision adoption signing key material must be separate');
+        }
+    }
     if (![config.catalogPath, config.statePath, config.trustPath].every(isAbsolute))
         throw new Error('plugin-control-plane: catalogPath, statePath and trustPath must be absolute');
     return config;
@@ -285,12 +330,14 @@ export class PluginControlPlaneService extends Service {
     nativeSourceRunner;
     sourceRuntimes = new Set();
     creationCapabilityRuntime;
+    revisionCapabilityRuntime;
     creationCapabilityRuntimes = new Set();
     creationCapabilityFlights = new Set();
     creationCapabilityReconcileRequested = false;
     growthRunProducer;
     growthProviderDraining = false;
     workItemCreationFrame;
+    workItemRevisionFrame;
     constructor(ctx, input) {
         super(ctx, 'pluginControlPlane');
         this.config = normalizeControlPlaneConfig(input);
@@ -565,6 +612,11 @@ export class PluginControlPlaneService extends Service {
                         if (typeof current('automations')[method] !== 'function')
                             throw new Error(`plugin-control-plane: durable source jobs require assistantAutomations.${method}`);
                     }
+                    const instructionDrainEnabled = this.config.sourceJobs?.revision !== undefined
+                        && this.config.sourceJobs.allowedModes?.includes('revise-created') !== false;
+                    if (instructionDrainEnabled && typeof current('automations').onSchedulerWake !== 'function') {
+                        throw new Error('plugin-control-plane: owner instruction drain requires assistantAutomations.onSchedulerWake');
+                    }
                     if (typeof current('delivery').validateOwnerRoute !== 'function')
                         throw new Error('plugin-control-plane: durable source jobs require Delivery v2 owner validation');
                     let capabilities;
@@ -662,30 +714,133 @@ export class PluginControlPlaneService extends Service {
                             throw error;
                         }
                     }
+                    let revisionCapabilities;
+                    if (this.config.revisionCapabilities) {
+                        const config = this.config.revisionCapabilities;
+                        const delivery = current('delivery');
+                        if (typeof delivery.validateOwnerAgentForRoute !== 'function') {
+                            throw new Error('plugin-control-plane: revision adoption requires authenticated live owner Agent admission');
+                        }
+                        const journal = new RevisionCapabilityJournal({ path: join(this.config.statePath, 'revision-adoptions.sqlite'), config });
+                        try {
+                            revisionCapabilities = new RevisionCapabilityRuntime({ ctx: jobsCtx, config, journal,
+                                regressionRequired: this.config.revisionRegressions !== undefined,
+                                ports: {
+                                    inspect: planId => {
+                                        const certificate = this.inspectVerifiedRevision(planId);
+                                        if (!certificate)
+                                            throw new Error('revision adoption requires a fresh independent certificate');
+                                        const prepared = this.inspectPreparedRevision(planId);
+                                        const source = this.store.readRevisionSource(planId);
+                                        if (!source)
+                                            throw new Error('revision adoption source archive unavailable');
+                                        const regression = this.config.revisionRegressions === undefined
+                                            ? undefined : this.inspectVerifiedRevisionRegression(planId);
+                                        return { certificate, artifact: Buffer.from(prepared.artifact), source,
+                                            plan: { id: prepared.plan.id, digest: prepared.plan.digest, name: prepared.plan.name },
+                                            ...(regression === undefined ? {} : { regression }), owner: config.owner };
+                                    },
+                                    recheck: async (planId, signal) => {
+                                        await this.inspectPreparedRevisionReviewContext(planId, signal);
+                                        if (this.config.sourceBuild && 'backend' in this.config.sourceBuild
+                                            && this.config.sourceBuild.backend === 'linux-native') {
+                                            await this.inspectPreparedRevisionLinuxBuild(planId, signal);
+                                        }
+                                        if (!this.inspectVerifiedRevision(planId))
+                                            throw new Error('revision adoption independent certificate changed');
+                                    },
+                                    parent: planId => {
+                                        const adoption = capabilities?.inspectAdoptionVersion(planId);
+                                        if (!adoption)
+                                            throw new Error('revision adoption parent adoption unavailable');
+                                        return adoption;
+                                    },
+                                    recheckParent: async (planId, signal) => {
+                                        if (!capabilities)
+                                            throw new Error('revision adoption parent adoption unavailable');
+                                        await capabilities.recheckAdoptionVersion(planId, signal);
+                                    },
+                                    inFlightParentCalls: planId => capabilities?.inspectInFlightCalls(planId) ?? 0,
+                                    suspendParent: async (planId) => {
+                                        if (!capabilities)
+                                            throw new Error('revision adoption parent adoption unavailable');
+                                        await capabilities.suspendEntry(planId);
+                                    },
+                                    resumeParent: async (planId) => {
+                                        if (!capabilities)
+                                            throw new Error('revision adoption parent adoption unavailable');
+                                        await capabilities.resumeEntry(planId);
+                                    },
+                                    runVersion: input => {
+                                        if (!capabilities)
+                                            throw new Error('revision adoption runner unavailable');
+                                        return capabilities.runRevisionArtifact(input);
+                                    },
+                                    recheckExecution: async (certificate, signal) => {
+                                        if (!capabilities)
+                                            throw new Error('revision adoption runner unavailable');
+                                        await capabilities.verifyArtifactExecution(certificate, signal);
+                                    },
+                                    matchesExecution: certificate => capabilities?.matchesArtifactExecution(certificate) === true,
+                                    inspectCall: (_record, execution, toolAlias, argumentsJson) => {
+                                        if (!execution.agent || typeof delivery.inspectOwnerForegroundToolCall !== 'function')
+                                            return undefined;
+                                        return delivery.inspectOwnerForegroundToolCall({ agent: execution.agent,
+                                            authorityId: config.owner.authorityId, callId: String(execution.callId),
+                                            toolName: toolAlias, argumentsJson });
+                                    },
+                                    assertCaller: execution => {
+                                        if (!execution.agent)
+                                            throw new Error('revision capability requires an authenticated owner Agent');
+                                        const receipt = delivery.validateOwnerAgentForRoute(execution.agent, config.owner.authorityId);
+                                        if (!receipt || Object.keys(config.owner).some(key => receipt[key] !== config.owner[key])) {
+                                            throw new Error('revision capability caller is not the current authorized owner');
+                                        }
+                                    },
+                                } });
+                        }
+                        catch (error) {
+                            journal.close();
+                            throw error;
+                        }
+                    }
+                    const closeRevision = async () => {
+                        const currentRuntime = revisionCapabilities;
+                        revisionCapabilities = undefined;
+                        if (this.revisionCapabilityRuntime === currentRuntime)
+                            this.revisionCapabilityRuntime = undefined;
+                        if (currentRuntime)
+                            await currentRuntime.close();
+                    };
                     const sourceBuild = this.config.sourceBuild;
                     let nativeRunner;
                     try {
-                        nativeRunner = !('backend' in sourceBuild) ? undefined : sourceBuild.backend === 'macos-seatbelt'
-                            ? { backend: 'macos-seatbelt', runner: new NativeMacVerifierRunner({ backend: 'macos-seatbelt',
-                                    stateRoot: sourceBuild.stateRoot, authorityDigest: sourceBuild.authorityDigest,
-                                    runtime: sourceBuild.runtime, source: NATIVE_SOURCE_COMPILER, expiresAt: sourceBuild.expiresAt,
-                                    maxRuns: sourceBuild.maxRuns, maxTotalDurationMs: sourceBuild.maxTotalDurationMs,
-                                    maxDurationMs: sourceBuild.timeoutMs, maxOutputBytes: sourceBuild.outputBytes }) }
-                            : { backend: 'linux-native', runner: new LinuxRepositoryRunner({ backend: 'linux-native',
-                                    stateRoot: sourceBuild.stateRoot, authorityDigest: sourceBuild.authorityDigest,
-                                    runtime: sourceBuild.runtime, cgroupRoots: sourceBuild.cgroupRoots, expiresAt: sourceBuild.expiresAt,
-                                    maxRuns: sourceBuild.maxRuns, maxTotalDurationMs: sourceBuild.maxTotalDurationMs,
-                                    ...(sourceBuild.stateSeal === undefined ? {} : { stateSeal: sourceBuild.stateSeal }),
-                                    ...(sourceBuild.userNamespace === undefined ? {} : { userNamespace: sourceBuild.userNamespace,
-                                        systemSnapshot: sourceBuild.systemSnapshot }),
-                                    limits: { maxDurationMs: sourceBuild.timeoutMs, maxInputBytes: 64 * 1024 ** 2,
-                                        maxOutputBytes: sourceBuild.outputBytes, maxArtifactBytes: 32 * 1024 ** 2, maxFiles: 128,
-                                        memoryMiB: sourceBuild.memoryMiB, cpus: sourceBuild.cpus, pidsLimit: sourceBuild.pidsLimit,
-                                        workspaceMiB: sourceBuild.workspaceMiB, workspaceInodes: sourceBuild.workspaceInodes,
-                                        tmpMiB: sourceBuild.temporaryMiB, tmpInodes: sourceBuild.temporaryInodes, inputMiB: 65, inputInodes: 16 } }) };
+                        nativeRunner = !('backend' in sourceBuild) ? undefined
+                            : sourceBuild.backend === 'macos-seatbelt'
+                                ? { backend: 'macos-seatbelt', runner: new NativeMacVerifierRunner({ backend: 'macos-seatbelt',
+                                        stateRoot: sourceBuild.stateRoot, authorityDigest: sourceBuild.authorityDigest,
+                                        runtime: sourceBuild.runtime, source: NATIVE_SOURCE_COMPILER, expiresAt: sourceBuild.expiresAt,
+                                        maxRuns: sourceBuild.maxRuns, maxTotalDurationMs: sourceBuild.maxTotalDurationMs,
+                                        maxDurationMs: sourceBuild.timeoutMs, maxOutputBytes: sourceBuild.outputBytes }) }
+                                : { backend: 'linux-native', runner: new LinuxRepositoryRunner({ backend: 'linux-native',
+                                        stateRoot: sourceBuild.stateRoot, authorityDigest: sourceBuild.authorityDigest,
+                                        runtime: sourceBuild.runtime, cgroupRoots: sourceBuild.cgroupRoots, expiresAt: sourceBuild.expiresAt,
+                                        maxRuns: sourceBuild.maxRuns, maxTotalDurationMs: sourceBuild.maxTotalDurationMs,
+                                        ...(sourceBuild.stateSeal === undefined ? {} : { stateSeal: sourceBuild.stateSeal }),
+                                        ...(sourceBuild.userNamespace === undefined ? {} : { userNamespace: sourceBuild.userNamespace,
+                                            systemSnapshot: sourceBuild.systemSnapshot }),
+                                        limits: { maxDurationMs: sourceBuild.timeoutMs, maxInputBytes: 64 * 1024 ** 2,
+                                            maxOutputBytes: sourceBuild.outputBytes, maxArtifactBytes: 32 * 1024 ** 2, maxFiles: 128,
+                                            memoryMiB: sourceBuild.memoryMiB, cpus: sourceBuild.cpus, pidsLimit: sourceBuild.pidsLimit,
+                                            workspaceMiB: sourceBuild.workspaceMiB, workspaceInodes: sourceBuild.workspaceInodes,
+                                            tmpMiB: sourceBuild.temporaryMiB, tmpInodes: sourceBuild.temporaryInodes, inputMiB: 65, inputInodes: 16 } }) };
                     }
                     catch (error) {
                         unsubscribeTaskChanges?.();
+                        try {
+                            await closeRevision();
+                        }
+                        catch { /* original error wins */ }
                         if (capabilities) {
                             await capabilities.close();
                             this.creationCapabilityRuntimes.delete(capabilities);
@@ -699,11 +854,13 @@ export class PluginControlPlaneService extends Service {
                         // Restored fresh adoptions read their original Linux build receipt.
                         // Their source runner must exist before capability reconciliation.
                         await capabilities?.start();
+                        await revisionCapabilities?.start();
                         this.abort.signal.throwIfAborted();
                         runtime = new SourceJobRuntime({ config: this.config.sourceJobs, build: sourceBuild, statePath: this.config.statePath, store: this.store,
                             ports: {
                                 automations: {
                                     registerHostExecutor: executor => current('automations').registerHostExecutor(executor),
+                                    onSchedulerWake: listener => current('automations').onSchedulerWake(listener),
                                     reconcileSystem: request => current('automations').reconcileSystem(request),
                                     reconcileSystemExact: request => current('automations').reconcileSystemExact(request),
                                     pauseSystemOwned: request => current('automations').pauseSystemOwned(request),
@@ -712,7 +869,7 @@ export class PluginControlPlaneService extends Service {
                                 },
                                 delivery: { validateOwnerRoute: request => current('delivery').validateOwnerRoute(request) },
                             }, withGapSourceFence: (gapId, owner, callback) => this.taskGaps.withCurrent(gapId, owner, callback),
-                            withWorkItemGrowthRunFence: (run, gapId, owner, generation, callback) => this.withWorkItemGrowthFrame(run, gapId, owner, generation, callback),
+                            withWorkItemGrowthRunFence: (run, gapId, owner, generation, callback) => run.protocol === 'assistant-growth/source-run/v3' ? this.withWorkItemRevisionFrame(run, gapId, owner, generation, callback) : this.withWorkItemGrowthFrame(run, gapId, owner, generation, callback),
                             assertGrowthRun: (run, gapId, owner, generation) => this.assertSourceGrowthRun(run, gapId, owner, generation),
                             ...(this.config.revisionVerifications ? { inspectRevisionParent: this.inspectRevisionParent,
                                 verifyPreparedRevision: (job, signal) => this.verifyPreparedRevision(job, signal, () => jobsCtx.get('assistantVerifier')) } : {}),
@@ -724,6 +881,12 @@ export class PluginControlPlaneService extends Service {
                                         throw new Error('created capability has no prepared source plan');
                                     await capabilities.adopt(job.planId, signal);
                                 } } : {}),
+                            ...(revisionCapabilities ? { revisionAdoptionEligible: (planId) => revisionCapabilities.eligible(planId),
+                                adoptVerifiedRevision: async (job, signal) => {
+                                    if (!job.planId)
+                                        throw new Error('revision adoption has no prepared source plan');
+                                    await revisionCapabilities.adopt(job.planId, signal);
+                                } } : {}),
                             ...(this.config.sourceApprovals ? { approvePrepared: async (job, signal) => {
                                     if (!job.planId)
                                         throw new Error('source job has no prepared plan');
@@ -746,6 +909,14 @@ export class PluginControlPlaneService extends Service {
                                         throw new Error('source job has no released plan');
                                     await this.adoptOwnerSourceRelease({ sourcePlanId: job.planId, signal, expectedTrustDigest: job.intent.trustDigest, assertCurrent });
                                 } } : {}),
+                            ...(this.config.sourceJobs?.revisionBenefit === undefined ? {} : {
+                                reconcileRevisionBenefits: () => this.reconcileRevisionBenefits(),
+                                allowReviewOnlyFirstAdoption: this.config.sourceJobs.allowReviewOnlyFirstAdoption === true,
+                            }),
+                            ...(instructionDrainEnabled ? {
+                                hasOwnerInstructionRequests: () => this.store.hasOwnerInstructionRequestWork(Date.now(), OWNER_INSTRUCTION_CLAIM_TIMEOUT_MS),
+                                drainOwnerInstructionRequests: (signal) => this.drainOwnerInstructionRequests(signal),
+                            } : {}),
                             trust: () => this.boundTrust(), prepare: (job, signal, assertCurrent) => this.prepareSourceJob(job, signal, assertCurrent, nativeRunner?.backend === 'linux-native' ? { runner: nativeRunner.runner, generation: preparationGeneration } : undefined),
                             ...(nativeRunner?.backend === 'linux-native' ? { isPreparationNotStarted: (error, job) => consumeCleanedLinuxSourcePreflight(error, job, preparationGeneration),
                                 deterministicBuildFailure: (error, job) => consumeCleanedLinuxSourceBuildFailure(error, job, preparationGeneration) } : {}),
@@ -757,6 +928,10 @@ export class PluginControlPlaneService extends Service {
                             this.nativeSourceRunner = undefined;
                         await nativeRunner?.runner.close();
                         unsubscribeTaskChanges?.();
+                        try {
+                            await closeRevision();
+                        }
+                        catch { /* original error wins */ }
                         if (capabilities) {
                             await capabilities.close();
                             this.creationCapabilityRuntimes.delete(capabilities);
@@ -765,6 +940,7 @@ export class PluginControlPlaneService extends Service {
                     }
                     this.sourceRuntimes.add(runtime);
                     this.creationCapabilityRuntime = capabilities;
+                    this.revisionCapabilityRuntime = revisionCapabilities;
                     const close = async () => {
                         unsubscribeTaskChanges?.();
                         if (this.sourceRuntime === runtime)
@@ -781,12 +957,20 @@ export class PluginControlPlaneService extends Service {
                         this.sourceRuntimes.delete(runtime);
                         if (this.creationCapabilityRuntime === capabilities)
                             this.creationCapabilityRuntime = undefined;
+                        let revisionCloseError;
+                        try {
+                            await closeRevision();
+                        }
+                        catch (error) {
+                            revisionCloseError = error;
+                        }
                         const results = await Promise.allSettled([nativeRunner?.runner.close(), capabilities?.close()]);
                         if (capabilities)
                             this.creationCapabilityRuntimes.delete(capabilities);
                         const failures = results.filter((result) => result.status === 'rejected');
-                        if (closeError !== undefined || failures.length) {
-                            throw new AggregateError([...(closeError === undefined ? [] : [closeError]), ...failures.map(result => result.reason)], 'source runtime cleanup failed');
+                        if (closeError !== undefined || revisionCloseError !== undefined || failures.length) {
+                            throw new AggregateError([...(closeError === undefined ? [] : [closeError]),
+                                ...(revisionCloseError === undefined ? [] : [revisionCloseError]), ...failures.map(result => result.reason)], 'source runtime cleanup failed');
                         }
                     };
                     try {
@@ -1145,6 +1329,78 @@ export class PluginControlPlaneService extends Service {
         this.abort.signal.throwIfAborted();
         return this.creationCapabilityRuntime?.inspectCallEvidence(planId) ?? [];
     };
+    /** Host-only read-only revision adoption readiness; undefined when not configured or not admitting. */
+    inspectRevisionAdoptionReadiness = () => {
+        this.abort.signal.throwIfAborted();
+        return this.revisionCapabilityRuntime?.inspectReadiness();
+    };
+    /** Host-only current stable entry version; no certificate, artifact bytes or key material escape. */
+    inspectRevisionCapabilityEntry = (entryId) => {
+        this.abort.signal.throwIfAborted();
+        return this.revisionCapabilityRuntime?.inspectEntry(entryId);
+    };
+    /** Host-only bounded call attribution of one stable entry, including the exact version per call. */
+    inspectRevisionCapabilityCalls = (entryId) => {
+        this.abort.signal.throwIfAborted();
+        return this.revisionCapabilityRuntime?.inspectCallEvidence(entryId) ?? [];
+    };
+    /**
+     * Host-only P1-4 negative-observation rollback of one active revision: after
+     * the observation window, a recorded `inferior` benefit outcome rolls the
+     * stable entry back to its exact parent under the separate rollback grant,
+     * and stops this lineage from preparing further spontaneous revisions until
+     * the owner re-authorizes. Anything else leaves the adoption untouched.
+     */
+    autoRollbackRevisionIfInferior = async (planId, options) => {
+        this.abort.signal.throwIfAborted();
+        const runtime = this.revisionCapabilityRuntime;
+        const contract = this.config.sourceJobs?.revisionBenefit;
+        if (runtime === undefined || contract === undefined) {
+            return { rolledBack: false, reason: 'benefit-not-configured' };
+        }
+        const intent = this.store.inspectRevisionBenefitIntent(planId);
+        const pinned = intent?.pinnedContractDigest === undefined ? undefined : { contractDigest: intent.pinnedContractDigest };
+        const liveDigest = revisionBenefitContractDigest(contract);
+        const plan = this.store.getSourcePlan(planId);
+        const result = await autoRollbackInferiorRevision({
+            runtime: { listEntries: () => runtime.listEntries(), inspectEntry: entryId => runtime.inspectEntry(entryId),
+                rollback: input => runtime.rollback(input) },
+            planId, benefitConfigured: true,
+            pinnedContractDigest: pinned !== undefined && pinned.contractDigest === liveDigest ? pinned.contractDigest : undefined,
+            growthRunCreatedAt: plan.sourceRevision?.growthRun?.createdAt,
+            observeWindowMs: options.observeWindowMs,
+            ...(options.observationDeadline === undefined ? {} : { observationDeadline: options.observationDeadline }),
+            outcome: this.store.inspectRevisionBenefitOutcome(planId), now: Date.now(),
+            ...(options.signal === undefined ? {} : {
+                rollback: (target, input) => target.rollback({ ...input, signal: options.signal }),
+            }),
+        });
+        return { rolledBack: result.rolledBack, reason: result.reason,
+            ...(result.record === undefined ? {} : { record: result.record }) };
+    };
+    /**
+     * Host-only authenticated-owner exact parent rollback under its own finite grant. The parent
+     * adoption receipt must still be current and the entry must be on the exact expected revision.
+     */
+    rollbackRevisionCapabilityAdoption = async (input) => {
+        this.abort.signal.throwIfAborted();
+        const runtime = this.revisionCapabilityRuntime;
+        const config = this.config.revisionCapabilities;
+        if (!runtime || !config)
+            throw new Error('revision adoption is not configured');
+        const delivery = this.ctx.get('assistantDelivery', false);
+        if (!delivery || typeof delivery.validateOwnerRoute !== 'function')
+            throw new Error('revision rollback requires Delivery owner validation');
+        const receipt = delivery.validateOwnerRoute({ authorityId: config.owner.authorityId, principalId: config.owner.principalId,
+            workspace: config.owner.workspace, agentPreset: config.owner.agentPreset });
+        if (!receipt || receipt.authorityId !== config.owner.authorityId || receipt.authorityHash !== config.owner.authorityHash
+            || receipt.principalId !== config.owner.principalId || receipt.principalRecordId !== config.owner.principalRecordId
+            || receipt.principalVersion !== config.owner.principalVersion || receipt.workspace !== config.owner.workspace
+            || receipt.agentPreset !== config.owner.agentPreset) {
+            throw new Error('revision rollback caller is not the current authorized owner');
+        }
+        return runtime.rollback({ entryId: input.entryId, expectedCurrentPlanId: input.expectedVersionPlanId });
+    };
     /** Host-only historical source data. It grants no continuation, activation or replacement. */
     inspectCreatedCapabilitySource = (planId) => {
         this.abort.signal.throwIfAborted();
@@ -1261,6 +1517,143 @@ export class PluginControlPlaneService extends Service {
             return undefined;
         }
     };
+    /**
+     * Host-only P1-4 benefit evaluation of one prepared revision. Windows come
+     * from the revision journal's foreground-attributed entry calls (parent
+     * version before adoption, candidate version after it), never from the
+     * creation-capability association ledger. The outcome is recorded only for a
+     * revision job whose grant pins this exact contract digest. Never adoption
+     * evidence by itself and never model-callable.
+     */
+    /**
+     * Host-only terminal read: the benefit ledger outcome/reason plus the latest
+     * exact-parent rollback from the revision journal. Not a model-callable tool.
+     */
+    inspectRevisionBenefitTerminal = (planId) => inspectRevisionBenefitTerminal({ planId, outcome: this.store.inspectRevisionBenefitOutcome(planId),
+        runtime: this.revisionCapabilityRuntime ?? { inspectBenefitEvidence: () => undefined, listEntries: () => [],
+            inspectLatestRollback: () => undefined } });
+    evaluateRevisionBenefit = (planId) => {
+        const contract = this.config.sourceJobs?.revisionBenefit;
+        const plan = this.store.getSourcePlan(planId);
+        const runtime = this.revisionCapabilityRuntime;
+        // The benefit rows are owner-scope evidence; adoption and creation
+        // capabilities are validated to carry the same owner when both are set.
+        const owner = this.config.revisionCapabilities?.owner ?? this.config.creationCapabilities?.owner;
+        if (!contract || !runtime || !owner || plan.mode !== 'prepared-revise'
+            || !plan.sourceRevision?.parent)
+            return undefined;
+        const intent = this.store.inspectRevisionBenefitIntent(planId);
+        if (intent === undefined || intent.pinnedContractDigest === undefined || !intent.growthRunAcceptance)
+            return undefined;
+        const pinned = { contractDigest: intent.pinnedContractDigest };
+        const evaluationPort = this.ctx.get('assistantEvaluation', false);
+        const delivery = this.ctx.get('assistantDelivery', false);
+        if (!evaluationPort || !delivery)
+            return undefined;
+        // Candidate evidence is the revision journal's post-adoption foreground
+        // calls. Parent evidence combines its creation-adoption associations (before
+        // the switch) with revision-journal parent-version calls (after a rollback or
+        // for a chained revision parent); the two sources are disjoint by entry
+        // lifetime. Windows are equal-length and adjacent around the adoption.
+        const candidate = runtime.inspectBenefitEvidence(planId);
+        if (!candidate)
+            return undefined;
+        const parentPlanId = plan.sourceRevision.parent.planId;
+        const parentRevision = runtime.inspectBenefitEvidence(parentPlanId);
+        const parentInput = this.createdCapabilityFeedbackInput(parentPlanId);
+        const parentVersion = parentRevision?.version ?? (() => {
+            const receipt = parentInput?.().record.receipt;
+            return receipt === undefined ? undefined : { adoptedAt: receipt.adoptedAt, expiresAt: receipt.expiresAt };
+        })();
+        if (parentVersion === undefined)
+            return undefined;
+        const now = Date.now();
+        const windows = revisionBenefitPairedWindows({ candidate, parent: parentVersion, now });
+        if (windows === undefined)
+            return undefined;
+        const creationStats = parentInput === undefined ? undefined
+            : inspectCreationCapabilityBenefitWindow({ ...parentInput(), window: windows.parent });
+        const revisionParentStats = parentRevision === undefined ? undefined
+            : inspectRevisionCapabilityBenefitWindow({ sample: parentRevision, windowStart: windows.parent.start,
+                windowEnd: windows.parent.end, owner, evaluation: evaluationPort, delivery, now });
+        const parent = creationStats === undefined ? revisionParentStats
+            : revisionParentStats === undefined ? creationStats : mergeRevisionBenefitWindows(creationStats, revisionParentStats);
+        if (parent === undefined)
+            return undefined;
+        const result = evaluateRevisionBenefitEvidence({ contract, candidate, parent, windows, owner,
+            evaluation: evaluationPort, delivery, now });
+        if (result === undefined)
+            return undefined;
+        if (result.contractDigest === pinned.contractDigest) {
+            this.store.recordRevisionBenefit(planId, { contractDigest: result.contractDigest,
+                status: result.evaluation.verdict.status, reason: result.evaluation.verdict.reason,
+                evaluation: result.evaluation });
+        }
+        return { planId, contractDigest: result.contractDigest,
+            pinned: result.contractDigest === pinned.contractDigest, evaluation: result.evaluation };
+    };
+    /**
+     * Host-only P1-4 reconciliation over every prepared revision plan: after its
+     * observation window, evaluate the benefit outcome and roll back an active
+     * inferior revision. Driven by the SourceJobs continuation cron occurrence;
+     * never a new loop and never model-callable.
+     */
+    reconcileRevisionBenefits = () => {
+        const contract = this.config.sourceJobs?.revisionBenefit;
+        const runtime = this.revisionCapabilityRuntime;
+        if (!contract || !runtime)
+            return;
+        const contractDigest = revisionBenefitContractDigest(contract);
+        for (const plan of this.store.listPreparedSourcePlans()) {
+            if (plan.mode !== 'prepared-revise')
+                continue;
+            try {
+                const intent = this.store.inspectRevisionBenefitIntent(plan.id);
+                if (intent?.pinnedContractDigest === undefined || intent.pinnedContractDigest !== contractDigest)
+                    continue;
+                const evidence = runtime.inspectBenefitEvidence(plan.id);
+                if (evidence === undefined)
+                    continue;
+                const now = Date.now();
+                const parentVersion = this.revisionBenefitParentVersion(plan);
+                const deadline = parentVersion === undefined ? undefined
+                    : revisionBenefitObservationDeadline({ candidate: evidence, parent: parentVersion, now });
+                if (deadline === undefined)
+                    continue;
+                const evaluation = this.evaluateRevisionBenefit(plan.id);
+                const outcome = this.store.inspectRevisionBenefitOutcome(plan.id);
+                if (evaluation !== undefined && evaluation.pinned && evaluation.evaluation.verdict.status === 'inferior') {
+                    void this.autoRollbackRevisionIfInferior(plan.id, { observeWindowMs: 0 })
+                        .catch(() => { });
+                    continue;
+                }
+                // Bounded terminal: once the observation window elapsed without a
+                // non-inferior verdict, record the owner-visible unverified result and
+                // roll the stable entry back instead of leaving a silent mount.
+                if (now < deadline || outcome?.status === 'non-inferior')
+                    continue;
+                if (outcome === undefined || outcome.status === 'insufficient') {
+                    this.store.recordRevisionBenefit(plan.id, { contractDigest, status: 'insufficient',
+                        reason: 'observation-expired-unverified',
+                        evaluation: evaluation?.evaluation ?? { verdict: { status: 'insufficient', reason: 'observation-expired-unverified' } } });
+                }
+                void this.autoRollbackRevisionIfInferior(plan.id, { observeWindowMs: 0, observationDeadline: deadline })
+                    .catch(() => { });
+            }
+            catch { /* a plan without a current job or admission is skipped this tick */ }
+        }
+    };
+    /** Parent adoption version for the same equal-length paired window as evaluation. */
+    revisionBenefitParentVersion(plan) {
+        const parentPlanId = plan.sourceRevision?.parent?.planId;
+        if (parentPlanId === undefined)
+            return undefined;
+        const revision = this.revisionCapabilityRuntime?.inspectBenefitEvidence(parentPlanId);
+        if (revision !== undefined)
+            return revision.version;
+        const receipt = this.createdCapabilityFeedbackInput(parentPlanId)?.().record.receipt;
+        return receipt === undefined ? undefined : { adoptedAt: receipt.adoptedAt, expiresAt: receipt.expiresAt };
+    }
     /**
      * Host-only, owner-invoked: seal the current ordinary-use trend of one adoption into the append-only,
      * content-addressed snapshot ledger. Re-sealing an unchanged trend returns the existing row (`created: false`);
@@ -1323,7 +1716,8 @@ export class PluginControlPlaneService extends Service {
         const growth = plan.creation?.growthRun;
         const artifactSha256 = createHash('sha256').update(record.artifact).digest('hex');
         if (!certificate || controlPlaneDigest(certificate) !== controlPlaneDigest(record.certificate)
-            || !growth || !plan.creation || !job.intent.creation?.growthRun || !plan.sourceCheck || !plan.preparedEvidence
+            || !growth || growth.protocol === 'assistant-growth/source-run/v3'
+            || !plan.creation || !job.intent.creation?.growthRun || !plan.sourceCheck || !plan.preparedEvidence
             || plan.id !== receipt.planId || plan.digest !== receipt.planDigest
             || plan.name !== record.certificate.plan.name || plan.generatorDigest !== record.certificate.plan.generatorDigest
             || plan.sourceCheck.treeDigest !== record.certificate.plan.sourceTreeDigest
@@ -1375,7 +1769,8 @@ export class PluginControlPlaneService extends Service {
             const ownerGrant = this.config.creationCapabilities?.owner;
             const artifactSha256 = createHash('sha256').update(record.artifact).digest('hex');
             if (!certificate || controlPlaneDigest(certificate) !== controlPlaneDigest(record.certificate)
-                || !growth || !creation || !ownerGrant || !job.intent.creation?.growthRun
+                || !growth || growth.protocol === 'assistant-growth/source-run/v3'
+                || !creation || !ownerGrant || !job.intent.creation?.growthRun
                 || !plan.sourceCheck || !plan.preparedEvidence
                 || plan.id !== receipt.planId || plan.digest !== receipt.planDigest
                 || plan.name !== record.certificate.plan.name || plan.generatorDigest !== record.certificate.plan.generatorDigest
@@ -1483,7 +1878,7 @@ export class PluginControlPlaneService extends Service {
             throw new Error('work item growth authority pins changed');
         const source = this.taskGaps.engineeringSnapshot(gapId, owner);
         return producer.withWorkItemRunFence({ runId: run.runId, intentDigest: run.intentDigest, expectedGrowthRunDigest: sourceGrowthRunDigest(run) }, actual => {
-            if (this.growthRunProducer !== producer || sourceGrowthRunDigest(actual) !== sourceGrowthRunDigest(run) || this.workItemCreationFrame)
+            if (this.growthRunProducer !== producer || sourceGrowthRunDigest(actual) !== sourceGrowthRunDigest(run) || actual.protocol !== 'assistant-growth/source-run/v2' || this.workItemCreationFrame)
                 throw new Error('work item producer changed its true binding');
             this.workItemCreationFrame = { gapId, run: actual, source };
             try {
@@ -1494,6 +1889,121 @@ export class PluginControlPlaneService extends Service {
             }
         });
     }
+    inspectWorkItemPreparedRevisionProtocol = () => {
+        return !this.abort.signal.aborted && this.config.sourceJobs?.revision?.workItemFailures === true && this.sourceRuntime?.available() ? 'dsh-prepared-revision/v2' : undefined;
+    };
+    inspectWorkItemRevisionReadiness = (input) => {
+        try {
+            this.abort.signal.throwIfAborted();
+            const owner = inertCreationData(input).owner, config = this.config, source = this.sourceRuntime?.inspectWorkItemRevisionReadiness(owner);
+            if (!source || !config.sourceJobs || !config.sourceBuild || config.sourceJobs.revision?.workItemFailures !== true || !config.revisionVerifications)
+                return undefined;
+            const delivery = this.ctx.get('assistantDelivery', false);
+            const verifier = this.ctx.get('assistantVerifier', false);
+            if (typeof delivery?.withOwnerWorkItemEngineeringContextFence !== 'function' || typeof verifier?.inspectWorkItemRevisionReviewReadiness !== 'function')
+                return undefined;
+            const actual = delivery.validateOwnerRoute({ authorityId: owner.authorityId, principalId: owner.principalId, workspace: owner.workspace, agentPreset: owner.agentPreset });
+            if (!isSourceOwnerContinuation(actual, owner))
+                return undefined;
+            const review = verifier.inspectWorkItemRevisionReviewReadiness();
+            if (!review || review.protocol !== 'assistant-growth/work-item-revision-review-readiness/v1'
+                || review.sourceProtocol !== WORK_ITEM_ENGINEERING_PROTOCOL || review.runProtocol !== 'assistant-growth/source-run/v3'
+                || review.workItemFailures !== true || controlPlaneDigest(review.authority) !== controlPlaneDigest(config.revisionVerifications.authority)
+                || !createPublicKey(review.publicKey).export({ type: 'spki', format: 'der' }).equals(createPublicKey(config.revisionVerifications.publicKey).export({ type: 'spki', format: 'der' })))
+                return undefined;
+            const adoption = this.revisionCapabilityRuntime?.inspectReadiness();
+            const adoptionPins = config.revisionCapabilities && adoption ? {
+                authorityId: adoption.authority.authorityId,
+                authorityDigest: revisionCapabilityAuthorityDigest({ path: join(config.statePath, 'revision-adoptions.sqlite'), config: config.revisionCapabilities }),
+                expiresAt: adoption.authority.expiresAt
+            } : undefined;
+            if (adoption !== undefined && !adoptionPins)
+                return undefined;
+            const pins = { protocol: 'assistant-growth/work-item-revision-authorities/v1',
+                sourceJobs: { authorityId: source.authority.id, authorityDigest: source.authority.digest, expiresAt: source.authority.expiresAt },
+                revisionGrant: { id: source.revision.id, digest: controlPlaneDigest(source.revision), expiresAt: source.revision.expiresAt, workItemFailures: true },
+                revisionAcceptance: structuredClone(review.authority),
+                ...(adoptionPins ? { revisionAdoption: adoptionPins } : {}) };
+            validateWorkItemRevisionAuthorityPins(pins);
+            if (source.authority.digest !== controlPlaneDigest({ config: config.sourceJobs, build: config.sourceBuild }))
+                return undefined;
+            const expiries = [pins.sourceJobs.expiresAt, pins.revisionGrant.expiresAt, pins.revisionAcceptance.expiresAt, ...(pins.revisionAdoption ? [pins.revisionAdoption.expiresAt] : [])];
+            if (expiries.some(expiry => Date.now() >= expiry))
+                return undefined;
+            const remaining = { ...source.remaining, verifications: review.remainingVerifications, ...(adoption ? { adoptions: adoption.remainingAdoptions } : {}) };
+            if (Object.values(remaining).some(count => !Number.isSafeInteger(count) || count < 0))
+                return undefined;
+            return { protocol: 'assistant-growth/work-item-revision-readiness/v1', sourceProtocol: WORK_ITEM_ENGINEERING_PROTOCOL, runProtocol: 'assistant-growth/source-run/v3', workItemFailures: true, pins, remaining, available: Object.values(remaining).every(count => count > 0) && review.available && (adoption ? adoption.available : true) };
+        }
+        catch {
+            return undefined;
+        }
+    };
+    assertWorkItemRevisionPinsLocal(run) {
+        const jobs = this.config.sourceJobs, verification = this.config.revisionVerifications;
+        if (!jobs || !this.config.sourceBuild || jobs.revision?.workItemFailures !== true || !verification
+            || run.authorities.sourceJobs.authorityId !== jobs.authorityId || run.authorities.sourceJobs.authorityDigest !== controlPlaneDigest({ config: jobs, build: this.config.sourceBuild }) || run.authorities.sourceJobs.expiresAt !== jobs.expiresAt
+            || run.authorities.revisionGrant.id !== jobs.revision.id || run.authorities.revisionGrant.digest !== controlPlaneDigest(jobs.revision) || run.authorities.revisionGrant.expiresAt !== jobs.revision.expiresAt
+            || run.authorities.revisionGrant.workItemFailures !== true
+            || controlPlaneDigest(run.revisionAcceptance) !== controlPlaneDigest(verification.authority) || controlPlaneDigest(run.authorities.revisionAcceptance) !== controlPlaneDigest(verification.authority)
+            || (run.authorities.revisionAdoption !== undefined) !== (this.config.revisionCapabilities !== undefined))
+            throw new Error('work item revision authority pins changed');
+        if (run.authorities.revisionAdoption !== undefined && this.config.revisionCapabilities !== undefined) {
+            const adoption = this.config.revisionCapabilities;
+            if (run.authorities.revisionAdoption.authorityId !== adoption.authorityId
+                || run.authorities.revisionAdoption.authorityDigest !== revisionCapabilityAuthorityDigest({ path: join(this.config.statePath, 'revision-adoptions.sqlite'), config: adoption })
+                || run.authorities.revisionAdoption.expiresAt !== adoption.expiresAt)
+                throw new Error('work item revision authority pins changed');
+        }
+        if (run.authorities.revisionRegressionAcceptance !== undefined) {
+            const regression = this.config.revisionRegressions;
+            if (!regression || controlPlaneDigest(run.authorities.revisionRegressionAcceptance) !== controlPlaneDigest(regression.authority))
+                throw new Error('work item revision authority pins changed');
+        }
+        const expiries = [run.authorities.sourceJobs.expiresAt, run.authorities.revisionGrant.expiresAt, run.authorities.revisionAcceptance.expiresAt, ...(run.authorities.revisionAdoption ? [run.authorities.revisionAdoption.expiresAt] : [])];
+        if (expiries.some(expiry => Date.now() >= expiry))
+            throw new Error('work item revision authority pins changed or expired');
+    }
+    assertWorkItemRevisionRunLocal(run, gapId, owner, generation) {
+        const reference = this.store.getOwnerTaskFailureReference(gapId);
+        if (!reference || reference.schemaVersion !== 2 || run.ownerDigest !== controlPlaneDigest(reference.owner) || !isSourceOwnerContinuation(owner, reference.owner))
+            throw new Error('work item revision owner reference changed');
+        assertWorkItemRevisionRunReference(run, reference);
+        this.assertWorkItemRevisionPinsLocal(run);
+        if (Date.now() >= run.expiresAt || generation && Date.now() >= run.generationDeadlineAt)
+            throw new Error('work item revision source run expired');
+        if (run.modelOrigin === 'inherited-owner-task' && this.workItemRevisionFrame && controlPlaneDigest(this.workItemRevisionFrame.source.task.proofIdentity.supplier) !== controlPlaneDigest(run.model))
+            throw new Error('work item revision source supplier changed');
+    }
+    withWorkItemRevisionFrame(run, gapId, owner, generation, callback) {
+        this.abort.signal.throwIfAborted();
+        if (this.workItemRevisionFrame) {
+            if (this.workItemRevisionFrame.gapId !== gapId || sourceGrowthRunDigest(this.workItemRevisionFrame.run) !== sourceGrowthRunDigest(run))
+                throw new Error('work item revision frame reentry');
+            this.assertWorkItemRevisionRunLocal(run, gapId, owner, generation);
+            return callback();
+        }
+        const producer = this.growthRunProducer;
+        if (!producer || producer.protocol !== 'assistant-growth-source-run-producer/v2')
+            throw new SourceGrowthRunUnavailableError('work item revision growth producer unavailable');
+        const readiness = this.inspectWorkItemRevisionReadiness({ owner });
+        if (!readiness)
+            throw new SourceGrowthRunUnavailableError('work item revision growth peers unavailable');
+        if (controlPlaneDigest(readiness.pins) !== controlPlaneDigest(run.authorities))
+            throw new Error('work item revision authority pins changed');
+        const source = this.taskGaps.engineeringSnapshot(gapId, owner);
+        return producer.withWorkItemRunFence({ runId: run.runId, intentDigest: run.intentDigest, expectedGrowthRunDigest: sourceGrowthRunDigest(run) }, actual => {
+            if (this.growthRunProducer !== producer || sourceGrowthRunDigest(actual) !== sourceGrowthRunDigest(run) || actual.protocol !== 'assistant-growth/source-run/v3' || this.workItemRevisionFrame)
+                throw new Error('work item revision producer changed its true binding');
+            this.workItemRevisionFrame = { gapId, run: actual, source };
+            try {
+                return this.store.withOwnerTaskFailureGapAdmission(gapId, () => { this.assertWorkItemRevisionRunLocal(actual, gapId, owner, generation); return callback(); });
+            }
+            finally {
+                this.workItemRevisionFrame = undefined;
+            }
+        });
+    }
     assertSourceGrowthRun(expected, gapId, owner, generation) {
         validateSourceGrowthRunBinding(expected);
         if (expected.protocol === 'assistant-growth/source-run/v2') {
@@ -1503,6 +2013,13 @@ export class PluginControlPlaneService extends Service {
             }
             return this.withWorkItemGrowthFrame(expected, gapId, owner, generation, () => { });
         }
+        if (expected.protocol === 'assistant-growth/source-run/v3') {
+            if (this.workItemRevisionFrame) {
+                this.assertWorkItemRevisionRunLocal(expected, gapId, owner, generation);
+                return;
+            }
+            return this.withWorkItemRevisionFrame(expected, gapId, owner, generation, () => { });
+        }
         const producer = this.growthRunProducer;
         if (!producer)
             throw new SourceGrowthRunUnavailableError('source growth run producer unavailable');
@@ -1525,7 +2042,7 @@ export class PluginControlPlaneService extends Service {
                 || controlPlaneDigest(expected.revisionRegressionAcceptance) !== controlPlaneDigest(this.config.revisionRegressions.authority))) {
             throw new Error('source growth run regression policy changed or was not pinned before authoring');
         }
-        if (expected.creationAcceptance !== undefined
+        if ('creationAcceptance' in expected && expected.creationAcceptance !== undefined
             && (policy === undefined || controlPlaneDigest(policy) !== controlPlaneDigest(expected.creationAcceptance))) {
             throw new Error('source growth run creation acceptance policy changed or was not pinned before authoring');
         }
@@ -1609,6 +2126,7 @@ export class PluginControlPlaneService extends Service {
             const current = this.store.getSourcePlan(input.planId);
             const job = this.store.getPreparedSourceJob(input.planId);
             if (current.digest !== input.planDigest || current.mode !== 'prepared-create' || !current.creation?.growthRun
+                || current.creation.growthRun.protocol === 'assistant-growth/source-run/v3'
                 || !job.intent.creation?.growthRun || !current.sourceCheck || !current.preparedEvidence
                 || current.preparedEvidence.pack.sha256 !== input.artifactSha256
                 || controlPlaneDigest(reference) !== input.referenceDigest
@@ -1701,6 +2219,9 @@ export class PluginControlPlaneService extends Service {
         const combined = AbortSignal.any([this.abort.signal, signal, AbortSignal.timeout(120_000)]);
         combined.throwIfAborted();
         const prepared = this.inspectPreparedRevision(planId), build = this.config.sourceBuild;
+        if (prepared.protocol === 'dsh-prepared-revision/v3') {
+            throw new Error('owner-instruction revisions do not use the task-failure Linux build binding');
+        }
         const native = this.nativeSourceRunner, evidence = prepared.plan.preparedEvidence;
         if (!build || !('backend' in build) || build.backend !== 'linux-native' || !build.userNamespace || !build.systemSnapshot
             || native?.backend !== 'linux-native'
@@ -1788,10 +2309,34 @@ export class PluginControlPlaneService extends Service {
         this.abort.signal.throwIfAborted();
         const plan = this.store.getSourcePlan(planId);
         const reference = this.store.getOwnerTaskFailureReference(plan.gapId);
-        if (!reference || plan.mode !== 'prepared-revise' || plan.status !== 'pending-approval'
+        if (plan.mode !== 'prepared-revise' || plan.status !== 'pending-approval'
             || Date.now() >= plan.expiresAt || !plan.sourceRevision || Date.now() >= plan.sourceRevision.grant.expiresAt) {
             throw new Error('prepared revision package is unavailable for independent verification');
         }
+        if (!reference) {
+            // Owner-instruction revisions have no task reference; the frozen
+            // instruction is their whole provenance.
+            const job = this.store.getPreparedRevisionJob(plan.id);
+            const binding = job.intent.ownerInstruction;
+            const stored = binding === undefined ? undefined : this.store.getOwnerInstruction(binding.instructionId);
+            if (!binding || stored === undefined || controlPlaneDigest(stored) !== binding.digest
+                || stored.expiresAt <= Date.now() || plan.sourceRevision.growthRun !== undefined
+                || stored.planId !== plan.sourceRevision.parent.planId || stored.pluginName !== plan.name
+                || job.intent.revision?.growthRun !== undefined) {
+                throw new Error('prepared instruction revision is unavailable or changed');
+            }
+            this.assertInstructionRevisionOwner(stored.ownerReceipt, plan);
+            return { protocol: 'dsh-prepared-revision/v3', plan: structuredClone(plan), job: structuredClone(job),
+                source: { instruction: binding, owner: job.intent.owner,
+                    reviewModel: this.resolveInstructionReviewModel(stored, job.intent.ownerInstruction) },
+                artifact: this.store.readPreparedSourceArtifact(plan.id) };
+        }
+        if (reference.schemaVersion === 2) {
+            const run = plan.sourceRevision.growthRun;
+            if (run?.protocol !== 'assistant-growth/source-run/v3')
+                throw new Error('work item prepared revision run unavailable');
+            return this.withWorkItemRevisionFrame(run, plan.gapId, reference.owner, false, () => ({ protocol: 'dsh-prepared-revision/v2', plan: structuredClone(this.store.getSourcePlan(plan.id)), job: structuredClone(this.store.getPreparedRevisionJob(plan.id)), reference: structuredClone(reference), source: structuredClone(this.workItemRevisionFrame.source), artifact: this.store.readPreparedSourceArtifact(plan.id) }));
+        }
         return this.taskGaps.withCurrent(plan.gapId, reference.owner, () => {
             this.abort.signal.throwIfAborted();
             const job = this.store.getPreparedRevisionJob(plan.id);
@@ -1808,6 +2353,104 @@ export class PluginControlPlaneService extends Service {
         });
     };
     /** Host-only pre-author policy reference; never grants candidate or model authority. */
+    assertInstructionRevisionOwner(owner, plan) {
+        const config = this.config.sourceJobs;
+        const revision = plan.sourceRevision;
+        const delivery = this.ctx.get('assistantDelivery', false);
+        if (!config?.revision || !revision || !delivery || config.expiresAt <= Date.now()
+            || controlPlaneDigest(config.revision) !== controlPlaneDigest(revision.grant)) {
+            throw new Error('instruction revision owner authority unavailable');
+        }
+        const current = delivery.validateOwnerRoute({ authorityId: config.ownerRouteId, principalId: config.principalId,
+            workspace: config.workspace, agentPreset: config.preset });
+        if (!isSourceOwnerContinuation(current, owner)
+            || controlPlaneDigest(this.inspectRevisionParent(revision.parent.planId).parent) !== controlPlaneDigest(revision.parent)) {
+            throw new Error('instruction revision owner or adopted parent changed');
+        }
+    }
+    /**
+     * Reads the review supplier frozen when the owner instruction was enqueued.
+     * Missing or drifted freeze fails closed: the live owner route and live
+     * verifier configuration are never substituted for the recorded values.
+     */
+    resolveInstructionReviewModel(stored, expected) {
+        const freeze = this.store.getOwnerInstructionReviewFreeze(stored.instructionId);
+        if (freeze === undefined)
+            throw new Error('owner instruction has no frozen review supplier');
+        if (expected !== undefined && (expected.reviewFreezeDigest === undefined || expected.reviewWindow === undefined
+            || expected.reviewFreezeDigest !== freeze.digest
+            || controlPlaneDigest(expected.reviewWindow) !== controlPlaneDigest(freeze.budget.window))) {
+            throw new Error('owner instruction frozen review supplier or budget changed');
+        }
+        const live = this.ownerInstructionReviewBudget();
+        if (controlPlaneDigest(freeze.budget.authority) !== controlPlaneDigest(live.authority)
+            || freeze.budget.verifierKeyDigest !== live.verifierKeyDigest) {
+            throw new Error('frozen review budget no longer matches the configured revision verifier');
+        }
+        if (freeze.budget.authority.expiresAt <= Date.now())
+            throw new Error('frozen review authority expired');
+        return { provider: freeze.supplier.provider, model: freeze.supplier.model,
+            ...(freeze.supplier.reasoningEffort === undefined ? {} : { reasoningEffort: freeze.supplier.reasoningEffort }) };
+    }
+    /**
+     * The independent-review budget identity configured for this Host, evaluated
+     * once per use. The budget itself (maxOutputTokens/maxDurationMs/maxCases/
+     * maxVerifications/runner/policy) is committed by
+     * `RevisionAcceptanceAuthorityRef.authorityDigest`, so freezing this exact
+     * authority ref plus the verifier key digest pins the review budget identity.
+     * Narrowing the budget for one request (a per-plan token cap) is NOT possible
+     * under the current review request protocol, which carries only the plan id
+     * and lets the verifier compile its bounds once; that would require a
+     * verifier request/response protocol v2. Do not emulate it by re-resolving
+     * live configuration during recovery.
+     */
+    ownerInstructionReviewBudget() {
+        const verification = this.config.revisionVerifications;
+        if (verification === undefined)
+            throw new Error('owner-instruction revision requires a configured independent review authority');
+        const build = this.config.sourceBuild;
+        const window = instructionReviewWindowFor({
+            linuxBackend: build !== undefined && 'backend' in build && build.backend === 'linux-native',
+            verification: true,
+            regression: this.config.revisionRegressions !== undefined,
+            adoption: this.config.revisionCapabilities !== undefined,
+        });
+        return Object.freeze({ protocol: 'plugin-control-plane/owner-instruction-review-budget/v1',
+            authority: Object.freeze(structuredClone(verification.authority)),
+            verifierKeyDigest: createHash('sha256').update(verification.publicKey).digest('hex'), window });
+    }
+    /** Live owner-route supplier resolution is allowed once, when the instruction is created. */
+    resolveLiveInstructionReviewSupplier(receipt) {
+        const delivery = this.ctx.get('assistantDelivery', false);
+        const selection = delivery?.inspectOwnerModelSelection?.({ authorityId: receipt.authorityId,
+            principalId: receipt.principalId, workspace: receipt.workspace,
+            agentPreset: receipt.agentPreset });
+        if (selection?.provider === undefined || selection.model === undefined) {
+            throw new Error('owner-instruction revision requires a live owner model selection');
+        }
+        return { provider: selection.provider, model: selection.model,
+            ...(selection.reasoningEffort === undefined ? {} : { reasoningEffort: selection.reasoningEffort }) };
+    }
+    /** Builds the write-once freeze for a first instruction write. */
+    frozenInstructionReview(receipt) {
+        return createOwnerInstructionReviewFreeze({ supplier: this.resolveLiveInstructionReviewSupplier(receipt),
+            budget: this.ownerInstructionReviewBudget() });
+    }
+    /** Re-reads an existing freeze and fails closed if the review capability drifted. */
+    reusedInstructionReview(stored) {
+        const freeze = this.store.getOwnerInstructionReviewFreeze(stored.instructionId);
+        if (freeze === undefined)
+            throw new Error('owner instruction was recorded without a frozen review supplier; request a new revision');
+        const live = this.ownerInstructionReviewBudget();
+        if (controlPlaneDigest(freeze.budget.authority) !== controlPlaneDigest(live.authority)
+            || freeze.budget.verifierKeyDigest !== live.verifierKeyDigest
+            || controlPlaneDigest(freeze.budget.window) !== controlPlaneDigest(live.window)) {
+            throw new Error('frozen review budget no longer matches the configured revision verifier');
+        }
+        if (freeze.budget.authority.expiresAt <= Date.now())
+            throw new Error('frozen review authority expired');
+        return freeze;
+    }
     inspectSourceRevisionAcceptanceAuthority = () => {
         const policy = this.config.revisionVerifications?.authority;
         if (this.abort.signal.aborted || !policy || Date.now() >= policy.expiresAt
@@ -1834,7 +2477,7 @@ export class PluginControlPlaneService extends Service {
         const policy = this.inspectSourceRevisionRegressionAcceptanceAuthority();
         const run = prepared.plan.sourceRevision.growthRun;
         const source = this.store.readRevisionSource(planId);
-        if (!certificate || !source || !policy || !run.revisionRegressionAcceptance
+        if (!certificate || !source || !policy || !run || !run.revisionRegressionAcceptance
             || controlPlaneDigest(run.revisionRegressionAcceptance) !== controlPlaneDigest(policy)) {
             throw new Error('regression requires fresh independently verified candidate and pre-author policy');
         }
@@ -1848,6 +2491,9 @@ export class PluginControlPlaneService extends Service {
             throw new Error('regression parent immutable artifact unavailable or changed');
         }
         this.inspectRevisionParent(parent.parent.planId);
+        if (prepared.protocol === 'dsh-prepared-revision/v3') {
+            throw new Error('owner-instruction revisions carry no regression acceptance');
+        }
         return { protocol: 'dsh-prepared-revision-regression/v1',
             plan: prepared.plan, job: prepared.job, reference: prepared.reference,
             candidate: { certificate, artifact: Buffer.from(prepared.artifact), sourceDigest: source.digest },
@@ -1868,6 +2514,7 @@ export class PluginControlPlaneService extends Service {
                 || controlPlaneDigest(snapshot.candidate.certificate) !== input.candidateVerificationDigest
                 || source.digest !== input.sourceDigest || snapshot.candidate.sourceDigest !== input.sourceDigest
                 || controlPlaneDigest(policy) !== input.regressionAuthorityDigest
+                || snapshot.plan.sourceRevision.growthRun?.revisionRegressionAcceptance === undefined
                 || controlPlaneDigest(snapshot.plan.sourceRevision.growthRun.revisionRegressionAcceptance) !== input.regressionAuthorityDigest
                 || controlPlaneDigest(snapshot.parent.binding) !== input.parentDigest) {
                 throw new Error('regression parent, candidate or policy changed');
@@ -1879,6 +2526,9 @@ export class PluginControlPlaneService extends Service {
         const certificate = this.store.getRevisionRegression(planId), policy = this.config.revisionRegressions;
         if (!certificate || !policy || !verifyPluginRevisionRegressionCertificate(certificate, policy.authority, policy.publicKey))
             return undefined;
+        // Instruction revisions carry no regression acceptance and never enter this corridor.
+        if (!isPluginRevisionTaskSource(certificate.source))
+            return undefined;
         const prepared = this.inspectPreparedRevisionRegression(planId);
         this.withPreparedRevisionRegressionFence({ planId, planDigest: certificate.plan.digest, artifactSha256: certificate.plan.artifactSha256,
             growthRunDigest: certificate.source.growthRunDigest, referenceDigest: certificate.source.referenceDigest,
@@ -1902,6 +2552,17 @@ export class PluginControlPlaneService extends Service {
         const reference = this.store.getOwnerTaskFailureReference(plan.gapId);
         if (!reference)
             throw new Error('revision verification source unavailable');
+        if (reference.schemaVersion === 2) {
+            const run = plan.sourceRevision?.growthRun;
+            if (run?.protocol !== 'assistant-growth/source-run/v3')
+                throw new Error('work item revision verification run unavailable');
+            return this.withWorkItemRevisionFrame(run, plan.gapId, reference.owner, false, () => {
+                const current = this.store.getSourcePlan(input.planId), job = this.store.getPreparedRevisionJob(input.planId);
+                if (current.digest !== input.planDigest || current.preparedEvidence?.pack.sha256 !== input.artifactSha256 || controlPlaneDigest(reference) !== input.referenceDigest || sourceGrowthRunDigest(run) !== input.growthRunDigest || !job.intent.revision?.growthRun || sourceGrowthRunDigest(job.intent.revision.growthRun) !== input.growthRunDigest || controlPlaneDigest(current.sourceRevision.parent) !== input.parentDigest || createHash('sha256').update(this.store.readPreparedSourceArtifact(input.planId)).digest('hex') !== input.artifactSha256)
+                    throw new Error('work item prepared revision exact binding changed');
+                return callback();
+            });
+        }
         return this.taskGaps.withCurrent(plan.gapId, reference.owner, () => {
             this.abort.signal.throwIfAborted();
             const current = this.store.getSourcePlan(input.planId);
@@ -1927,15 +2588,57 @@ export class PluginControlPlaneService extends Service {
             return callback();
         });
     };
+    /**
+     * Exact-source fence for owner-instruction revisions: the frozen instruction
+     * row replaces the task reference and growth run, and every comparison is
+     * replayed against durable state inside the Evaluation writer transaction.
+     */
+    withPreparedInstructionRevisionFence = (input, callback) => {
+        this.abort.signal.throwIfAborted();
+        const policy = this.inspectSourceRevisionAcceptanceAuthority();
+        if (!policy)
+            throw new Error('revision verification authority unavailable');
+        const plan = this.store.getSourcePlan(input.planId);
+        if (this.store.getOwnerTaskFailureReference(plan.gapId) !== undefined) {
+            throw new Error('instruction revision fence cannot ride a task failure');
+        }
+        const job = this.store.getPreparedRevisionJob(input.planId);
+        const instruction = job.intent.ownerInstruction;
+        const current = this.store.getSourcePlan(input.planId);
+        const stored = instruction === undefined ? undefined : this.store.getOwnerInstruction(instruction.instructionId);
+        if (!instruction || stored === undefined || controlPlaneDigest(stored) !== instruction.digest
+            || instruction.digest !== input.instructionDigest
+            || current.digest !== input.planDigest || current.mode !== 'prepared-revise' || !current.sourceCheck || !current.preparedEvidence
+            || current.preparedEvidence.pack.sha256 !== input.artifactSha256
+            || current.sourceRevision?.growthRun !== undefined || job.intent.revision?.growthRun !== undefined
+            || controlPlaneDigest(current.sourceRevision?.parent) !== input.parentDigest
+            || controlPlaneDigest(current.sourceRevision?.grant) !== controlPlaneDigest(this.config.sourceJobs?.revision)) {
+            throw new Error('instruction revision exact source binding changed');
+        }
+        if (stored.expiresAt <= Date.now())
+            throw new Error('owner instruction expired');
+        this.assertInstructionRevisionOwner(stored.ownerReceipt, current);
+        const artifact = this.store.readPreparedSourceArtifact(input.planId);
+        if (createHash('sha256').update(artifact).digest('hex') !== input.artifactSha256) {
+            throw new Error('instruction revision artifact changed');
+        }
+        return callback();
+    };
     /** Independent reviewer reads the actual checked tree through a disposable Git index. */
     inspectPreparedRevisionReviewContext = async (planId, signal) => {
         const combined = AbortSignal.any([this.abort.signal, signal, AbortSignal.timeout(120_000)]);
         combined.throwIfAborted();
         const prepared = this.inspectPreparedRevision(planId);
-        const current = () => this.withPreparedRevisionFence({ planId, planDigest: prepared.plan.digest,
-            artifactSha256: prepared.plan.preparedEvidence.pack.sha256,
-            growthRunDigest: sourceGrowthRunDigest(prepared.plan.sourceRevision.growthRun),
-            referenceDigest: controlPlaneDigest(prepared.reference), parentDigest: controlPlaneDigest(prepared.plan.sourceRevision.parent) }, () => undefined);
+        const assertCurrent = prepared.protocol === 'dsh-prepared-revision/v3'
+            ? () => this.withPreparedInstructionRevisionFence({ planId, planDigest: prepared.plan.digest,
+                artifactSha256: prepared.plan.preparedEvidence.pack.sha256,
+                instructionDigest: prepared.source.instruction.digest,
+                parentDigest: controlPlaneDigest(prepared.plan.sourceRevision.parent) }, () => undefined)
+            : () => this.withPreparedRevisionFence({ planId, planDigest: prepared.plan.digest,
+                artifactSha256: prepared.plan.preparedEvidence.pack.sha256,
+                growthRunDigest: sourceGrowthRunDigest(prepared.plan.sourceRevision.growthRun),
+                referenceDigest: controlPlaneDigest(prepared.reference), parentDigest: controlPlaneDigest(prepared.plan.sourceRevision.parent) }, () => undefined);
+        const current = assertCurrent;
         current();
         const trust = await this.boundTrust();
         const environment = inheritedEnvironment(trust);
@@ -1956,6 +2659,21 @@ export class PluginControlPlaneService extends Service {
         const config = this.config.revisionVerifications;
         if (!config || !verifyPluginRevisionVerificationCertificate(certificate, config.authority, config.publicKey))
             return undefined;
+        if (!isPluginRevisionTaskSource(certificate.source)) {
+            this.withPreparedInstructionRevisionFence({ planId, planDigest: certificate.plan.digest,
+                artifactSha256: certificate.plan.artifactSha256,
+                instructionDigest: certificate.source.instructionDigest, parentDigest: controlPlaneDigest(certificate.parent) }, () => {
+                const plan = this.store.getSourcePlan(planId);
+                if (!plan.sourceCheck || !plan.preparedEvidence || certificate.plan.name !== plan.name
+                    || certificate.plan.generatorDigest !== plan.generatorDigest
+                    || certificate.plan.sourceTreeDigest !== plan.sourceCheck.treeDigest
+                    || certificate.plan.sourcePatchDigest !== plan.sourceCheck.patchDigest
+                    || certificate.plan.artifactBytes !== plan.preparedEvidence.pack.sizeBytes) {
+                    throw new Error('revision verification exact plan evidence changed');
+                }
+            });
+            return structuredClone(certificate);
+        }
         this.withPreparedRevisionFence({ planId, planDigest: certificate.plan.digest,
             artifactSha256: certificate.plan.artifactSha256, growthRunDigest: certificate.source.growthRunDigest,
             referenceDigest: certificate.source.referenceDigest, parentDigest: controlPlaneDigest(certificate.parent) }, () => {
@@ -1975,8 +2693,17 @@ export class PluginControlPlaneService extends Service {
         this.abort.signal.throwIfAborted();
         const plan = this.store.getSourcePlan(planId);
         const reference = this.store.getOwnerTaskFailureReference(plan.gapId);
-        if (!reference || plan.mode !== 'prepared-revise')
+        if (plan.mode !== 'prepared-revise')
             throw new Error('revision verification owner source unavailable');
+        if (!reference) {
+            const job = this.store.getPreparedRevisionJob(planId);
+            const instruction = job.intent.ownerInstruction;
+            if (!instruction || !plan.preparedEvidence || !plan.sourceRevision)
+                throw new Error('revision verification owner source unavailable');
+            return this.withPreparedInstructionRevisionFence({ planId, planDigest: plan.digest,
+                artifactSha256: plan.preparedEvidence.pack.sha256, instructionDigest: instruction.digest,
+                parentDigest: controlPlaneDigest(plan.sourceRevision.parent) }, () => this.store.inspectRevisionVerificationRecord(planId));
+        }
         return this.taskGaps.withCurrent(plan.gapId, reference.owner, () => {
             const current = this.store.getSourcePlan(planId);
             if (current.mode !== 'prepared-revise' || current.digest !== plan.digest) {
@@ -2005,6 +2732,8 @@ export class PluginControlPlaneService extends Service {
             const { plan, reference, job } = this.store.getRetainedPreparedRevision(planId);
             const certificate = this.store.getRevisionVerification(planId);
             if (!certificate || !plan.sourceRevision || !isSourceOwnerContinuation(before, reference.owner)
+                || !isPluginRevisionTaskSource(certificate.source)
+                || plan.sourceRevision.growthRun === undefined
                 || !verifyPluginRevisionVerificationCertificate(certificate, policy.authority, policy.publicKey, certificate.verifiedAt)
                 || certificate.plan.digest !== plan.digest || certificate.source.referenceDigest !== controlPlaneDigest(reference)
                 || certificate.source.ownerDigest !== job.intent.ownerDigest
@@ -2050,6 +2779,104 @@ export class PluginControlPlaneService extends Service {
             throw new Error('plugin-control-plane: durable source jobs unavailable');
         return this.sourceRuntime.inspect(input);
     };
+    async drainOwnerInstructionRequests(signal) {
+        await drainPendingOwnerInstructionRequests({
+            store: this.store,
+            now: Date.now(),
+            readNow: Date.now,
+            signal,
+            maxPerPass: 1,
+            admit: (request, assertCurrent) => this.requestOwnerInstructionRevision({ planId: request.planId, pluginName: request.pluginName,
+                files: request.files, ttlMs: request.ttlMs, idempotencyKey: request.idempotencyKey,
+                expectedBaseCommit: request.expectedBaseCommit, window: { createdAt: request.createdAt, expiresAt: request.expiresAt },
+                signal, assertCurrent }),
+        });
+    }
+    /**
+     * Host-only owner instruction entry. Freezes one authenticated owner
+     * receipt, the adopted revision parent and the exact submitted files into an
+     * expiring instruction row, then enqueues one `revise-created` source job
+     * against the synthetic instruction gap. The model tool surface never
+     * reaches this method; without a valid instruction the admission still
+     * requires an owner task failure.
+     */
+    requestOwnerInstructionRevision = (input) => {
+        const assertCurrent = () => {
+            this.abort.signal.throwIfAborted();
+            input.signal?.throwIfAborted();
+            input.assertCurrent?.();
+        };
+        assertCurrent();
+        const config = this.config.sourceJobs;
+        const delivery = this.ctx.get('assistantDelivery', false);
+        if (config === undefined || config.revision === undefined || delivery === undefined) {
+            throw new Error('plugin-control-plane: owner instruction revisions require source jobs, a revision grant and a live owner route');
+        }
+        if (config.revision.expiresAt <= Date.now())
+            throw new Error('plugin-control-plane: the source revision grant is expired');
+        if (!Number.isSafeInteger(input.ttlMs) || input.ttlMs < 900_000 || input.ttlMs > 86_400_000) {
+            throw new Error('plugin-control-plane: owner instruction ttl is invalid');
+        }
+        if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/u.test(input.idempotencyKey)) {
+            throw new Error('plugin-control-plane: owner instruction idempotency key is invalid');
+        }
+        validateSourceCreationFiles(input.files);
+        const receipt = delivery.validateOwnerRoute({ authorityId: config.ownerRouteId,
+            principalId: config.principalId, workspace: config.workspace, agentPreset: config.preset });
+        const parent = this.inspectRevisionParent(input.planId);
+        if (parent.name !== input.pluginName)
+            throw new Error('plugin-control-plane: owner instruction target does not match the adopted parent');
+        const instructionId = `instruction-${createHash('sha256').update(config.authorityId).update('\0')
+            .update(input.idempotencyKey).digest('hex').slice(0, 32)}`;
+        const prior = this.store.getOwnerInstruction(instructionId);
+        const now = Date.now();
+        const createdAt = input.window?.createdAt ?? prior?.createdAt ?? now;
+        const expiresAt = input.window?.expiresAt ?? prior?.expiresAt ?? createdAt + input.ttlMs;
+        if (!Number.isSafeInteger(createdAt) || !Number.isSafeInteger(expiresAt)
+            || expiresAt - createdAt !== input.ttlMs || expiresAt <= now) {
+            throw new Error('plugin-control-plane: owner instruction request expired or invalid');
+        }
+        if (prior && !isSourceOwnerContinuation(receipt, prior.ownerReceipt))
+            throw new Error('plugin-control-plane: owner route changed');
+        // Resolve the independent review supplier and budget exactly once. An
+        // existing instruction reuses its write-once freeze; a changed owner model
+        // selection or changed verifier identity can never silently replace it.
+        const review = prior === undefined ? this.frozenInstructionReview(receipt) : this.reusedInstructionReview(prior);
+        const gap = this.store.recordGap({
+            idempotencyKey: `owner-instruction:${instructionId}`, capability: `plugin-revision:${input.pluginName}`,
+            context: 'Owner instruction revision request', expectedValue: 1, frequency: 1, estimatedCost: 1, risk: 0,
+        });
+        const instruction = this.store.recordOwnerInstruction({
+            instructionId, ownerReceipt: prior?.ownerReceipt ?? receipt, ownerRouteId: config.ownerRouteId, planId: input.planId,
+            pluginName: input.pluginName, filesDigest: controlPlaneDigest(input.files),
+            createdAt, expiresAt, idempotencyKey: input.idempotencyKey, review,
+        });
+        const signal = AbortSignal.any([this.abort.signal, AbortSignal.timeout(Math.max(1, expiresAt - Date.now())),
+            ...(input.signal === undefined ? [] : [input.signal])]);
+        return this.enqueueSourceJob({
+            gapId: gap.id, mode: 'revise-created', name: input.pluginName, files: input.files,
+            repository: config.repository, parentPlanId: input.planId,
+            ownerInstruction: { instructionId: instruction.instructionId,
+                digest: controlPlaneDigest(instruction) },
+            expectedBaseCommit: input.expectedBaseCommit, ttlMs: input.ttlMs,
+            idempotencyKey: input.idempotencyKey,
+            owner: { ownerRouteId: receipt.authorityId, principalId: receipt.principalId,
+                principalRecordId: receipt.principalRecordId, principalVersion: receipt.principalVersion,
+                workspace: receipt.workspace, preset: receipt.agentPreset },
+            signal, assertCurrent,
+        }).then(job => {
+            const persisted = this.store.getSourceJob(job.id);
+            // A queued result from enqueue has passed native activation. For an
+            // already settled job, the bound definition alone only proves the
+            // paused registration existed. A durable occurrence proves dispatch.
+            if (persisted?.intent.ownerInstruction?.instructionId !== instruction.instructionId
+                || persisted.intent.ownerInstruction.digest !== controlPlaneDigest(instruction)
+                || !persisted.definitionHash || (persisted.status !== 'queued' && persisted.occurrenceId === undefined)) {
+                throw new Error('plugin-control-plane: source-job-registration-rejected');
+            }
+            return { instructionId: instruction.instructionId, jobId: job.id };
+        });
+    };
     reconcileSourceJob = (input) => {
         if (this.sourceRuntime === undefined || this.sourceBuilds.size !== 0)
             throw new Error('plugin-control-plane: durable source jobs unavailable or still draining');
@@ -2131,19 +2958,42 @@ export class PluginControlPlaneService extends Service {
         if (!job.planId || !this.config.revisionVerifications || this.store.getRevisionVerificationStatus(job.planId) !== undefined)
             return;
         const prepared = this.inspectPreparedRevision(job.planId);
-        if (prepared.job.id !== job.id || !prepared.plan.sourceRevision?.growthRun || !prepared.plan.preparedEvidence) {
+        if (prepared.job.id !== job.id || !prepared.plan.preparedEvidence) {
             throw new Error('revision verification job is not the exact prepared source');
         }
+        if (prepared.protocol === 'dsh-prepared-revision/v3') {
+            // Owner-instruction revisions claim through their instruction binding.
+            const instruction = prepared.source.instruction;
+            this.withPreparedInstructionRevisionFence({ planId: prepared.plan.id, planDigest: prepared.plan.digest,
+                artifactSha256: prepared.plan.preparedEvidence.pack.sha256,
+                instructionDigest: instruction.digest, parentDigest: controlPlaneDigest(prepared.plan.sourceRevision.parent) }, () => this.store.claimRevisionVerification(job.planId));
+            return this.runPreparedRevisionVerifier(job, prepared, signal, verifier, { planId: prepared.plan.id, planDigest: prepared.plan.digest,
+                artifactSha256: prepared.plan.preparedEvidence.pack.sha256,
+                instructionDigest: instruction.digest, parentDigest: controlPlaneDigest(prepared.plan.sourceRevision.parent),
+                ownerDigest: controlPlaneDigest(prepared.source.owner) });
+        }
+        if (!prepared.plan.sourceRevision?.growthRun)
+            throw new Error('prepared revision lacks a frozen source growth run');
         const binding = { planId: prepared.plan.id, planDigest: prepared.plan.digest,
             artifactSha256: prepared.plan.preparedEvidence.pack.sha256,
             growthRunDigest: sourceGrowthRunDigest(prepared.plan.sourceRevision.growthRun),
             referenceDigest: controlPlaneDigest(prepared.reference), parentDigest: controlPlaneDigest(prepared.plan.sourceRevision.parent) };
         this.withPreparedRevisionFence(binding, () => this.store.claimRevisionVerification(job.planId));
+        return this.runPreparedRevisionVerifier(job, prepared, signal, verifier, binding);
+    }
+    /** Runs the independent reviewer and settles the claimed row inside the caller's exact-source fence. */
+    async runPreparedRevisionVerifier(job, prepared, signal, verifier, fenceInput) {
+        const inFence = (callback) => 'growthRunDigest' in fenceInput
+            ? this.withPreparedRevisionFence(fenceInput, callback)
+            : this.withPreparedInstructionRevisionFence(fenceInput, callback);
+        const planId = job.planId;
+        if (!planId)
+            throw new Error('revision verification job has no plan');
         try {
             const current = verifier();
             if (typeof current?.verifyPluginRevision !== 'function')
                 throw new Error('independent revision verifier unavailable');
-            const result = await current.verifyPluginRevision({ protocol: 'assistant-growth/revision-verification-request/v1', planId: job.planId }, signal);
+            const result = await current.verifyPluginRevision({ protocol: 'assistant-growth/revision-verification-request/v1', planId }, signal);
             signal.throwIfAborted();
             if (result.status === 'verified' && !verifyPluginRevisionVerificationCertificate(result.certificate, this.config.revisionVerifications.authority, this.config.revisionVerifications.publicKey)) {
                 throw new Error('revision verification certificate signature or policy invalid');
@@ -2154,7 +3004,7 @@ export class PluginControlPlaneService extends Service {
             const source = result.status === 'verified' ? await captureCreationCapabilitySource({ worktree: prepared.plan.worktree,
                 baseCommit: prepared.plan.baseCommit, scope: [...prepared.plan.scope].sort(), certificate: result.certificate,
                 environment: inheritedEnvironment(await this.boundTrust()), signal }) : undefined;
-            this.withPreparedRevisionFence(binding, () => {
+            inFence(() => {
                 if (result.status === 'verified') {
                     if (!source)
                         throw new Error('verified revision source archive unavailable');
@@ -2169,7 +3019,7 @@ export class PluginControlPlaneService extends Service {
             // The claimed row is a durable no-replay fence even if the process dies
             // before settlement. A later native tick cannot dispatch another review.
             try {
-                this.withPreparedRevisionFence(binding, () => {
+                inFence(() => {
                     if (this.store.getRevisionVerificationStatus(job.planId) === 'claimed') {
                         this.store.settleRevisionVerification(job.planId, 'unknown', 'independent-verification-unsettled');
                     }
@@ -2187,11 +3037,17 @@ export class PluginControlPlaneService extends Service {
         if (prepared.job.id !== job.id)
             throw new Error('regression job is not exact prepared revision');
         const certificate = prepared.candidate.certificate;
+        const acceptance = prepared.plan.sourceRevision?.growthRun?.revisionRegressionAcceptance;
+        if (acceptance === undefined)
+            throw new Error('owner-instruction revisions carry no regression acceptance');
+        if (!isPluginRevisionTaskSource(certificate.source)) {
+            throw new Error('owner-instruction revisions carry no regression acceptance');
+        }
         const binding = { planId: prepared.plan.id, planDigest: prepared.plan.digest, artifactSha256: certificate.plan.artifactSha256,
             growthRunDigest: certificate.source.growthRunDigest, referenceDigest: certificate.source.referenceDigest,
             parentDigest: controlPlaneDigest(certificate.parent), candidateVerificationDigest: controlPlaneDigest(certificate),
             sourceDigest: prepared.candidate.sourceDigest,
-            regressionAuthorityDigest: controlPlaneDigest(prepared.plan.sourceRevision.growthRun.revisionRegressionAcceptance) };
+            regressionAuthorityDigest: controlPlaneDigest(acceptance) };
         this.withPreparedRevisionRegressionFence(binding, () => this.store.claimRevisionRegression(job.planId));
         try {
             const current = verifier();
@@ -2438,8 +3294,7 @@ export class PluginControlPlaneService extends Service {
             throw new ControlPlaneCliError('INVALID_ARGUMENT', 'ttlMs must be an integer within 900000..86400000');
         }
         const buildConfig = this.config.sourceBuild;
-        const repositoryBuild = buildConfig !== undefined && ('backend' in buildConfig
-            ? buildConfig.backend === 'linux-native' : ['repository', 'portable-repository'].includes(buildConfig.profile ?? ''));
+        const repositoryBuild = buildConfig !== undefined && 'backend' in buildConfig && buildConfig.backend === 'linux-native';
         const maximumTimeoutMs = repositoryBuild ? 1_800_000 : 240_000;
         const timeoutMs = input.timeoutMs ?? 180_000;
         if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 60_000 || timeoutMs > maximumTimeoutMs) {
@@ -2484,31 +3339,26 @@ export class PluginControlPlaneService extends Service {
             }
             // Only owner-bound creation jobs retain the exact package for the
             // independent verifier. Ordinary source tools never receive these bytes.
-            const capturePack = (creating || revising) && this.store.getOwnerTaskFailureReference(input.gapId) !== undefined;
+            const capturePack = (creating || revising) && (this.store.getOwnerTaskFailureReference(input.gapId) !== undefined
+                || sourceJob?.intent.ownerInstruction !== undefined);
             const common = { worktree: isolated.worktree, baseCommit, name, scope: generated?.scope ?? [`plugins/${name}`],
                 environment, signal, assertCurrent, preparedAt: Date.now(), ...(creation === undefined ? {} : { creation }),
                 ...(revision === undefined ? {} : { revision: { binding: revision, parentSource: parent.source,
                         parentCertificate: parent.certificate, files: input.files } }), ...(capturePack ? { capturePack: true } : {}) };
-            const checked = 'backend' in configured
-                ? await (async () => {
-                    const native = this.nativeSourceRunner;
-                    if (sourceJob === undefined || native === undefined || native.backend !== configured.backend
-                        || sourceJob.intent.nativeResource?.backend !== configured.backend || sourceJob.intent.nativeResource.key !== sourceJob.id) {
-                        throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'native source preparation requires its bound durable source job');
-                    }
-                    if (configured.backend === 'linux-native' && native.backend === 'linux-native') {
-                        linuxBuildInvoked = true;
-                        return runLinuxPreparedChecks({ ...common, config: { ...configured, timeoutMs: Math.min(timeoutMs, configured.timeoutMs) },
-                            runner: native.runner, sourceJob: { id: sourceJob.id } });
-                    }
-                    if (configured.backend !== 'macos-seatbelt' || native.backend !== 'macos-seatbelt' || !creating && !revising) {
-                        throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'macOS source preparation requires a Host-scaffolded creation job');
-                    }
-                    return runNativePreparedChecks({ ...common, config: { ...configured, timeoutMs: Math.min(timeoutMs, configured.timeoutMs) },
-                        runner: native.runner, sourceJob: { id: sourceJob.id } });
-                })()
-                : await runDockerPreparedChecks({ ...common, config: { ...configured, timeoutMs: Math.min(timeoutMs, configured.timeoutMs) },
-                    ...(sourceJob === undefined ? {} : { sourceJob: { id: sourceJob.id, containerName: sourceJob.intent.containerName } }) });
+            if (!('backend' in configured))
+                throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'source build requires a native backend');
+            const native = this.nativeSourceRunner;
+            if (sourceJob === undefined || native === undefined || native.backend !== configured.backend
+                || sourceJob.intent.nativeResource?.backend !== configured.backend || sourceJob.intent.nativeResource.key !== sourceJob.id) {
+                throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'native source preparation requires its bound durable source job');
+            }
+            const checked = configured.backend === 'linux-native' && native.backend === 'linux-native'
+                ? await (linuxBuildInvoked = true, runLinuxPreparedChecks({ ...common, config: { ...configured, timeoutMs: Math.min(timeoutMs, configured.timeoutMs) },
+                    runner: native.runner, sourceJob: { id: sourceJob.id } }))
+                : configured.backend === 'macos-seatbelt' && native.backend === 'macos-seatbelt' && (creating || revising)
+                    ? await runNativePreparedChecks({ ...common, config: { ...configured, timeoutMs: Math.min(timeoutMs, configured.timeoutMs) },
+                        runner: native.runner, sourceJob: { id: sourceJob.id } })
+                    : (() => { throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'native source preparation backend is unavailable'); })();
             await assertCurrent();
             if (capturePack && checked.packArtifact === undefined)
                 throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'prepared creation artifact was not captured');
@@ -2535,6 +3385,11 @@ export class PluginControlPlaneService extends Service {
                         throw new Error('work item creation owner unavailable');
                     return this.withWorkItemGrowthFrame(creation.growthRun, input.gapId, gapOwner, false, callback);
                 }
+                if (revision?.growthRun?.protocol === 'assistant-growth/source-run/v3') {
+                    if (!gapOwner || !('receiptVersion' in gapOwner))
+                        throw new Error('work item revision owner unavailable');
+                    return this.withWorkItemRevisionFrame(revision.growthRun, input.gapId, gapOwner, false, callback);
+                }
                 return this.taskGaps.withCurrent(input.gapId, gapOwner, callback);
             };
             return commitSource(() => this.store.createSourcePlan({ gapId: input.gapId, repository, worktree: isolated.worktree, baseCommit,