@dsh-enhanced/plugin-control-plane 0.1.32 → 0.1.34

package/lib/service.js

@@ -1,14 +1,46 @@
+import { AdoptionCoordinatorRuntime, validateAdoptionCoordinatorConfig } from './adoption-coordinator.js';
 import { lstat, realpath } from 'node:fs/promises';
+import { realpathSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { TaskObservationRuntime, validateTaskObservationConfig } from './task-observation-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 { ControlPlaneStore } from './store.js';
-import { loadTrustConfig } from './trust.js';
+import { ControlPlaneCliError } from './errors.js';
+import { assertPluginModificationAllowed, createIsolatedWorktree, gcPreparedModifyWorktrees, 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';
+import { Ed25519SourceReleaseAuthorizationAuthority } from './release.js';
+import { advanceSourceRelease, sourceReleaseAuthorities, validateSourceReleaseExecutionConfig } from './source-release-runner.js';
+import { adoptSourceRelease, validateSourceAdoptionConfig } from './source-adoption-runner.js';
+import { Ed25519ApprovalAuthority } from './approval.js';
+import { ControlPlaneStore, MODIFY_GENERATOR_DIGEST, controlPlaneDigest } from './store.js';
+import { runDockerPreparedChecks, validateSourceBuildConfig } from './source-build.js';
+import { awaitSourceSignal, inspectSourceContext } from './source-context.js';
+import { inheritedEnvironment, loadTrustConfig, resolveTrustKey } from './trust.js';
 import { registerPluginControlTools } from './tools.js';
+import { 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';
 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(),
+    sourceApprovals: Schema.any(),
+    sourceReleases: Schema.any(),
+    sourceReleaseExecution: Schema.any(),
+    sourceAdoptions: Schema.any(),
+    adoptionCoordinator: Schema.any(),
+    runtimeObserver: Schema.any(),
+    foregroundDeployments: Schema.any(),
+    taskObservations: Schema.any(),
+    replayEndpoint: Schema.any(),
 });
 async function canonicalTarget(dshHome, profile) {
     const profiles = join(dshHome, 'profiles');
@@ -28,19 +60,311 @@ async function canonicalTarget(dshHome, profile) {
     }
     return Object.freeze({ dshHome, profile, profilePath });
 }
+/**
+ * Read-only deployment preflight for profile installers. It validates and clones
+ * control-plane configuration without opening a ledger, mounting a service,
+ * starting effects, or creating runtime resources. Existing path/key validators
+ * may read deployment files.
+ */
+export function normalizeControlPlaneConfig(input) {
+    const config = structuredClone(schema(input));
+    if (config.runtimeObserver !== undefined)
+        validateRuntimeObserverConfig(config.runtimeObserver);
+    if (config.foregroundDeployments !== undefined) {
+        validateForegroundDeploymentConfig(config.foregroundDeployments);
+        if (!config.runtimeObserver)
+            throw new Error('plugin-control-plane: foregroundDeployments requires runtimeObserver');
+    }
+    if (config.taskObservations !== undefined) {
+        validateTaskObservationConfig(config.taskObservations);
+        if (!config.foregroundDeployments || config.taskObservations.profilePath !== config.runtimeObserver?.profilePath) {
+            throw new Error('plugin-control-plane: taskObservations requires foregroundDeployments on the same profile');
+        }
+    }
+    if (config.replayEndpoint !== undefined) {
+        validateReplayEndpointConfig(config.replayEndpoint);
+        if (config.runtimeObserver !== undefined) {
+            const observer = config.runtimeObserver, replay = config.replayEndpoint.runtime;
+            if (observer.socketPath === replay.socketPath || observer.keyPath === replay.keyPath)
+                throw new Error('plugin-control-plane: replay requires a separate socket and key');
+            const observerKey = readPrivateRuntimeObserverKey(observer.keyPath), replayKey = readPrivateRuntimeObserverKey(replay.keyPath);
+            try {
+                if (observerKey.equals(replayKey))
+                    throw new Error('plugin-control-plane: replay requires distinct key material');
+            }
+            finally {
+                observerKey.fill(0);
+                replayKey.fill(0);
+            }
+        }
+    }
+    if (config.sourceApprovals !== undefined)
+        validateSourceApprovalClientConfig(config.sourceApprovals);
+    if (config.sourceBuild !== undefined)
+        validateSourceBuildConfig(config.sourceBuild);
+    if (config.sourceReleases !== undefined) {
+        validateSourceReleaseClientConfig(config.sourceReleases);
+        if (!config.sourceApprovals || config.sourceBuild?.versioning !== 'patch')
+            throw new Error('plugin-control-plane: sourceReleases requires sourceApprovals and Host patch versioning');
+    }
+    if (config.sourceReleaseExecution !== undefined) {
+        validateSourceReleaseExecutionConfig(config.sourceReleaseExecution);
+        if (!config.sourceReleases)
+            throw new Error('plugin-control-plane: sourceReleaseExecution requires sourceReleases');
+    }
+    if (config.adoptionCoordinator !== undefined) {
+        validateAdoptionCoordinatorConfig(config.adoptionCoordinator);
+        if (config.sourceJobs || config.sourceAdoptions || config.runtimeObserver || config.replayEndpoint) {
+            throw new Error('plugin-control-plane: adoptionCoordinator requires a separate Host from target source jobs and observation');
+        }
+    }
+    if (config.sourceAdoptions !== undefined) {
+        validateSourceAdoptionConfig(config.sourceAdoptions);
+        if (!config.sourceReleaseExecution)
+            throw new Error('plugin-control-plane: sourceAdoptions requires sourceReleaseExecution');
+    }
+    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.catalogPath, config.statePath, config.trustPath].every(isAbsolute))
+        throw new Error('plugin-control-plane: catalogPath, statePath and trustPath must be absolute');
+    return config;
+}
 export class PluginControlPlaneService extends Service {
     static Config = schema;
     config;
     store;
+    taskGaps;
+    abort = new AbortController();
+    sourceBuilds = new Set();
+    sourceInspections = new Set();
+    sourceApprovalFlights = new Set();
+    sourceReleaseFlights = new Set();
+    sourceReleaseAdvances = new Map();
+    sourceAdoptionFlights = new Map();
+    foregroundObservers = new Set();
+    sourceRuntime;
+    sourceRuntimes = new Set();
     constructor(ctx, input) {
         super(ctx, 'pluginControlPlane');
-        this.config = schema(input);
-        if (![this.config.catalogPath, this.config.statePath, this.config.trustPath].every(isAbsolute))
-            throw new Error('plugin-control-plane: catalogPath, statePath and trustPath must be absolute');
+        this.config = normalizeControlPlaneConfig(input);
         this.store = new ControlPlaneStore({ path: join(this.config.statePath, 'control.sqlite') });
-        ctx.effect(() => () => this.store.close(), 'plugin-control-plane.store');
+        this.taskGaps = new OwnerTaskFailureGaps(this.store, () => {
+            this.abort.signal.throwIfAborted();
+            const delivery = ctx.get('assistantDelivery', false);
+            const evaluation = ctx.get('assistantEvaluation', false);
+            if (typeof delivery?.inspectOwnerForegroundLearningTask !== 'function'
+                || typeof evaluation?.withTrustedCanonicalTaskWriterFence !== 'function')
+                throw new Error('plugin-control-plane: owner task source services unavailable');
+            return { delivery, evaluation };
+        });
+        ctx.effect(() => async () => {
+            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();
+        }, 'plugin-control-plane.store');
         ctx.inject(['tools'], toolsCtx => registerPluginControlTools(toolsCtx, this));
+        if (this.config.runtimeObserver !== undefined)
+            installRuntimeObserver(ctx, this.config.runtimeObserver, this.config.foregroundDeployments ? (observerCtx, sample) => {
+                const fiber = observerCtx.inject(['assistantDelivery'], deliveryCtx => {
+                    deliveryCtx.effect(async () => {
+                        const snapshot = foregroundTrustSnapshot(this.config.trustPath);
+                        const trust = await this.boundTrust();
+                        let live = true;
+                        const assertCurrent = () => {
+                            this.abort.signal.throwIfAborted();
+                            if (!live || foregroundTrustSnapshot(this.config.trustPath) !== snapshot)
+                                throw new Error('foreground deployment trust changed');
+                        };
+                        assertCurrent();
+                        const registration = createForegroundDeploymentObserver({ config: this.config.foregroundDeployments,
+                            profilePath: this.config.runtimeObserver.profilePath, store: this.store, trust, sample, assertCurrent, owner: this });
+                        this.foregroundObservers.add(registration);
+                        try {
+                            const delivery = deliveryCtx.get('assistantDelivery');
+                            const remove = delivery.registerForegroundTaskObserver(registration);
+                            return () => { live = false; this.foregroundObservers.delete(registration); remove(); };
+                        }
+                        catch (error) {
+                            live = false;
+                            this.foregroundObservers.delete(registration);
+                            throw error;
+                        }
+                    }, 'plugin-control-plane.foreground-deployments');
+                });
+                return () => fiber.dispose();
+            } : undefined);
+        if (this.config.replayEndpoint !== undefined)
+            installReplayEndpoint(ctx, this.config.replayEndpoint);
+        if (this.config.adoptionCoordinator !== undefined)
+            ctx.inject(['assistantAutomations'], coordinatorCtx => {
+                coordinatorCtx.effect(async () => {
+                    const snapshot = foregroundTrustSnapshot(this.config.trustPath), trust = await this.boundTrust();
+                    this.abort.signal.throwIfAborted();
+                    const store = new ControlPlaneStore({ path: trust.ledger.path, adoptionCoordinatorId: this.config.adoptionCoordinator.coordinatorId });
+                    const automations = () => coordinatorCtx.get('assistantAutomations');
+                    let runtime;
+                    try {
+                        runtime = new AdoptionCoordinatorRuntime({ config: this.config.adoptionCoordinator, store, trust,
+                            assertCurrent: () => {
+                                this.abort.signal.throwIfAborted();
+                                if (foregroundTrustSnapshot(this.config.trustPath) !== snapshot)
+                                    throw new Error('adoption coordinator trust changed');
+                            },
+                            automations: {
+                                registerHostExecutor: input => automations().registerHostExecutor(input),
+                                reconcileSystem: input => automations().reconcileSystem(input),
+                                inspectSystemOwnedActivation: input => automations().inspectSystemOwnedActivation(input),
+                            }, });
+                        runtime.start();
+                        return () => runtime.close();
+                    }
+                    catch (error) {
+                        if (runtime)
+                            await runtime.close();
+                        else
+                            store.close();
+                        throw error;
+                    }
+                }, 'plugin-control-plane.adoption-coordinator');
+            });
+        if (this.config.taskObservations !== 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 TaskObservationRuntime({ config: this.config.taskObservations, store, trust,
+                            assertCurrent: () => {
+                                this.abort.signal.throwIfAborted();
+                                if (foregroundTrustSnapshot(this.config.trustPath) !== snapshot)
+                                    throw new Error('task observation trust changed');
+                            },
+                            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),
+                            },
+                            rollback: (planId, signal) => rollbackPluginWatch({ store, trust, planId, signal }), });
+                        runtime.start();
+                        return () => runtime.close();
+                    }
+                    catch (error) {
+                        if (runtime)
+                            await runtime.close();
+                        else
+                            store.close();
+                        throw error;
+                    }
+                }, 'plugin-control-plane.task-observations');
+            });
+        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 => {
+                jobsCtx.effect(async () => {
+                    this.abort.signal.throwIfAborted();
+                    const current = (key) => jobsCtx.get((key === 'automations' ? 'assistantAutomations' : 'assistantDelivery'));
+                    for (const method of ['registerHostExecutor', 'reconcileSystem', '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');
+                    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),
+                                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),
+                        ...(this.config.sourceApprovals ? { approvePrepared: async (job, signal) => {
+                                if (!job.planId)
+                                    throw new Error('source job has no prepared plan');
+                                await this.requestOwnerSourceApproval({ planId: job.planId, signal, expectedTrustDigest: job.intent.trustDigest });
+                            } } : {}),
+                        ...(this.config.sourceReleases ? { releasePrepared: async (job, signal) => {
+                                if (!job.planId)
+                                    throw new Error('source job has no prepared plan');
+                                await this.requestOwnerSourceRelease({ planId: job.planId, signal, expectedTrustDigest: job.intent.trustDigest });
+                            } } : {}),
+                        ...(this.config.sourceReleaseExecution ? { releaseTimeoutMs: this.config.sourceReleaseExecution.timeoutMs,
+                            advanceReleased: async (job, signal) => {
+                                if (!job.planId)
+                                    throw new Error('source job has no release plan');
+                                await this.advanceOwnerSourceRelease({ planId: job.planId, signal, expectedTrustDigest: job.intent.trustDigest });
+                            } } : {}),
+                        ...(this.config.sourceAdoptions ? { adoptionTimeoutMs: this.config.sourceAdoptions.timeoutMs,
+                            adoptReleased: async (job, signal, assertCurrent) => {
+                                if (!job.planId)
+                                    throw new Error('source job has no released plan');
+                                await this.adoptOwnerSourceRelease({ sourcePlanId: job.planId, signal, expectedTrustDigest: job.intent.trustDigest, assertCurrent });
+                            } } : {}),
+                        trust: () => this.boundTrust(), prepare: (job, signal, assertCurrent) => this.prepareSourceJob(job, signal, assertCurrent), });
+                    this.sourceRuntimes.add(runtime);
+                    const close = async () => {
+                        if (this.sourceRuntime === runtime)
+                            this.sourceRuntime = undefined;
+                        try {
+                            await runtime.close();
+                        }
+                        finally {
+                            this.sourceRuntimes.delete(runtime);
+                        }
+                    };
+                    try {
+                        runtime.start();
+                        this.abort.signal.throwIfAborted();
+                        this.sourceRuntime = runtime;
+                        return close;
+                    }
+                    catch (error) {
+                        await close();
+                        throw error;
+                    }
+                }, 'plugin-control-plane.source-jobs');
+            });
     }
+    ownsForegroundTaskObservationRegistration = (registration) => !this.abort.signal.aborted && this.foregroundObservers.has(registration);
+    /** Host-only readback. The current trusted task is reread; no caller rating is accepted. */
+    inspectOwnerForegroundDeployment = (input) => {
+        this.abort.signal.throwIfAborted();
+        const delivery = this.ctx.get('assistantDelivery', false);
+        if (!delivery)
+            throw new Error('foreground deployment Delivery unavailable');
+        const source = delivery.inspectOwnerForegroundLearningTask(input);
+        if (!source)
+            return undefined;
+        const record = this.store.getForegroundDeployment(source.source.inboxId);
+        if (!record || record.state !== 'observed' || !source.source.quiescent
+            || record.task.sessionId !== source.source.sessionId
+            || record.task.owner.principalRecordId !== source.owner.principalRecordId
+            || record.task.owner.principalVersion !== source.owner.principalVersion
+            || record.task.scope.workspace !== source.owner.workspace || record.task.scope.preset !== source.owner.agentPreset)
+            return undefined;
+        return record;
+    };
     async boundTrust() {
         const trust = await loadTrustConfig(this.config.trustPath);
         if (resolve(join(this.config.statePath, 'control.sqlite')) !== trust.ledger.path
@@ -54,9 +378,297 @@ export class PluginControlPlaneService extends Service {
         const loaded = await loadCatalogWithMetadata(this.config.catalogPath);
         return discover(loaded.catalog, capability);
     }
+    /** Host only: reread the exact source; no caller text or ratings are admitted. */
+    recordOwnerTaskFailureGap = (source) => {
+        this.abort.signal.throwIfAborted();
+        return this.taskGaps.record(source);
+    };
+    /** Host-only idempotent approval under a preconfigured finite authority. */
+    requestOwnerSourceApproval = async (input) => {
+        this.abort.signal.throwIfAborted();
+        const config = this.config.sourceApprovals;
+        if (!config)
+            throw new Error('plugin-control-plane: source approval authority unavailable');
+        const signal = AbortSignal.any([this.abort.signal, ...(input.signal ? [input.signal] : [])]);
+        const operation = (async () => {
+            const plan = this.store.getSourcePlan(input.planId);
+            const source = this.store.getOwnerTaskFailureReference(plan.gapId);
+            if (!source || plan.mode !== 'modify' || !plan.sourceCheck || !plan.preparedEvidence)
+                throw new Error('source approval requires a prepared owner task repair');
+            signal.throwIfAborted();
+            this.taskGaps.withCurrent(plan.gapId, source.owner, () => { });
+            if (plan.status === 'approved')
+                return plan;
+            if (plan.status !== 'pending-approval')
+                throw new Error('source plan is not pending approval');
+            const trust = await this.boundTrust();
+            if (input.expectedTrustDigest !== undefined && controlPlaneDigest(trust) !== input.expectedTrustDigest)
+                throw new Error('source job approval trust changed');
+            const receipt = await requestSourceApproval(config, { protocol: 'dsh-source-approval/v1', planId: plan.id,
+                planDigest: plan.digest, sourceReferenceDigest: controlPlaneDigest(source) }, signal);
+            signal.throwIfAborted();
+            if (controlPlaneDigest(await this.boundTrust()) !== controlPlaneDigest(trust))
+                throw new Error('source approval trust changed');
+            const key = resolveTrustKey(trust, 'approval', receipt.authority, receipt.keyId);
+            const result = await this.store.approveSource({ planId: plan.id, expectedRevision: plan.revision, receipt,
+                resolveAuthority: () => new Ed25519ApprovalAuthority(key.publicKeyPem, key.authority, key.keyId),
+                idempotencyKey: `source-authority:${plan.id}`, withSourceFence: callback => {
+                    signal.throwIfAborted();
+                    return this.taskGaps.withCurrent(plan.gapId, source.owner, callback);
+                } });
+            return result.result;
+        })();
+        // The child has a bounded timeout and is drained before the store closes.
+        this.sourceApprovalFlights.add(operation);
+        try {
+            return await operation;
+        }
+        finally {
+            this.sourceApprovalFlights.delete(operation);
+        }
+    };
+    /** Host-only: enter the existing release state machine under a separate finite grant. */
+    requestOwnerSourceRelease = async (input) => {
+        this.abort.signal.throwIfAborted();
+        const config = this.config.sourceReleases;
+        if (!config)
+            throw new Error('plugin-control-plane: source release authority unavailable');
+        const signal = AbortSignal.any([this.abort.signal, AbortSignal.timeout(30_000), ...(input.signal ? [input.signal] : [])]);
+        const operation = (async () => {
+            let plan = this.store.getSourcePlan(input.planId);
+            const source = this.store.getOwnerTaskFailureReference(plan.gapId);
+            if (!source || plan.mode !== 'modify' || !plan.sourceCheck || !plan.preparedEvidence)
+                throw new Error('source release requires a prepared owner task repair');
+            const withSourceFence = (callback) => {
+                signal.throwIfAborted();
+                return this.taskGaps.withCurrent(plan.gapId, source.owner, callback);
+            };
+            withSourceFence(() => { });
+            const trust = await this.boundTrust();
+            if (input.expectedTrustDigest !== undefined && controlPlaneDigest(trust) !== input.expectedTrustDigest)
+                throw new Error('source job release trust changed');
+            signal.throwIfAborted();
+            if (trust.schemaVersion !== 4 || !trust.releaseRegistry || !trust.releaseRegistry.locator.startsWith('file:'))
+                throw new Error('finite source release requires local schema-v4 release trust');
+            // A committed release never requests a new signature, even after restart.
+            if (plan.release !== undefined)
+                return withSourceFence(() => plan);
+            if (plan.status !== 'approved' && plan.status !== 'ready-for-human-review')
+                throw new Error('source plan is not approved for release preparation');
+            const checked = await verifyPreparedSourceWorktree(plan, inheritedEnvironment(trust), signal);
+            if (plan.status === 'approved')
+                plan = this.store.verifyPreparedSourcePlan({ planId: plan.id, expectedRevision: plan.revision,
+                    recheckedTreeDigest: checked.checkedTreeDigest, recheckedPatchDigest: checked.checkedPatchDigest, withSourceFence }).result;
+            withSourceFence(() => { });
+            const authorization = await requestSourceReleaseAuthorization(config, { protocol: 'dsh-source-release-authorization/v1',
+                planId: plan.id, planDigest: plan.digest, sourceReferenceDigest: controlPlaneDigest(source) }, signal);
+            signal.throwIfAborted();
+            if (controlPlaneDigest(await this.boundTrust()) !== controlPlaneDigest(trust))
+                throw new Error('source release trust changed');
+            const policy = authorization.releasePolicy;
+            if (policy.registryId !== trust.releaseRegistry.id || policy.registryLocator !== trust.releaseRegistry.locator
+                || policy.catalogId !== trust.catalog.id || policy.catalogPath !== trust.catalog.path
+                || policy.packageName !== `@dsh-enhanced/${plan.name}` || policy.packagePath !== `plugins/${plan.name}`
+                || policy.packageVersion !== plan.preparedEvidence.pack.version)
+                throw new Error('source release policy differs from configured trust or prepared package');
+            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;
+        })();
+        this.sourceReleaseFlights.add(operation);
+        try {
+            return await operation;
+        }
+        finally {
+            this.sourceReleaseFlights.delete(operation);
+        }
+    };
+    /** Host-only continuation, also used by an independent reviewer after its decision is ready. */
+    advanceOwnerSourceRelease = async (input) => {
+        this.abort.signal.throwIfAborted();
+        const config = this.config.sourceReleaseExecution;
+        if (!config)
+            throw new Error('plugin-control-plane: source release execution unavailable');
+        if (this.sourceReleaseAdvances.has(input.planId))
+            throw new Error('source release continuation already running');
+        const signal = AbortSignal.any([this.abort.signal, AbortSignal.timeout(config.timeoutMs), ...(input.signal ? [input.signal] : [])]);
+        const operation = (async () => {
+            const plan = this.store.getSourcePlan(input.planId), source = this.store.getOwnerTaskFailureReference(plan.gapId);
+            if (!source || plan.mode !== 'modify' || !plan.release)
+                throw new Error('source release continuation requires an owner repair release');
+            const reviewerAvailable = (operationId) => {
+                const reviewer = this.ctx.get('assistantVerifier');
+                const snapshot = this.taskGaps.snapshot(plan.gapId, source.owner);
+                return reviewer?.canReviewSourceRepair?.({ decisionRoot: config.reviewDecisionRoot, owner: snapshot.owner, name: plan.name,
+                    ...(operationId === undefined ? {} : { operationId }),
+                    ...(snapshot.source.modelSelectionState === 'frozen' && snapshot.source.modelSelection
+                        ? { modelSelection: snapshot.source.modelSelection } : {}) }) === true;
+            };
+            if (config.independentReview && plan.status === 'awaiting-pr' && !reviewerAvailable() && !input.receipt)
+                return plan;
+            const withSourceFence = (callback) => { signal.throwIfAborted(); return this.taskGaps.withCurrent(plan.gapId, source.owner, callback); };
+            withSourceFence(() => { });
+            const trust = await this.boundTrust(), trustDigest = controlPlaneDigest(trust);
+            if (input.expectedTrustDigest !== undefined && trustDigest !== input.expectedTrustDigest)
+                throw new Error('source release continuation trust changed');
+            const assertCurrent = async () => {
+                withSourceFence(() => { });
+                if (controlPlaneDigest(await this.boundTrust()) !== trustDigest)
+                    throw new Error('source release continuation trust changed');
+                withSourceFence(() => { });
+            };
+            if (input.receipt) {
+                if (input.receipt.planId !== plan.id)
+                    throw new Error('release reconciliation receipt targets another plan');
+                await assertCurrent();
+                const { authorize, authority } = sourceReleaseAuthorities(trust);
+                await this.store.acceptSourceReleaseReceipt({ operationId: input.receipt.operationId, expectedRevision: plan.revision,
+                    expectedFence: plan.release.fence, receipt: input.receipt, resolveAuthority: authority,
+                    resolveAuthorizationAuthority: authorize, withSourceFence });
+            }
+            return advanceSourceRelease({ store: this.store, planId: plan.id, trust, config, signal, assertCurrent, withSourceFence,
+                review: async (request, currentPlan) => {
+                    const reviewer = this.ctx.get('assistantVerifier');
+                    if (!reviewer || typeof reviewer.reviewSourceRepair !== 'function' || !reviewerAvailable(request.operationId))
+                        return;
+                    const snapshot = this.taskGaps.snapshot(plan.gapId, source.owner);
+                    await reviewer.reviewSourceRepair({ request: {
+                            protocol: 'dsh-source-review/v1', operationId: request.operationId,
+                            planId: currentPlan.id, planDigest: currentPlan.digest, releaseId: request.release.id,
+                            fence: request.release.fence, revision: request.plan.revision, name: currentPlan.name,
+                            ...request.input, checkedTreeDigest: request.authorization.checkedTreeDigest,
+                            checkedPatchDigest: request.authorization.checkedPatchDigest, scope: request.authorization.scope,
+                            source: { owner: snapshot.owner, outcomeId: source.outcomeId, sourceDigest: source.sourceDigest,
+                                objective: snapshot.source.objective,
+                                ...(snapshot.source.modelSelectionState === 'frozen' && snapshot.source.modelSelection
+                                    ? { modelSelection: snapshot.source.modelSelection } : {}) },
+                        }, signal, withSourceFence });
+                } });
+        })();
+        this.sourceReleaseAdvances.set(input.planId, operation);
+        this.sourceReleaseFlights.add(operation);
+        try {
+            return await operation;
+        }
+        finally {
+            this.sourceReleaseAdvances.delete(input.planId);
+            this.sourceReleaseFlights.delete(operation);
+        }
+    };
+    /** Host only. Dedicated connection keeps activation writer locks out of the source job's connection. */
+    adoptOwnerSourceRelease = async (input) => {
+        const config = this.config.sourceAdoptions;
+        if (!config)
+            throw new Error('plugin-control-plane: source adoption authority unavailable');
+        if (this.sourceAdoptionFlights.size !== 0)
+            throw new Error('source adoption worker is already running');
+        const signal = AbortSignal.any([this.abort.signal, AbortSignal.timeout(config.timeoutMs), ...(input.signal ? [input.signal] : [])]);
+        const operation = (async () => {
+            const plan = this.store.getSourcePlan(input.sourcePlanId);
+            const source = this.store.getOwnerTaskFailureReference(plan.gapId);
+            if (!source || plan.mode !== 'modify' || plan.status !== 'release-complete')
+                throw new Error('source adoption requires a completed owner repair release');
+            const current = (callback) => {
+                signal.throwIfAborted();
+                return this.taskGaps.withCurrent(plan.gapId, source.owner, callback);
+            };
+            const trust = await this.boundTrust(), trustDigest = controlPlaneDigest(trust);
+            if (input.expectedTrustDigest !== undefined && trustDigest !== input.expectedTrustDigest)
+                throw new Error('source adoption trust changed');
+            const store = new ControlPlaneStore({ path: trust.ledger.path,
+                withOwnerActivationFence: (gapId, callback) => {
+                    if (gapId !== plan.gapId)
+                        throw new Error('source adoption escaped its owner task');
+                    return current(callback);
+                } });
+            const withSourceFence = (callback) => current(() => store.withOwnerTaskFailureGapAdmission(plan.gapId, callback));
+            try {
+                return await adoptSourceRelease({ store, sourcePlanId: plan.id, trust, config, signal, withSourceFence,
+                    assertCurrent: async () => {
+                        await input.assertCurrent?.();
+                        current(() => { });
+                        if (controlPlaneDigest(await this.boundTrust()) !== trustDigest)
+                            throw new Error('source adoption trust changed');
+                        current(() => { });
+                    } });
+            }
+            finally {
+                store.close();
+            }
+        })();
+        this.sourceAdoptionFlights.set(input.sourcePlanId, operation);
+        try {
+            return await operation;
+        }
+        finally {
+            this.sourceAdoptionFlights.delete(input.sourcePlanId);
+        }
+    };
     recordGap(input) { return this.store.recordGap(input); }
     gaps(limit) { return this.store.listGaps(limit); }
     health() { return this.store.health(); }
+    canPrepareSource() { return this.config.sourceBuild !== undefined; }
+    canEnqueueSource() { return this.sourceRuntime?.available() === true && !this.abort.signal.aborted; }
+    // Bind Host entry points: Cordis service proxies must not become resource owners.
+    enqueueSourceJob = async (input) => {
+        this.abort.signal.throwIfAborted();
+        const runtime = this.sourceRuntime;
+        if (runtime === undefined || !runtime.available())
+            throw new Error('plugin-control-plane: durable source jobs unavailable');
+        if (this.sourceBuilds.size !== 0 || this.sourceInspections.size !== 0)
+            throw new Error('plugin-control-plane: another source operation is draining');
+        const operation = runtime.enqueue(input);
+        this.sourceInspections.add(operation);
+        try {
+            return await operation;
+        }
+        finally {
+            this.sourceInspections.delete(operation);
+        }
+    };
+    inspectSourceJob = (input) => {
+        if (this.sourceRuntime === undefined)
+            throw new Error('plugin-control-plane: durable source jobs unavailable');
+        return this.sourceRuntime.inspect(input);
+    };
+    reconcileSourceJob = (input) => {
+        if (this.sourceRuntime === undefined || this.sourceBuilds.size !== 0)
+            throw new Error('plugin-control-plane: durable source jobs unavailable or still draining');
+        return this.sourceRuntime.reconcileUnknown(input);
+    };
+    async prepareSourceJob(job, signal, assertCurrent) {
+        this.abort.signal.throwIfAborted();
+        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,
+            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 {
+            return await operation;
+        }
+        finally {
+            this.sourceBuilds.delete(operation);
+        }
+    }
+    async inspectSource(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.inspectSourceOwned({ ...input, signal });
+        this.sourceInspections.add(operation);
+        void operation.then(() => this.sourceInspections.delete(operation), () => this.sourceInspections.delete(operation));
+        return operation;
+    }
+    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 });
+    }
     async plan(candidateId, profile, idempotencyKey, gapId) {
         const gap = this.store.getGap(gapId);
         const loaded = await loadCatalogWithMetadata(this.config.catalogPath);
@@ -73,6 +685,122 @@ export class PluginControlPlaneService extends Service {
             executor: { id: trust.executor.id, version: trust.executor.version, path: trust.executor.path, sha256: trust.executor.sha256 }, ttlMs: this.config.proposalTtlMs,
             gapId, idempotencyKey }).result;
     }
+    /**
+     * Prepare a 'modify' source plan for an pre-existing control-plane open capability gap:
+     * write the caller-supplied bounded patch into a fresh isolated worktree and
+     * persist a pending plan.  The build gate is deliberately delegated to the
+     * configured owner isolation runner; this Host service must never execute
+     * proposal-controlled package scripts in its own process environment.
+     *
+     * This is a proposal-only entry point. It never approves, signs, releases,
+     * activates, reloads or touches a production profile; the repository, base
+     * commit, environment, timeouts and TTL are host-controlled and cannot be
+     * supplied by the proposal caller. On any worktree/build failure the isolated
+     * worktree is removed and no plan row is written and no gap is reserved.
+     */
+    async prepareModifySourcePlan(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 operation = this.prepareModifySourcePlanOwned(input);
+        this.sourceBuilds.add(operation);
+        void operation.then(() => this.sourceBuilds.delete(operation), () => this.sourceBuilds.delete(operation));
+        return operation;
+    }
+    async prepareModifySourcePlanOwned(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 assertCurrent = async () => {
+            signal.throwIfAborted();
+            await input.assertCurrent?.();
+            signal.throwIfAborted();
+            this.taskGaps.withCurrent(input.gapId, gapOwner, () => { });
+        };
+        await assertCurrent();
+        const trust = await this.boundTrust();
+        const name = input.name.normalize('NFC').trim();
+        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);
+        // 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');
+        }
+        const repository = await realpath(resolve(input.repository));
+        if (resolve(repository) !== repository)
+            throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'repository path must be canonical');
+        const ttlMs = input.ttlMs ?? 86_400_000;
+        if (!Number.isSafeInteger(ttlMs) || ttlMs < 900_000 || ttlMs > 86_400_000) {
+            throw new ControlPlaneCliError('INVALID_ARGUMENT', 'ttlMs must be an integer within 900000..86400000');
+        }
+        const maximumTimeoutMs = this.config.sourceBuild?.profile === 'repository' ? 1_800_000 : 240_000;
+        const timeoutMs = input.timeoutMs ?? 180_000;
+        if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 60_000 || timeoutMs > maximumTimeoutMs) {
+            throw new ControlPlaneCliError('INVALID_ARGUMENT', `timeoutMs must be an integer within 60000..${maximumTimeoutMs}`);
+        }
+        const offline = input.offline ?? true;
+        const environment = inheritedEnvironment(trust);
+        const baseCommit = (await runLocalCommand('git', ['rev-parse', 'HEAD'], repository, environment, { capture: true })).trim();
+        await assertCurrent();
+        if (!/^[a-f0-9]{40}$/u.test(baseCommit))
+            throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'repository HEAD is not a 40-hex commit id');
+        if (input.expectedBaseCommit !== undefined && input.expectedBaseCommit !== baseCommit)
+            throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'prepared source base commit is stale');
+        const stateRoot = join(this.config.statePath, 'source-worktrees');
+        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 });
+            await assertCurrent();
+            if (this.config.sourceBuild === undefined)
+                throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'isolated source build runner is not configured');
+            if (!offline)
+                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;
+            if (managed !== undefined) {
+                await assertCurrent();
+                await writeScopedPluginFiles({ worktree: isolated.worktree, name, files: managed.files });
+                await verifyManagedPatchVersion(versionInput);
+            }
+            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 } }) });
+            await assertCurrent();
+            if (managed !== undefined) {
+                await verifyManagedPatchVersion(versionInput);
+                if (checked.evidence.pack.version !== managed.version)
+                    throw new ControlPlaneCliError('SOURCE_BOUNDARY', 'prepared artifact does not carry the Host-managed version');
+            }
+            // 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,
+                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);
+        }
+        catch (error) {
+            await isolated.remove();
+            throw error;
+        }
+    }
+    /**
+     * Garbage-collect prepared modify worktrees whose plans expired while still
+     * pending owner action. The trust binding is re-checked first.
+     */
+    async gcPreparedSourceWorktrees(now = Date.now()) {
+        const trust = await this.boundTrust();
+        return gcPreparedModifyWorktrees({ store: this.store,
+            statePath: this.config.statePath, environment: inheritedEnvironment(trust), now });
+    }
 }
 export const Config = schema;
 //# sourceMappingURL=service.js.map