@dsh-enhanced/plugin-control-plane 0.1.65 → 0.1.67

package/lib/service.js

@@ -1,16 +1,20 @@
+import { cleanedLinuxSourceBuildFailure, cleanedLinuxSourcePreflight, consumeCleanedLinuxSourceBuildFailure, consumeCleanedLinuxSourcePreflight, consumeLinuxSourceBuildFailed, consumeLinuxSourceNotStarted, isLinuxSourceBuildFailed } from './linux-source-preflight.js';
 import { AdoptionCoordinatorRuntime, validateAdoptionCoordinatorConfig } from './adoption-coordinator.js';
-import { CreationCapabilityJournal, creationCapabilityPublicKey, validateCreationCapabilityConfig } from './creation-capability-journal.js';
+import { CreationCapabilityJournal, creationCapabilityAuthorityDigest, creationCapabilityPublicKey, validateCreationCapabilityConfig } from './creation-capability-journal.js';
 import { CreationCapabilityRuntime } from './creation-capability-runtime.js';
-import { inspectCreationCapabilityTaskAssociations } from './creation-capability-feedback.js';
+import { RevisionCapabilityJournal, revisionCapabilityPublicKey, validateRevisionCapabilityConfig } from './revision-capability-journal.js';
+import { RevisionCapabilityRuntime } from './revision-capability-runtime.js';
+import { inspectCreationCapabilityAvailabilityAttribution, inspectCreationCapabilityOrdinaryUseReport, inspectCreationCapabilityOrdinaryUseTrend, inspectCreationCapabilityTaskAssociations } from './creation-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, sourceGrowthRunDigest, validateCreationAcceptanceAuthorityRef, verifyPluginCreationVerificationCertificate, validateRevisionAcceptanceAuthorityRef, verifyPluginRevisionVerificationCertificate, validateRevisionRegressionAcceptanceAuthorityRef, verifyPluginRevisionRegressionCertificate, validateSourceGrowthRunBinding } from '@dsh-enhanced/assistant-growth-contract';
+import { isSourceOwnerContinuation, anySourceGrowthRunDigest as sourceGrowthRunDigest, validateAnySourceGrowthRunBinding as validateSourceGrowthRunBinding, validateWorkItemGrowthAuthorityPins, validateCreationAcceptanceAuthorityRef, verifyPluginCreationVerificationCertificate, validateRevisionAcceptanceAuthorityRef, verifyPluginRevisionVerificationCertificate, validateRevisionRegressionAcceptanceAuthorityRef, verifyPluginRevisionRegressionCertificate } 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 { OwnerTaskFailureGaps } from './owner-task-gaps.js';
 import { Context, Service } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
@@ -27,7 +31,8 @@ import { Ed25519ApprovalAuthority } from './approval.js';
 import { ControlPlaneStore, MODIFY_GENERATOR_DIGEST, controlPlaneDigest } from './store.js';
 import { runDockerPreparedChecks, validateSourceBuildConfig } from './source-build.js';
 import { runNativePreparedChecks } from './native-source-build.js';
-import { NativeMacVerifierRunner } from '@dsh-enhanced/assistant-isolation';
+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';
 import { NATIVE_SOURCE_COMPILER } from './native-source-build-worker.js';
 import { awaitSourceSignal, inspectSourceContext, inspectSourceTargetsContext } from './source-context.js';
 import { inspectSourceRevisionContext, prepareRevisedPluginWorkspace, verifyRevisedPluginWorkspace } from './source-revision.js';
@@ -35,7 +40,7 @@ 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, validateSourceJobsConfig } from './source-jobs.js';
+import { SourceGrowthRunUnavailableError, SourceJobRuntime, normalizeSourceJobsConfig } from './source-jobs.js';
 import { installRuntimeObserver, validateRuntimeObserverConfig } from './runtime-observer.js';
 import { installReplayEndpoint, validateReplayEndpointConfig } from './replay-endpoint.js';
 import { readPrivateRuntimeObserverKey } from './runtime-observer-protocol.js';
@@ -54,6 +59,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(),
@@ -136,13 +142,22 @@ export function normalizeControlPlaneConfig(input) {
         validateSourceApprovalClientConfig(config.sourceApprovals);
     if (config.sourceBuild !== undefined)
         validateSourceBuildConfig(config.sourceBuild);
-    if (config.sourceBuild !== undefined && 'backend' in config.sourceBuild) {
+    if (config.sourceBuild !== undefined && 'backend' in config.sourceBuild && config.sourceBuild.backend === 'macos-seatbelt') {
         if (!config.sourceJobs?.allowedModes || config.sourceJobs.allowedModes.some(mode => mode === 'modify')
             || config.sourceReleases !== undefined || config.sourceReleaseExecution !== undefined
             || config.sourceAdoptions !== undefined || config.sourceApprovals !== undefined) {
             throw new Error('plugin-control-plane: native source build only supports Host-scaffolded create/revise-created');
         }
     }
+    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
+            || config.revisionCapabilities)
+            && (!config.sourceBuild.userNamespace || !config.sourceBuild.systemSnapshot)) {
+            throw new Error('plugin-control-plane: Linux independent verification requires the dual-UID repository boundary');
+        }
+    }
     if (config.sourceReleases !== undefined) {
         validateSourceReleaseClientConfig(config.sourceReleases);
         if (!config.sourceApprovals || config.sourceBuild?.versioning !== 'patch')
@@ -168,7 +183,7 @@ export function normalizeControlPlaneConfig(input) {
         }
     }
     if (config.sourceJobs !== undefined) {
-        validateSourceJobsConfig(config.sourceJobs, config.sourceBuild);
+        config.sourceJobs = normalizeSourceJobsConfig(config.sourceJobs, config.sourceBuild);
         if (realpathSync(config.sourceJobs.repository) !== config.sourceJobs.repository)
             throw new Error('plugin-control-plane: sourceJobs.repository must be canonical');
     }
@@ -227,9 +242,19 @@ export function normalizeControlPlaneConfig(input) {
     }
     if (config.creationCapabilities !== undefined) {
         validateCreationCapabilityConfig(config.creationCapabilities);
+        if (config.creationCapabilities.workItemFailures === false) {
+            config.creationCapabilities = { ...config.creationCapabilities };
+            delete config.creationCapabilities.workItemFailures;
+        }
         const capability = config.creationCapabilities;
         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) {
+            throw new Error('plugin-control-plane: creation build, verification and adoption require matching execution backends');
+        }
         if (!verification || !jobs?.creation || capability.namePrefix !== jobs.creation.namePrefix
             || capability.owner.authorityId !== jobs.ownerRouteId || capability.owner.principalId !== jobs.principalId
             || capability.owner.workspace !== jobs.workspace || capability.owner.agentPreset !== jobs.preset
@@ -241,6 +266,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;
@@ -264,11 +322,13 @@ export class PluginControlPlaneService extends Service {
     nativeSourceRunner;
     sourceRuntimes = new Set();
     creationCapabilityRuntime;
+    revisionCapabilityRuntime;
     creationCapabilityRuntimes = new Set();
     creationCapabilityFlights = new Set();
     creationCapabilityReconcileRequested = false;
     growthRunProducer;
     growthProviderDraining = false;
+    workItemCreationFrame;
     constructor(ctx, input) {
         super(ctx, 'pluginControlPlane');
         this.config = normalizeControlPlaneConfig(input);
@@ -437,9 +497,14 @@ export class PluginControlPlaneService extends Service {
                             },
                             delivery: {
                                 validateOwnerRoute: input => delivery().validateOwnerRoute(input),
+                                inspectOwnerRouteState: input => delivery().inspectOwnerRouteState(input),
                                 inspectOwnerForegroundLearningTask: input => delivery().inspectOwnerForegroundLearningTask(input),
                             },
                             automations: {
+                                inspectSystemOwnedRetirement: input => automations().inspectSystemOwnedRetirement(input),
+                                onSchedulerWake: listener => automations().onSchedulerWake(listener),
+                                retireSystemOwned: input => automations().retireSystemOwned(input),
+                                inspectSystemOwned: input => automations().inspectSystemOwned(input),
                                 registerHostExecutor: input => automations().registerHostExecutor(input),
                                 reconcileSystem: input => automations().reconcileSystem(input),
                                 inspectSystemOwnedActivation: input => automations().inspectSystemOwnedActivation(input),
@@ -495,9 +560,14 @@ export class PluginControlPlaneService extends Service {
                             },
                             delivery: {
                                 validateOwnerRoute: input => delivery().validateOwnerRoute(input),
+                                inspectOwnerRouteState: input => delivery().inspectOwnerRouteState(input),
                                 inspectOwnerForegroundLearningTask: input => delivery().inspectOwnerForegroundLearningTask(input),
                             },
                             automations: {
+                                inspectSystemOwnedRetirement: input => automations().inspectSystemOwnedRetirement(input),
+                                onSchedulerWake: listener => automations().onSchedulerWake(listener),
+                                retireSystemOwned: input => automations().retireSystemOwned(input),
+                                inspectSystemOwned: input => automations().inspectSystemOwned(input),
                                 registerHostExecutor: input => automations().registerHostExecutor(input),
                                 reconcileSystem: input => automations().reconcileSystem(input),
                                 inspectSystemOwnedActivation: input => automations().inspectSystemOwnedActivation(input),
@@ -558,10 +628,14 @@ export class PluginControlPlaneService extends Service {
                                         if (Object.keys(owner).some(key => prepared.reference.owner[key] !== owner[key])) {
                                             throw new Error('created capability owner differs from the finite grant');
                                         }
-                                        return { certificate, artifact: prepared.artifact, owner };
+                                        return { certificate, artifact: prepared.artifact, owner, ...(prepared.protocol === 'dsh-prepared-creation/v2' ? { sourceRun: prepared.plan.creation.growthRun } : {}) };
                                     },
                                     recheck: async (planId, signal) => {
                                         await this.inspectPreparedCreationReviewContext(planId, signal);
+                                        if (this.config.sourceBuild && 'backend' in this.config.sourceBuild
+                                            && this.config.sourceBuild.backend === 'linux-native') {
+                                            await this.inspectPreparedCreationLinuxBuild(planId, signal);
+                                        }
                                         if (!this.inspectVerifiedCreation(planId))
                                             throw new Error('created capability independent certificate changed');
                                     },
@@ -584,7 +658,7 @@ export class PluginControlPlaneService extends Service {
                                         return source;
                                     },
                                     inspectRetained: record => this.withRetainedCreatedCapabilityCurrent(record, () => ({
-                                        certificate: record.certificate, artifact: record.artifact, owner: config.owner
+                                        certificate: record.certificate, artifact: record.artifact, owner: config.owner, ...(this.store.getRetainedPreparedCreation(record.planId).plan.creation?.growthRun?.protocol === 'assistant-growth/source-run/v2' ? { sourceRun: this.store.getRetainedPreparedCreation(record.planId).plan.creation.growthRun } : {})
                                     })),
                                     recheckRetained: async (record, signal) => {
                                         signal.throwIfAborted();
@@ -613,9 +687,6 @@ export class PluginControlPlaneService extends Service {
                                     },
                                 } });
                             this.creationCapabilityRuntimes.add(capabilities);
-                            await capabilities.start();
-                            this.abort.signal.throwIfAborted();
-                            this.creationCapabilityRuntime = capabilities;
                             unsubscribeTaskChanges = evaluation.onTrustedTaskChange(() => this.reconcileCreatedCapabilities());
                         }
                         catch (error) {
@@ -629,17 +700,125 @@ 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,
+                                    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 ? 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 }) : undefined;
+                        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);
@@ -648,7 +827,13 @@ export class PluginControlPlaneService extends Service {
                     }
                     this.nativeSourceRunner = nativeRunner;
                     let runtime;
+                    const preparationGeneration = {};
                     try {
+                        // 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: {
@@ -661,6 +846,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),
                             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')) } : {}),
@@ -672,6 +858,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');
@@ -694,15 +886,21 @@ 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 });
                                 } } : {}),
-                            trust: () => this.boundTrust(), prepare: (job, signal, assertCurrent) => this.prepareSourceJob(job, signal, assertCurrent),
-                            ...(nativeRunner ? { inspectNativeQuiescence: (key) => nativeRunner.inspectQuiescence(key) } : {}),
+                            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) } : {}),
+                            ...(nativeRunner ? { inspectNativeQuiescence: (key) => nativeRunner.runner.inspectQuiescence(key) } : {}),
                         });
                     }
                     catch (error) {
                         if (this.nativeSourceRunner === nativeRunner)
                             this.nativeSourceRunner = undefined;
-                        await nativeRunner?.close();
+                        await nativeRunner?.runner.close();
                         unsubscribeTaskChanges?.();
+                        try {
+                            await closeRevision();
+                        }
+                        catch { /* original error wins */ }
                         if (capabilities) {
                             await capabilities.close();
                             this.creationCapabilityRuntimes.delete(capabilities);
@@ -710,6 +908,8 @@ export class PluginControlPlaneService extends Service {
                         throw error;
                     }
                     this.sourceRuntimes.add(runtime);
+                    this.creationCapabilityRuntime = capabilities;
+                    this.revisionCapabilityRuntime = revisionCapabilities;
                     const close = async () => {
                         unsubscribeTaskChanges?.();
                         if (this.sourceRuntime === runtime)
@@ -726,18 +926,30 @@ export class PluginControlPlaneService extends Service {
                         this.sourceRuntimes.delete(runtime);
                         if (this.creationCapabilityRuntime === capabilities)
                             this.creationCapabilityRuntime = undefined;
-                        const results = await Promise.allSettled([nativeRunner?.close(), capabilities?.close()]);
+                        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 {
                         runtime.start();
                         this.abort.signal.throwIfAborted();
                         this.sourceRuntime = runtime;
+                        // Producer/binding readiness can arrive while capabilities.start() is
+                        // awaiting its source checks, before these runtime fields are public.
+                        // Reconcile once after publication so that notification is not lost.
+                        this.reconcileCreatedCapabilities();
                         return close;
                     }
                     catch (error) {
@@ -782,6 +994,10 @@ export class PluginControlPlaneService extends Service {
         return discover(loaded.catalog, capability);
     }
     /** Host only: reread the exact source; no caller text or ratings are admitted. */
+    recordOwnerWorkItemFailureGap = (source) => {
+        this.abort.signal.throwIfAborted();
+        return this.taskGaps.recordWorkItem(source);
+    };
     recordOwnerTaskFailureGap = (source) => {
         this.abort.signal.throwIfAborted();
         return this.taskGaps.record(source);
@@ -1021,7 +1237,8 @@ export class PluginControlPlaneService extends Service {
     /** Host-only durable Usage reader; the caller's binding is always an expectation. */
     registerSourceGrowthRunProducer = (producer) => {
         this.abort.signal.throwIfAborted();
-        if (producer?.protocol !== 'assistant-growth-source-run-producer/v1' || typeof producer.inspect !== 'function'
+        if (!['assistant-growth-source-run-producer/v1', 'assistant-growth-source-run-producer/v2'].includes(producer?.protocol) || typeof producer.inspect !== 'function'
+            || producer.protocol === 'assistant-growth-source-run-producer/v2' && typeof producer.withWorkItemRunFence !== 'function'
             || this.growthRunProducer !== undefined || this.growthProviderDraining)
             throw new Error('plugin-control-plane: source growth run producer is invalid or already registered');
         this.growthRunProducer = producer;
@@ -1081,6 +1298,44 @@ 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 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();
@@ -1142,29 +1397,109 @@ export class PluginControlPlaneService extends Service {
     };
     /** Host-only current association of exact adopted call versions with authenticated task heads. */
     inspectCreatedCapabilityTaskAssociations = (planId) => {
+        const input = this.createdCapabilityFeedbackInput(planId);
+        if (!input)
+            return [];
+        try {
+            return inspectCreationCapabilityTaskAssociations(input());
+        }
+        catch {
+            return [];
+        }
+    };
+    /** Host-only descriptive ordinary-use counts over the same fenced associations; never causal or adoption evidence. */
+    inspectCreatedCapabilityOrdinaryUseReport = (planId) => {
+        const input = this.createdCapabilityFeedbackInput(planId);
+        if (!input)
+            return undefined;
+        try {
+            return inspectCreationCapabilityOrdinaryUseReport(input());
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** Host-only observational before/after attribution of one adoption over the owner's certified tasks; never causal. */
+    inspectCreatedCapabilityAvailabilityAttribution = (planId, options = {}) => {
+        const input = this.createdCapabilityFeedbackInput(planId);
+        if (!input)
+            return undefined;
+        try {
+            return inspectCreationCapabilityAvailabilityAttribution({ ...input(),
+                otherAdoptedAt: this.creationCapabilityRuntime?.inspectOtherAdoptionTimes(planId) ?? [],
+                ...(options.windowMs === undefined ? {} : { windowMs: options.windowMs }) });
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /**
+     * Host-only longitudinal ordinary-use series of one adoption in fixed windows with a same-scope session-cohort
+     * control and a model-stratified difference-in-differences estimate; observational, never causal. Pure read.
+     */
+    inspectCreatedCapabilityOrdinaryUseTrend = (planId, options = {}) => {
+        const input = this.createdCapabilityFeedbackInput(planId);
+        if (!input)
+            return undefined;
+        try {
+            return inspectCreationCapabilityOrdinaryUseTrend({ ...input(),
+                otherAdoptedAt: this.creationCapabilityRuntime?.inspectOtherAdoptionTimes(planId) ?? [],
+                ...(options.windowMs === undefined ? {} : { windowMs: options.windowMs }),
+                ...(options.preWindows === undefined ? {} : { preWindows: options.preWindows }),
+                ...(options.maxPostWindows === undefined ? {} : { maxPostWindows: options.maxPostWindows }) });
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /**
+     * 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`);
+     * rows are never rewritten. Still observational (`causal: false`); never adoption or revocation evidence.
+     */
+    sealCreatedCapabilityOrdinaryUseTrendSnapshot = (planId, options = {}) => {
+        const trend = this.inspectCreatedCapabilityOrdinaryUseTrend(planId, options);
+        if (!trend)
+            return undefined;
+        try {
+            return this.store.sealCreatedCapabilityTrendSnapshot(trend);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** Host-only bounded newest-first read of sealed trend snapshots; undefined on invalid query or any tampered row. */
+    inspectCreatedCapabilityOrdinaryUseTrendSnapshots = (query = {}) => {
+        try {
+            this.abort.signal.throwIfAborted();
+            return this.store.listCreatedCapabilityTrendSnapshots(query);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** The historical read is deferred so callers keep it inside their own failure boundary. */
+    createdCapabilityFeedbackInput(planId) {
         this.abort.signal.throwIfAborted();
         const snapshot = this.creationCapabilityRuntime?.inspectAssociationEvidence(planId);
         if (!snapshot || !this.config.creationCapabilities)
-            return [];
+            return undefined;
         const owner = this.config.creationCapabilities.owner;
         const evaluation = this.ctx.get('assistantEvaluation', false);
         const delivery = this.ctx.get('assistantDelivery', false);
         if (!evaluation || !delivery)
-            return [];
-        try {
+            return undefined;
+        return () => {
             const historical = this.store.getRetainedPreparedCreation(planId);
-            return inspectCreationCapabilityTaskAssociations({ ...snapshot, owner, evaluation, delivery,
+            return { ...snapshot, owner, evaluation, delivery,
                 triggerInboxId: historical.reference.projection.subjectRef,
                 readSourceCurrent: () => {
                     this.assertCreatedCapabilityAssociationSource(snapshot.record);
                     const current = this.taskGaps.inspectCurrent(historical.plan.gapId, historical.reference.owner);
                     return { projection: current.canonical.projection, scopeWatermark: current.canonical.scopeWatermark };
-                } });
-        }
-        catch {
-            return [];
-        }
-    };
+                } };
+        };
+    }
     /** Exact historical certificate and source check without nesting an Evaluation writer fence. */
     assertCreatedCapabilityAssociationSource(record) {
         this.abort.signal.throwIfAborted();
@@ -1252,11 +1587,113 @@ export class PluginControlPlaneService extends Service {
                     !== ownerGrant[key])) {
                 throw new Error('created capability retained source binding changed');
             }
+            if (growth.protocol === 'assistant-growth/source-run/v2') {
+                if (reference.schemaVersion !== 2 || growth.ownerDigest !== controlPlaneDigest(reference.owner))
+                    throw new Error('retained work item reference changed');
+                assertWorkItemRunReference(growth, reference);
+                this.assertWorkItemPinsLocal(growth, 'retained');
+                return callback(growth);
+            }
+            return callback();
+        });
+    }
+    inspectWorkItemPreparedCreationProtocol = () => {
+        return !this.abort.signal.aborted && this.config.sourceJobs?.creation?.workItemFailures === true && this.sourceRuntime?.available() ? 'dsh-prepared-creation/v2' : undefined;
+    };
+    inspectWorkItemCreationReadiness = (input) => {
+        try {
+            this.abort.signal.throwIfAborted();
+            const owner = inertCreationData(input).owner, config = this.config, source = this.sourceRuntime?.inspectWorkItemReadiness(owner);
+            if (!source || !config.sourceJobs || !config.sourceBuild || config.sourceJobs.creation?.workItemFailures !== true || config.creationCapabilities?.workItemFailures !== true || !config.creationVerifications)
+                return undefined;
+            const delivery = this.ctx.get('assistantDelivery', false);
+            const verifier = this.ctx.get('assistantVerifier', false);
+            if (typeof delivery?.withOwnerWorkItemEngineeringContextFence !== 'function' || typeof verifier?.inspectWorkItemCreationReviewReadiness !== 'function' || typeof this.creationCapabilityRuntime?.inspectWorkItemAdoptionReadiness !== 'function')
+                return undefined;
+            const actual = delivery.validateOwnerRoute({ authorityId: owner.authorityId, principalId: owner.principalId, workspace: owner.workspace, agentPreset: owner.agentPreset });
+            if (!isSourceOwnerContinuation(actual, owner) || Object.entries(config.creationCapabilities.owner).some(([key, value]) => actual[key] !== value))
+                return undefined;
+            const review = verifier.inspectWorkItemCreationReviewReadiness(), adoption = this.creationCapabilityRuntime.inspectWorkItemAdoptionReadiness();
+            if (!review || !adoption || review.protocol !== 'assistant-growth/work-item-review-readiness/v1' || adoption.protocol !== 'assistant-growth/work-item-adoption-readiness/v1'
+                || review.sourceProtocol !== WORK_ITEM_ENGINEERING_PROTOCOL || adoption.sourceProtocol !== WORK_ITEM_ENGINEERING_PROTOCOL || review.runProtocol !== 'assistant-growth/source-run/v2' || adoption.runProtocol !== 'assistant-growth/source-run/v2'
+                || review.workItemFailures !== true || adoption.workItemFailures !== true || controlPlaneDigest(review.authority) !== controlPlaneDigest(config.creationVerifications.authority)
+                || !createPublicKey(review.publicKey).export({ type: 'spki', format: 'der' }).equals(createPublicKey(config.creationVerifications.publicKey).export({ type: 'spki', format: 'der' }))
+                || adoption.authority.authorityDigest !== creationCapabilityAuthorityDigest({ path: join(config.statePath, 'creation-adoptions.sqlite'), config: config.creationCapabilities })
+                || adoption.authority.authorityId !== config.creationCapabilities.authorityId || adoption.authority.expiresAt !== config.creationCapabilities.expiresAt)
+                return undefined;
+            const pins = { protocol: 'assistant-growth/work-item-authorities/v1', sourceJobs: { authorityId: source.authority.id, authorityDigest: source.authority.digest, expiresAt: source.authority.expiresAt },
+                creationGrant: { id: source.creation.id, digest: controlPlaneDigest(source.creation), expiresAt: source.creation.expiresAt }, creationAcceptance: structuredClone(review.authority), adoption: structuredClone(adoption.authority) };
+            validateWorkItemGrowthAuthorityPins(pins);
+            if (source.authority.digest !== controlPlaneDigest({ config: config.sourceJobs, build: config.sourceBuild }) || [pins.sourceJobs.expiresAt, pins.creationGrant.expiresAt, pins.creationAcceptance.expiresAt, pins.adoption.expiresAt].some(expiry => Date.now() >= expiry))
+                return undefined;
+            const remaining = { ...source.remaining, verifications: review.remainingVerifications, adoptions: adoption.remainingAdoptions };
+            if (Object.values(remaining).some(count => !Number.isSafeInteger(count) || count < 0))
+                return undefined;
+            return { protocol: 'assistant-growth/work-item-creation-readiness/v1', sourceProtocol: WORK_ITEM_ENGINEERING_PROTOCOL, runProtocol: 'assistant-growth/source-run/v2', workItemFailures: true, pins, remaining, available: Object.values(remaining).every(count => count > 0) && review.available && adoption.available };
+        }
+        catch {
+            return undefined;
+        }
+    };
+    assertWorkItemPinsLocal(run, phase = 'current') {
+        const jobs = this.config.sourceJobs, verification = this.config.creationVerifications, adoption = this.config.creationCapabilities;
+        if (!jobs || !this.config.sourceBuild || jobs.creation?.workItemFailures !== true || !verification || adoption?.workItemFailures !== true
+            || 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.creationGrant.id !== jobs.creation.id || run.authorities.creationGrant.digest !== controlPlaneDigest(jobs.creation) || run.authorities.creationGrant.expiresAt !== jobs.creation.expiresAt
+            || controlPlaneDigest(run.creationAcceptance) !== controlPlaneDigest(verification.authority) || controlPlaneDigest(run.authorities.creationAcceptance) !== controlPlaneDigest(verification.authority)
+            || run.authorities.adoption.authorityId !== adoption.authorityId || run.authorities.adoption.authorityDigest !== creationCapabilityAuthorityDigest({ path: join(this.config.statePath, 'creation-adoptions.sqlite'), config: adoption }) || run.authorities.adoption.expiresAt !== adoption.expiresAt
+            || (phase === 'current' ? [run.authorities.sourceJobs.expiresAt, run.authorities.creationGrant.expiresAt, run.authorities.creationAcceptance.expiresAt, run.authorities.adoption.expiresAt] : [run.authorities.adoption.expiresAt]).some(expiry => Date.now() >= expiry))
+            throw new Error('work item creation authority pins changed or expired');
+    }
+    assertWorkItemRunLocal(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 creation owner reference changed');
+        assertWorkItemRunReference(run, reference);
+        this.assertWorkItemPinsLocal(run);
+        if (Date.now() >= run.expiresAt || generation && Date.now() >= run.generationDeadlineAt)
+            throw new Error('work item source run expired');
+        if (run.modelOrigin === 'inherited-owner-task' && this.workItemCreationFrame && controlPlaneDigest(this.workItemCreationFrame.source.task.proofIdentity.supplier) !== controlPlaneDigest(run.model))
+            throw new Error('work item source supplier changed');
+    }
+    withWorkItemGrowthFrame(run, gapId, owner, generation, callback) {
+        this.abort.signal.throwIfAborted();
+        if (this.workItemCreationFrame) {
+            if (this.workItemCreationFrame.gapId !== gapId || sourceGrowthRunDigest(this.workItemCreationFrame.run) !== sourceGrowthRunDigest(run))
+                throw new Error('work item growth frame reentry');
+            this.assertWorkItemRunLocal(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 growth producer unavailable');
+        const readiness = this.inspectWorkItemCreationReadiness({ owner });
+        if (!readiness)
+            throw new SourceGrowthRunUnavailableError('work item growth peers unavailable');
+        if (controlPlaneDigest(readiness.pins) !== controlPlaneDigest(run.authorities))
+            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)
+                throw new Error('work item producer changed its true binding');
+            this.workItemCreationFrame = { gapId, run: actual, source };
+            try {
+                return this.store.withOwnerTaskFailureGapAdmission(gapId, () => { this.assertWorkItemRunLocal(actual, gapId, owner, generation); return callback(); });
+            }
+            finally {
+                this.workItemCreationFrame = undefined;
+            }
         });
     }
     assertSourceGrowthRun(expected, gapId, owner, generation) {
         validateSourceGrowthRunBinding(expected);
+        if (expected.protocol === 'assistant-growth/source-run/v2') {
+            if (this.workItemCreationFrame) {
+                this.assertWorkItemRunLocal(expected, gapId, owner, generation);
+                return;
+            }
+            return this.withWorkItemGrowthFrame(expected, gapId, owner, generation, () => { });
+        }
         const producer = this.growthRunProducer;
         if (!producer)
             throw new SourceGrowthRunUnavailableError('source growth run producer unavailable');
@@ -1264,6 +1701,8 @@ export class PluginControlPlaneService extends Service {
         if (!actual)
             throw new Error('source growth run is absent or no longer current');
         validateSourceGrowthRunBinding(actual);
+        if (actual.protocol !== 'assistant-growth/source-run/v1')
+            throw new Error('foreground source cannot use a work item run');
         if (sourceGrowthRunDigest(actual) !== sourceGrowthRunDigest(expected)
             || expected.ownerDigest !== controlPlaneDigest(owner))
             throw new Error('source growth run immutable binding changed');
@@ -1282,7 +1721,7 @@ export class PluginControlPlaneService extends Service {
             throw new Error('source growth run creation acceptance policy changed or was not pinned before authoring');
         }
         const reference = this.store.getOwnerTaskFailureReference(gapId);
-        if (!reference || expected.source.outcomeId !== reference.outcomeId
+        if (!reference || reference.schemaVersion !== 1 || expected.source.outcomeId !== reference.outcomeId
             || expected.source.sourceDigest !== reference.sourceDigest
             || controlPlaneDigest(expected.source.projection) !== controlPlaneDigest(reference.projection)
             || expected.ownerDigest !== controlPlaneDigest(reference.owner))
@@ -1306,6 +1745,12 @@ export class PluginControlPlaneService extends Service {
             || Date.now() >= plan.expiresAt || !plan.creation || Date.now() >= plan.creation.grant.expiresAt) {
             throw new Error('prepared creation package is unavailable for independent verification');
         }
+        if (reference.schemaVersion === 2) {
+            const run = plan.creation.growthRun;
+            if (run?.protocol !== 'assistant-growth/source-run/v2')
+                throw new Error('work item prepared creation run unavailable');
+            return this.withWorkItemGrowthFrame(run, plan.gapId, reference.owner, false, () => ({ protocol: 'dsh-prepared-creation/v2', plan: structuredClone(this.store.getSourcePlan(plan.id)), job: structuredClone(this.store.getPreparedSourceJob(plan.id)), reference: structuredClone(reference), source: structuredClone(this.workItemCreationFrame.source), artifact: this.store.readPreparedSourceArtifact(plan.id) }));
+        }
         return this.taskGaps.withCurrent(plan.gapId, reference.owner, () => {
             this.abort.signal.throwIfAborted();
             const job = this.store.getPreparedSourceJob(plan.id);
@@ -1339,6 +1784,17 @@ export class PluginControlPlaneService extends Service {
         const reference = this.store.getOwnerTaskFailureReference(plan.gapId);
         if (!reference)
             throw new Error('creation verification source unavailable');
+        if (reference.schemaVersion === 2) {
+            const run = plan.creation?.growthRun;
+            if (run?.protocol !== 'assistant-growth/source-run/v2')
+                throw new Error('work item verification run unavailable');
+            return this.withWorkItemGrowthFrame(run, plan.gapId, reference.owner, false, () => {
+                const current = this.store.getSourcePlan(input.planId), job = this.store.getPreparedSourceJob(input.planId);
+                if (current.digest !== input.planDigest || current.preparedEvidence?.pack.sha256 !== input.artifactSha256 || controlPlaneDigest(reference) !== input.referenceDigest || sourceGrowthRunDigest(run) !== input.growthRunDigest || !job.intent.creation?.growthRun || sourceGrowthRunDigest(job.intent.creation.growthRun) !== input.growthRunDigest || createHash('sha256').update(this.store.readPreparedSourceArtifact(input.planId)).digest('hex') !== input.artifactSha256)
+                    throw new Error('work item prepared verification exact binding changed');
+                return callback(run);
+            });
+        }
         return this.taskGaps.withCurrent(plan.gapId, reference.owner, () => {
             this.abort.signal.throwIfAborted();
             const current = this.store.getSourcePlan(input.planId);
@@ -1382,6 +1838,105 @@ export class PluginControlPlaneService extends Service {
         current();
         return review;
     };
+    /** Host-only read of the original successful build; never admits or replays a job. */
+    inspectPreparedCreationLinuxBuild = async (planId, signal) => {
+        const combined = AbortSignal.any([this.abort.signal, signal, AbortSignal.timeout(120_000)]);
+        combined.throwIfAborted();
+        const prepared = this.inspectPreparedCreation(planId), build = this.config.sourceBuild;
+        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'
+            || evidence?.schemaVersion !== 3 || evidence.boundary !== 'linux-native-repository-v1'
+            || !('backend' in prepared.job.intent.build) || prepared.job.intent.build.backend !== 'linux-native'
+            || prepared.job.intent.nativeResource?.backend !== 'linux-native' || prepared.job.intent.nativeResource.key !== prepared.job.id
+            || evidence.runtimeDigest !== linuxRuntimeDigest(build.runtime)
+            || evidence.runtimeDigest !== native.runner.runtimeDigest || evidence.executionContractDigest !== native.runner.contractDigest
+            || evidence.buildScriptSha256 !== createHash('sha256').update(LINUX_PREPARED_SOURCE_BUILD_SCRIPT).digest('hex')) {
+            throw new Error('creation verification Linux build binding unavailable');
+        }
+        const evidenceDigest = controlPlaneDigest(evidence);
+        const current = () => this.withPreparedCreationFence({ planId, planDigest: prepared.plan.digest,
+            artifactSha256: evidence.pack.sha256, growthRunDigest: sourceGrowthRunDigest(prepared.plan.creation.growthRun),
+            referenceDigest: controlPlaneDigest(prepared.reference) }, () => {
+            combined.throwIfAborted();
+            if (this.nativeSourceRunner !== native || this.config.sourceBuild !== build || Date.now() >= build.expiresAt
+                || controlPlaneDigest(this.store.getSourcePlan(planId).preparedEvidence) !== evidenceDigest
+                || controlPlaneDigest(this.store.getPreparedSourceJob(planId)) !== controlPlaneDigest(prepared.job)) {
+                throw new Error('creation verification Linux build authority changed');
+            }
+        });
+        current();
+        if (controlPlaneDigest(await this.boundTrust()) !== prepared.job.intent.trustDigest)
+            throw new Error('creation verification trust changed');
+        await verifyLinuxRuntime(build.runtime, combined);
+        current();
+        const execution = await native.runner.inspectSuccessfulExecution(prepared.job.id, combined);
+        current();
+        const artifact = execution?.artifacts[0];
+        if (!execution || execution.runtimeDigest !== evidence.runtimeDigest || execution.contractDigest !== evidence.executionContractDigest
+            || execution.result.status !== 'succeeded' || !execution.result.quiescent || execution.result.exitCode !== 0
+            || !execution.receiptBinding || controlPlaneDigest(execution.receiptBinding) !== controlPlaneDigest(evidence.receipt)
+            || execution.artifacts.length !== 1 || artifact?.path !== LINUX_SOURCE_PACK_PATH || artifact.sha256 !== evidence.pack.sha256
+            || artifact.bytes.length !== evidence.pack.sizeBytes || !Buffer.from(artifact.bytes).equals(prepared.artifact)
+            || createHash('sha256').update((execution.result.stdout ?? '') + '\0' + (execution.result.stderr ?? '')).digest('hex') !== evidence.logDigest) {
+            throw new Error('creation verification original Linux build receipt or artifact changed');
+        }
+        if (controlPlaneDigest(await this.boundTrust()) !== prepared.job.intent.trustDigest)
+            throw new Error('creation verification trust changed');
+        await verifyLinuxRuntime(build.runtime, combined);
+        current();
+        return { runtime: structuredClone(build.runtime), evidenceDigest };
+    };
+    /** Host-only read of the original successful revision build; never admits or replays a job. */
+    inspectPreparedRevisionLinuxBuild = async (planId, signal) => {
+        const combined = AbortSignal.any([this.abort.signal, signal, AbortSignal.timeout(120_000)]);
+        combined.throwIfAborted();
+        const prepared = this.inspectPreparedRevision(planId), build = this.config.sourceBuild;
+        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'
+            || evidence?.schemaVersion !== 3 || evidence.boundary !== 'linux-native-repository-v1'
+            || !('backend' in prepared.job.intent.build) || prepared.job.intent.build.backend !== 'linux-native'
+            || prepared.job.intent.nativeResource?.backend !== 'linux-native' || prepared.job.intent.nativeResource.key !== prepared.job.id
+            || evidence.runtimeDigest !== linuxRuntimeDigest(build.runtime)
+            || evidence.runtimeDigest !== native.runner.runtimeDigest || evidence.executionContractDigest !== native.runner.contractDigest
+            || evidence.buildScriptSha256 !== createHash('sha256').update(LINUX_PREPARED_SOURCE_BUILD_SCRIPT).digest('hex')) {
+            throw new Error('revision verification Linux build binding unavailable');
+        }
+        const sourceRevision = prepared.plan.sourceRevision;
+        const evidenceDigest = controlPlaneDigest(evidence);
+        const current = () => this.withPreparedRevisionFence({ planId, planDigest: prepared.plan.digest,
+            artifactSha256: evidence.pack.sha256, growthRunDigest: sourceGrowthRunDigest(sourceRevision.growthRun),
+            referenceDigest: controlPlaneDigest(prepared.reference), parentDigest: controlPlaneDigest(sourceRevision.parent) }, () => {
+            combined.throwIfAborted();
+            if (this.nativeSourceRunner !== native || this.config.sourceBuild !== build || Date.now() >= build.expiresAt
+                || controlPlaneDigest(this.store.getSourcePlan(planId).preparedEvidence) !== evidenceDigest
+                || controlPlaneDigest(this.store.getPreparedRevisionJob(planId)) !== controlPlaneDigest(prepared.job)) {
+                throw new Error('revision verification Linux build authority changed');
+            }
+        });
+        current();
+        if (controlPlaneDigest(await this.boundTrust()) !== prepared.job.intent.trustDigest)
+            throw new Error('revision verification trust changed');
+        await verifyLinuxRuntime(build.runtime, combined);
+        current();
+        const execution = await native.runner.inspectSuccessfulExecution(prepared.job.id, combined);
+        current();
+        const artifact = execution?.artifacts[0];
+        if (!execution || execution.runtimeDigest !== evidence.runtimeDigest || execution.contractDigest !== evidence.executionContractDigest
+            || execution.result.status !== 'succeeded' || !execution.result.quiescent || execution.result.exitCode !== 0
+            || !execution.receiptBinding || controlPlaneDigest(execution.receiptBinding) !== controlPlaneDigest(evidence.receipt)
+            || execution.artifacts.length !== 1 || artifact?.path !== LINUX_SOURCE_PACK_PATH || artifact.sha256 !== evidence.pack.sha256
+            || artifact.bytes.length !== evidence.pack.sizeBytes || !Buffer.from(artifact.bytes).equals(prepared.artifact)
+            || createHash('sha256').update((execution.result.stdout ?? '') + '\0' + (execution.result.stderr ?? '')).digest('hex') !== evidence.logDigest) {
+            throw new Error('revision verification original Linux build receipt or artifact changed');
+        }
+        if (controlPlaneDigest(await this.boundTrust()) !== prepared.job.intent.trustDigest)
+            throw new Error('revision verification trust changed');
+        await verifyLinuxRuntime(build.runtime, combined);
+        current();
+        return { runtime: structuredClone(build.runtime), evidenceDigest };
+    };
     /** Signed behavior evidence over stored pack/checks. Adoption must await async review-context recheck. */
     inspectVerifiedCreation = (planId) => {
         const certificate = this.store.getCreationVerification(planId);
@@ -1691,13 +2246,21 @@ export class PluginControlPlaneService extends Service {
             throw new Error('plugin-control-plane: durable source jobs unavailable or still draining');
         return this.sourceRuntime.reconcileUnknown(input);
     };
-    async prepareSourceJob(job, signal, assertCurrent) {
+    async prepareSourceJob(job, signal, assertCurrent, preflight) {
         this.abort.signal.throwIfAborted();
-        if (this.sourceBuilds.size !== 0 || this.sourceInspections.size !== 0)
-            throw new Error('plugin-control-plane: another source operation is draining');
+        if (this.sourceBuilds.size !== 0 || this.sourceInspections.size !== 0) {
+            const error = new Error('plugin-control-plane: another source operation is draining');
+            // This call has not created an operation/worktree or called a runner.
+            if (preflight && job.intent.nativeResource?.backend === 'linux-native' && job.intent.nativeResource.key === job.id
+                && controlPlaneDigest(job.intent) === job.intentDigest) {
+                throw cleanedLinuxSourcePreflight(error, job, preflight.generation, () => !this.abort.signal.aborted
+                    && this.nativeSourceRunner?.backend === 'linux-native' && this.nativeSourceRunner.runner === preflight.runner);
+            }
+            throw error;
+        }
         const intent = job.intent;
         const operation = this.prepareSourcePlanOwned({ gapId: intent.gapId, name: intent.name, repository: intent.repository, files: intent.files,
-            idempotencyKey: `source-job-plan:${job.id}`, expectedBaseCommit: intent.baseCommit, ttlMs: intent.ttlMs, timeoutMs: intent.build.timeoutMs, offline: true, signal, assertCurrent }, job);
+            idempotencyKey: `source-job-plan:${job.id}`, expectedBaseCommit: intent.baseCommit, ttlMs: intent.ttlMs, timeoutMs: intent.build.timeoutMs, offline: true, signal, assertCurrent }, job, preflight);
         this.sourceBuilds.add(operation);
         try {
             return await operation;
@@ -2016,7 +2579,7 @@ export class PluginControlPlaneService extends Service {
         void operation.then(() => this.sourceBuilds.delete(operation), () => this.sourceBuilds.delete(operation));
         return operation;
     }
-    async prepareSourcePlanOwned(input, sourceJob) {
+    async prepareSourcePlanOwned(input, sourceJob, preflight) {
         const signal = input.signal === undefined ? this.abort.signal : AbortSignal.any([this.abort.signal, input.signal]);
         const gapOwner = sourceJob?.intent.owner ?? input.owner;
         const creating = sourceJob?.intent.mode === 'create';
@@ -2065,8 +2628,10 @@ export class PluginControlPlaneService extends Service {
         if (!Number.isSafeInteger(ttlMs) || ttlMs < 900_000 || ttlMs > 86_400_000) {
             throw new ControlPlaneCliError('INVALID_ARGUMENT', 'ttlMs must be an integer within 900000..86400000');
         }
-        const maximumTimeoutMs = this.config.sourceBuild !== undefined && !('backend' in this.config.sourceBuild)
-            && ['repository', 'portable-repository'].includes(this.config.sourceBuild.profile ?? '') ? 1_800_000 : 240_000;
+        const buildConfig = this.config.sourceBuild;
+        const repositoryBuild = buildConfig !== undefined && ('backend' in buildConfig
+            ? buildConfig.backend === 'linux-native' : ['repository', 'portable-repository'].includes(buildConfig.profile ?? ''));
+        const maximumTimeoutMs = repositoryBuild ? 1_800_000 : 240_000;
         const timeoutMs = input.timeoutMs ?? 180_000;
         if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 60_000 || timeoutMs > maximumTimeoutMs) {
             throw new ControlPlaneCliError('INVALID_ARGUMENT', `timeoutMs must be an integer within 60000..${maximumTimeoutMs}`);
@@ -2087,6 +2652,7 @@ export class PluginControlPlaneService extends Service {
         const stateRoot = join(this.config.statePath, 'source-worktrees');
         const isolated = await createIsolatedWorktree({ stateRoot, repository, baseCommit, environment,
             ...(sourceJob === undefined ? {} : { worktreeName: basename(sourceJob.intent.worktree) }) });
+        let linuxBuildInvoked = false;
         try {
             const generated = revision !== undefined ? await prepareRevisedPluginWorkspace({ worktree: isolated.worktree,
                 baseCommit, name, files: input.files, environment, signal, assertCurrent, revision, parentSource: parent.source, parentCertificate: parent.certificate })
@@ -2116,12 +2682,21 @@ export class PluginControlPlaneService extends Service {
                         parentCertificate: parent.certificate, files: input.files } }), ...(capturePack ? { capturePack: true } : {}) };
             const checked = 'backend' in configured
                 ? await (async () => {
-                    if ((!creating && !revising) || sourceJob === undefined || this.nativeSourceRunner === undefined
-                        || sourceJob.intent.nativeResource?.key !== sourceJob.id) {
-                        throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'native source preparation requires a durable Host-scaffolded creation job');
+                    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: this.nativeSourceRunner, sourceJob: { id: sourceJob.id } });
+                        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 } }) });
@@ -2145,7 +2720,15 @@ export class PluginControlPlaneService extends Service {
             }
             // The worktree survives success: the owner recomputes its digests on this
             // exact directory during `source verify-prepared`.
-            return this.taskGaps.withCurrent(input.gapId, gapOwner, () => this.store.createSourcePlan({ gapId: input.gapId, repository, worktree: isolated.worktree, baseCommit,
+            const commitSource = (callback) => {
+                if (creation?.growthRun?.protocol === 'assistant-growth/source-run/v2') {
+                    if (!gapOwner || !('receiptVersion' in gapOwner))
+                        throw new Error('work item creation owner unavailable');
+                    return this.withWorkItemGrowthFrame(creation.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,
                 name, generatorDigest: generated?.generatorDigest ?? MODIFY_GENERATOR_DIGEST,
                 scope: generated?.scope ?? [`plugins/${name}`], mode: creating ? 'prepared-create' : revising ? 'prepared-revise' : 'modify', ttlMs,
                 ...(creation === undefined ? {} : { creation }), ...(revision === undefined ? {} : { revision }),
@@ -2156,6 +2739,19 @@ export class PluginControlPlaneService extends Service {
         }
         catch (error) {
             await isolated.remove();
+            if (preflight && sourceJob && sourceJob.intent.nativeResource?.backend === 'linux-native'
+                && sourceJob.intent.nativeResource.key === sourceJob.id && controlPlaneDigest(sourceJob.intent) === sourceJob.intentDigest) {
+                // Preserve native authority checks across asynchronous worktree cleanup.
+                // The runtime consumes the complete chain immediately before its original claim CAS.
+                if (linuxBuildInvoked && isLinuxSourceBuildFailed(error)) {
+                    throw cleanedLinuxSourceBuildFailure(error, sourceJob, preflight.generation, () => !this.abort.signal.aborted && this.nativeSourceRunner?.backend === 'linux-native'
+                        && this.nativeSourceRunner.runner === preflight.runner
+                        ? consumeLinuxSourceBuildFailed(error, { runner: preflight.runner, key: sourceJob.id }) : undefined);
+                }
+                throw cleanedLinuxSourcePreflight(error, sourceJob, preflight.generation, () => !this.abort.signal.aborted && this.nativeSourceRunner?.backend === 'linux-native'
+                    && this.nativeSourceRunner.runner === preflight.runner
+                    && (!linuxBuildInvoked || consumeLinuxSourceNotStarted(error, { runner: preflight.runner, key: sourceJob.id })));
+            }
             throw error;
         }
     }