@dsh-enhanced/assistant-automations 0.1.6 → 0.1.12

package/lib/service.js

@@ -1,13 +1,40 @@
-import { isAbsolute } from 'node:path';
+import { isAbsolute, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { Context, Service } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
+import { canonicalEvaluationHostScope, } from '@dsh-enhanced/assistant-evaluation';
+import { canonicalGrowthJson, growthObjectDigest, WORKFLOW_MODEL_TURN_CATALOG_ID, validateGrowthAutomationApprovalReceipt, validateGrowthAutomationApprovalRequest, validateGrowthAutomationArtifactRequest, validateGrowthAutomationProposalReceipt, validateGrowthAutomationProposalRequest, validateGrowthCanaryInspectionReceipt, validateGrowthCanaryInspectionRequest, validateGrowthCanaryReceipt, validateGrowthPromotionReceipt, validateGrowthReplayReceipt, validateGrowthRollbackReceipt, validateGrowthShadowReceipt, validateResolvedWorkflowAutomationTemplate, withGrowthPortReceiptDigest, } from '@dsh-enhanced/assistant-growth-contract';
 import { AutomationArtifactStore } from './artifacts.js';
+import { HostAutomationExecutorRegistry } from './host-executors.js';
+import { GROWTH_AUTOMATION_OWNER, GrowthAutomationStore, } from './growth.js';
 import { AutomationCoordinator, } from './coordinator.js';
 import { AutomationProposalManager, AutomationProposalStore } from './proposals.js';
-import { DshAutomationRunner } from './runner.js';
+import { DshAutomationRunner, HostAutomationRunner, RoutedAutomationRunner } from './runner.js';
 import { AutomationStore } from './store.js';
 import { registerAutomationTools } from './tools.js';
+import { isHostAutomationDefinition } from './types.js';
+function registrationOwnedByEvaluation(registration) {
+    const candidate = registration;
+    try {
+        return typeof candidate.owner === 'object' && candidate.owner !== null
+            && typeof candidate.owner.ownsTrustedAutomationEvaluationRegistration === 'function'
+            && candidate.owner.ownsTrustedAutomationEvaluationRegistration(registration);
+    }
+    catch {
+        return false;
+    }
+}
+function registrationOwnedByDeliveryPresentation(registration) {
+    const candidate = registration;
+    try {
+        return typeof candidate.owner === 'object' && candidate.owner !== null
+            && typeof candidate.owner.ownsTrustedDeliveryPresentationRegistration === 'function'
+            && candidate.owner.ownsTrustedDeliveryPresentationRegistration(registration);
+    }
+    catch {
+        return false;
+    }
+}
 export class AssistantAutomationsError extends Error {
     code;
     constructor(code, message) {
@@ -72,6 +99,32 @@ const configSchema = Schema.object({
 function policyError(decision) {
     return new AssistantAutomationsError('policy-denied', `assistant-automations policy denied operation: ${decision.reasonCode}`);
 }
+function growthIdentity(input) {
+    return Object.freeze({
+        contractVersion: 1,
+        operationId: input.operationId,
+        experimentId: input.experimentId,
+        candidateId: input.candidateId,
+        candidateRevision: input.candidateRevision,
+        candidateDigest: input.candidateDigest,
+    });
+}
+function boundedGrowthKey(prefix, value) {
+    return `${prefix}:${growthObjectDigest(value)}`;
+}
+const growthEffectBlockerAttestation = Object.freeze({
+    contract: 'assistant-automations-effect-blocker/v1',
+    blockedEffects: Object.freeze(['delivery', 'tool-execution']),
+    implementationDigest: growthObjectDigest({
+        contract: 'assistant-automations-growth-effect-blocker-implementation/v1',
+        immutablePausedTaskAdmission: true,
+        executionMode: 'preview',
+        supportedWorkflowKind: 'model-turn-only',
+        validatedOrchestrationStep: WORKFLOW_MODEL_TURN_CATALOG_ID,
+        runnerToolAllowlist: [],
+        terminalDelivery: 'suppressed',
+    }),
+});
 class PolicyBoundRunner {
     policy;
     delegate;
@@ -92,10 +145,23 @@ class PolicyBoundRunner {
             context: { initiator: 'background' },
         }, { idempotencyKey: `automation-execute:${input.occurrence.id}` });
         if (decision.effect !== 'allow') {
+            const host = isHostAutomationDefinition(input.automation.definition);
             return Promise.resolve({
                 outcome: 'cancelled',
                 output: `policy denied background execution: ${decision.reasonCode}`,
                 usage: {},
+                diagnostic: Object.freeze({
+                    schemaVersion: 1,
+                    failureClass: 'policy',
+                    failurePhase: 'preflight',
+                    failureCode: 'policy-denied',
+                    promptSubmissionState: host ? 'not-applicable' : 'not-submitted',
+                    sideEffectState: 'none',
+                    retryability: 'after-intervention',
+                    budgetSettlementState: input.automation.definition.budgetId === undefined
+                        ? 'not-required'
+                        : 'not-reserved',
+                }),
             });
         }
         return this.delegate.run(input);
@@ -105,11 +171,19 @@ export class AssistantAutomationsService extends Service {
     static Config = configSchema;
     store;
     proposalStore;
+    growthStore;
     proposals;
     policy;
     coordinator;
+    hostExecutors = new HostAutomationExecutorRegistry();
     config;
+    evaluationProducerGeneration = `assistant-automations:${randomUUID()}`;
+    presentationProducerGeneration = `assistant-automations-presentation:${randomUUID()}`;
+    evaluationSink;
+    presentationSink;
     approvalDelivery;
+    workflowTemplateResolver;
+    evaluation;
     active = true;
     constructor(ctx, input) {
         super(ctx, 'assistantAutomations');
@@ -131,14 +205,20 @@ export class AssistantAutomationsService extends Service {
             throw new Error('assistant-automations: assistantPolicy service is required');
         this.config = config;
         this.policy = policy;
-        this.approvalDelivery = ctx.get('assistantDelivery');
+        const initialDelivery = ctx.get('assistantDelivery');
+        this.approvalDelivery = initialDelivery;
+        this.workflowTemplateResolver = initialDelivery;
+        this.evaluation = ctx.get('assistantEvaluation');
         this.store = new AutomationStore({ path: config.databasePath });
         this.proposalStore = new AutomationProposalStore({ path: config.databasePath });
+        this.growthStore = new GrowthAutomationStore(config.databasePath);
         this.proposals = new AutomationProposalManager(this.store, this.proposalStore, policy);
         const artifacts = new AutomationArtifactStore({ rootPath: config.runsPath, maxBytes: config.maxArtifactBytes });
-        const runner = new PolicyBoundRunner(policy, new DshAutomationRunner(ctx, policy, {
+        const runner = new PolicyBoundRunner(policy, new RoutedAutomationRunner(new DshAutomationRunner(ctx, policy, {
             allowUnbudgetedExecution: config.allowUnbudgetedExecution,
-        }));
+        }), new HostAutomationRunner(this.hostExecutors, policy, {
+            allowUnbudgetedExecution: config.allowUnbudgetedExecution,
+        })));
         this.coordinator = new AutomationCoordinator({
             store: this.store,
             artifacts,
@@ -150,15 +230,31 @@ export class AssistantAutomationsService extends Service {
             maxCatchUp: config.maxCatchUp,
             maxConcurrency: config.maxConcurrency,
             tickIntervalMs: config.tickIntervalMs,
+            hostExecutors: this.hostExecutors,
         });
+        if (initialDelivery !== undefined) {
+            this.coordinator.setDeliveryDispatcher(this.deliveryDispatcher(initialDelivery));
+        }
         ctx.inject(['assistantDelivery'], deliveryCtx => {
             const delivery = deliveryCtx.get('assistantDelivery');
             this.approvalDelivery = delivery;
-            this.coordinator.setDeliveryDispatcher(delivery);
+            this.workflowTemplateResolver = delivery;
+            this.coordinator.setDeliveryDispatcher(this.deliveryDispatcher(delivery));
             return () => {
-                if (this.approvalDelivery === delivery)
+                if (this.approvalDelivery === delivery) {
                     this.approvalDelivery = undefined;
-                this.coordinator.setDeliveryDispatcher(undefined);
+                    if (this.workflowTemplateResolver === delivery)
+                        this.workflowTemplateResolver = undefined;
+                    this.coordinator.setDeliveryDispatcher(undefined);
+                }
+            };
+        });
+        ctx.inject(['assistantEvaluation'], evaluationCtx => {
+            const evaluation = evaluationCtx.get('assistantEvaluation');
+            this.evaluation = evaluation;
+            return () => {
+                if (this.evaluation === evaluation)
+                    this.evaluation = undefined;
             };
         });
         // Optional: when a learning plugin is composed, finished runs become evidence.
@@ -169,6 +265,9 @@ export class AssistantAutomationsService extends Service {
             this.coordinator.setOutcomeRecorder(recorder);
             return () => this.coordinator.setOutcomeRecorder(undefined);
         });
+        // Evaluation attaches in the opposite direction through the private
+        // producer capability below.  Passing the public Evaluation service to the
+        // coordinator would let an ordinary caller self-assert `trust: trusted`.
         if (config.schedulerEnabled)
             this.coordinator.start();
         if (config.reconcileIntervalMs > 0) {
@@ -189,11 +288,712 @@ export class AssistantAutomationsService extends Service {
         ctx.inject(['tools'], toolsCtx => registerAutomationTools(toolsCtx, this));
         ctx.effect(() => async () => {
             this.active = false;
+            this.evaluationSink = undefined;
+            this.presentationSink?.dispose();
+            this.coordinator.setEvaluationRecorder(undefined);
             await this.coordinator.stop();
             this.proposalStore.close();
+            this.growthStore.close();
             this.store.close();
         }, 'assistant-automations.runtime');
     }
+    trustedEvaluationProducerGeneration() {
+        this.assertActive();
+        return this.evaluationProducerGeneration;
+    }
+    trustedDeliveryPresentationProducerGeneration() {
+        this.assertActive();
+        return this.presentationProducerGeneration;
+    }
+    /**
+     * Delivery creates this publisher and can revoke it on either service's
+     * reload. Automations retains it only as a private coordinator adapter; no
+     * Agent, Automation definition, or public Delivery dispatcher can mint one.
+     */
+    registerTrustedDeliveryPresentationSink(registration) {
+        this.assertActive();
+        if (registration.protocol !== 'assistant-delivery/trusted-presentation-producer/v1'
+            || registration.producer !== 'assistant-automations'
+            || registration.generation !== this.presentationProducerGeneration
+            || typeof registration.publish !== 'function'
+            || !registrationOwnedByDeliveryPresentation(registration)) {
+            throw new AssistantAutomationsError('runtime-conflict', 'trusted Delivery presentation registration is invalid');
+        }
+        const current = this.presentationSink;
+        if (current !== undefined) {
+            if (current.registration === registration)
+                return current.dispose;
+            throw new AssistantAutomationsError('runtime-conflict', 'trusted Delivery presentation sink is already registered');
+        }
+        const token = Symbol('assistant-automations.trusted-delivery-presentation');
+        let live = true;
+        const dispose = () => {
+            if (!live)
+                return;
+            live = false;
+            if (this.presentationSink?.token === token)
+                this.presentationSink = undefined;
+        };
+        this.presentationSink = Object.freeze({ token, registration, dispose });
+        return dispose;
+    }
+    deliveryDispatcher(delivery) {
+        return Object.freeze({
+            enqueueBackground: (input) => delivery.enqueueBackground(input),
+            enqueueAutomationResult: (input) => delivery.enqueueAutomationResult(input),
+            enqueueBackgroundRoute: (input) => delivery.enqueueBackgroundRoute(input),
+            // This is a closure over the private registration rather than a method
+            // taken from the public Delivery service object.
+            publishDeliveryPresentation: (input) => this.publishAutomationIncidentPresentation(input),
+        });
+    }
+    publishAutomationIncidentPresentation(input) {
+        this.assertActive();
+        const sink = this.presentationSink;
+        if (sink === undefined) {
+            throw new AssistantAutomationsError('runtime-conflict', 'trusted Delivery presentation sink is unavailable');
+        }
+        return sink.registration.publish(input);
+    }
+    /**
+     * Bind the one exact Evaluation instance allowed to consume this service's
+     * durable terminal outbox.  The registration object is a process-local
+     * capability; it is never exposed as a model tool or accepted from payload
+     * data.
+     */
+    registerTrustedAutomationEvaluationSink(registration) {
+        this.assertActive();
+        if (registration.protocol !== 'assistant-evaluation/trusted-producer/v1'
+            || registration.producer !== 'assistant-automations'
+            || registration.generation !== this.evaluationProducerGeneration
+            || typeof registration.issueCapability !== 'function'
+            || typeof registration.append !== 'function'
+            || !registrationOwnedByEvaluation(registration)) {
+            throw new AssistantAutomationsError('runtime-conflict', 'trusted Evaluation registration is invalid');
+        }
+        if (this.evaluationSink !== undefined) {
+            throw new AssistantAutomationsError('runtime-conflict', 'trusted Evaluation sink is already registered');
+        }
+        const token = Symbol('assistant-automations.trusted-evaluation');
+        this.evaluationSink = Object.freeze({ token, registration });
+        this.coordinator.setEvaluationRecorder(Object.freeze({
+            append: (outcome) => this.appendTrustedEvaluation(token, outcome),
+        }));
+        let active = true;
+        return () => {
+            if (!active)
+                return;
+            active = false;
+            if (this.evaluationSink?.token !== token)
+                return;
+            this.evaluationSink = undefined;
+            this.coordinator.setEvaluationRecorder(undefined);
+        };
+    }
+    appendTrustedEvaluation(token, outcome) {
+        this.assertActive();
+        const sink = this.evaluationSink;
+        const runEvidence = outcome.evidence.filter(entry => entry.kind === 'automation-run');
+        const automationId = outcome.situation.startsWith('automation:')
+            ? outcome.situation.slice('automation:'.length)
+            : '';
+        const runId = runEvidence[0]?.ref;
+        const proof = runId === undefined ? undefined : this.store.getProvenProductionRun(runId);
+        const expectedExecutionStatus = proof?.run.status === 'timed_out'
+            ? 'timed-out'
+            : proof?.run.status;
+        const hostObjectiveProven = proof !== undefined
+            && isHostAutomationDefinition(proof.automation.definition)
+            && (proof.run.status === 'succeeded'
+                || proof.run.status === 'failed' || proof.run.status === 'timed_out');
+        const expectedObjectiveStatus = proof === undefined || !hostObjectiveProven
+            ? 'unknown'
+            : proof.run.status === 'succeeded' ? 'achieved' : 'not-achieved';
+        const expectedEvaluatorVersion = hostObjectiveProven ? 'host-runbook-v1' : 'terminal-v1';
+        if (sink?.token !== token || outcome.executionMode !== 'production'
+            || automationId === '' || runEvidence.length !== 1
+            || runId === undefined || proof === undefined
+            || proof.run.automationId !== automationId
+            || proof.automation.definition.workspace !== outcome.scope.workspace
+            || proof.automation.definition.agentPreset !== outcome.scope.preset
+            || outcome.situation !== `automation:${automationId}`
+            || outcome.executionStatus !== expectedExecutionStatus
+            || outcome.objectiveStatus !== expectedObjectiveStatus
+            || outcome.occurredAt !== proof.run.createdAt
+            || outcome.idempotencyKey !== `assistant-automations:terminal:${runId}:v1`
+            || outcome.evaluator.version !== expectedEvaluatorVersion
+            || outcome.source.kind !== 'automation' || outcome.source.id !== 'assistant-automations'
+            || outcome.trust !== 'trusted' || outcome.evaluator.id !== 'assistant-automations') {
+            throw new AssistantAutomationsError('runtime-conflict', 'trusted Evaluation outbox payload is invalid');
+        }
+        const claims = Object.freeze({
+            scope: Object.freeze({ ...outcome.scope }),
+            automationId,
+            situation: outcome.situation,
+            runId,
+            executionMode: 'production',
+            executionStatus: outcome.executionStatus,
+            objectiveStatus: outcome.objectiveStatus,
+            deliveryStatus: outcome.deliveryStatus,
+            metrics: Object.freeze({ ...outcome.metrics }),
+            occurredAt: outcome.occurredAt,
+            idempotencyKey: outcome.idempotencyKey,
+            evaluatorVersion: outcome.evaluator.version,
+        });
+        const capabilityReceipt = sink.registration.issueCapability(claims);
+        if (this.evaluationSink?.token !== token) {
+            throw new AssistantAutomationsError('runtime-conflict', 'trusted Evaluation capability became stale');
+        }
+        const receipt = sink.registration.append({
+            capabilityReceipt,
+            automationId,
+            runId: claims.runId,
+            idempotencyKey: claims.idempotencyKey,
+        });
+        if (receipt.idempotencyKey !== claims.idempotencyKey
+            || receipt.source.kind !== 'automation' || receipt.source.id !== 'assistant-automations'
+            || receipt.trust !== 'trusted') {
+            throw new AssistantAutomationsError('runtime-conflict', 'trusted Evaluation receipt is invalid');
+        }
+        return receipt;
+    }
+    /**
+     * Re-prove Delivery's mutable owner/template authority immediately before a
+     * Growth phase can submit a model turn, expose production output, or promote
+     * the definition. Rollback deliberately does not use this gate: losing the
+     * old owner route must never prevent reducing authority.
+     */
+    hasShadowEffectBlocker(run) {
+        // Preview execution has no Delivery lane at all. `undefined` is the
+        // durable Store representation of that structural no-send state; a
+        // pending/enqueued/suppressed delivery record is not interchangeable with
+        // a preview blocker and must fail closed here.
+        return run.executionMode === 'preview'
+            && run.deliveryStatus === undefined
+            && run.deliveryRef === undefined
+            && run.evidenceStatus === 'suppressed'
+            && run.usage['toolCalls'] === 0;
+    }
+    requireLiveGrowthArtifact(artifact) {
+        const resolver = this.workflowTemplateResolver;
+        if (resolver === undefined || typeof resolver.resolveWorkflowAutomationTemplate !== 'function') {
+            throw new AssistantAutomationsError('runtime-conflict', 'Delivery template authority is unavailable');
+        }
+        const live = validateResolvedWorkflowAutomationTemplate(resolver.resolveWorkflowAutomationTemplate({
+            contractVersion: 1,
+            template: {
+                templateRef: artifact.templateRef,
+                templateDigest: artifact.templateDigest,
+                privacyAttestation: artifact.privacyAttestation,
+            },
+            scope: { workspace: artifact.workspace, preset: artifact.preset },
+            ownerBindingId: artifact.ownerBindingId,
+        }));
+        const definition = this.store.get(artifact.automationId);
+        const observedCatalog = [...new Set(artifact.steps.map(step => step.catalogId))].sort();
+        const exact = definition !== undefined && definition.owner === GROWTH_AUTOMATION_OWNER
+            && !isHostAutomationDefinition(definition.definition)
+            && canonicalGrowthJson(live.template) === canonicalGrowthJson({
+                templateRef: artifact.templateRef,
+                templateDigest: artifact.templateDigest,
+                privacyAttestation: artifact.privacyAttestation,
+            })
+            && live.scope.workspace === artifact.workspace && live.scope.preset === artifact.preset
+            && live.ownerBindingId === artifact.ownerBindingId && live.principalId === artifact.principalId
+            && canonicalGrowthJson(live.toolCatalogIds) === canonicalGrowthJson(observedCatalog)
+            && definition.definition.name === live.name && definition.definition.prompt === live.prompt
+            && canonicalGrowthJson(definition.definition.schedule) === canonicalGrowthJson(live.schedule)
+            && definition.definition.workspace === live.scope.workspace
+            && definition.definition.agentPreset === live.scope.preset
+            && definition.definition.timeoutMs === live.timeoutMs
+            && canonicalGrowthJson(definition.definition.allowedTools) === canonicalGrowthJson([])
+            && definition.definition.maxToolCalls === 0
+            && definition.definition.principal === live.principalId
+            && definition.definition.approvalBindingId === live.ownerBindingId
+            && definition.definition.deliveryBindingId === live.deliveryBindingId
+            && this.store.getDefinitionHash(definition.id) === artifact.definitionHash;
+        if (!exact || definition === undefined) {
+            throw new AssistantAutomationsError('runtime-conflict', 'Growth owner, template, or materialized Automation changed before execution');
+        }
+        return definition;
+    }
+    async requestWorkflowAutomation(inputValue) {
+        this.assertActive();
+        const input = validateGrowthAutomationProposalRequest(inputValue);
+        const replay = this.growthStore.beginOperation('approval-proposal', input);
+        if (replay !== undefined)
+            return validateGrowthAutomationProposalReceipt(replay, growthIdentity(input));
+        const resolver = this.workflowTemplateResolver;
+        if (resolver === undefined || typeof resolver.resolveWorkflowAutomationTemplate !== 'function') {
+            throw new AssistantAutomationsError('runtime-conflict', 'Growth materialization requires the private Delivery workflow template resolver');
+        }
+        const resolved = validateResolvedWorkflowAutomationTemplate(resolver.resolveWorkflowAutomationTemplate({
+            contractVersion: 1,
+            template: input.template,
+            scope: input.scope,
+            ownerBindingId: input.ownerBindingId,
+        }));
+        if (canonicalGrowthJson(resolved.template) !== canonicalGrowthJson(input.template)
+            || canonicalGrowthJson(resolved.scope) !== canonicalGrowthJson(input.scope)
+            || resolved.ownerBindingId !== input.ownerBindingId) {
+            throw new AssistantAutomationsError('runtime-conflict', 'Delivery resolved a different workflow template or owner scope');
+        }
+        const approvalDelivery = this.approvalDelivery;
+        if (approvalDelivery === undefined || typeof approvalDelivery.prepareWorkflowApproval !== 'function') {
+            throw new AssistantAutomationsError('runtime-conflict', 'Growth approval requires the private Delivery v2 approval route resolver');
+        }
+        const dispatch = approvalDelivery.prepareWorkflowApproval({
+            sourceId: GROWTH_AUTOMATION_OWNER,
+            contractVersion: 1,
+            template: input.template,
+            scope: input.scope,
+            ownerBindingId: input.ownerBindingId,
+        });
+        if (dispatch.routeVersion !== 2
+            || dispatch.sourceId !== GROWTH_AUTOMATION_OWNER
+            || dispatch.bindingId !== resolved.ownerBindingId
+            || dispatch.workspace !== resolved.scope.workspace
+            || dispatch.principal !== resolved.principalId) {
+            throw new AssistantAutomationsError('runtime-conflict', 'Delivery resolved a different workflow approval route');
+        }
+        const requestedCatalog = [...resolved.toolCatalogIds];
+        const observedCatalog = [...new Set(input.steps.map(step => step.catalogId))].sort();
+        if (canonicalGrowthJson(observedCatalog) !== canonicalGrowthJson(requestedCatalog)) {
+            throw new AssistantAutomationsError('invalid-proposal', 'Growth workflow catalog must exactly match its observed step catalog');
+        }
+        const orchestrationSteps = input.steps.filter(step => step.catalogId === WORKFLOW_MODEL_TURN_CATALOG_ID);
+        const requestedTools = requestedCatalog.filter(id => id !== WORKFLOW_MODEL_TURN_CATALOG_ID);
+        // The current shadow executor has a real empty tool plane, so it can prove
+        // delivery/tool effects are impossible only for Delivery's built-in model
+        // turn. A tool-bearing workflow remains representable in the trace contract
+        // but cannot enter approval until a Host-owned per-step interception receipt
+        // exists; zero observed calls is never treated as that proof.
+        if (orchestrationSteps.length !== 1 || input.steps.length !== 1 || requestedTools.length !== 0) {
+            throw new AssistantAutomationsError('invalid-proposal', 'Growth shadow currently supports only one assistant.agent-turn step and fails closed for tool workflows');
+        }
+        if (requestedTools.some(tool => !this.config.proposalDefaults.allowedTools.includes(tool))
+            || new Set(requestedTools).size !== requestedTools.length
+            || canonicalGrowthJson([...new Set(input.steps.map(step => step.catalogId))].sort())
+                !== canonicalGrowthJson(requestedCatalog)) {
+            throw new AssistantAutomationsError('invalid-proposal', 'Growth workflow catalog must exactly match observed steps and configured trusted tools');
+        }
+        const defaults = this.config.proposalDefaults;
+        const misfire = defaults.misfireKind === 'bounded-replay'
+            ? { kind: 'bounded-replay', limit: defaults.misfireLimit }
+            : { kind: defaults.misfireKind };
+        const definition = Object.freeze({
+            name: resolved.name,
+            prompt: resolved.prompt,
+            schedule: resolved.schedule,
+            workspace: resolved.scope.workspace,
+            agentPreset: resolved.scope.preset,
+            provider: defaults.provider,
+            model: defaults.model,
+            allowedTools: Object.freeze(requestedTools),
+            timeoutMs: resolved.timeoutMs,
+            maxOutputTokens: defaults.maxOutputTokens,
+            maxToolCalls: 0,
+            misfire,
+            overlap: defaults.overlap,
+            retrySafety: defaults.retrySafety,
+            maxRetries: defaults.maxRetries,
+            principal: resolved.principalId,
+            budgetId: defaults.budgetId,
+            budgetAmount: defaults.budgetAmount,
+            approvalBindingId: resolved.ownerBindingId,
+            deliveryBindingId: resolved.deliveryBindingId,
+        });
+        const automationId = this.growthStore.automationId(input);
+        const artifactId = this.growthStore.artifactId(input);
+        const diff = JSON.stringify({
+            contract: 'assistant-growth-approval-diff/v2',
+            artifactId,
+            automationId,
+            candidateId: input.candidateId,
+            candidateRevision: input.candidateRevision,
+            candidateDigest: input.candidateDigest,
+            template: input.template,
+            scope: input.scope,
+            ownerBindingId: input.ownerBindingId,
+            exactBehavior: {
+                name: resolved.name,
+                prompt: resolved.prompt,
+                schedule: resolved.schedule,
+                timeoutMs: resolved.timeoutMs,
+                provider: defaults.provider,
+                model: defaults.model,
+                maxOutputTokens: defaults.maxOutputTokens,
+                orchestrationCatalogIds: resolved.toolCatalogIds,
+                executableTools: requestedTools,
+                approvalBindingId: resolved.ownerBindingId,
+                deliveryBindingId: resolved.deliveryBindingId,
+            },
+            initialState: 'paused',
+        }, null, 2);
+        const approval = this.policy.recoverOrCreateProposal({
+            idempotencyKey: boundedGrowthKey('growth-approval', growthIdentity(input)),
+            requester: GROWTH_AUTOMATION_OWNER,
+            principal: resolved.principalId,
+            action: 'create',
+            resource: { kind: 'automation', id: automationId },
+            diff,
+            summary: 'Approve learned workflow as a paused Automation',
+            notAfter: input.deadlineAt,
+            dispatch,
+        });
+        if (approval.kind === 'abandoned') {
+            const receipt = withGrowthPortReceiptDigest({
+                ...growthIdentity(input), outcome: 'expired',
+            });
+            return validateGrowthAutomationProposalReceipt(this.growthStore.completeOperation('approval-proposal', input, receipt), growthIdentity(input));
+        }
+        const automation = this.reconcileSystem({
+            owner: GROWTH_AUTOMATION_OWNER,
+            automationId,
+            idempotencyKey: boundedGrowthKey('growth-materialize', growthIdentity(input)),
+            desiredStatus: 'paused',
+            definition,
+        });
+        const stored = this.growthStore.upsertArtifact({
+            request: input,
+            resolved,
+            automation,
+            proposalId: approval.proposal.proposalId,
+            approvalDiffHash: approval.proposal.diffHash,
+            policyStatus: approval.proposal.status,
+        });
+        const receipt = approval.proposal.status === 'approved'
+            ? withGrowthPortReceiptDigest({
+                ...growthIdentity(input),
+                outcome: 'approved-paused',
+                proposalId: approval.proposal.proposalId,
+                artifactId: stored.artifactId,
+                artifactVersion: stored.definitionVersion,
+                artifactDigest: stored.definitionHash,
+            })
+            : approval.proposal.status === 'pending'
+                ? withGrowthPortReceiptDigest({
+                    ...growthIdentity(input),
+                    outcome: 'approval-pending',
+                    proposalId: approval.proposal.proposalId,
+                })
+                : withGrowthPortReceiptDigest({
+                    ...growthIdentity(input),
+                    outcome: approval.proposal.status,
+                    proposalId: approval.proposal.proposalId,
+                });
+        return validateGrowthAutomationProposalReceipt(this.growthStore.completeOperation('approval-proposal', input, receipt), growthIdentity(input));
+    }
+    async settleWorkflowAutomation(inputValue) {
+        this.assertActive();
+        const input = validateGrowthAutomationApprovalRequest(inputValue);
+        const replay = this.growthStore.beginOperation('approval-settlement', input);
+        if (replay !== undefined)
+            return validateGrowthAutomationApprovalReceipt(replay, growthIdentity(input));
+        const artifact = this.growthStore.byExperiment(input.experimentId);
+        const proposal = this.policy.getProposal(input.proposalId);
+        const definition = artifact === undefined ? undefined : this.store.get(artifact.automationId);
+        const exact = artifact !== undefined && artifact.proposalId === input.proposalId
+            && artifact.candidateId === input.candidateId
+            && artifact.candidateRevision === input.candidateRevision
+            && artifact.candidateDigest === input.candidateDigest
+            && proposal?.requester === GROWTH_AUTOMATION_OWNER
+            && proposal.principal === artifact.principalId
+            && proposal.action === 'create'
+            && proposal.resource.kind === 'automation'
+            && proposal.resource.id === artifact.automationId
+            && proposal.diffHash === artifact.approvalDiffHash
+            && proposal.expiresAt === artifact.deadlineAt
+            && definition?.owner === GROWTH_AUTOMATION_OWNER
+            && definition.status === 'paused'
+            && definition.version === artifact.definitionVersion
+            && this.store.getDefinitionHash(artifact.automationId) === artifact.definitionHash;
+        if (!exact || artifact === undefined || proposal === undefined) {
+            const receipt = withGrowthPortReceiptDigest({
+                ...growthIdentity(input), outcome: 'conflicted', proposalId: input.proposalId,
+            });
+            return validateGrowthAutomationApprovalReceipt(this.growthStore.completeOperation('approval-settlement', input, receipt), growthIdentity(input));
+        }
+        if (proposal.status === 'approved') {
+            const resolver = this.workflowTemplateResolver;
+            if (resolver === undefined || typeof resolver.resolveWorkflowAutomationTemplate !== 'function') {
+                throw new AssistantAutomationsError('runtime-conflict', 'Delivery template authority is unavailable');
+            }
+            const live = validateResolvedWorkflowAutomationTemplate(resolver.resolveWorkflowAutomationTemplate({
+                contractVersion: 1,
+                template: {
+                    templateRef: artifact.templateRef,
+                    templateDigest: artifact.templateDigest,
+                    privacyAttestation: artifact.privacyAttestation,
+                },
+                scope: { workspace: artifact.workspace, preset: artifact.preset },
+                ownerBindingId: artifact.ownerBindingId,
+            }));
+            if (live.template.templateRef !== artifact.templateRef
+                || live.template.templateDigest !== artifact.templateDigest
+                || canonicalGrowthJson(live.template.privacyAttestation)
+                    !== canonicalGrowthJson(artifact.privacyAttestation)
+                || live.scope.workspace !== artifact.workspace || live.scope.preset !== artifact.preset
+                || live.principalId !== artifact.principalId
+                || live.deliveryBindingId !== definition.definition.deliveryBindingId
+                || live.ownerBindingId !== definition.definition.approvalBindingId) {
+                throw new AssistantAutomationsError('runtime-conflict', 'Growth owner route changed before approval settlement');
+            }
+        }
+        this.growthStore.updateApproval(artifact.artifactId, input.proposalId, proposal.status);
+        const receipt = proposal.status === 'approved'
+            ? withGrowthPortReceiptDigest({
+                ...growthIdentity(input), outcome: 'approved-paused', proposalId: input.proposalId,
+                artifactId: artifact.artifactId, artifactVersion: artifact.definitionVersion,
+                artifactDigest: artifact.definitionHash,
+            })
+            : proposal.status === 'pending'
+                ? withGrowthPortReceiptDigest({
+                    ...growthIdentity(input), outcome: 'approval-pending', proposalId: input.proposalId,
+                })
+                : withGrowthPortReceiptDigest({
+                    ...growthIdentity(input), outcome: proposal.status, proposalId: input.proposalId,
+                });
+        return validateGrowthAutomationApprovalReceipt(this.growthStore.completeOperation('approval-settlement', input, receipt), growthIdentity(input));
+    }
+    replayWorkflowAutomation(inputValue) {
+        this.assertActive();
+        const input = validateGrowthAutomationArtifactRequest(inputValue);
+        const replay = this.growthStore.beginOperation('replay', input);
+        if (replay !== undefined)
+            return validateGrowthReplayReceipt(replay, input);
+        const artifact = this.growthStore.requireArtifact(input);
+        if (artifact.state !== 'paused') {
+            throw new AssistantAutomationsError('runtime-conflict', 'replay requires an exact paused artifact');
+        }
+        this.requireLiveGrowthArtifact(artifact);
+        // This is a content-free historical replay: it checks the immutable
+        // Delivery→Growth evidence window and never schedules or executes anything.
+        const replayDigest = growthObjectDigest({
+            contract: 'assistant-automations-growth-replay/v1',
+            evidenceDigest: artifact.evidenceDigest,
+            evidenceCount: artifact.evidenceCount,
+            templateDigest: artifact.templateDigest,
+            steps: artifact.steps,
+        });
+        const receipt = withGrowthPortReceiptDigest({
+            ...growthIdentity(input),
+            artifactId: input.artifactId,
+            artifactVersion: input.artifactVersion,
+            artifactDigest: input.artifactDigest,
+            outcome: artifact.evidenceCount > 0 ? 'passed' : 'failed',
+            replayDigest,
+        });
+        return validateGrowthReplayReceipt(this.growthStore.completeOperation('replay', input, receipt), input);
+    }
+    async shadowWorkflowAutomation(inputValue) {
+        this.assertActive();
+        const input = validateGrowthAutomationArtifactRequest(inputValue);
+        const replay = this.growthStore.beginOperation('shadow', input);
+        if (replay !== undefined)
+            return validateGrowthShadowReceipt(replay, input);
+        const artifact = this.growthStore.requireArtifact(input);
+        this.requireLiveGrowthArtifact(artifact);
+        const task = this.growthStore.createExecutionTask({ artifact, operationId: input.operationId, kind: 'shadow' });
+        let run = this.store.getRun(`run-${task.taskId}`);
+        if (run === undefined) {
+            await this.coordinator.tick();
+            await this.coordinator.whenIdle();
+            run = this.store.getRun(`run-${task.taskId}`);
+        }
+        if (run === undefined || !this.hasShadowEffectBlocker(run)) {
+            throw new AssistantAutomationsError('runtime-conflict', 'shadow execution lacks durable delivery/tool effect-blocker proof');
+        }
+        const receipt = withGrowthPortReceiptDigest({
+            ...growthIdentity(input),
+            artifactId: input.artifactId,
+            artifactVersion: input.artifactVersion,
+            artifactDigest: input.artifactDigest,
+            outcome: run.status === 'succeeded' ? 'passed' : 'failed',
+            effectsBlocked: true,
+            effectBlockerAttestation: growthEffectBlockerAttestation,
+            shadowDigest: growthObjectDigest({
+                contract: 'assistant-automations-growth-shadow/v1',
+                runId: run.id,
+                status: run.status,
+                definitionHash: run.definitionHash,
+                implementationDigest: growthEffectBlockerAttestation.implementationDigest,
+            }),
+        });
+        return validateGrowthShadowReceipt(this.growthStore.completeOperation('shadow', input, receipt), input);
+    }
+    async canaryWorkflowAutomation(inputValue) {
+        this.assertActive();
+        const input = validateGrowthAutomationArtifactRequest(inputValue);
+        const replay = this.growthStore.beginOperation('canary', input);
+        if (replay !== undefined)
+            return validateGrowthCanaryReceipt(replay, input);
+        const artifact = this.growthStore.requireArtifact(input);
+        this.requireLiveGrowthArtifact(artifact);
+        const task = this.growthStore.createExecutionTask({ artifact, operationId: input.operationId, kind: 'canary' });
+        let run = this.store.getRun(`run-${task.taskId}`);
+        if (run === undefined) {
+            await this.coordinator.tick();
+            await this.coordinator.whenIdle();
+            run = this.store.getRun(`run-${task.taskId}`);
+        }
+        if (run === undefined || run.executionMode !== 'production') {
+            throw new AssistantAutomationsError('runtime-conflict', 'canary exposure has no durable production run');
+        }
+        this.growthStore.recordCanaryRun(artifact.artifactId, run);
+        const terminalFailure = run.status !== 'succeeded';
+        const receipt = withGrowthPortReceiptDigest({
+            ...growthIdentity(input),
+            artifactId: input.artifactId,
+            artifactVersion: input.artifactVersion,
+            artifactDigest: input.artifactDigest,
+            outcome: terminalFailure ? 'failed' : 'pending',
+            exposureCount: 1,
+            exposureOperationId: `${input.experimentId}:canary`,
+        });
+        return validateGrowthCanaryReceipt(this.growthStore.completeOperation('canary', input, receipt), input);
+    }
+    inspectWorkflowCanary(inputValue) {
+        this.assertActive();
+        const input = validateGrowthCanaryInspectionRequest(inputValue);
+        const replay = this.growthStore.beginOperation('canary-inspection', input);
+        if (replay !== undefined)
+            return validateGrowthCanaryInspectionReceipt(replay, input);
+        const artifact = this.growthStore.requireArtifact(input);
+        const run = artifact.canaryRunId === undefined ? undefined : this.store.getRun(artifact.canaryRunId);
+        if (artifact.canaryTaskId === undefined || artifact.canaryRunId === undefined || run === undefined
+            || run.taskId !== artifact.canaryTaskId || run.executionMode !== 'production') {
+            throw new AssistantAutomationsError('runtime-conflict', 'canary inspection has no exact exposure proof');
+        }
+        let proof;
+        const evaluation = this.evaluation;
+        if (evaluation !== undefined && run.status === 'succeeded') {
+            const scope = canonicalEvaluationHostScope({ workspace: artifact.workspace, preset: artifact.preset });
+            const matches = evaluation.query({
+                scope,
+                situation: `automation:${artifact.automationId}`,
+                objectiveStatus: 'achieved',
+                trust: 'trusted',
+                limit: 100,
+            }).filter(outcome => outcome.evidence.some(entry => entry.kind === 'automation-run' && entry.ref === run.id));
+            if (matches.length === 1) {
+                proof = evaluation.getTrustedOutcome({ scope, outcomeId: matches[0].id });
+            }
+        }
+        const passed = proof !== undefined && proof.trust === 'trusted'
+            && proof.objectiveStatus === 'achieved'
+            && proof.evidence.some(entry => entry.kind === 'automation-run' && entry.ref === run.id);
+        const failed = run.status !== 'succeeded';
+        const evaluationDigest = !passed ? undefined : growthObjectDigest({
+            contract: 'assistant-automations-growth-evaluation-proof/v1',
+            id: proof.id,
+            scopeKey: proof.scopeKey,
+            situation: proof.situation,
+            objectiveStatus: proof.objectiveStatus,
+            trust: proof.trust,
+            evidence: proof.evidence,
+            occurredAt: proof.occurredAt,
+            evaluator: proof.evaluator,
+        });
+        if (passed) {
+            this.growthStore.recordCanaryEvaluation({
+                artifactId: artifact.artifactId,
+                runId: run.id,
+                evaluationId: proof.id,
+                evaluationDigest: evaluationDigest,
+            });
+        }
+        const receipt = withGrowthPortReceiptDigest({
+            ...growthIdentity(input),
+            artifactId: input.artifactId,
+            artifactVersion: input.artifactVersion,
+            artifactDigest: input.artifactDigest,
+            outcome: passed ? 'passed' : failed ? 'failed' : 'pending',
+            exposureCount: 1,
+            exposureOperationId: input.exposureOperationId,
+            ...(passed ? {
+                evaluationDigest: evaluationDigest,
+                evaluationTrust: 'trusted',
+                objectiveStatus: 'achieved',
+            } : {}),
+        });
+        return validateGrowthCanaryInspectionReceipt(this.growthStore.completeOperation('canary-inspection', input, receipt), input);
+    }
+    promoteWorkflowAutomation(inputValue) {
+        this.assertActive();
+        const input = validateGrowthAutomationArtifactRequest(inputValue);
+        const replay = this.growthStore.beginOperation('promotion', input);
+        if (replay !== undefined)
+            return validateGrowthPromotionReceipt(replay, input);
+        const artifact = this.growthStore.requireArtifact(input);
+        if (artifact.state !== 'canary-pending' || artifact.canaryRunId === undefined
+            || artifact.canaryEvaluationId === undefined || artifact.canaryEvaluationDigest === undefined) {
+            throw new AssistantAutomationsError('runtime-conflict', 'promotion requires the exact canary artifact');
+        }
+        const definition = this.requireLiveGrowthArtifact(artifact);
+        if (definition === undefined || definition.owner !== GROWTH_AUTOMATION_OWNER
+            || this.store.getDefinitionHash(definition.id) !== input.artifactDigest
+            || !((definition.status === 'paused' && definition.version === input.artifactVersion)
+                || (definition.status === 'active' && definition.version === input.artifactVersion + 1))) {
+            throw new AssistantAutomationsError('runtime-conflict', 'promotion artifact changed before exact CAS');
+        }
+        const promoted = definition.status === 'active'
+            ? definition
+            : this.reconcileSystem({
+                owner: GROWTH_AUTOMATION_OWNER,
+                automationId: definition.id,
+                idempotencyKey: boundedGrowthKey('growth-promote', input),
+                desiredStatus: 'active',
+                definition: definition.definition,
+            });
+        const stored = this.growthStore.completePromotion({ request: input, automation: promoted });
+        const receipt = withGrowthPortReceiptDigest({
+            ...growthIdentity(input),
+            artifactId: input.artifactId,
+            artifactVersion: input.artifactVersion,
+            artifactDigest: input.artifactDigest,
+            outcome: 'promoted',
+            resultingArtifactVersion: stored.definitionVersion,
+            resultingArtifactDigest: stored.definitionHash,
+        });
+        return validateGrowthPromotionReceipt(this.growthStore.completeOperation('promotion', input, receipt), input);
+    }
+    rollbackWorkflowAutomation(inputValue) {
+        this.assertActive();
+        const input = validateGrowthAutomationArtifactRequest(inputValue);
+        const replay = this.growthStore.beginOperation('rollback', input);
+        if (replay !== undefined)
+            return validateGrowthRollbackReceipt(replay, input);
+        const artifact = this.growthStore.requireArtifact(input);
+        let automation = this.store.get(artifact.automationId);
+        if (automation === undefined || automation.owner !== GROWTH_AUTOMATION_OWNER
+            || this.store.getDefinitionHash(automation.id) !== input.artifactDigest
+            || !((automation.status === 'active' && automation.version === input.artifactVersion)
+                || (automation.status === 'paused'
+                    && (automation.version === input.artifactVersion
+                        || automation.version === input.artifactVersion + 1)))) {
+            throw new AssistantAutomationsError('runtime-conflict', 'rollback artifact changed before exact CAS');
+        }
+        if (automation.status === 'active') {
+            this.store.pauseSystemOwned({
+                owner: GROWTH_AUTOMATION_OWNER,
+                operationId: boundedGrowthKey('growth-rollback-pause', input),
+                automationId: automation.id,
+                definitionHash: input.artifactDigest,
+                expectedVersion: input.artifactVersion,
+            });
+            automation = this.store.get(automation.id);
+        }
+        this.growthStore.completeRollback({ request: input, automation });
+        const receipt = withGrowthPortReceiptDigest({
+            ...growthIdentity(input),
+            artifactId: input.artifactId,
+            artifactVersion: input.artifactVersion,
+            artifactDigest: input.artifactDigest,
+            outcome: 'rolled-back',
+        });
+        return validateGrowthRollbackReceipt(this.growthStore.completeOperation('rollback', input, receipt), input);
+    }
     propose(agent, input) {
         const identity = this.authorizeAgent(agent, 'propose', input.mutation.automationId, `automation-propose:${input.idempotencyKey}`);
         const approval = this.resolveApprovalRoute(agent, identity, input.principal);
@@ -241,7 +1041,8 @@ export class AssistantAutomationsService extends Service {
             if (current !== undefined && (current.definition.workspace !== identity.workspace
                 || current.definition.agentPreset !== identity.agentPreset
                 || current.definition.principal !== approval.principal
-                || current.definition.deliveryBindingId !== approval.dispatch?.bindingId)) {
+                || (current.definition.approvalBindingId ?? current.definition.deliveryBindingId)
+                    !== approval.dispatch?.bindingId)) {
                 throw new AssistantAutomationsError('missing-approval-route', 'automation lifecycle proposal does not match the immutable owner route');
             }
             mutation = input.mutation;
@@ -301,15 +1102,42 @@ export class AssistantAutomationsService extends Service {
         return this.store.list();
     }
     history(agent, input = {}) {
-        this.authorizeAgent(agent, 'history', input.automationId ?? 'catalog');
+        const identity = this.authorizeAgent(agent, 'history', input.automationId ?? 'catalog');
+        if (input.runId !== undefined && input.automationId !== undefined) {
+            throw new AssistantAutomationsError('invalid-input', 'history accepts runId or automationId, not both');
+        }
         const limit = input.limit ?? 20;
+        if (input.runId !== undefined) {
+            if (!/^run-task-occ-[a-f0-9]{64}$/u.test(input.runId)) {
+                throw new AssistantAutomationsError('invalid-input', 'runId is not a canonical Automation run id');
+            }
+            const run = this.store.getRun(input.runId);
+            const snapshot = run === undefined ? undefined : this.store.getRunExecutionSnapshot(run.id);
+            const sameScope = snapshot !== undefined
+                && resolve(snapshot.definition.workspace.normalize('NFC')) === resolve(identity.workspace.normalize('NFC'))
+                && snapshot.definition.agentPreset.normalize('NFC').trim()
+                    === identity.agentPreset.normalize('NFC').trim();
+            if (run === undefined || !sameScope) {
+                // Do not reveal whether a cross-scope run exists.
+                throw new AssistantAutomationsError('not-found', 'automation run was not found in the current Agent scope');
+            }
+            const occurrence = this.store.getOccurrence(run.occurrenceId);
+            if (occurrence === undefined) {
+                throw new AssistantAutomationsError('not-found', 'automation run occurrence was not found');
+            }
+            return { occurrences: [occurrence], runs: [run] };
+        }
+        const runs = this.store.listRunsForExecutionScope({
+            ...identity,
+            ...(input.automationId === undefined ? {} : { automationId: input.automationId }),
+            limit,
+        });
         return {
-            occurrences: this.store.listOccurrences({
-                ...(input.automationId === undefined ? {} : { automationId: input.automationId }), limit,
-            }),
-            runs: this.store.listRuns({
-                ...(input.automationId === undefined ? {} : { automationId: input.automationId }), limit,
+            occurrences: runs.flatMap(value => {
+                const occurrence = this.store.getOccurrence(value.occurrenceId);
+                return occurrence === undefined ? [] : [occurrence];
             }),
+            runs,
         };
     }
     async runDry(agent, input) {
@@ -331,6 +1159,48 @@ export class AssistantAutomationsService extends Service {
             throw new Error('assistant-automations: dry-run task was not claimed by this duty owner');
         return { occurrence: this.store.getOccurrence(occurrence.id), run };
     }
+    /** Exact Host-only preview lane for one system-owned immutable definition. */
+    async runSystemDry(input) {
+        this.assertActive();
+        const current = this.store.get(input.automationId);
+        if (current === undefined || current.owner !== input.owner) {
+            throw new AssistantAutomationsError('not-found', 'system automation was not found for the exact owner');
+        }
+        if (this.store.getDefinitionHash(input.automationId) !== input.definitionHash) {
+            throw new AssistantAutomationsError('invalid-input', 'system dry-run definition hash is stale');
+        }
+        const decision = this.policy.authorize({
+            subject: {
+                kind: 'background', id: input.owner,
+                workspace: current.definition.workspace, principal: current.definition.principal,
+            },
+            action: 'run-dry',
+            resource: { kind: 'automation', id: input.automationId },
+            context: { initiator: 'background' },
+        }, { idempotencyKey: [
+                'automation-system-dry', input.owner, input.automationId,
+                input.definitionHash, input.idempotencyKey,
+            ].join(':') });
+        if (decision.effect !== 'allow')
+            throw policyError(decision);
+        const occurrence = this.store.createManual({
+            automationId: input.automationId,
+            requestId: `system-dry:${input.owner}:${input.definitionHash}:${input.idempotencyKey}`,
+            dryRun: true,
+        });
+        let run = this.store.listRuns({ automationId: input.automationId, limit: 1_000 })
+            .find(value => value.occurrenceId === occurrence.id);
+        if (run === undefined) {
+            await this.coordinator.tick();
+            await this.coordinator.whenIdle();
+            run = this.store.listRuns({ automationId: input.automationId, limit: 1_000 })
+                .find(value => value.occurrenceId === occurrence.id);
+        }
+        if (run === undefined) {
+            throw new Error('assistant-automations: system dry-run was not claimed by this duty owner');
+        }
+        return { occurrence: this.store.getOccurrence(occurrence.id), run };
+    }
     ingestExternal(input) {
         this.assertActive();
         const automation = this.store.get(input.automationId);
@@ -384,6 +1254,140 @@ export class AssistantAutomationsService extends Service {
         this.assertActive();
         return this.store.health();
     }
+    /** Host-only, content-free projection for recovery/runbook controllers. */
+    inspectSystemOwned(input) {
+        this.assertActive();
+        return this.store.inspectSystemOwned(input);
+    }
+    /** Host-only bounded identity inventory; definitions and scopes never leave the store. */
+    listSystemOwned(input) {
+        this.assertActive();
+        return this.store.listSystemOwned(input);
+    }
+    /** Host-only exact CAS used by fleet owners to retire removed jobs safely. */
+    pauseSystemOwned(input) {
+        this.assertActive();
+        const current = this.store.get(input.automationId);
+        if (current === undefined || current.owner !== input.owner) {
+            throw new AssistantAutomationsError('not-found', 'system-owned automation was not found for the exact owner');
+        }
+        if (this.store.getDefinitionHash(input.automationId) !== input.definitionHash) {
+            throw new AssistantAutomationsError('invalid-input', 'system pause definition hash does not match the current automation definition');
+        }
+        const decision = this.policy.authorize({
+            subject: {
+                kind: 'background', id: input.owner,
+                workspace: current.definition.workspace, principal: current.definition.principal,
+            },
+            action: 'reconcile',
+            resource: { kind: 'automation', id: input.automationId },
+            context: { initiator: 'background' },
+        }, { idempotencyKey: [
+                'automation-system-pause', input.owner, input.automationId,
+                input.definitionHash, input.expectedVersion, input.operationId,
+            ].join(':') });
+        if (decision.effect !== 'allow')
+            throw policyError(decision);
+        return this.store.pauseSystemOwned(input);
+    }
+    resolveQualityEvidence(input) {
+        this.assertActive();
+        return this.store.resolveQualityEvidence(input);
+    }
+    resolveDeliveryEvidence(input) {
+        this.assertActive();
+        return this.store.resolveDeliveryEvidence(input);
+    }
+    validateQualityEvidence(receipt) {
+        this.assertActive();
+        return this.store.validateQualityEvidence(receipt);
+    }
+    /** Process-local Host executor registration; never exposed as a model tool. */
+    registerHostExecutor(executor) {
+        this.assertActive();
+        return this.hostExecutors.register(executor);
+    }
+    /**
+     * Host/operator seam for one exact circuit repair. This is deliberately not
+     * registered as a model tool. The current immutable definition hash must
+     * still match, so an old repaired hash cannot clear a newer definition or an
+     * ABA-reverted definition behind the operator's back.
+     */
+    probeCircuit(input) {
+        this.assertActive();
+        const current = this.store.get(input.automationId);
+        if (current === undefined || current.owner !== input.owner) {
+            throw new AssistantAutomationsError('not-found', 'system-owned circuit was not found for the exact owner');
+        }
+        if (this.store.getDefinitionHash(input.automationId) !== input.definitionHash) {
+            throw new AssistantAutomationsError('invalid-input', 'circuit probe definition hash does not match the current automation definition');
+        }
+        const decision = this.policy.authorize({
+            subject: {
+                kind: 'background', id: input.owner,
+                workspace: current.definition.workspace, principal: current.definition.principal,
+            },
+            action: 'repair',
+            resource: { kind: 'automation', id: `${input.automationId}:circuit:${input.definitionHash}` },
+            context: { initiator: 'background' },
+        }, { idempotencyKey: [
+                'automation-circuit-probe', input.owner, input.automationId,
+                input.definitionHash, input.expectedCircuitVersion, input.operationId,
+            ].join(':') });
+        if (decision.effect !== 'allow')
+            throw policyError(decision);
+        const leaseMs = input.leaseMs
+            ?? Math.min(86_400_000, Math.max(this.config.taskLeaseMs, current.definition.timeoutMs));
+        return this.store.armCircuitProbe({
+            owner: input.owner,
+            operationId: input.operationId,
+            automationId: input.automationId,
+            definitionHash: input.definitionHash,
+            expectedVersion: input.expectedCircuitVersion,
+            now: Date.now(),
+            leaseMs,
+        });
+    }
+    /**
+     * Recovery seam that atomically arms an exact circuit and schedules its one
+     * production canary. Unlike probeCircuit(), callers cannot leave a durable
+     * half-open circuit without a corresponding task.
+     */
+    probeCircuitAndScheduleCanary(input) {
+        this.assertActive();
+        const current = this.store.get(input.automationId);
+        if (current === undefined || current.owner !== input.owner) {
+            throw new AssistantAutomationsError('not-found', 'system-owned circuit was not found for the exact owner');
+        }
+        if (this.store.getDefinitionHash(input.automationId) !== input.definitionHash) {
+            throw new AssistantAutomationsError('invalid-input', 'circuit canary definition hash does not match the current automation definition');
+        }
+        const decision = this.policy.authorize({
+            subject: {
+                kind: 'background', id: input.owner,
+                workspace: current.definition.workspace, principal: current.definition.principal,
+            },
+            action: 'repair',
+            resource: { kind: 'automation', id: `${input.automationId}:circuit:${input.definitionHash}` },
+            context: { initiator: 'background' },
+        }, { idempotencyKey: [
+                'automation-circuit-canary', input.owner, input.automationId,
+                input.definitionHash, input.expectedCircuitVersion, input.operationId,
+            ].join(':') });
+        if (decision.effect !== 'allow')
+            throw policyError(decision);
+        const leaseMs = input.leaseMs
+            ?? Math.min(86_400_000, Math.max(this.config.taskLeaseMs, current.definition.timeoutMs));
+        return this.store.probeCircuitAndScheduleCanary({
+            owner: input.owner,
+            operationId: input.operationId,
+            automationId: input.automationId,
+            definitionHash: input.definitionHash,
+            expectedVersion: input.expectedCircuitVersion,
+            now: Date.now(),
+            leaseMs,
+        });
+    }
     start() {
         this.assertActive();
         this.coordinator.start();
@@ -421,7 +1425,8 @@ export class AssistantAutomationsService extends Service {
         const dispatch = delivery.prepareAgentApproval(agent, {
             sourceId: 'dsh-enhanced-assistant-automations',
         });
-        if (dispatch.sourceId !== 'dsh-enhanced-assistant-automations'
+        if (dispatch.routeVersion !== 2
+            || dispatch.sourceId !== 'dsh-enhanced-assistant-automations'
             || dispatch.workspace !== identity.workspace
             || dispatch.bindingId.trim() === ''
             || dispatch.principal.trim() === '') {