@dsh-enhanced/assistant-memory-learning 0.0.0-stage → 0.1.53

package/lib/runtime.d.ts

@@ -0,0 +1,116 @@
+import type { AssistantAutomationsService } from '@dsh-enhanced/assistant-automations';
+import type { AssistantDeliveryService, OwnerForegroundTaskSource, OwnerForegroundTaskSourceScope } from '@dsh-enhanced/assistant-delivery';
+import type { AssistantEvaluationService } from '@dsh-enhanced/assistant-evaluation';
+import type { AssistantPolicyService } from '@dsh-enhanced/assistant-policy';
+import type { MemoryReviewReceipt } from '@dsh-enhanced/assistant-verifier';
+import { type MemoryLearningProposal, type MemoryLearningReviewRequest } from '@dsh-enhanced/assistant-growth-contract';
+import type { LearningConfig, LearningJob, LearningSnapshot } from './types.js';
+type Delivery = Pick<AssistantDeliveryService, 'validateOwnerRoute' | 'listOwnerForegroundTaskSources' | 'withOwnerForegroundTaskSourcesFence' | 'inspectOwnerForegroundLearningTask'> & {
+    inspectOwnerForegroundTaskSource(input: OwnerForegroundTaskSourceScope & {
+        inboxId: string;
+    }): Readonly<OwnerForegroundTaskSource> | undefined;
+};
+type Evaluation = Pick<AssistantEvaluationService, 'canonicalHostScope' | 'listTrustedTaskLearningProjections' | 'withTrustedCanonicalScopeWriterFence' | 'getTrustedForegroundLearningProjection' | 'inspectTrustedTaskOwnerRevision'>;
+type Automations = Pick<AssistantAutomationsService, 'registerHostExecutor' | 'reconcileSystem' | 'inspectSystemOwnedActivation' | 'inspectSystemOwned'>;
+type Target = LearningSnapshot['targets'][number];
+interface Memory {
+    listLearningTargets(input: {
+        owner: LearningConfig['owner'];
+        limit?: number;
+    }): readonly Target[];
+    inspectLearningAdoptionAvailability(input: {
+        owner: LearningConfig['owner'];
+    }): Readonly<{
+        authorityId: string;
+        grantDigest: string;
+        expiresAt: number;
+        remainingMutations: number;
+        remainingContentBytes: number;
+        available: boolean;
+    }>;
+    lookupLearningAdoption(input: {
+        request: MemoryLearningReviewRequest;
+    }): Readonly<{
+        receiptDigest: string;
+    }> | undefined;
+    adoptReviewedLearning(input: {
+        request: MemoryLearningReviewRequest;
+    }): Readonly<{
+        receiptDigest: string;
+    }>;
+}
+interface Verifier {
+    inspectMemoryLearningReviewAvailability(input: {
+        owner: LearningConfig['owner'];
+    }): Readonly<{
+        authorityId: string;
+        authorityDigest: string;
+        expiresAt: number;
+        remainingReviews: number;
+        available: boolean;
+    }> | undefined;
+    reviewMemoryLearning(request: MemoryLearningReviewRequest, signal?: AbortSignal): Promise<MemoryReviewReceipt>;
+    lookupMemoryLearningReview(request: MemoryLearningReviewRequest): Readonly<MemoryReviewReceipt> | undefined;
+}
+export interface LearningPorts {
+    delivery: Delivery;
+    evaluation: Evaluation;
+    automations: Automations;
+    memory: Memory;
+    verifier: Verifier;
+    policy: Pick<AssistantPolicyService, 'evaluate' | 'authorize'>;
+    extract(input: {
+        config: LearningConfig;
+        job: LearningJob;
+        signal: AbortSignal;
+        assertCurrent(): void;
+    }): Promise<{
+        proposal: MemoryLearningProposal | null;
+        reason: string;
+        sessionId: string;
+        outputDigest: string;
+    }>;
+}
+/** Two durable source cursors. Native Automations owns every timer and dispatch. */
+export declare class MemoryLearningRuntime {
+    private readonly ports;
+    private readonly config;
+    private readonly store;
+    private readonly configDigest;
+    private readonly lane;
+    private readonly scanId;
+    private readonly abort;
+    private readonly flights;
+    private unregister;
+    private active;
+    private scanning;
+    private lastError;
+    private lastScanAt;
+    private closing;
+    constructor(config: LearningConfig, ports: LearningPorts);
+    health: () => {
+        remainingExtractions: number;
+        available: boolean;
+        enabled: boolean;
+        connected: boolean;
+        lastScanAt: number | null;
+        lastError: string | null;
+        counts: Record<import("./types.js").LearningState, number>;
+    };
+    start(): void;
+    close(): Promise<void>;
+    private scope;
+    private owner;
+    private policy;
+    private available;
+    private evaluationFence;
+    private withSource;
+    scan: () => void;
+    private definition;
+    private schedule;
+    private reviewMatches;
+    private reconcile;
+    private execute;
+}
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/lib/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}

package/lib/runtime.js

@@ -0,0 +1,474 @@
+import { growthObjectDigest, memoryLearningRequestDigest, validateMemoryLearningReviewRequest } from '@dsh-enhanced/assistant-growth-contract';
+import { validateLearningConfig, validateLearningModel } from './config.js';
+import { LearningStore } from './store.js';
+const OWNER = 'assistant-memory-learning';
+const EXECUTOR = 'assistant-memory-learning-v1';
+const CATALOG = growthObjectDigest({ executor: EXECUTOR, contract: 1 });
+class SourcePending extends Error {
+}
+class SourceObsolete extends Error {
+}
+const same = (a, b) => growthObjectDigest(a) === growthObjectDigest(b);
+const reasonText = (value) => Array.from(String(value).normalize('NFC').replaceAll('\0', '').trim())
+    .slice(0, 120).join('') || 'learning-incomplete';
+/** Two durable source cursors. Native Automations owns every timer and dispatch. */
+export class MemoryLearningRuntime {
+    ports;
+    config;
+    store;
+    configDigest;
+    lane;
+    scanId;
+    abort = new AbortController();
+    flights = new Set();
+    unregister;
+    active = false;
+    scanning = false;
+    lastError = null;
+    lastScanAt = null;
+    closing;
+    constructor(config, ports) {
+        this.ports = ports;
+        this.config = validateLearningConfig(config);
+        this.configDigest = growthObjectDigest(this.config);
+        this.lane = growthObjectDigest([this.config.authorityId, this.config.owner]);
+        this.scanId = `memory-scan-${this.lane}`;
+        for (const [port, methods] of [
+            [ports.delivery, ['validateOwnerRoute', 'listOwnerForegroundTaskSources', 'inspectOwnerForegroundTaskSource', 'withOwnerForegroundTaskSourcesFence', 'inspectOwnerForegroundLearningTask']],
+            [ports.evaluation, ['canonicalHostScope', 'listTrustedTaskLearningProjections', 'withTrustedCanonicalScopeWriterFence', 'getTrustedForegroundLearningProjection', 'inspectTrustedTaskOwnerRevision']],
+            [ports.automations, ['registerHostExecutor', 'reconcileSystem', 'inspectSystemOwnedActivation', 'inspectSystemOwned']],
+            [ports.memory, ['listLearningTargets', 'inspectLearningAdoptionAvailability', 'lookupLearningAdoption', 'adoptReviewedLearning']],
+            [ports.verifier, ['inspectMemoryLearningReviewAvailability', 'reviewMemoryLearning', 'lookupMemoryLearningReview']],
+            [ports.policy, ['evaluate', 'authorize']],
+        ])
+            for (const method of methods)
+                if (typeof port[method] !== 'function')
+                    throw new Error(`memory learning requires compatible Host API: ${method}`);
+        this.store = new LearningStore(this.config.databasePath, { authorityId: this.config.authorityId,
+            configDigest: this.configDigest, maxExtractions: this.config.maxExtractions });
+    }
+    health = () => ({ enabled: true, connected: this.active, lastScanAt: this.lastScanAt,
+        lastError: this.lastError, counts: this.store.counts(this.lane), ...this.store.availability() });
+    start() {
+        if (this.active || this.closing)
+            throw new Error('memory learning runtime cannot be started twice');
+        try {
+            this.store.interrupt(this.lane);
+            this.unregister = this.ports.automations.registerHostExecutor({
+                descriptor: { executorId: EXECUTOR, contractVersion: 1, catalogDigest: CATALOG },
+                accepts: spec => spec.executorId === EXECUTOR && spec.executorContractVersion === 1 && spec.catalogDigest === CATALOG
+                    && spec.runbookVersion === 1 && ['scan', 'learn'].includes(spec.runbookId),
+                execute: input => {
+                    const flight = this.execute(input);
+                    this.flights.add(flight);
+                    void flight.finally(() => this.flights.delete(flight)).catch(() => { });
+                    return flight;
+                },
+            });
+            this.active = true;
+            this.owner();
+            this.ports.automations.reconcileSystem({ owner: OWNER, automationId: this.scanId,
+                idempotencyKey: `${this.scanId}:${this.configDigest}`, desiredStatus: 'active', definition: this.definition() });
+            // One bounded activation reconciliation; subsequent scans are native jobs.
+            this.scan();
+        }
+        catch (error) {
+            this.active = false;
+            this.unregister?.();
+            this.abort.abort(error);
+            this.store.close();
+            throw error;
+        }
+    }
+    close() {
+        return this.closing ??= (async () => {
+            this.active = false;
+            this.unregister?.();
+            this.abort.abort(new Error('memory learning provider disposed'));
+            this.store.interrupt(this.lane);
+            const deadline = AbortSignal.timeout(5000);
+            let release;
+            const expired = new Promise(resolve => {
+                const timeout = () => resolve(false);
+                deadline.addEventListener('abort', timeout, { once: true });
+                release = () => deadline.removeEventListener('abort', timeout);
+            });
+            try {
+                const drained = await Promise.race([Promise.allSettled(this.flights).then(() => true), expired]);
+                if (!drained)
+                    throw new Error('memory learning shutdown timed out; pending dispatches remain unknown');
+            }
+            finally {
+                release();
+                this.store.close();
+            }
+        })();
+    }
+    scope() {
+        const owner = this.config.owner;
+        return { authorityId: owner.authorityId, principalId: owner.principalId, workspace: owner.workspace,
+            agentPreset: owner.agentPreset, expectedOwner: { authorityHash: owner.authorityHash,
+                principalRecordId: owner.principalRecordId, principalVersion: owner.principalVersion } };
+    }
+    owner() {
+        if (!this.active)
+            throw new Error('memory learning unavailable');
+        const current = this.ports.delivery.validateOwnerRoute(this.scope());
+        for (const key of Object.keys(this.config.owner)) {
+            if (current[key] !== this.config.owner[key])
+                throw new Error('memory learning owner authority changed');
+        }
+    }
+    policy(consume = false, idempotencyKey) {
+        const owner = this.config.owner;
+        const input = { subject: { kind: 'background', id: OWNER, workspace: owner.workspace, principal: owner.principalId },
+            action: 'extract', resource: { kind: 'memory', id: `learning:${this.config.authorityId}` }, context: { initiator: 'background' } };
+        const decision = consume ? this.ports.policy.authorize(input, idempotencyKey === undefined ? {} : { idempotencyKey }) : this.ports.policy.evaluate(input);
+        if (decision.effect !== 'allow')
+            throw new Error('memory learning extraction policy denied');
+    }
+    available() {
+        this.owner();
+        this.policy();
+        const review = this.ports.verifier.inspectMemoryLearningReviewAvailability({ owner: this.config.owner });
+        const memory = this.ports.memory.inspectLearningAdoptionAvailability({ owner: this.config.owner });
+        return Date.now() < this.config.expiresAt && this.store.availability().available && review?.available === true
+            && review.authorityId === this.config.reviewAuthorityId && review.authorityDigest === this.config.reviewAuthorityDigest
+            && memory.available && memory.authorityId === this.config.adoptionAuthorityId && memory.grantDigest === this.config.adoptionGrantDigest;
+    }
+    evaluationFence(callback) {
+        const owner = this.config.owner;
+        const scope = this.ports.evaluation.canonicalHostScope({ workspace: owner.workspace, preset: owner.agentPreset });
+        const { scopeWatermark } = this.ports.evaluation.listTrustedTaskLearningProjections({ scope, limit: 1 });
+        const result = this.ports.evaluation.withTrustedCanonicalScopeWriterFence({ scope, scopeWatermark }, callback);
+        if (!result.matched)
+            throw new SourcePending('canonical scope changed during read');
+        return result.value;
+    }
+    withSource(job, callback) {
+        this.abort.signal.throwIfAborted();
+        this.owner();
+        this.policy();
+        if (job.intent.configDigest !== this.configDigest || !same(job.intent.owner, this.config.owner)
+            || Date.now() >= Math.min(job.intent.expiresAt, this.config.expiresAt))
+            throw new SourceObsolete('learning authority or source window expired');
+        const metadata = this.ports.delivery.inspectOwnerForegroundTaskSource({ ...this.scope(), inboxId: job.intent.inboxId });
+        if (!metadata)
+            throw new SourcePending('completed source unavailable');
+        if (job.intent.expectedSourceDigest && metadata.sourceDigest !== job.intent.expectedSourceDigest
+            || job.snapshot && metadata.sourceDigest !== job.snapshot.source.sourceDigest
+            || metadata.execution.status !== 'succeeded' || !metadata.execution.quiescent
+            || metadata.execution.modelSelectionState !== 'frozen' || !metadata.execution.modelSelection)
+            throw new SourceObsolete('source completion or model changed');
+        return this.ports.delivery.withOwnerForegroundTaskSourcesFence({ ...this.scope(),
+            sources: [{ inboxId: metadata.inboxId, expectedSourceDigest: metadata.sourceDigest }] }, contents => this.evaluationFence(() => {
+            const owner = this.config.owner;
+            const scope = this.ports.evaluation.canonicalHostScope({ workspace: owner.workspace, preset: owner.agentPreset });
+            const canonical = this.ports.evaluation.getTrustedForegroundLearningProjection({ scope, inboxId: job.intent.inboxId });
+            const revision = canonical && this.ports.evaluation.inspectTrustedTaskOwnerRevision({ scope, outcomeId: canonical.triggerOutcomeId,
+                principalRecordId: owner.principalRecordId, principalVersion: owner.principalVersion });
+            if (revision?.action === 'withdraw')
+                throw new SourceObsolete('owner withdrew learning source');
+            const content = contents[0];
+            if (!content)
+                throw new SourcePending('original reply not yet readable');
+            if (content.input.truncated || content.reply.truncated)
+                throw new SourceObsolete('learning source exceeds text boundary');
+            let feedback;
+            if (job.intent.canonical) {
+                const expected = job.intent.canonical;
+                if (!canonical || canonical.projection.disposition !== 'upsert' || canonical.projection.version !== expected.version
+                    || canonical.projection.digest !== expected.digest || canonical.objective?.status !== expected.objectiveStatus)
+                    throw new SourceObsolete('canonical result changed');
+                const task = this.ports.delivery.inspectOwnerForegroundLearningTask({ authorityId: owner.authorityId, principalId: owner.principalId,
+                    workspace: owner.workspace, agentPreset: owner.agentPreset, outcomeId: expected.outcomeId });
+                if (!task || task.judgement === 'unresolved' || !task.source.quiescent || task.source.truncated || task.feedback?.truncated)
+                    throw new SourcePending('canonical owner source not yet readable');
+                if (task.source.inboxId !== job.intent.inboxId || task.ownerRevision?.action === 'withdraw'
+                    || task.canonical.projection.version !== expected.version || task.canonical.projection.digest !== expected.digest
+                    || task.canonical.objective?.status !== expected.objectiveStatus
+                    || task.owner.authorityHash !== owner.authorityHash || task.owner.principalRecordId !== owner.principalRecordId
+                    || task.owner.principalVersion !== owner.principalVersion)
+                    throw new SourceObsolete('canonical source owner changed');
+                feedback = task.feedback?.text;
+            }
+            if (job.snapshot && (content.contentDigest !== job.snapshot.source.contentDigest
+                || content.input.text !== job.snapshot.ownerStatement || content.reply.text !== job.snapshot.assistantReply
+                || feedback !== job.snapshot.ownerFeedback
+                || !same(this.config.model ?? content.source.execution.modelSelection, job.snapshot.model)))
+                throw new SourceObsolete('frozen learning inputs changed');
+            return callback(content, feedback);
+        }));
+    }
+    scan = () => {
+        if (!this.active || this.scanning)
+            return;
+        this.scanning = true;
+        try {
+            this.lastError = null;
+            this.owner();
+            // Lost acknowledgements reconcile before admitting more paid work.
+            for (const job of this.store.pending(this.lane))
+                if (job.state === 'unknown') {
+                    if (job.request)
+                        this.reconcile(job);
+                    // A durable request is always saved before any review/adoption call.
+                    // No request proves that no memory mutation was dispatched. The paid
+                    // extraction attempt remains consumed and is never retried.
+                    else
+                        this.store.settle(job.id, 'failed', 'interrupted-extraction-no-mutation-dispatched');
+                }
+            if (!this.available()) {
+                this.lastError = 'learning-authority-or-budget-unavailable';
+                return;
+            }
+            const owner = this.config.owner;
+            let stopped = false;
+            for (let pageNumber = 0; pageNumber < 10 && !stopped; pageNumber++) {
+                const after = this.store.cursor(this.lane, 'delivery');
+                const page = this.ports.delivery.listOwnerForegroundTaskSources({ ...this.scope(), ...(after ? { after } : {}), limit: 100 });
+                for (const source of page.items) {
+                    const now = Date.now(), at = source.execution.completedAt ?? 0;
+                    const eligible = source.execution.status === 'succeeded' && source.execution.quiescent && at <= now
+                        && now - at <= this.config.lookbackMs && source.execution.modelSelectionState === 'frozen';
+                    const intent = eligible ? { configDigest: this.configDigest, owner, kind: 'fact', subject: source.inboxId,
+                        inboxId: source.inboxId, expectedSourceDigest: source.sourceDigest, createdAt: now,
+                        expiresAt: Math.min(this.config.expiresAt, now + this.config.lookbackMs) } : undefined;
+                    if (!this.store.stage({ lane: this.lane, feed: 'delivery', cursor: { ...page.nextCursor, sequence: source.completionSequence },
+                        sequence: source.completionSequence, subject: source.inboxId, ...(intent ? { intent } : {}), maxPending: this.config.maxPending })) {
+                        stopped = true;
+                        break;
+                    }
+                }
+                if (!stopped)
+                    this.store.stage({ lane: this.lane, feed: 'delivery', cursor: page.nextCursor, sequence: page.nextCursor.sequence,
+                        subject: 'cursor:delivery', maxPending: this.config.maxPending });
+                if (!page.hasMore)
+                    break;
+            }
+            const scope = this.ports.evaluation.canonicalHostScope({ workspace: owner.workspace, preset: owner.agentPreset });
+            stopped = false;
+            for (let pageNumber = 0; pageNumber < 10 && !stopped; pageNumber++) {
+                const after = this.store.cursor(this.lane, 'evaluation');
+                const page = this.ports.evaluation.listTrustedTaskLearningProjections({ scope, ...(after ? { after } : {}), limit: 100 });
+                for (const item of page.items) {
+                    const canonical = item.receipt, now = Date.now(), at = canonical.objective?.occurredAt ?? 0;
+                    const foreground = canonical.projection.subjectKind === 'foreground-turn';
+                    const status = canonical.objective?.status;
+                    const eligible = foreground && canonical.projection.disposition === 'upsert' && (status === 'achieved' || status === 'not-achieved')
+                        && at <= now && now - at <= this.config.lookbackMs;
+                    const intent = eligible ? { configDigest: this.configDigest, owner, kind: 'experience',
+                        subject: canonical.projection.subjectRef, inboxId: canonical.projection.subjectRef,
+                        canonical: { outcomeId: canonical.triggerOutcomeId, version: canonical.projection.version,
+                            digest: canonical.projection.digest, objectiveStatus: status }, createdAt: now,
+                        expiresAt: Math.min(this.config.expiresAt, now + this.config.lookbackMs) } : undefined;
+                    // No Delivery or Memory calls under this Evaluation lock.
+                    const result = this.ports.evaluation.withTrustedCanonicalScopeWriterFence({ scope, scopeWatermark: page.scopeWatermark }, () => this.store.stage({ lane: this.lane, feed: 'evaluation', cursor: { scopeKey: page.nextCursor.scopeKey, watermark: item.watermark },
+                        sequence: item.watermark, subject: canonical.projection.subjectRef, ...(intent ? { intent } : {}),
+                        maxPending: this.config.maxPending, supersede: foreground }));
+                    if (!result.matched || !result.value) {
+                        stopped = true;
+                        break;
+                    }
+                }
+                if (!page.hasMore)
+                    break;
+            }
+            for (const pending of this.store.pending(this.lane)) {
+                if (pending.state !== 'pending' && pending.state !== 'queued')
+                    continue;
+                try {
+                    let job = pending;
+                    if (job.state === 'pending') {
+                        // Each API owns its own producer locks; do not nest target discovery.
+                        const targets = this.ports.memory.listLearningTargets({ owner, limit: 20 });
+                        job = this.withSource(job, (content, feedback) => this.store.freeze(job.id, {
+                            model: validateLearningModel(this.config.model ?? content.source.execution.modelSelection),
+                            source: { inboxId: content.source.inboxId, sourceDigest: content.sourceDigest, contentDigest: content.contentDigest,
+                                ...(job.intent.canonical ? { canonical: job.intent.canonical } : {}) },
+                            ownerStatement: content.input.text, assistantReply: content.reply.text,
+                            ...(feedback === undefined ? {} : { ownerFeedback: feedback }), targets,
+                        }));
+                    }
+                    this.withSource(job, () => this.schedule(job));
+                }
+                catch (error) {
+                    if (error instanceof SourceObsolete)
+                        this.store.settle(pending.id, 'superseded', reasonText(error.message));
+                    // Missing source/provider/scheduling readiness keeps the same durable intent.
+                    else if (!(error instanceof SourcePending))
+                        this.lastError = String(error).slice(0, 200);
+                }
+            }
+            this.lastScanAt = Date.now();
+            if (this.lastError === 'learning-authority-or-budget-unavailable')
+                this.lastError = null;
+        }
+        catch (error) {
+            this.lastError = String(error).slice(0, 200);
+        }
+        finally {
+            this.scanning = false;
+        }
+    };
+    definition(job) {
+        const owner = this.config.owner;
+        return { name: job ? 'Learn from an ordinary owner task' : 'Discover ordinary owner learning',
+            schedule: job ? { kind: 'at', at: new Date(job.intent.createdAt + 1000).toISOString() }
+                : { kind: 'cron', expression: '* * * * *', timezone: 'UTC' }, workspace: owner.workspace, agentPreset: owner.agentPreset,
+            timeoutMs: job ? this.config.timeoutMs + 310_000 : 30_000, misfire: { kind: 'latest' }, overlap: 'skip',
+            retrySafety: 'never', maxRetries: 0, principal: owner.principalId,
+            budgetId: job ? this.config.budgetId : this.config.scanBudgetId,
+            budgetAmount: job ? this.config.budgetAmount : this.config.scanBudgetAmount,
+            execution: { kind: 'host', executorId: EXECUTOR, executorContractVersion: 1, runbookId: job ? 'learn' : 'scan',
+                runbookVersion: 1, catalogDigest: CATALOG, targetScope: { workspace: owner.workspace, preset: owner.agentPreset },
+                scopeDigest: growthObjectDigest([owner.workspace, owner.agentPreset]), ownerRouteId: owner.authorityId,
+                activationNonce: job?.digest ?? this.configDigest } };
+    }
+    schedule(input) {
+        let job = input;
+        const definition = this.definition(job);
+        if (job.definitionHash === null) {
+            this.ports.automations.reconcileSystem({ owner: OWNER, automationId: job.id,
+                idempotencyKey: `${job.id}:prepare`, desiredStatus: 'paused', definition });
+            const receipt = this.ports.automations.inspectSystemOwnedActivation({ owner: OWNER, automationId: job.id });
+            if (!receipt || receipt.activationNonce !== job.digest || receipt.ownerRouteId !== this.config.owner.authorityId)
+                throw new Error('learning registration mismatch');
+            job = this.store.bind(job.id, receipt.definitionHash);
+        }
+        const receipt = this.ports.automations.inspectSystemOwnedActivation({ owner: OWNER, automationId: job.id });
+        if (!receipt || receipt.definitionHash !== job.definitionHash || receipt.activationNonce !== job.digest)
+            throw new Error('learning definition changed');
+        const terminal = this.ports.automations.inspectSystemOwned({ owner: OWNER, automationId: job.id }).latestTerminalRuns.production;
+        if (terminal && terminal.immutableContext.state === 'verified' && terminal.immutableContext.definitionHash === job.definitionHash) {
+            this.store.settle(job.id, 'failed', 'native-run-ended-before-claim');
+            return;
+        }
+        this.ports.automations.reconcileSystem({ owner: OWNER, automationId: job.id,
+            idempotencyKey: `${job.id}:activate`, desiredStatus: 'active', definition });
+    }
+    reviewMatches(job, receipt) {
+        return receipt.operationId === job.request.operationId && receipt.requestDigest === memoryLearningRequestDigest(job.request)
+            && receipt.authorityId === this.config.reviewAuthorityId && receipt.authorityDigest === this.config.reviewAuthorityDigest
+            && receipt.sessionId !== job.request.extractionSessionId;
+    }
+    reconcile(job) {
+        try {
+            const prior = this.ports.memory.lookupLearningAdoption({ request: job.request });
+            if (prior) {
+                this.store.settle(job.id, 'adopted', 'reconciled-original-adoption', prior.receiptDigest);
+                return;
+            }
+            this.withSource(job, () => undefined);
+            const review = this.ports.verifier.lookupMemoryLearningReview(job.request);
+            if (!review || !this.reviewMatches(job, review) || review.status === 'unknown')
+                return;
+            if (review.status === 'rejected')
+                this.store.settle(job.id, 'rejected', reasonText(review.reason), review.receiptDigest);
+            else {
+                // Lookup completed outside producer locks. Memory owns its adoption locks.
+                this.withSource(job, () => undefined);
+                const adopted = this.ports.memory.adoptReviewedLearning({ request: job.request });
+                this.store.settle(job.id, 'adopted', 'reconciled-approved-adoption', adopted.receiptDigest);
+            }
+        }
+        catch (error) {
+            if (error instanceof SourceObsolete)
+                this.store.settle(job.id, 'superseded', reasonText(error.message));
+            // Temporary absence retains the same request; paid calls are not replayed.
+        }
+    }
+    async execute(input) {
+        const result = (outcome) => ({ outcome,
+            failureClass: outcome === 'succeeded' ? 'none' : outcome === 'unknown' ? 'unknown' : 'configuration',
+            failurePhase: outcome === 'succeeded' ? 'none' : 'host-execution', failureCode: outcome === 'succeeded' ? 'none' : 'memory-learning-incomplete',
+            sideEffectState: outcome === 'succeeded' ? 'possible' : outcome === 'unknown' ? 'unknown' : 'none',
+            retryability: outcome === 'failed' ? 'after-intervention' : 'unsafe' });
+        let claimed;
+        try {
+            this.owner();
+            this.abort.signal.throwIfAborted();
+            input.signal.throwIfAborted();
+            const owner = this.config.owner;
+            if (input.executionMode !== 'production' || input.catalogDigest !== CATALOG || input.ownerRouteId !== owner.authorityId
+                || input.principal !== owner.principalId || input.targetScope.workspace !== owner.workspace
+                || input.targetScope.preset !== owner.agentPreset)
+                throw new Error('learning dispatch scope mismatch');
+            const activation = this.ports.automations.inspectSystemOwnedActivation({ owner: OWNER, automationId: input.automationId });
+            if (!activation || activation.definitionHash !== input.definitionHash || activation.activationNonce !== input.activationNonce)
+                throw new Error('learning activation changed');
+            if (input.automationId === this.scanId) {
+                if (input.activationNonce !== this.configDigest)
+                    throw new Error('learning scanner configuration changed');
+                this.scan();
+                return result(this.lastError === null ? 'succeeded' : 'failed');
+            }
+            const queued = this.store.get(input.automationId);
+            if (!queued || queued.state !== 'queued' || !queued.snapshot || queued.digest !== input.activationNonce
+                || queued.definitionHash !== input.definitionHash || !this.available())
+                throw new Error('learning job is not admissible');
+            this.withSource(queued, () => { claimed = this.store.claim(queued.id, input.definitionHash, input.occurrenceId); });
+            const job = claimed;
+            const signal = AbortSignal.any([input.signal, this.abort.signal, AbortSignal.timeout(Math.max(1, Math.min(this.config.timeoutMs + 310_000, job.intent.expiresAt - Date.now(), this.config.expiresAt - Date.now())))]);
+            const assertCurrent = () => {
+                signal.throwIfAborted();
+                const current = this.store.get(job.id);
+                if (!current || current.state !== 'running' || current.occurrenceId !== input.occurrenceId)
+                    throw new Error('learning claim superseded');
+                this.withSource(job, () => undefined);
+            };
+            assertCurrent();
+            this.policy(true, `memory-extract:${this.config.authorityId}:${job.id}`);
+            const extractionSignal = AbortSignal.any([signal, AbortSignal.timeout(this.config.timeoutMs)]);
+            const extraction = await this.ports.extract({ config: this.config, job, signal: extractionSignal, assertCurrent });
+            assertCurrent();
+            if (!extraction.proposal) {
+                this.store.settle(job.id, 'noop', reasonText(extraction.reason), extraction.outputDigest, input.occurrenceId);
+                return result('succeeded');
+            }
+            const proposal = extraction.proposal;
+            const quoteSources = [job.snapshot.ownerStatement, job.snapshot.ownerFeedback ?? ''];
+            if (!quoteSources.some(text => text.includes(proposal.evidenceQuote)))
+                throw new Error('learning quotation is not an owner source');
+            if (proposal.mutation.op !== 'remove' && proposal.mutation.entry.kind !== job.intent.kind)
+                throw new Error('learning kind changed');
+            const mutation = proposal.mutation;
+            if (mutation.op !== 'add' && !job.snapshot.targets.some(target => target.id === mutation.id && target.version === mutation.expectedVersion))
+                throw new Error('learning target not in frozen managed set');
+            const request = validateMemoryLearningReviewRequest({ protocol: 'memory-learning-review/v1',
+                operationId: job.id, extractionSessionId: extraction.sessionId,
+                owner, source: job.snapshot.source, ...proposal });
+            const saved = this.store.saveRequest(job.id, input.occurrenceId, request);
+            const review = await this.ports.verifier.reviewMemoryLearning(request, signal);
+            assertCurrent();
+            if (!this.reviewMatches(saved, review) || review.status === 'unknown') {
+                this.store.settle(job.id, 'unknown', 'independent-review-unresolved', undefined, input.occurrenceId);
+                return result('unknown');
+            }
+            if (review.status === 'rejected') {
+                this.store.settle(job.id, 'rejected', reasonText(review.reason), review.receiptDigest, input.occurrenceId);
+                return result('succeeded');
+            }
+            assertCurrent();
+            const adopted = this.ports.memory.adoptReviewedLearning({ request });
+            this.store.settle(job.id, 'adopted', 'independently-reviewed-and-adopted', adopted.receiptDigest, input.occurrenceId);
+            return result('succeeded');
+        }
+        catch (error) {
+            if (!this.active || this.abort.signal.aborted)
+                return result(claimed ? 'unknown' : 'failed');
+            if (claimed) {
+                const current = this.store.get(claimed.id);
+                if (current?.state === 'running' && current.occurrenceId === input.occurrenceId) {
+                    this.store.settle(claimed.id, current.request ? 'unknown' : 'failed', reasonText(error), undefined, input.occurrenceId);
+                }
+            }
+            return result(claimed ? 'unknown' : 'failed');
+        }
+        finally {
+            if (this.active)
+                this.scan();
+        }
+    }
+}
+//# sourceMappingURL=runtime.js.map