@dsh-enhanced/plugin-control-plane 0.1.47 → 0.1.49

package/lib/service.js

@@ -1,15 +1,22 @@
 import { AdoptionCoordinatorRuntime, validateAdoptionCoordinatorConfig } from './adoption-coordinator.js';
-import { lstat, realpath } from 'node:fs/promises';
+import { CreationCapabilityJournal, creationCapabilityPublicKey, validateCreationCapabilityConfig } from './creation-capability-journal.js';
+import { CreationCapabilityRuntime } from './creation-capability-runtime.js';
+import { 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 { TaskObservationRuntime, validateTaskObservationConfig } from './task-observation-runtime.js';
+import { LiveQualificationRuntime, validateLiveQualificationConfig } from './live-qualification-runtime.js';
 import { rollbackPluginWatch } from './cli.js';
 import { OwnerTaskFailureGaps } from './owner-task-gaps.js';
 import { Context, Service } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
 import { discover, loadCatalogWithMetadata } from './catalog.js';
 import { ControlPlaneCliError } from './errors.js';
-import { assertPluginModificationAllowed, createIsolatedWorktree, gcPreparedModifyWorktrees, runLocalCommand, validateScopedPluginFiles, verifyPreparedSourceWorktree, writeScopedPluginFiles, } from './source-workspace.js';
+import { assertPluginModificationAllowed, createIsolatedWorktree, gcPreparedModifyWorktrees, inspectPreparedCreationPatch, runLocalCommand, validateScopedPluginFiles, verifyPreparedSourceWorktree, writeScopedPluginFiles, } from './source-workspace.js';
 import { assertManagedVersionPaths, managedPatchVersionFiles, verifyManagedPatchVersion } from './source-versioning.js';
 import { requestSourceApproval, validateSourceApprovalClientConfig } from './source-approval-client.js';
 import { requestSourceReleaseAuthorization, validateSourceReleaseClientConfig } from './source-release-client.js';
@@ -19,19 +26,31 @@ import { adoptSourceRelease, validateSourceAdoptionConfig } from './source-adopt
 import { Ed25519ApprovalAuthority } from './approval.js';
 import { ControlPlaneStore, MODIFY_GENERATOR_DIGEST, controlPlaneDigest } from './store.js';
 import { runDockerPreparedChecks, validateSourceBuildConfig } from './source-build.js';
-import { awaitSourceSignal, inspectSourceContext } from './source-context.js';
+import { awaitSourceSignal, inspectSourceContext, inspectSourceTargetsContext } from './source-context.js';
+import { inspectSourceRevisionContext, prepareRevisedPluginWorkspace, verifyRevisedPluginWorkspace } from './source-revision.js';
+import { inspectSourceCreationContext, prepareCreatedPluginWorkspace, validateSourceCreationFiles, verifyCreatedPluginWorkspace } from './source-creation.js';
+import { resolveSourceBaseline } from './source-baseline.js';
 import { inheritedEnvironment, loadTrustConfig, resolveTrustKey } from './trust.js';
 import { registerPluginControlTools } from './tools.js';
-import { SourceJobRuntime, validateSourceJobsConfig } from './source-jobs.js';
+import { SourceGrowthRunUnavailableError, SourceJobRuntime, validateSourceJobsConfig } 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';
-import { createForegroundDeploymentObserver, foregroundTrustSnapshot, validateForegroundDeploymentConfig } from './foreground-deployment-runtime.js';
+import { createForegroundDeploymentObserver, foregroundTrustSnapshot, queueRuntimeEpoch, validateForegroundDeploymentConfig } from './foreground-deployment-runtime.js';
+import { captureRetainedDeploymentReadiness } from './deployment-readiness.js';
+import { installHostReadiness, onHostReady } from './host-readiness.js';
+const CREATION_UNKNOWN_CODES = new Set(['schema-observation-unknown', 'case-observation-unknown', 'contract-insufficient',
+    'interrupted', 'stale-source', 'verification-unknown', 'previous-unknown']);
+const CREATION_REJECTED_CODES = new Set(['case-mismatch', 'source-review-rejected', 'request-invalid']);
 const schema = Schema.object({
     catalogPath: Schema.string().required(), statePath: Schema.string().required(), trustPath: Schema.string().required(),
     proposalTtlMs: Schema.number().step(1).min(60_000).max(86_400_000).default(900_000),
     sourceBuild: Schema.any(),
     sourceJobs: Schema.any(),
+    creationVerifications: Schema.any(),
+    revisionVerifications: Schema.any(),
+    revisionRegressions: Schema.any(),
+    creationCapabilities: Schema.any(),
     sourceApprovals: Schema.any(),
     sourceReleases: Schema.any(),
     sourceReleaseExecution: Schema.any(),
@@ -40,6 +59,7 @@ const schema = Schema.object({
     runtimeObserver: Schema.any(),
     foregroundDeployments: Schema.any(),
     taskObservations: Schema.any(),
+    liveQualification: Schema.any(),
     replayEndpoint: Schema.any(),
 });
 async function canonicalTarget(dshHome, profile) {
@@ -81,6 +101,17 @@ export function normalizeControlPlaneConfig(input) {
             throw new Error('plugin-control-plane: taskObservations requires foregroundDeployments on the same profile');
         }
     }
+    if (config.liveQualification !== undefined) {
+        validateLiveQualificationConfig(config.liveQualification);
+        if (!config.foregroundDeployments || config.liveQualification.profilePath !== config.runtimeObserver?.profilePath) {
+            throw new Error('plugin-control-plane: liveQualification requires foregroundDeployments on the same profile');
+        }
+        if (!config.sourceAdoptions?.liveQualification || !config.sourceReleaseExecution?.independentReview
+            || !config.taskObservations || config.taskObservations.profilePath !== config.liveQualification.profilePath
+            || config.sourceAdoptions.profile !== basename(config.liveQualification.profilePath)) {
+            throw new Error('plugin-control-plane: liveQualification requires independently reviewed sourceAdoptions');
+        }
+    }
     if (config.replayEndpoint !== undefined) {
         validateReplayEndpointConfig(config.replayEndpoint);
         if (config.runtimeObserver !== undefined) {
@@ -122,12 +153,84 @@ export function normalizeControlPlaneConfig(input) {
         validateSourceAdoptionConfig(config.sourceAdoptions);
         if (!config.sourceReleaseExecution)
             throw new Error('plugin-control-plane: sourceAdoptions requires sourceReleaseExecution');
+        if (config.sourceAdoptions.liveQualification && !config.liveQualification) {
+            throw new Error('plugin-control-plane: bounded-live sourceAdoptions requires liveQualification runtime');
+        }
     }
     if (config.sourceJobs !== undefined) {
         validateSourceJobsConfig(config.sourceJobs, config.sourceBuild);
         if (realpathSync(config.sourceJobs.repository) !== config.sourceJobs.repository)
             throw new Error('plugin-control-plane: sourceJobs.repository must be canonical');
     }
+    if (config.creationVerifications !== undefined) {
+        const policy = config.creationVerifications;
+        if (!policy || typeof policy !== 'object' || Array.isArray(policy)
+            || Object.keys(policy).sort().join(',') !== 'authority,publicKey'
+            || typeof policy.publicKey !== 'string' || policy.publicKey.length > 4096) {
+            throw new Error('plugin-control-plane: invalid creation verification configuration');
+        }
+        validateCreationAcceptanceAuthorityRef(policy.authority);
+        let key;
+        try {
+            key = createPublicKey(policy.publicKey);
+        }
+        catch {
+            throw new Error('plugin-control-plane: creation verification public key is invalid');
+        }
+        if (!policy.publicKey.startsWith('-----BEGIN PUBLIC KEY-----\n') || key.asymmetricKeyType !== 'ed25519' || key.type !== 'public'
+            || key.export({ format: 'pem', type: 'spki' }).toString() !== policy.publicKey
+            || (policy.authority.expiresAt <= Date.now() && config.creationCapabilities?.retention === undefined)
+            || !config.sourceJobs?.creation || policy.authority.namePrefix !== config.sourceJobs.creation.namePrefix
+            || policy.authority.expiresAt > Math.min(config.sourceJobs.creation.expiresAt, config.sourceJobs.expiresAt)) {
+            throw new Error('plugin-control-plane: creation verification authority does not match finite source creation grant');
+        }
+    }
+    if (config.revisionVerifications !== undefined || config.sourceJobs?.revision !== undefined) {
+        const policy = config.revisionVerifications, grant = config.sourceJobs?.revision;
+        if (!policy || !grant || !config.creationCapabilities || !config.sourceJobs
+            || Object.keys(policy).sort().join(',') !== 'authority,publicKey' || typeof policy.publicKey !== 'string') {
+            throw new Error('plugin-control-plane: revision verification requires its separate finite grant and retained adopted source');
+        }
+        validateRevisionAcceptanceAuthorityRef(policy.authority);
+        const key = createPublicKey(policy.publicKey);
+        if (key.asymmetricKeyType !== 'ed25519' || policy.authority.namePrefix !== grant.namePrefix
+            || policy.authority.expiresAt > Math.min(grant.expiresAt, config.sourceJobs.expiresAt)
+            || createPublicKey(creationCapabilityPublicKey(config.creationCapabilities)).export({ format: 'der', type: 'spki' })
+                .equals(key.export({ format: 'der', type: 'spki' }))) {
+            throw new Error('plugin-control-plane: invalid independent revision verification authority');
+        }
+    }
+    if (config.revisionRegressions !== undefined) {
+        const policy = config.revisionRegressions, jobs = config.sourceJobs, adoption = config.creationCapabilities;
+        if (!jobs?.revision || !config.revisionVerifications || !adoption
+            || Object.keys(policy).sort().join(',') !== 'authority,publicKey' || typeof policy.publicKey !== 'string') {
+            throw new Error('plugin-control-plane: regression requires independently configured review and retained parent source');
+        }
+        validateRevisionRegressionAcceptanceAuthorityRef(policy.authority);
+        const key = createPublicKey(policy.publicKey);
+        if (key.asymmetricKeyType !== 'ed25519' || policy.authority.namePrefix !== jobs.revision.namePrefix
+            || policy.authority.expiresAt > Math.min(jobs.expiresAt, jobs.revision.expiresAt, config.revisionVerifications.authority.expiresAt)
+            || createPublicKey(creationCapabilityPublicKey(adoption)).export({ format: 'der', type: 'spki' })
+                .equals(key.export({ format: 'der', type: 'spki' }))) {
+            throw new Error('plugin-control-plane: invalid independent revision regression authority');
+        }
+    }
+    if (config.creationCapabilities !== undefined) {
+        validateCreationCapabilityConfig(config.creationCapabilities);
+        const capability = config.creationCapabilities;
+        const verification = config.creationVerifications;
+        const jobs = config.sourceJobs;
+        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
+            || capability.keyId === verification.authority.keyId) {
+            throw new Error('plugin-control-plane: created capability authority does not match its authenticated creation lane');
+        }
+        const adoptionKey = createPublicKey(creationCapabilityPublicKey(capability)).export({ format: 'der', type: 'spki' });
+        const verificationKey = createPublicKey(verification.publicKey).export({ format: 'der', type: 'spki' });
+        if (adoptionKey.equals(verificationKey))
+            throw new Error('plugin-control-plane: adoption and verification signing keys 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;
@@ -145,8 +248,16 @@ export class PluginControlPlaneService extends Service {
     sourceReleaseAdvances = new Map();
     sourceAdoptionFlights = new Map();
     foregroundObservers = new Set();
+    liveRuntime;
+    assertLiveRuntime;
     sourceRuntime;
     sourceRuntimes = new Set();
+    creationCapabilityRuntime;
+    creationCapabilityRuntimes = new Set();
+    creationCapabilityFlights = new Set();
+    creationCapabilityReconcileRequested = false;
+    growthRunProducer;
+    growthProviderDraining = false;
     constructor(ctx, input) {
         super(ctx, 'pluginControlPlane');
         this.config = normalizeControlPlaneConfig(input);
@@ -164,8 +275,20 @@ export class PluginControlPlaneService extends Service {
             this.abort.abort();
             await Promise.allSettled([...this.sourceRuntimes].map(runtime => runtime.close()));
             await Promise.allSettled([...this.sourceBuilds, ...this.sourceInspections, ...this.sourceApprovalFlights, ...this.sourceReleaseFlights, ...this.sourceAdoptionFlights.values()]);
-            this.store.close();
+            await Promise.allSettled(this.creationCapabilityFlights);
+            const closed = await Promise.allSettled([...this.creationCapabilityRuntimes].map(runtime => runtime.close()));
+            const failures = closed.filter((result) => result.status === 'rejected')
+                .map(result => result.reason);
+            try {
+                this.store.close();
+            }
+            catch (error) {
+                failures.push(error);
+            }
+            if (failures.length)
+                throw new AggregateError(failures, 'created capability resource release unconfirmed');
         }, 'plugin-control-plane.store');
+        installHostReadiness(ctx);
         ctx.inject(['tools'], toolsCtx => registerPluginControlTools(toolsCtx, this));
         if (this.config.runtimeObserver !== undefined)
             installRuntimeObserver(ctx, this.config.runtimeObserver, this.config.foregroundDeployments ? (observerCtx, sample) => {
@@ -180,16 +303,54 @@ export class PluginControlPlaneService extends Service {
                                 throw new Error('foreground deployment trust changed');
                         };
                         assertCurrent();
+                        const assertLiveRuntime = (planId) => {
+                            assertCurrent();
+                            const plan = this.store.getPlan(planId);
+                            const operation = this.store.getLiveQualificationReadiness(planId);
+                            if (!operation.receipt)
+                                throw new Error('live qualification has no retained signed readiness');
+                            const binding = captureRetainedDeploymentReadiness({ plan, operation, receipt: operation.receipt, trust,
+                                journalPath: this.config.foregroundDeployments.attestorJournalPath,
+                                runtime: sample(randomBytes(32).toString('hex')) });
+                            const window = this.store.getLiveQualificationWindow(planId);
+                            if (binding.receiptDigest !== window.readinessDigest || binding.hostGeneration !== window.hostGeneration) {
+                                throw new Error('live qualification runtime differs from retained readiness');
+                            }
+                            assertCurrent();
+                        };
+                        const requestRuntimeEpoch = (runtime) => {
+                            assertCurrent();
+                            queueRuntimeEpoch(this.store, trust, runtime, (gapId, owner, callback) => this.taskGaps.withCurrent(gapId, owner, callback));
+                        };
                         const registration = createForegroundDeploymentObserver({ config: this.config.foregroundDeployments,
-                            profilePath: this.config.runtimeObserver.profilePath, store: this.store, trust, sample, assertCurrent, owner: this });
+                            profilePath: this.config.runtimeObserver.profilePath, store: this.store, trust, sample, assertCurrent, owner: this, requestRuntimeEpoch });
+                        onHostReady(deliveryCtx, () => {
+                            try {
+                                requestRuntimeEpoch(sample(randomBytes(32).toString('hex')));
+                            }
+                            catch { /* Initial deployment and inactive/retracted sources have no continuity work. */ }
+                        });
                         this.foregroundObservers.add(registration);
                         try {
                             const delivery = deliveryCtx.get('assistantDelivery');
                             const remove = delivery.registerForegroundTaskObserver(registration);
-                            return () => { live = false; this.foregroundObservers.delete(registration); remove(); };
+                            if (this.config.liveQualification) {
+                                this.assertLiveRuntime = assertLiveRuntime;
+                                this.liveRuntime?.scan();
+                            }
+                            return () => {
+                                live = false;
+                                if (this.assertLiveRuntime === assertLiveRuntime)
+                                    this.assertLiveRuntime = undefined;
+                                this.liveRuntime?.scan();
+                                this.foregroundObservers.delete(registration);
+                                remove();
+                            };
                         }
                         catch (error) {
                             live = false;
+                            if (this.assertLiveRuntime === assertLiveRuntime)
+                                this.assertLiveRuntime = undefined;
                             this.foregroundObservers.delete(registration);
                             throw error;
                         }
@@ -220,7 +381,16 @@ export class PluginControlPlaneService extends Service {
                                 inspectSystemOwnedActivation: input => automations().inspectSystemOwnedActivation(input),
                             }, });
                         runtime.start();
-                        return () => runtime.close();
+                        const owner = 'plugin-control-plane-adoption-coordinator';
+                        const automationId = `adoption-coordinator-${controlPlaneDigest({
+                            coordinatorId: this.config.adoptionCoordinator.coordinatorId,
+                            scope: this.config.adoptionCoordinator.scope,
+                        }).slice(0, 40)}`;
+                        const activationNonce = automations().inspectSystemOwnedActivation({ owner, automationId })?.activationNonce;
+                        if (activationNonce === undefined)
+                            throw new Error('plugin-control-plane: adoption coordinator registration is missing');
+                        const stop = automations().registerHostShutdown(coordinatorCtx, { owner, automationId, activationNonce }, () => runtime.close({ skipPause: true }));
+                        return stop;
                     }
                     catch (error) {
                         if (runtime)
@@ -276,29 +446,201 @@ export class PluginControlPlaneService extends Service {
                     }
                 }, 'plugin-control-plane.task-observations');
             });
+        if (this.config.liveQualification !== undefined)
+            ctx.inject(['assistantAutomations', 'assistantDelivery', 'assistantEvaluation'], observerCtx => {
+                observerCtx.effect(async () => {
+                    const snapshot = foregroundTrustSnapshot(this.config.trustPath), trust = await this.boundTrust();
+                    this.abort.signal.throwIfAborted();
+                    const store = new ControlPlaneStore({ path: trust.ledger.path });
+                    const evaluation = () => observerCtx.get('assistantEvaluation');
+                    const delivery = () => observerCtx.get('assistantDelivery');
+                    const automations = () => observerCtx.get('assistantAutomations');
+                    let runtime;
+                    try {
+                        runtime = new LiveQualificationRuntime({ config: this.config.liveQualification, store, trust,
+                            assertCurrent: () => {
+                                this.abort.signal.throwIfAborted();
+                                if (foregroundTrustSnapshot(this.config.trustPath) !== snapshot)
+                                    throw new Error('live qualification trust changed');
+                            },
+                            assertRuntime: planId => {
+                                if (!this.assertLiveRuntime)
+                                    throw new Error('live qualification Host observer unavailable');
+                                this.assertLiveRuntime(planId);
+                            },
+                            runtimeAvailable: () => this.assertLiveRuntime !== undefined,
+                            qualificationSource: planId => {
+                                const plan = this.store.getPlan(planId);
+                                const reference = this.store.getOwnerTaskFailureReference(plan.gapId);
+                                if (!reference)
+                                    throw new Error('live qualification original owner failure unavailable');
+                                return this.taskGaps.inspectCurrent(plan.gapId, reference.owner);
+                            },
+                            evaluation: {
+                                canonicalHostScope: input => evaluation().canonicalHostScope(input),
+                                getTrustedForegroundLearningProjection: input => evaluation().getTrustedForegroundLearningProjection(input),
+                                withTrustedCanonicalTaskWriterFence: (input, callback) => evaluation().withTrustedCanonicalTaskWriterFence(input, callback),
+                                onTrustedTaskChange: callback => evaluation().onTrustedTaskChange(callback),
+                            },
+                            delivery: {
+                                validateOwnerRoute: input => delivery().validateOwnerRoute(input),
+                                inspectOwnerForegroundLearningTask: input => delivery().inspectOwnerForegroundLearningTask(input),
+                            },
+                            automations: {
+                                registerHostExecutor: input => automations().registerHostExecutor(input),
+                                reconcileSystem: input => automations().reconcileSystem(input),
+                                inspectSystemOwnedActivation: input => automations().inspectSystemOwnedActivation(input),
+                            }, });
+                        runtime.start();
+                        this.liveRuntime = runtime;
+                        return async () => {
+                            if (this.liveRuntime === runtime)
+                                this.liveRuntime = undefined;
+                            await runtime.close();
+                        };
+                    }
+                    catch (error) {
+                        if (runtime)
+                            await runtime.close();
+                        else
+                            store.close();
+                        throw error;
+                    }
+                }, 'plugin-control-plane.live-qualification');
+            });
         if (this.config.sourceJobs !== undefined)
             ctx.inject(['assistantAutomations', 'assistantDelivery',
                 ...(this.config.sourceApprovals ? ['assistantEvaluation'] : []),
-                ...(this.config.sourceReleaseExecution?.independentReview ? ['assistantVerifier', 'agents', 'sessions', 'tools', 'llm', 'systemPrompt', 'assistantPolicy'] : [])], jobsCtx => {
+                ...(this.config.sourceReleaseExecution?.independentReview ? ['assistantVerifier', 'agents', 'sessions', 'tools', 'llm', 'systemPrompt', 'assistantPolicy'] : []),
+                ...(this.config.creationVerifications || this.config.revisionVerifications || this.config.revisionRegressions ? ['assistantVerifier'] : []),
+                ...(this.config.creationCapabilities ? ['tools', 'assistantEvaluation', 'assistantPolicy'] : [])], jobsCtx => {
                 jobsCtx.effect(async () => {
                     this.abort.signal.throwIfAborted();
                     const current = (key) => jobsCtx.get((key === 'automations' ? 'assistantAutomations' : 'assistantDelivery'));
-                    for (const method of ['registerHostExecutor', 'reconcileSystem', 'inspectSystemOwnedActivation', 'inspectSystemOwned']) {
+                    for (const method of ['registerHostExecutor', 'reconcileSystem', 'reconcileSystemExact', 'pauseSystemOwned',
+                        'inspectSystemOwnedActivation', 'inspectSystemOwned']) {
                         if (typeof current('automations')[method] !== 'function')
                             throw new Error(`plugin-control-plane: durable source jobs require assistantAutomations.${method}`);
                     }
                     if (typeof current('delivery').validateOwnerRoute !== 'function')
                         throw new Error('plugin-control-plane: durable source jobs require Delivery v2 owner validation');
+                    let capabilities;
+                    let unsubscribeTaskChanges;
+                    if (this.config.creationCapabilities) {
+                        if (typeof current('delivery').validateOwnerAgentForRoute !== 'function') {
+                            throw new Error('plugin-control-plane: created capabilities require authenticated live owner Agent admission');
+                        }
+                        const evaluation = jobsCtx.get('assistantEvaluation');
+                        if (typeof evaluation.onTrustedTaskChange !== 'function') {
+                            throw new Error('created capabilities require canonical task change notifications');
+                        }
+                        const config = this.config.creationCapabilities;
+                        const journal = new CreationCapabilityJournal({ path: join(this.config.statePath, 'creation-adoptions.sqlite'), config });
+                        try {
+                            capabilities = new CreationCapabilityRuntime({ ctx: jobsCtx, config, journal, ports: {
+                                    inspect: planId => {
+                                        const certificate = this.inspectVerifiedCreation(planId);
+                                        if (!certificate)
+                                            throw new Error('created capability requires a fresh independent certificate');
+                                        const prepared = this.inspectPreparedCreation(planId);
+                                        const owner = config.owner;
+                                        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 };
+                                    },
+                                    recheck: async (planId, signal) => {
+                                        await this.inspectPreparedCreationReviewContext(planId, signal);
+                                        if (!this.inspectVerifiedCreation(planId))
+                                            throw new Error('created capability independent certificate changed');
+                                    },
+                                    captureSource: async (planId, signal) => {
+                                        const combined = AbortSignal.any([this.abort.signal, signal, AbortSignal.timeout(120_000)]);
+                                        const prepared = this.inspectPreparedCreation(planId);
+                                        const certificate = this.inspectVerifiedCreation(planId);
+                                        if (!certificate)
+                                            throw new Error('created capability source lacks a fresh certificate');
+                                        const trust = await this.boundTrust();
+                                        combined.throwIfAborted();
+                                        const source = await captureCreationCapabilitySource({ worktree: prepared.plan.worktree,
+                                            baseCommit: prepared.plan.baseCommit, scope: [...prepared.plan.scope].sort(), certificate,
+                                            environment: inheritedEnvironment(trust), signal: combined });
+                                        combined.throwIfAborted();
+                                        const latest = this.inspectVerifiedCreation(planId);
+                                        if (!latest || controlPlaneDigest(latest) !== controlPlaneDigest(certificate)) {
+                                            throw new Error('created capability source changed during capture');
+                                        }
+                                        return source;
+                                    },
+                                    inspectRetained: record => this.withRetainedCreatedCapabilityCurrent(record, () => ({
+                                        certificate: record.certificate, artifact: record.artifact, owner: config.owner
+                                    })),
+                                    recheckRetained: async (record, signal) => {
+                                        signal.throwIfAborted();
+                                        this.withRetainedCreatedCapabilityCurrent(record, () => undefined);
+                                        signal.throwIfAborted();
+                                    },
+                                    withCurrent: (record, callback) => this.withCreatedCapabilityCurrent(record, callback),
+                                    inspectCall: (_record, execution, toolAlias, argumentsJson) => {
+                                        if (!execution.agent)
+                                            return undefined;
+                                        const delivery = current('delivery');
+                                        if (typeof delivery.inspectOwnerForegroundToolCall !== 'function')
+                                            return undefined;
+                                        return delivery.inspectOwnerForegroundToolCall({ agent: execution.agent,
+                                            authorityId: config.owner.authorityId, callId: String(execution.callId),
+                                            toolName: toolAlias, argumentsJson });
+                                    },
+                                    assertCaller: (_record, execution) => {
+                                        if (!execution.agent)
+                                            throw new Error('created capability requires an authenticated owner Agent');
+                                        const delivery = current('delivery');
+                                        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('created capability caller is not the current authorized owner');
+                                        }
+                                    },
+                                } });
+                            this.creationCapabilityRuntimes.add(capabilities);
+                            await capabilities.start();
+                            this.abort.signal.throwIfAborted();
+                            this.creationCapabilityRuntime = capabilities;
+                            unsubscribeTaskChanges = evaluation.onTrustedTaskChange(() => this.reconcileCreatedCapabilities());
+                        }
+                        catch (error) {
+                            unsubscribeTaskChanges?.();
+                            if (capabilities) {
+                                await capabilities.close();
+                                this.creationCapabilityRuntimes.delete(capabilities);
+                            }
+                            else
+                                journal.close();
+                            throw error;
+                        }
+                    }
                     const runtime = new SourceJobRuntime({ config: this.config.sourceJobs, build: this.config.sourceBuild, statePath: this.config.statePath, store: this.store,
                         ports: {
                             automations: {
                                 registerHostExecutor: executor => current('automations').registerHostExecutor(executor),
                                 reconcileSystem: request => current('automations').reconcileSystem(request),
+                                reconcileSystemExact: request => current('automations').reconcileSystemExact(request),
+                                pauseSystemOwned: request => current('automations').pauseSystemOwned(request),
                                 inspectSystemOwnedActivation: request => current('automations').inspectSystemOwnedActivation(request),
                                 inspectSystemOwned: request => current('automations').inspectSystemOwned(request),
                             },
                             delivery: { validateOwnerRoute: request => current('delivery').validateOwnerRoute(request) },
                         }, withGapSourceFence: (gapId, owner, callback) => this.taskGaps.withCurrent(gapId, owner, 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')) } : {}),
+                        ...(this.config.revisionRegressions ? { verifyPreparedRevisionRegression: (job, signal) => this.verifyPreparedRevisionRegression(job, signal, () => jobsCtx.get('assistantVerifier')) } : {}),
+                        ...(this.config.creationVerifications ? { verifyPreparedCreation: (job, signal) => this.verifyPreparedCreation(job, signal, () => jobsCtx.get('assistantVerifier')) } : {}),
+                        ...(capabilities ? { creationAdoptionEligible: (planId) => capabilities.eligible(planId),
+                            adoptVerifiedCreation: async (job, signal) => {
+                                if (!job.planId)
+                                    throw new Error('created capability has no prepared source plan');
+                                await capabilities.adopt(job.planId, signal);
+                            } } : {}),
                         ...(this.config.sourceApprovals ? { approvePrepared: async (job, signal) => {
                                 if (!job.planId)
                                     throw new Error('source job has no prepared plan');
@@ -324,6 +666,7 @@ export class PluginControlPlaneService extends Service {
                         trust: () => this.boundTrust(), prepare: (job, signal, assertCurrent) => this.prepareSourceJob(job, signal, assertCurrent), });
                     this.sourceRuntimes.add(runtime);
                     const close = async () => {
+                        unsubscribeTaskChanges?.();
                         if (this.sourceRuntime === runtime)
                             this.sourceRuntime = undefined;
                         try {
@@ -331,6 +674,12 @@ export class PluginControlPlaneService extends Service {
                         }
                         finally {
                             this.sourceRuntimes.delete(runtime);
+                            if (capabilities) {
+                                if (this.creationCapabilityRuntime === capabilities)
+                                    this.creationCapabilityRuntime = undefined;
+                                await capabilities.close();
+                                this.creationCapabilityRuntimes.delete(capabilities);
+                            }
                         }
                     };
                     try {
@@ -367,7 +716,9 @@ export class PluginControlPlaneService extends Service {
     };
     async boundTrust() {
         const trust = await loadTrustConfig(this.config.trustPath);
-        if (resolve(join(this.config.statePath, 'control.sqlite')) !== trust.ledger.path
+        const localLedgerPath = resolve(join(this.config.statePath, 'control.sqlite'));
+        if ((this.config.adoptionCoordinator === undefined
+            ? localLedgerPath !== trust.ledger.path : localLedgerPath === trust.ledger.path)
             || resolve(this.config.catalogPath) !== trust.catalog.path) {
             throw new Error('plugin-control-plane: configured ledger/catalog do not match the owner trust binding');
         }
@@ -474,7 +825,7 @@ export class PluginControlPlaneService extends Service {
             const key = resolveTrustKey(trust, 'release-authorization', authorization.authority, authorization.keyId);
             return (await this.store.startSourceRelease({ planId: plan.id, expectedRevision: plan.revision, authorization,
                 resolveAuthority: () => new Ed25519SourceReleaseAuthorizationAuthority(key.publicKeyPem, key.authority, key.keyId),
-                idempotencyKey: `source-release-authorization:${authorization.authorizationId}`, withSourceFence })).result;
+                idempotencyKey: `source-release-authorization:${authorization.authorizationId}`, withSourceFence, trust })).result;
         })();
         this.sourceReleaseFlights.add(operation);
         try {
@@ -581,6 +932,11 @@ export class PluginControlPlaneService extends Service {
                     if (gapId !== plan.gapId)
                         throw new Error('source adoption escaped its owner task');
                     return current(callback);
+                },
+                withLiveQualificationFence: (planId, callback) => {
+                    if (!this.liveRuntime)
+                        throw new Error('live qualification runtime unavailable');
+                    return this.liveRuntime.withQualificationFence(planId, callback);
                 } });
             const withSourceFence = (callback) => current(() => store.withOwnerTaskFailureGapAdmission(plan.gapId, callback));
             try {
@@ -610,6 +966,652 @@ export class PluginControlPlaneService extends Service {
     health() { return this.store.health(); }
     canPrepareSource() { return this.config.sourceBuild !== undefined; }
     canEnqueueSource() { return this.sourceRuntime?.available() === true && !this.abort.signal.aborted; }
+    /** 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'
+            || this.growthRunProducer !== undefined || this.growthProviderDraining)
+            throw new Error('plugin-control-plane: source growth run producer is invalid or already registered');
+        this.growthRunProducer = producer;
+        try {
+            this.sourceRuntime?.reconcileQueued();
+            this.reconcileCreatedCapabilities();
+        }
+        catch (error) {
+            this.growthRunProducer = undefined;
+            throw error;
+        }
+        return async () => {
+            if (this.growthRunProducer !== producer)
+                return;
+            this.growthRunProducer = undefined;
+            this.growthProviderDraining = true;
+            try {
+                await this.sourceRuntime?.growthProviderDisposed();
+                await this.creationCapabilityRuntime?.reconcile();
+            }
+            finally {
+                this.growthProviderDraining = false;
+            }
+        };
+    };
+    /** Host readiness nudge after durable Usage becomes available. */
+    reconcileSourceGrowthRuns = () => {
+        this.abort.signal.throwIfAborted();
+        if (this.growthRunProducer !== undefined)
+            this.sourceRuntime?.reconcileQueued();
+        this.reconcileCreatedCapabilities();
+    };
+    reconcileCreatedCapabilities() {
+        const runtime = this.creationCapabilityRuntime;
+        if (!runtime || this.abort.signal.aborted)
+            return;
+        this.creationCapabilityReconcileRequested = true;
+        if (this.creationCapabilityFlights.size)
+            return;
+        this.creationCapabilityReconcileRequested = false;
+        const operation = runtime.reconcile();
+        this.creationCapabilityFlights.add(operation);
+        void operation.catch(error => this.ctx.logger.warn('created capability reconciliation failed', error))
+            .finally(() => {
+            this.creationCapabilityFlights.delete(operation);
+            if (this.creationCapabilityReconcileRequested)
+                this.reconcileCreatedCapabilities();
+        });
+    }
+    /** Content-free Host diagnostics; never register adoption as a model tool. */
+    inspectCreatedCapability = (planId) => {
+        this.abort.signal.throwIfAborted();
+        return this.creationCapabilityRuntime?.inspectStatus(planId);
+    };
+    /** Exact immutable adoption and actual call evidence; no arguments, results or quality rating. */
+    inspectCreatedCapabilityCalls = (planId) => {
+        this.abort.signal.throwIfAborted();
+        return this.creationCapabilityRuntime?.inspectCallEvidence(planId) ?? [];
+    };
+    /** Host-only historical source data. It grants no continuation, activation or replacement. */
+    inspectCreatedCapabilitySource = (planId) => {
+        this.abort.signal.throwIfAborted();
+        const owner = this.config.creationCapabilities?.owner;
+        const delivery = this.ctx.get('assistantDelivery', false);
+        if (!owner || !delivery || typeof delivery.validateOwnerRoute !== 'function')
+            return undefined;
+        try {
+            const before = delivery.validateOwnerRoute(owner);
+            const snapshot = this.creationCapabilityRuntime?.inspectSourceEvidence(planId);
+            if (!snapshot)
+                return undefined;
+            this.assertCreatedCapabilityAssociationSource(snapshot.record);
+            const { plan, reference } = this.store.getRetainedPreparedCreation(planId);
+            if (!isSourceOwnerContinuation(before, reference.owner)
+                || snapshot.archive.source.baseCommit !== plan.baseCommit
+                || controlPlaneDigest(snapshot.archive.source.scope) !== controlPlaneDigest([...plan.scope].sort())
+                || controlPlaneDigest(before) !== controlPlaneDigest(delivery.validateOwnerRoute(owner)))
+                return undefined;
+            const source = snapshot.archive.source;
+            return Object.freeze({ ...snapshot.archive, source: Object.freeze({ ...source,
+                    scope: Object.freeze([...source.scope]), entries: Object.freeze(source.entries.map(entry => Object.freeze({ ...entry }))),
+                    files: Object.freeze(source.files.map(file => Object.freeze({ ...file }))),
+                }) });
+        }
+        catch {
+            return undefined;
+        }
+    };
+    inspectRevisionParent = (planId) => {
+        const archive = this.inspectCreatedCapabilitySource(planId);
+        const certificate = this.store.getCreationVerification(planId);
+        const grant = this.config.sourceJobs?.revision;
+        if (!archive || !certificate || !grant || !certificate.plan.name.startsWith(grant.namePrefix)
+            || archive.certificateDigest !== controlPlaneDigest(certificate) || archive.artifactSha256 !== certificate.plan.artifactSha256) {
+            throw new Error('adopted revision parent source unavailable or changed');
+        }
+        return { name: certificate.plan.name, certificate, source: archive.source,
+            parent: { planId, certificateDigest: archive.certificateDigest, artifactSha256: archive.artifactSha256,
+                sourceArchiveDigest: controlPlaneDigest(archive), sourceDigest: archive.source.digest } };
+    };
+    /** Bounded current-owner inventory. These identities are hints, never causal evidence or use grants. */
+    inspectCreatedCapabilityRevisionTargets = () => {
+        if (!this.inspectSourceRevisionAcceptanceAuthority())
+            return [];
+        const targets = [];
+        for (const plan of this.store.listPreparedSourcePlans().filter(plan => plan.mode === 'prepared-create').slice(-64)) {
+            try {
+                const parent = this.inspectRevisionParent(plan.id);
+                targets.push({ parentPlanId: plan.id, name: parent.name, parentSourceDigest: parent.source.digest });
+            }
+            catch { /* an unavailable archive is not a revision target */ }
+        }
+        return Object.freeze(targets.map(target => Object.freeze(target)));
+    };
+    getSourceRevisionNamespace = () => {
+        const policy = this.inspectSourceRevisionAcceptanceAuthority();
+        return policy ? { namePrefix: policy.namePrefix } : undefined;
+    };
+    /** Host-only current association of exact adopted call versions with authenticated task heads. */
+    inspectCreatedCapabilityTaskAssociations = (planId) => {
+        this.abort.signal.throwIfAborted();
+        const snapshot = this.creationCapabilityRuntime?.inspectAssociationEvidence(planId);
+        if (!snapshot || !this.config.creationCapabilities)
+            return [];
+        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 {
+            const historical = this.store.getRetainedPreparedCreation(planId);
+            return inspectCreationCapabilityTaskAssociations({ ...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();
+        const receipt = record.receipt;
+        const config = this.config.creationVerifications;
+        const ownerGrant = this.config.creationCapabilities?.owner;
+        if (!receipt || !config || !ownerGrant
+            || !verifyPluginCreationVerificationCertificate(record.certificate, config.authority, config.publicKey, receipt.adoptedAt))
+            throw new Error('created capability association certificate invalid');
+        const { plan, job, reference } = this.store.getRetainedPreparedCreation(record.planId);
+        const certificate = this.store.getCreationVerification(record.planId);
+        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
+            || 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
+            || plan.sourceCheck.patchDigest !== record.certificate.plan.sourcePatchDigest
+            || plan.preparedEvidence.pack.sha256 !== record.certificate.plan.artifactSha256
+            || plan.preparedEvidence.pack.sizeBytes !== record.certificate.plan.artifactBytes
+            || artifactSha256 !== record.certificate.plan.artifactSha256
+            || record.artifact.length !== record.certificate.plan.artifactBytes
+            || controlPlaneDigest(reference) !== record.certificate.source.referenceDigest
+            || controlPlaneDigest(reference.owner) !== record.certificate.source.ownerDigest
+            || sourceGrowthRunDigest(growth) !== record.certificate.source.growthRunDigest
+            || sourceGrowthRunDigest(job.intent.creation.growthRun) !== record.certificate.source.growthRunDigest
+            || controlPlaneDigest(growth.model) !== controlPlaneDigest(record.certificate.model)
+            || controlPlaneDigest(growth.creationAcceptance) !== controlPlaneDigest(config.authority)
+            || controlPlaneDigest(plan.creation.grant) !== controlPlaneDigest(this.config.sourceJobs?.creation)
+            || Object.keys(ownerGrant).some(key => reference.owner[key]
+                !== ownerGrant[key]))
+            throw new Error('created capability association source changed');
+    }
+    withCreatedCapabilityCurrent(record, callback) {
+        this.abort.signal.throwIfAborted();
+        if (record.status === 'active' && record.receipt?.protocol === 'dsh-created-capability-adoption/v2') {
+            return this.withRetainedCreatedCapabilityCurrent(record, callback);
+        }
+        const certificate = this.inspectVerifiedCreation(record.planId);
+        if (!certificate || controlPlaneDigest(certificate) !== controlPlaneDigest(record.certificate)) {
+            throw new Error('created capability certificate or current source changed');
+        }
+        return this.withPreparedCreationFence({ planId: record.planId, planDigest: certificate.plan.digest,
+            artifactSha256: certificate.plan.artifactSha256, growthRunDigest: certificate.source.growthRunDigest,
+            referenceDigest: certificate.source.referenceDigest }, callback);
+    }
+    /** Historical signed evidence and immutable job are checked under the current canonical owner writer fence. */
+    withRetainedCreatedCapabilityCurrent(record, callback) {
+        this.abort.signal.throwIfAborted();
+        const receipt = record.receipt;
+        const config = this.config.creationVerifications;
+        if (!receipt || receipt.protocol !== 'dsh-created-capability-adoption/v2' || !config
+            || !verifyPluginCreationVerificationCertificate(record.certificate, config.authority, config.publicKey, receipt.adoptedAt)) {
+            throw new Error('created capability retained certificate is invalid');
+        }
+        const historical = this.store.getRetainedPreparedCreation(record.planId);
+        return this.taskGaps.withCurrent(historical.plan.gapId, historical.reference.owner, () => {
+            this.abort.signal.throwIfAborted();
+            const { plan, job, reference } = this.store.getRetainedPreparedCreation(record.planId);
+            const certificate = this.store.getCreationVerification(record.planId);
+            const growth = plan.creation?.growthRun;
+            const creation = plan.creation;
+            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
+                || !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
+                || plan.sourceCheck.patchDigest !== record.certificate.plan.sourcePatchDigest
+                || plan.preparedEvidence.pack.sha256 !== record.certificate.plan.artifactSha256
+                || plan.preparedEvidence.pack.sizeBytes !== record.certificate.plan.artifactBytes
+                || artifactSha256 !== record.certificate.plan.artifactSha256
+                || record.artifact.length !== record.certificate.plan.artifactBytes
+                || controlPlaneDigest(reference) !== record.certificate.source.referenceDigest
+                || controlPlaneDigest(reference.owner) !== record.certificate.source.ownerDigest
+                || sourceGrowthRunDigest(growth) !== record.certificate.source.growthRunDigest
+                || sourceGrowthRunDigest(job.intent.creation.growthRun) !== record.certificate.source.growthRunDigest
+                || controlPlaneDigest(growth.model) !== controlPlaneDigest(record.certificate.model)
+                || controlPlaneDigest(growth.creationAcceptance) !== controlPlaneDigest(config.authority)
+                || controlPlaneDigest(creation.grant) !== controlPlaneDigest(this.config.sourceJobs?.creation)
+                || Object.keys(ownerGrant).some(key => reference.owner[key]
+                    !== ownerGrant[key])) {
+                throw new Error('created capability retained source binding changed');
+            }
+            return callback();
+        });
+    }
+    assertSourceGrowthRun(expected, gapId, owner, generation) {
+        validateSourceGrowthRunBinding(expected);
+        const producer = this.growthRunProducer;
+        if (!producer)
+            throw new SourceGrowthRunUnavailableError('source growth run producer unavailable');
+        const actual = producer.inspect({ runId: expected.runId, intentDigest: expected.intentDigest });
+        if (!actual)
+            throw new Error('source growth run is absent or no longer current');
+        validateSourceGrowthRunBinding(actual);
+        if (sourceGrowthRunDigest(actual) !== sourceGrowthRunDigest(expected)
+            || expected.ownerDigest !== controlPlaneDigest(owner))
+            throw new Error('source growth run immutable binding changed');
+        const policy = this.config.creationVerifications?.authority;
+        if (expected.revisionAcceptance !== undefined && (this.config.revisionVerifications === undefined
+            || controlPlaneDigest(expected.revisionAcceptance) !== controlPlaneDigest(this.config.revisionVerifications.authority))) {
+            throw new Error('source growth run revision acceptance policy changed or was not pinned before authoring');
+        }
+        if ((expected.revisionRegressionAcceptance !== undefined || (this.config.revisionRegressions && expected.revisionAcceptance))
+            && (this.config.revisionRegressions === undefined || expected.revisionRegressionAcceptance === undefined
+                || 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
+            && (policy === undefined || controlPlaneDigest(policy) !== controlPlaneDigest(expected.creationAcceptance))) {
+            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
+            || expected.source.sourceDigest !== reference.sourceDigest
+            || controlPlaneDigest(expected.source.projection) !== controlPlaneDigest(reference.projection)
+            || expected.ownerDigest !== controlPlaneDigest(reference.owner))
+            throw new Error('source growth run task reference changed');
+        const current = this.taskGaps.inspectCurrent(gapId, owner);
+        if (expected.modelOrigin === 'inherited-owner-task'
+            && (current.source.modelSelectionState !== 'frozen'
+                || controlPlaneDigest(current.source.modelSelection) !== controlPlaneDigest(expected.model))) {
+            throw new Error('source growth run inherited model changed');
+        }
+        if (Date.now() >= expected.expiresAt || (generation && Date.now() >= expected.generationDeadlineAt)) {
+            throw new Error('source growth run window expired');
+        }
+    }
+    /** Private Host handoff. Never register this package reader as a model tool. */
+    inspectPreparedCreation = (planId) => {
+        this.abort.signal.throwIfAborted();
+        const plan = this.store.getSourcePlan(planId);
+        const reference = this.store.getOwnerTaskFailureReference(plan.gapId);
+        if (!reference || plan.mode !== 'prepared-create' || plan.status !== 'pending-approval'
+            || Date.now() >= plan.expiresAt || !plan.creation || Date.now() >= plan.creation.grant.expiresAt) {
+            throw new Error('prepared creation package is unavailable for independent verification');
+        }
+        return this.taskGaps.withCurrent(plan.gapId, reference.owner, () => {
+            this.abort.signal.throwIfAborted();
+            const job = this.store.getPreparedSourceJob(plan.id);
+            if (!plan.creation?.growthRun || !job.intent.creation?.growthRun)
+                throw new Error('prepared creation lacks a frozen source growth run');
+            this.assertSourceGrowthRun(plan.creation.growthRun, plan.gapId, reference.owner, false);
+            return {
+                protocol: 'dsh-prepared-creation/v1',
+                plan: structuredClone(plan), job: structuredClone(job), reference: structuredClone(reference),
+                source: this.taskGaps.inspectCurrent(plan.gapId, reference.owner),
+                artifact: this.store.readPreparedSourceArtifact(plan.id),
+            };
+        });
+    };
+    /** Host-only pre-author policy reference; never grants candidate or model authority. */
+    inspectSourceCreationAcceptanceAuthority = () => {
+        const policy = this.config.creationVerifications?.authority;
+        if (this.abort.signal.aborted || !policy || Date.now() >= policy.expiresAt
+            || Date.now() >= (this.config.sourceJobs?.creation?.expiresAt ?? 0)
+            || Date.now() >= (this.config.sourceJobs?.expiresAt ?? 0))
+            return undefined;
+        return structuredClone(policy);
+    };
+    /** Synchronous Evaluation writer fence for an exact independently reviewed creation. */
+    withPreparedCreationFence = (input, callback) => {
+        this.abort.signal.throwIfAborted();
+        const policy = this.inspectSourceCreationAcceptanceAuthority();
+        if (!policy)
+            throw new Error('creation verification authority unavailable');
+        const plan = this.store.getSourcePlan(input.planId);
+        const reference = this.store.getOwnerTaskFailureReference(plan.gapId);
+        if (!reference)
+            throw new Error('creation verification source unavailable');
+        return this.taskGaps.withCurrent(plan.gapId, reference.owner, () => {
+            this.abort.signal.throwIfAborted();
+            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
+                || !job.intent.creation?.growthRun || !current.sourceCheck || !current.preparedEvidence
+                || current.preparedEvidence.pack.sha256 !== input.artifactSha256
+                || controlPlaneDigest(reference) !== input.referenceDigest
+                || sourceGrowthRunDigest(current.creation.growthRun) !== input.growthRunDigest
+                || sourceGrowthRunDigest(job.intent.creation.growthRun) !== input.growthRunDigest
+                || !current.creation.growthRun.creationAcceptance
+                || controlPlaneDigest(current.creation.growthRun.creationAcceptance) !== controlPlaneDigest(policy)
+                || controlPlaneDigest(current.creation.grant) !== controlPlaneDigest(this.config.sourceJobs?.creation)) {
+                throw new Error('creation verification exact source binding changed');
+            }
+            this.assertSourceGrowthRun(current.creation.growthRun, current.gapId, reference.owner, false);
+            const artifact = this.store.readPreparedSourceArtifact(input.planId);
+            if (createHash('sha256').update(artifact).digest('hex') !== input.artifactSha256) {
+                throw new Error('creation verification artifact changed');
+            }
+            return callback();
+        });
+    };
+    /** Independent reviewer reads the actual checked tree through a disposable Git index. */
+    inspectPreparedCreationReviewContext = async (planId, signal) => {
+        const combined = AbortSignal.any([this.abort.signal, signal, AbortSignal.timeout(120_000)]);
+        combined.throwIfAborted();
+        const prepared = this.inspectPreparedCreation(planId);
+        const current = () => this.withPreparedCreationFence({ planId, planDigest: prepared.plan.digest,
+            artifactSha256: prepared.plan.preparedEvidence.pack.sha256,
+            growthRunDigest: sourceGrowthRunDigest(prepared.plan.creation.growthRun),
+            referenceDigest: controlPlaneDigest(prepared.reference) }, () => undefined);
+        current();
+        const trust = await this.boundTrust();
+        const environment = inheritedEnvironment(trust);
+        const job = prepared.job;
+        await verifyCreatedPluginWorkspace({ worktree: prepared.plan.worktree, baseCommit: prepared.plan.baseCommit,
+            name: prepared.plan.name, environment, signal: combined, assertCurrent: current,
+            creation: prepared.plan.creation, files: job.intent.files });
+        const review = await inspectPreparedCreationPatch(prepared.plan, environment, combined);
+        current();
+        return review;
+    };
+    /** Signed behavior evidence over stored pack/checks. Adoption must await async review-context recheck. */
+    inspectVerifiedCreation = (planId) => {
+        const certificate = this.store.getCreationVerification(planId);
+        if (!certificate)
+            return undefined;
+        const config = this.config.creationVerifications;
+        if (!config || !verifyPluginCreationVerificationCertificate(certificate, config.authority, config.publicKey))
+            return undefined;
+        this.withPreparedCreationFence({ planId, planDigest: certificate.plan.digest,
+            artifactSha256: certificate.plan.artifactSha256, growthRunDigest: certificate.source.growthRunDigest,
+            referenceDigest: certificate.source.referenceDigest }, () => {
+            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('creation verification exact plan evidence changed');
+            }
+        });
+        return structuredClone(certificate);
+    };
+    /** Private Host diagnostic; no cases, prompts, source bytes or verifier output. */
+    inspectCreationVerification = (planId) => {
+        this.abort.signal.throwIfAborted();
+        const plan = this.store.getSourcePlan(planId);
+        const reference = this.store.getOwnerTaskFailureReference(plan.gapId);
+        if (!reference || plan.mode !== 'prepared-create')
+            throw new Error('creation verification owner source unavailable');
+        return this.taskGaps.withCurrent(plan.gapId, reference.owner, () => {
+            const current = this.store.getSourcePlan(planId);
+            if (current.mode !== 'prepared-create' || current.digest !== plan.digest) {
+                throw new Error('creation verification diagnostic plan changed');
+            }
+            return this.store.inspectCreationVerificationRecord(planId);
+        });
+    };
+    /** Private Host handoff. Never register this package reader as a model tool. */
+    inspectPreparedRevision = (planId) => {
+        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'
+            || Date.now() >= plan.expiresAt || !plan.sourceRevision || Date.now() >= plan.sourceRevision.grant.expiresAt) {
+            throw new Error('prepared revision package is unavailable for independent verification');
+        }
+        return this.taskGaps.withCurrent(plan.gapId, reference.owner, () => {
+            this.abort.signal.throwIfAborted();
+            const job = this.store.getPreparedRevisionJob(plan.id);
+            if (!plan.sourceRevision?.growthRun || !job.intent.revision?.growthRun)
+                throw new Error('prepared revision lacks a frozen source growth run');
+            this.assertSourceGrowthRun(plan.sourceRevision.growthRun, plan.gapId, reference.owner, false);
+            this.inspectRevisionParent(plan.sourceRevision.parent.planId);
+            return {
+                protocol: 'dsh-prepared-revision/v1',
+                plan: structuredClone(plan), job: structuredClone(job), reference: structuredClone(reference),
+                source: this.taskGaps.inspectCurrent(plan.gapId, reference.owner),
+                artifact: this.store.readPreparedSourceArtifact(plan.id),
+            };
+        });
+    };
+    /** Host-only pre-author policy reference; never grants candidate or model authority. */
+    inspectSourceRevisionAcceptanceAuthority = () => {
+        const policy = this.config.revisionVerifications?.authority;
+        if (this.abort.signal.aborted || !policy || Date.now() >= policy.expiresAt
+            || Date.now() >= (this.config.sourceJobs?.revision?.expiresAt ?? 0)
+            || Date.now() >= (this.config.sourceJobs?.expiresAt ?? 0))
+            return undefined;
+        return structuredClone(policy);
+    };
+    /** Host-only pre-author reference, separate from candidate verification and execution grants. */
+    inspectSourceRevisionRegressionAcceptanceAuthority = () => {
+        const policy = this.config.revisionRegressions?.authority;
+        if (!policy)
+            return undefined;
+        if (this.abort.signal.aborted || Date.now() >= policy.expiresAt
+            || !this.inspectSourceRevisionAcceptanceAuthority()) {
+            throw new Error('configured revision regression authority unavailable');
+        }
+        return structuredClone(policy);
+    };
+    /** Immutable artifacts only. Historical parent permission never grants a new invocation. */
+    inspectPreparedRevisionRegression = (planId) => {
+        const prepared = this.inspectPreparedRevision(planId);
+        const certificate = this.inspectVerifiedRevision(planId);
+        const policy = this.inspectSourceRevisionRegressionAcceptanceAuthority();
+        const run = prepared.plan.sourceRevision.growthRun;
+        const source = this.store.readRevisionSource(planId);
+        if (!certificate || !source || !policy || !run.revisionRegressionAcceptance
+            || controlPlaneDigest(run.revisionRegressionAcceptance) !== controlPlaneDigest(policy)) {
+            throw new Error('regression requires fresh independently verified candidate and pre-author policy');
+        }
+        const parent = this.inspectRevisionParent(certificate.parent.planId);
+        const evidence = this.creationCapabilityRuntime?.inspectSourceEvidence(parent.parent.planId);
+        if (!evidence || !evidence.record.receipt
+            || controlPlaneDigest(evidence.archive) !== parent.parent.sourceArchiveDigest
+            || controlPlaneDigest(evidence.record.certificate) !== parent.parent.certificateDigest
+            || createHash('sha256').update(evidence.record.artifact).digest('hex') !== parent.parent.artifactSha256
+            || evidence.record.artifact.length !== parent.certificate.plan.artifactBytes) {
+            throw new Error('regression parent immutable artifact unavailable or changed');
+        }
+        this.inspectRevisionParent(parent.parent.planId);
+        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 },
+            parent: { binding: parent.parent, certificate: parent.certificate, artifact: Buffer.from(evidence.record.artifact) } };
+    };
+    withPreparedRevisionRegressionFence = (input, callback) => {
+        // Resolve read-only snapshots before acquiring Evaluation's non-reentrant
+        // writer transaction; inside it, compare durable data without another fence.
+        const snapshot = this.inspectPreparedRevisionRegression(input.planId);
+        return this.withPreparedRevisionFence(input, () => {
+            const certificate = this.store.getRevisionVerification(input.planId);
+            const source = this.store.readRevisionSource(input.planId);
+            const policy = this.inspectSourceRevisionRegressionAcceptanceAuthority();
+            const candidatePolicy = this.config.revisionVerifications;
+            if (!certificate || !source || !policy || !candidatePolicy
+                || !verifyPluginRevisionVerificationCertificate(certificate, candidatePolicy.authority, candidatePolicy.publicKey)
+                || controlPlaneDigest(certificate) !== input.candidateVerificationDigest
+                || controlPlaneDigest(snapshot.candidate.certificate) !== input.candidateVerificationDigest
+                || source.digest !== input.sourceDigest || snapshot.candidate.sourceDigest !== input.sourceDigest
+                || controlPlaneDigest(policy) !== input.regressionAuthorityDigest
+                || controlPlaneDigest(snapshot.plan.sourceRevision.growthRun.revisionRegressionAcceptance) !== input.regressionAuthorityDigest
+                || controlPlaneDigest(snapshot.parent.binding) !== input.parentDigest) {
+                throw new Error('regression parent, candidate or policy changed');
+            }
+            return callback();
+        });
+    };
+    inspectVerifiedRevisionRegression = (planId) => {
+        const certificate = this.store.getRevisionRegression(planId), policy = this.config.revisionRegressions;
+        if (!certificate || !policy || !verifyPluginRevisionRegressionCertificate(certificate, policy.authority, policy.publicKey))
+            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,
+            parentDigest: controlPlaneDigest(certificate.parent), candidateVerificationDigest: certificate.candidateVerificationDigest,
+            sourceDigest: certificate.sourceDigest, regressionAuthorityDigest: controlPlaneDigest(certificate.authority) }, () => {
+            if (certificate.contractDigest !== prepared.parent.certificate.contractDigest
+                || controlPlaneDigest(certificate.plan) !== controlPlaneDigest(prepared.candidate.certificate.plan)
+                || controlPlaneDigest(certificate.model) !== controlPlaneDigest(prepared.candidate.certificate.model)) {
+                throw new Error('regression result does not match original held-out and exact candidate');
+            }
+        });
+        return structuredClone(certificate);
+    };
+    /** Synchronous Evaluation writer fence for an exact independently reviewed creation. */
+    withPreparedRevisionFence = (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);
+        const reference = this.store.getOwnerTaskFailureReference(plan.gapId);
+        if (!reference)
+            throw new Error('revision verification source unavailable');
+        return this.taskGaps.withCurrent(plan.gapId, reference.owner, () => {
+            this.abort.signal.throwIfAborted();
+            const current = this.store.getSourcePlan(input.planId);
+            const job = this.store.getPreparedRevisionJob(input.planId);
+            if (current.digest !== input.planDigest || current.mode !== 'prepared-revise' || !current.sourceRevision?.growthRun
+                || !job.intent.revision?.growthRun || !current.sourceCheck || !current.preparedEvidence
+                || current.preparedEvidence.pack.sha256 !== input.artifactSha256
+                || controlPlaneDigest(reference) !== input.referenceDigest
+                || sourceGrowthRunDigest(current.sourceRevision.growthRun) !== input.growthRunDigest
+                || sourceGrowthRunDigest(job.intent.revision.growthRun) !== input.growthRunDigest
+                || !current.sourceRevision.growthRun.revisionAcceptance
+                || controlPlaneDigest(current.sourceRevision.growthRun.revisionAcceptance) !== controlPlaneDigest(policy)
+                || controlPlaneDigest(current.sourceRevision.grant) !== controlPlaneDigest(this.config.sourceJobs?.revision)
+                || controlPlaneDigest(current.sourceRevision.parent) !== input.parentDigest
+                || controlPlaneDigest(this.inspectRevisionParent(current.sourceRevision.parent.planId).parent) !== input.parentDigest) {
+                throw new Error('revision verification exact source binding changed');
+            }
+            this.assertSourceGrowthRun(current.sourceRevision.growthRun, current.gapId, reference.owner, false);
+            const artifact = this.store.readPreparedSourceArtifact(input.planId);
+            if (createHash('sha256').update(artifact).digest('hex') !== input.artifactSha256) {
+                throw new Error('revision verification 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);
+        current();
+        const trust = await this.boundTrust();
+        const environment = inheritedEnvironment(trust);
+        const job = prepared.job;
+        const parent = this.inspectRevisionParent(prepared.plan.sourceRevision.parent.planId);
+        await verifyRevisedPluginWorkspace({ worktree: prepared.plan.worktree, baseCommit: prepared.plan.baseCommit,
+            name: prepared.plan.name, environment, signal: combined, assertCurrent: current,
+            revision: prepared.plan.sourceRevision, parentSource: parent.source, parentCertificate: parent.certificate, files: job.intent.files });
+        const review = await inspectPreparedCreationPatch(prepared.plan, environment, combined);
+        current();
+        return review;
+    };
+    /** Signed behavior evidence over stored pack/checks. Adoption must await async review-context recheck. */
+    inspectVerifiedRevision = (planId) => {
+        const certificate = this.store.getRevisionVerification(planId);
+        if (!certificate)
+            return undefined;
+        const config = this.config.revisionVerifications;
+        if (!config || !verifyPluginRevisionVerificationCertificate(certificate, config.authority, config.publicKey))
+            return undefined;
+        this.withPreparedRevisionFence({ planId, planDigest: certificate.plan.digest,
+            artifactSha256: certificate.plan.artifactSha256, growthRunDigest: certificate.source.growthRunDigest,
+            referenceDigest: certificate.source.referenceDigest, 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);
+    };
+    /** Private Host diagnostic; no cases, prompts, source bytes or verifier output. */
+    inspectRevisionVerification = (planId) => {
+        this.abort.signal.throwIfAborted();
+        const plan = this.store.getSourcePlan(planId);
+        const reference = this.store.getOwnerTaskFailureReference(plan.gapId);
+        if (!reference || plan.mode !== 'prepared-revise')
+            throw new Error('revision verification owner source unavailable');
+        return this.taskGaps.withCurrent(plan.gapId, reference.owner, () => {
+            const current = this.store.getSourcePlan(planId);
+            if (current.mode !== 'prepared-revise' || current.digest !== plan.digest) {
+                throw new Error('revision verification diagnostic plan changed');
+            }
+            return this.store.inspectRevisionVerificationRecord(planId);
+        });
+    };
+    /** Public naming rule only; never disclose grant identity or mutation authority. */
+    getSourceCreationNamespace() {
+        const config = this.config.sourceJobs;
+        if (this.abort.signal.aborted || config?.creation === undefined
+            || Date.now() >= Math.min(config.expiresAt, config.creation.expiresAt))
+            return undefined;
+        return { namePrefix: config.creation.namePrefix };
+    }
+    inspectCreatedCapabilityRevisionCandidate = (planId) => {
+        this.abort.signal.throwIfAborted();
+        const policy = this.config.revisionVerifications;
+        const owner = this.config.creationCapabilities?.owner;
+        const delivery = this.ctx.get('assistantDelivery', false);
+        if (!policy || !owner || !delivery)
+            return undefined;
+        try {
+            const before = delivery.validateOwnerRoute(owner);
+            const { plan, reference, job } = this.store.getRetainedPreparedRevision(planId);
+            const certificate = this.store.getRevisionVerification(planId);
+            if (!certificate || !plan.sourceRevision || !isSourceOwnerContinuation(before, reference.owner)
+                || !verifyPluginRevisionVerificationCertificate(certificate, policy.authority, policy.publicKey, certificate.verifiedAt)
+                || certificate.plan.digest !== plan.digest || certificate.source.referenceDigest !== controlPlaneDigest(reference)
+                || certificate.source.ownerDigest !== job.intent.ownerDigest
+                || certificate.source.growthRunDigest !== sourceGrowthRunDigest(plan.sourceRevision.growthRun)
+                || controlPlaneDigest(certificate.parent) !== controlPlaneDigest(plan.sourceRevision.parent)
+                || controlPlaneDigest(certificate.model) !== controlPlaneDigest(plan.sourceRevision.growthRun.model)
+                || controlPlaneDigest(certificate.authority) !== controlPlaneDigest(plan.sourceRevision.growthRun.revisionAcceptance))
+                return undefined;
+            const parent = this.inspectRevisionParent(certificate.parent.planId);
+            if (controlPlaneDigest(parent.parent) !== controlPlaneDigest(certificate.parent))
+                return undefined;
+            const source = this.store.readRevisionSource(planId);
+            if (!source || controlPlaneDigest(before) !== controlPlaneDigest(delivery.validateOwnerRoute(owner)))
+                return undefined;
+            return Object.freeze({ protocol: 'dsh-created-capability-revision-candidate/v1',
+                certificate: Object.freeze(structuredClone(certificate)), source: Object.freeze({ ...source,
+                    scope: Object.freeze([...source.scope]), entries: Object.freeze(source.entries.map(entry => Object.freeze({ ...entry }))),
+                    files: Object.freeze(source.files.map(file => Object.freeze({ ...file }))) }) });
+        }
+        catch {
+            return undefined;
+        }
+    };
     // Bind Host entry points: Cordis service proxies must not become resource owners.
     enqueueSourceJob = async (input) => {
         this.abort.signal.throwIfAborted();
@@ -642,7 +1644,7 @@ export class PluginControlPlaneService extends Service {
         if (this.sourceBuilds.size !== 0 || this.sourceInspections.size !== 0)
             throw new Error('plugin-control-plane: another source operation is draining');
         const intent = job.intent;
-        const operation = this.prepareModifySourcePlanOwned({ gapId: intent.gapId, name: intent.name, repository: intent.repository, files: intent.files,
+        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);
         this.sourceBuilds.add(operation);
         try {
@@ -652,6 +1654,190 @@ export class PluginControlPlaneService extends Service {
             this.sourceBuilds.delete(operation);
         }
     }
+    async verifyPreparedCreation(job, signal, verifier) {
+        signal.throwIfAborted();
+        if (!job.planId || !this.config.creationVerifications || this.store.getCreationVerificationStatus(job.planId) !== undefined)
+            return;
+        const prepared = this.inspectPreparedCreation(job.planId);
+        if (prepared.job.id !== job.id || !prepared.plan.creation?.growthRun || !prepared.plan.preparedEvidence) {
+            throw new Error('creation verification job is not the exact prepared source');
+        }
+        const binding = { planId: prepared.plan.id, planDigest: prepared.plan.digest,
+            artifactSha256: prepared.plan.preparedEvidence.pack.sha256,
+            growthRunDigest: sourceGrowthRunDigest(prepared.plan.creation.growthRun),
+            referenceDigest: controlPlaneDigest(prepared.reference) };
+        this.withPreparedCreationFence(binding, () => this.store.claimCreationVerification(job.planId));
+        try {
+            const current = verifier();
+            if (typeof current?.verifyPluginCreation !== 'function')
+                throw new Error('independent creation verifier unavailable');
+            const result = await current.verifyPluginCreation({ protocol: 'assistant-growth/creation-verification-request/v1', planId: job.planId }, signal);
+            signal.throwIfAborted();
+            if (result.status === 'verified' && !verifyPluginCreationVerificationCertificate(result.certificate, this.config.creationVerifications.authority, this.config.creationVerifications.publicKey)) {
+                throw new Error('creation verification certificate signature or policy invalid');
+            }
+            if (controlPlaneDigest(await this.boundTrust()) !== job.intent.trustDigest)
+                throw new Error('creation verification trust changed');
+            await this.inspectPreparedCreationReviewContext(job.planId, signal);
+            this.withPreparedCreationFence(binding, () => {
+                if (result.status === 'verified') {
+                    this.store.recordCreationVerification(result.certificate);
+                }
+                else
+                    this.store.settleCreationVerification(job.planId, result.status, typeof result.reason === 'string' && (result.status === 'unknown' ? CREATION_UNKNOWN_CODES : CREATION_REJECTED_CODES).has(result.reason)
+                        ? result.reason : `independent-verifier-${result.status}`);
+            });
+        }
+        catch (error) {
+            // 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.withPreparedCreationFence(binding, () => {
+                    if (this.store.getCreationVerificationStatus(job.planId) === 'claimed') {
+                        this.store.settleCreationVerification(job.planId, 'unknown', 'independent-verification-unsettled');
+                    }
+                });
+            }
+            catch { /* stale owner/source remains permanently claimed */ }
+            throw error;
+        }
+    }
+    async verifyPreparedRevision(job, signal, verifier) {
+        signal.throwIfAborted();
+        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) {
+            throw new Error('revision verification job is not the exact prepared source');
+        }
+        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));
+        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);
+            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');
+            }
+            if (controlPlaneDigest(await this.boundTrust()) !== job.intent.trustDigest)
+                throw new Error('revision verification trust changed');
+            await this.inspectPreparedRevisionReviewContext(job.planId, signal);
+            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, () => {
+                if (result.status === 'verified') {
+                    if (!source)
+                        throw new Error('verified revision source archive unavailable');
+                    this.store.recordRevisionVerification(result.certificate, source);
+                }
+                else
+                    this.store.settleRevisionVerification(job.planId, result.status, typeof result.reason === 'string' && (result.status === 'unknown' ? CREATION_UNKNOWN_CODES : CREATION_REJECTED_CODES).has(result.reason)
+                        ? result.reason : `independent-verifier-${result.status}`);
+            });
+        }
+        catch (error) {
+            // 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, () => {
+                    if (this.store.getRevisionVerificationStatus(job.planId) === 'claimed') {
+                        this.store.settleRevisionVerification(job.planId, 'unknown', 'independent-verification-unsettled');
+                    }
+                });
+            }
+            catch { /* stale owner/source remains permanently claimed */ }
+            throw error;
+        }
+    }
+    async verifyPreparedRevisionRegression(job, signal, verifier) {
+        signal.throwIfAborted();
+        if (!job.planId || !this.config.revisionRegressions || this.store.getRevisionRegressionStatus(job.planId) !== undefined)
+            return;
+        const prepared = this.inspectPreparedRevisionRegression(job.planId);
+        if (prepared.job.id !== job.id)
+            throw new Error('regression job is not exact prepared revision');
+        const certificate = prepared.candidate.certificate;
+        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) };
+        this.withPreparedRevisionRegressionFence(binding, () => this.store.claimRevisionRegression(job.planId));
+        try {
+            const current = verifier();
+            if (typeof current?.verifyPluginRevisionRegression !== 'function')
+                throw new Error('independent regression verifier unavailable');
+            const result = await current.verifyPluginRevisionRegression({ protocol: 'assistant-growth/revision-regression-request/v1', planId: job.planId }, signal);
+            signal.throwIfAborted();
+            if (result.status === 'verified' && !verifyPluginRevisionRegressionCertificate(result.certificate, this.config.revisionRegressions.authority, this.config.revisionRegressions.publicKey)) {
+                throw new Error('regression signature or independent policy invalid');
+            }
+            if (controlPlaneDigest(await this.boundTrust()) !== job.intent.trustDigest)
+                throw new Error('regression trust changed');
+            await this.inspectPreparedRevisionReviewContext(job.planId, signal);
+            this.withPreparedRevisionRegressionFence(binding, () => {
+                if (result.status === 'verified') {
+                    if (!verifyPluginRevisionRegressionCertificate(result.certificate, this.config.revisionRegressions.authority, this.config.revisionRegressions.publicKey))
+                        throw new Error('regression certificate expired before settlement');
+                    this.store.recordRevisionRegression(result.certificate);
+                }
+                else
+                    this.store.settleRevisionRegression(job.planId, result.status, typeof result.reason === 'string' && /^[a-z][a-z0-9-]{0,79}$/u.test(result.reason)
+                        ? result.reason : `independent-regression-${result.status}`);
+            });
+        }
+        catch (error) {
+            try {
+                this.withPreparedRevisionRegressionFence(binding, () => {
+                    if (this.store.getRevisionRegressionStatus(job.planId) === 'claimed') {
+                        this.store.settleRevisionRegression(job.planId, 'unknown', 'independent-regression-unsettled');
+                    }
+                });
+            }
+            catch { /* changed source retains its durable no-replay claim */ }
+            throw error;
+        }
+    }
+    async inspectRevisionSource(input) {
+        this.abort.signal.throwIfAborted();
+        const config = this.config.sourceJobs;
+        if (!config?.revision || !this.inspectSourceRevisionAcceptanceAuthority() || input.repository !== config.repository
+            || this.sourceBuilds.size !== 0 || this.sourceInspections.size !== 0)
+            throw new Error('revision source inspection unavailable');
+        const signal = AbortSignal.any([this.abort.signal, ...(input.signal ? [input.signal] : []), AbortSignal.timeout(15_000)]);
+        const parent = this.inspectRevisionParent(input.parentPlanId);
+        if (parent.name !== input.name)
+            throw new Error('revision source name differs from adopted parent');
+        const assertCurrent = async () => {
+            signal.throwIfAborted();
+            await input.assertCurrent?.();
+            signal.throwIfAborted();
+            if (!this.inspectSourceRevisionAcceptanceAuthority() || controlPlaneDigest(this.inspectRevisionParent(input.parentPlanId).parent) !== controlPlaneDigest(parent.parent))
+                throw new Error('revision source authority or parent changed');
+        };
+        const operation = (async () => {
+            const trust = await this.boundTrust(), environment = inheritedEnvironment(trust);
+            const baselineCommit = config.baseline === undefined ? undefined : await resolveSourceBaseline({ repository: config.repository,
+                config: config.baseline, environment, signal, assertCurrent, trust,
+                readHistory: () => this.store.getSourceBaselineHistory(config.repository), readMaintenance: () => this.store.getSourceMaintenanceRecords(config.repository) });
+            return inspectSourceRevisionContext({ repository: config.repository, name: input.name, paths: input.paths,
+                ...(input.baseCommit === undefined ? {} : { baseCommit: input.baseCommit }), ...(baselineCommit === undefined ? {} : { baselineCommit }),
+                environment, signal, assertCurrent, grant: config.revision, parent: parent.parent, parentSource: parent.source, parentCertificate: parent.certificate });
+        })();
+        this.sourceInspections.add(operation);
+        try {
+            return await operation;
+        }
+        finally {
+            this.sourceInspections.delete(operation);
+        }
+    }
     async inspectSource(input) {
         this.abort.signal.throwIfAborted();
         if (this.sourceBuilds.size !== 0 || this.sourceInspections.size !== 0)
@@ -662,12 +1848,83 @@ export class PluginControlPlaneService extends Service {
         void operation.then(() => this.sourceInspections.delete(operation), () => this.sourceInspections.delete(operation));
         return operation;
     }
+    async inspectSourceTargets(input) {
+        this.abort.signal.throwIfAborted();
+        if (this.sourceBuilds.size !== 0 || this.sourceInspections.size !== 0)
+            throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'another source operation is still draining');
+        const signal = AbortSignal.any([this.abort.signal, ...(input.signal === undefined ? [] : [input.signal]), AbortSignal.timeout(15_000)]);
+        const operation = this.inspectSourceTargetsOwned({ ...input, signal });
+        this.sourceInspections.add(operation);
+        void operation.then(() => this.sourceInspections.delete(operation), () => this.sourceInspections.delete(operation));
+        return operation;
+    }
+    async inspectSourceTargetsOwned(input) {
+        const signal = input.signal === undefined ? this.abort.signal : AbortSignal.any([this.abort.signal, input.signal]);
+        const assertCurrent = async () => { signal.throwIfAborted(); await awaitSourceSignal(signal, () => input.assertCurrent?.()); signal.throwIfAborted(); };
+        await assertCurrent();
+        const trust = await awaitSourceSignal(signal, () => this.boundTrust());
+        const environment = inheritedEnvironment(trust);
+        const baseline = this.config.sourceJobs?.repository === input.repository ? this.config.sourceJobs.baseline : undefined;
+        const baselineCommit = baseline === undefined ? undefined : await resolveSourceBaseline({ repository: input.repository,
+            config: baseline, environment, signal, assertCurrent, trust,
+            readHistory: () => this.store.getSourceBaselineHistory(input.repository),
+            readMaintenance: () => this.store.getSourceMaintenanceRecords(input.repository) });
+        return inspectSourceTargetsContext({ repository: input.repository,
+            ...(input.baseCommit === undefined ? {} : { baseCommit: input.baseCommit }),
+            ...(baselineCommit === undefined ? {} : { baselineCommit }), environment, signal, assertCurrent });
+    }
     async inspectSourceOwned(input) {
         const signal = input.signal === undefined ? this.abort.signal : AbortSignal.any([this.abort.signal, input.signal]);
         const assertCurrent = async () => { signal.throwIfAborted(); await awaitSourceSignal(signal, () => input.assertCurrent?.()); signal.throwIfAborted(); };
         await assertCurrent();
         const trust = await awaitSourceSignal(signal, () => this.boundTrust());
-        return inspectSourceContext({ ...input, environment: inheritedEnvironment(trust), signal, assertCurrent });
+        const environment = inheritedEnvironment(trust);
+        const baseline = this.config.sourceJobs?.repository === input.repository ? this.config.sourceJobs.baseline : undefined;
+        const baselineCommit = baseline === undefined ? undefined : await resolveSourceBaseline({ repository: input.repository,
+            config: baseline, environment, signal, assertCurrent, trust,
+            readHistory: () => this.store.getSourceBaselineHistory(input.repository),
+            readMaintenance: () => this.store.getSourceMaintenanceRecords(input.repository) });
+        return inspectSourceContext({ repository: input.repository, name: input.name, paths: input.paths,
+            ...(input.baseCommit === undefined ? {} : { baseCommit: input.baseCommit }),
+            ...(baselineCommit === undefined ? {} : { baselineCommit }), environment, signal, assertCurrent });
+    }
+    async inspectCreateSource(input) {
+        this.abort.signal.throwIfAborted();
+        if (this.sourceBuilds.size !== 0 || this.sourceInspections.size !== 0)
+            throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'another source operation is still draining');
+        const signal = AbortSignal.any([this.abort.signal, ...(input.signal === undefined ? [] : [input.signal]), AbortSignal.timeout(15_000)]);
+        const operation = this.inspectCreateSourceOwned({ ...input, signal });
+        this.sourceInspections.add(operation);
+        try {
+            return await operation;
+        }
+        finally {
+            this.sourceInspections.delete(operation);
+        }
+    }
+    async inspectCreateSourceOwned(input) {
+        const config = this.config.sourceJobs;
+        if (!config?.creation || config.repository !== input.repository)
+            throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'plugin creation authority is not configured for this repository');
+        const signal = input.signal === undefined ? this.abort.signal : AbortSignal.any([this.abort.signal, input.signal]);
+        const assertCurrent = async () => {
+            signal.throwIfAborted();
+            await awaitSourceSignal(signal, () => input.assertCurrent?.());
+            signal.throwIfAborted();
+            if (Date.now() >= config.creation.expiresAt || Date.now() >= config.expiresAt)
+                throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'plugin creation authority expired');
+        };
+        await assertCurrent();
+        const trust = await awaitSourceSignal(signal, () => this.boundTrust());
+        const environment = inheritedEnvironment(trust);
+        const baselineCommit = config.baseline === undefined ? undefined : await resolveSourceBaseline({ repository: input.repository,
+            config: config.baseline, environment, signal, assertCurrent, trust,
+            readHistory: () => this.store.getSourceBaselineHistory(input.repository),
+            readMaintenance: () => this.store.getSourceMaintenanceRecords(input.repository) });
+        const inspected = await inspectSourceCreationContext({ repository: input.repository, name: input.name, paths: input.paths,
+            ...(input.baseCommit === undefined ? {} : { baseCommit: input.baseCommit }),
+            ...(baselineCommit === undefined ? {} : { baselineCommit }), environment, signal, assertCurrent, grant: config.creation });
+        return { name: inspected.name, baseCommit: inspected.baseCommit, files: inspected.files, contents: inspected.contents };
     }
     async plan(candidateId, profile, idempotencyKey, gapId) {
         const gap = this.store.getGap(gapId);
@@ -702,19 +1959,32 @@ export class PluginControlPlaneService extends Service {
         this.abort.signal.throwIfAborted();
         if (this.sourceBuilds.size !== 0 || this.sourceInspections.size !== 0)
             throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'another source operation is still draining');
-        const operation = this.prepareModifySourcePlanOwned(input);
+        const operation = this.prepareSourcePlanOwned(input);
         this.sourceBuilds.add(operation);
         void operation.then(() => this.sourceBuilds.delete(operation), () => this.sourceBuilds.delete(operation));
         return operation;
     }
-    async prepareModifySourcePlanOwned(input, sourceJob) {
+    async prepareSourcePlanOwned(input, sourceJob) {
         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';
+        const creation = creating ? sourceJob.intent.creation : undefined;
+        const revising = sourceJob?.intent.mode === 'revise-created';
+        const revision = revising ? sourceJob.intent.revision : undefined;
+        const parent = revision === undefined ? undefined : this.inspectRevisionParent(revision.parent.planId);
         const assertCurrent = async () => {
             signal.throwIfAborted();
             await input.assertCurrent?.();
             signal.throwIfAborted();
             this.taskGaps.withCurrent(input.gapId, gapOwner, () => { });
+            if (revising && (!revision || !this.config.sourceJobs?.revision || Date.now() >= revision.grant.expiresAt
+                || controlPlaneDigest(revision.grant) !== controlPlaneDigest(this.config.sourceJobs.revision)
+                || controlPlaneDigest(this.inspectRevisionParent(revision.parent.planId).parent) !== controlPlaneDigest(revision.parent)))
+                throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'plugin revision authority or parent changed');
+            if (creating && (!creation || !this.config.sourceJobs?.creation || Date.now() >= creation.grant.expiresAt
+                || controlPlaneDigest(creation.grant) !== controlPlaneDigest(this.config.sourceJobs.creation))) {
+                throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'plugin creation authority changed or expired');
+            }
         };
         await assertCurrent();
         const trust = await this.boundTrust();
@@ -722,15 +1992,19 @@ export class PluginControlPlaneService extends Service {
         if (!/^(?=.{1,64}$)[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u.test(name))
             throw new ControlPlaneCliError('INVALID_ARGUMENT', 'plugin name is invalid');
         assertPluginModificationAllowed(name);
-        validateScopedPluginFiles(input.files);
-        if (this.config.sourceBuild?.versioning === 'patch')
-            assertManagedVersionPaths(input.files);
+        if (creating || revising)
+            validateSourceCreationFiles(input.files);
+        else {
+            validateScopedPluginFiles(input.files);
+            if (this.config.sourceBuild?.versioning === 'patch')
+                assertManagedVersionPaths(input.files);
+        }
         // Re-validate the gap reservation immediately before doing the work: the
         // store re-checks under BEGIN IMMEDIATE, but failing early avoids building
         // a patch against a gap that is already matched or closed.
         const gap = this.store.getGap(input.gapId);
         if (gap.status !== 'open' || gap.candidateId !== undefined) {
-            throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'only an unreserved pre-existing control-plane open gap can receive a modify proposal');
+            throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'only an unreserved current control-plane open gap can receive a source proposal');
         }
         const repository = await realpath(resolve(input.repository));
         if (resolve(repository) !== repository)
@@ -746,7 +2020,12 @@ export class PluginControlPlaneService extends Service {
         }
         const offline = input.offline ?? true;
         const environment = inheritedEnvironment(trust);
-        const baseCommit = (await runLocalCommand('git', ['rev-parse', 'HEAD'], repository, environment, { capture: true })).trim();
+        const baseline = this.config.sourceJobs?.repository === repository ? this.config.sourceJobs.baseline : undefined;
+        const baseCommit = baseline === undefined
+            ? (await runLocalCommand('git', ['rev-parse', 'HEAD'], repository, environment, { capture: true })).trim()
+            : await resolveSourceBaseline({ repository, config: baseline, environment, signal, assertCurrent, trust,
+                readHistory: () => this.store.getSourceBaselineHistory(repository),
+                readMaintenance: () => this.store.getSourceMaintenanceRecords(repository) });
         await assertCurrent();
         if (!/^[a-f0-9]{40}$/u.test(baseCommit))
             throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'repository HEAD is not a 40-hex commit id');
@@ -756,7 +2035,12 @@ export class PluginControlPlaneService extends Service {
         const isolated = await createIsolatedWorktree({ stateRoot, repository, baseCommit, environment,
             ...(sourceJob === undefined ? {} : { worktreeName: basename(sourceJob.intent.worktree) }) });
         try {
-            await writeScopedPluginFiles({ worktree: isolated.worktree, name, files: input.files });
+            const generated = revision !== undefined ? await prepareRevisedPluginWorkspace({ worktree: isolated.worktree,
+                baseCommit, name, files: input.files, environment, signal, assertCurrent, revision, parentSource: parent.source, parentCertificate: parent.certificate })
+                : creation === undefined ? undefined : await prepareCreatedPluginWorkspace({ worktree: isolated.worktree,
+                    baseCommit, name, files: input.files, environment, signal, assertCurrent, creation });
+            if (generated === undefined)
+                await writeScopedPluginFiles({ worktree: isolated.worktree, name, files: input.files });
             await assertCurrent();
             if (this.config.sourceBuild === undefined)
                 throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'isolated source build runner is not configured');
@@ -764,16 +2048,34 @@ export class PluginControlPlaneService extends Service {
                 throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'isolated source builds must remain offline');
             const configured = this.config.sourceBuild;
             const versionInput = { worktree: isolated.worktree, baseCommit, name, environment, signal, assertCurrent };
-            const managed = configured.versioning === 'patch' ? await managedPatchVersionFiles(versionInput) : undefined;
+            const managed = !creating && !revising && configured.versioning === 'patch' ? await managedPatchVersionFiles(versionInput) : undefined;
             if (managed !== undefined) {
                 await assertCurrent();
                 await writeScopedPluginFiles({ worktree: isolated.worktree, name, files: managed.files });
                 await verifyManagedPatchVersion(versionInput);
             }
+            // 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 checked = await runDockerPreparedChecks({ config: { ...configured, timeoutMs: Math.min(timeoutMs, configured.timeoutMs) },
-                worktree: isolated.worktree, baseCommit, name, scope: [`plugins/${name}`], environment, signal,
-                assertCurrent, preparedAt: Date.now(), ...(sourceJob === undefined ? {} : { sourceJob: { id: sourceJob.id, containerName: sourceJob.intent.containerName } }) });
+                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 } : {}),
+                ...(sourceJob === undefined ? {} : { sourceJob: { id: sourceJob.id, containerName: sourceJob.intent.containerName } }) });
             await assertCurrent();
+            if (capturePack && checked.packArtifact === undefined)
+                throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'prepared creation artifact was not captured');
+            if (revision !== undefined) {
+                await verifyRevisedPluginWorkspace({ worktree: isolated.worktree, baseCommit, name, files: input.files, environment, signal, assertCurrent, revision, parentSource: parent.source, parentCertificate: parent.certificate });
+            }
+            if (creation !== undefined) {
+                await verifyCreatedPluginWorkspace({ worktree: isolated.worktree, baseCommit, name,
+                    files: input.files, environment, signal, assertCurrent, creation });
+                const manifest = JSON.parse(await readFile(join(isolated.worktree, 'plugins', name, 'package.json'), 'utf8'));
+                if (checked.evidence.pack.version !== manifest.version)
+                    throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'new plugin artifact does not carry the generated version');
+            }
             if (managed !== undefined) {
                 await verifyManagedPatchVersion(versionInput);
                 if (checked.evidence.pack.version !== managed.version)
@@ -782,7 +2084,10 @@ 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,
-                name, generatorDigest: MODIFY_GENERATOR_DIGEST, scope: [`plugins/${name}`], mode: 'modify', ttlMs,
+                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 }),
+                ...(capturePack && checked.packArtifact !== undefined ? { preparedArtifact: checked.packArtifact } : {}),
                 idempotencyKey: input.idempotencyKey,
                 ...(sourceJob === undefined ? {} : { sourceJob: { jobId: sourceJob.id, jobRevision: sourceJob.revision, occurrenceId: sourceJob.occurrenceId } }),
                 prepared: { treeDigest: checked.treeDigest, patchDigest: checked.patchDigest, checkedAt: checked.checkedAt, evidence: checked.evidence } }).result);