@dsh-enhanced/assistant-work-items 0.0.0-stage → 0.1.66

package/lib/service.js

@@ -0,0 +1,2388 @@
+import { WorkItemEngineeringTargets } from './engineering-context.js';
+import { Service } from '@deepseek-ai/cordis';
+import { classifyIntake, intakeSourcePolicy } from './intake.js';
+import { authenticatesIntakeText, WorkItemIntakeEvaluationRuntime } from './intake-evaluation-runtime.js';
+import { WorkItemIntakeAdmissionBridge } from './intake-admission.js';
+import { WorkItemAdmission } from './admission.js';
+import { storedBasisHolds, WorkItemAuthority } from './authority.js';
+import { ConfigSchema, isActive, normalizeConfig, text } from './config.js';
+import { WorkItemDispatch } from './dispatch.js';
+import { eventFollowReader, eventFollowRegistration } from './event-follow.js';
+import { WorkItemEvaluationExporter } from './evaluation.js';
+import { normalizeWorkItemReportSummary, WorkItemLedger } from './ledger.js';
+import { settleOutcomes as runSettlement } from './settlement.js';
+import { WorkItemOwnerRecall } from './owner-recall.js';
+import { MALFORMED_ACCEPTANCE_BINDING, WorkItemStore } from './store.js';
+import { normalizeFollowUp, normalizePolicyChange, noticePolicyChange } from './policy-notice.js';
+import { resolveAcceptanceBinding, settleAcceptance, workerRunTaskRef } from './acceptance-binding.js';
+import { WorkItemSignalIntake, } from './signals.js';
+import { registerWorkItemTools, workItemReportKey } from './tools.js';
+import { TERMINAL_STATES, WorkItemError } from './types.js';
+import { WorkItemWorkspace } from './workspace.js';
+import { WorkItemDiagnosis, persistedDiagnosisIntervention } from './diagnosis.js';
+import { WorkItemContinuation } from './continuation.js';
+import { WorkItemOwnerAccess } from './owner-access.js';
+import { WorkItemOwnerContinuation } from './owner-continuation.js';
+import { WorkItemOwnerReplies } from './owner-replies.js';
+import { WorkItemOwnerFeedbackTargets } from './feedback-targets.js';
+function fail(code, message, detail) {
+    throw new WorkItemError(code, message, detail);
+}
+/** Snapshot this shallow tool grammar without evaluating untrusted accessors. */
+function workItemToolArguments(candidate, allowed) {
+    if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)
+        || ![Object.prototype, null].includes(Object.getPrototypeOf(candidate)))
+        fail('invalid-input', 'work-item tool arguments must be a plain object');
+    const names = Reflect.ownKeys(candidate);
+    if (names.length > allowed.length || names.some(key => typeof key !== 'string' || !allowed.includes(key)))
+        fail('invalid-input', 'work-item tool arguments contain an unknown field');
+    const args = Object.create(null);
+    for (const key of names) {
+        const field = Object.getOwnPropertyDescriptor(candidate, key);
+        if (field === undefined || !field.enumerable || !('value' in field) || field.value === undefined)
+            fail('invalid-input', 'work-item tool arguments must contain only enumerable data fields');
+        if (key !== 'artifacts') {
+            args[key] = field.value;
+            continue;
+        }
+        const paths = field.value;
+        if (!Array.isArray(paths) || Object.getPrototypeOf(paths) !== Array.prototype)
+            fail('invalid-input', 'artifacts must be a plain array');
+        const length = Object.getOwnPropertyDescriptor(paths, 'length')?.value;
+        if (!Number.isSafeInteger(length) || length < 0 || length > 20)
+            fail('invalid-input', 'at most 20 artifact paths are accepted');
+        const indices = Reflect.ownKeys(paths);
+        if (indices.length !== length + 1 || indices.some(index => typeof index !== 'string'
+            || (index !== 'length' && !/^(?:0|[1-9][0-9]*)$/u.test(index))))
+            fail('invalid-input', 'artifacts must not contain symbols, holes or extra fields');
+        const copied = [];
+        for (let index = 0; index < length; index += 1) {
+            const entry = Object.getOwnPropertyDescriptor(paths, String(index));
+            if (entry === undefined || !entry.enumerable || !('value' in entry) || typeof entry.value !== 'string')
+                fail('invalid-input', 'artifacts must contain only enumerable string data entries');
+            copied.push(entry.value);
+        }
+        args[key] = copied;
+    }
+    return args;
+}
+// Neither the runtime nor the plan-mint closure is published on a Cordis service receiver.
+/** Rows `bindWorkerRun` may scan per wake, parked ones included. */
+const WORKER_RUN_BIND_SCAN_LIMIT = 100;
+/** Upper bound of in-memory parked (item, occurrence) pairs and warned malformed rows. */
+const WORKER_RUN_BIND_SKIP_LIMIT = 1_000;
+/** Consecutive `owner-route-drift` reads of one (item, occurrence) before a single warn. */
+const WORKER_RUN_DRIFT_WARN_AFTER = 5;
+/** Held reports released per scheduler wake; a full page advances the in-memory round-robin cursor. */
+const HELD_REPORT_RELEASE_LIMIT = 10;
+/**
+ * `bindWorkerRun` refusals that cannot change while the item keeps its
+ * occurrence: an expired, mismatched (ref, owner scope, digest), settled or
+ * non-independent contract, a changed or revoked owner route, a different
+ * frozen binding, a contract already bound elsewhere, or a malformed row.
+ * Everything else (no contract yet, missing or throwing peers) is transient.
+ */
+const WORKER_RUN_BIND_TERMINAL = new Set([
+    'mandate-bound', 'owner-changed', 'binding-mismatch', 'owner-route-binding-unknown',
+    'acceptance-mismatch', 'acceptance-expired', 'acceptance-already-settled', 'acceptance-not-awaiting', 'acceptance-not-independent',
+    'owner-route-invalid', 'owner-route-expired', 'identity-mismatch', 'malformed-binding',
+]);
+const continuationRuntimes = new WeakMap();
+const continuationAdmissions = new WeakMap();
+const continuationDispatches = new WeakMap();
+const replyConsumers = new WeakMap();
+const engineeringReaders = new WeakMap();
+const feedbackReaders = new WeakMap();
+const diagnosisRuntimes = new WeakMap();
+const diagnosisAdmissions = new WeakMap();
+/**
+ * Work-item intake kernel.
+ *
+ * This service owns configuration, the private ledger and identity resolution;
+ * it deliberately owns no agent loop, timer, outbox, budget or session. Every
+ * side effect is a call into an existing peer plugin (`assistant-automations`
+ * for the worker run, `assistant-delivery` for the owner notification), and the
+ * disabled default opens no file at all.
+ */
+export class AssistantWorkItemsService extends Service {
+    static Config = ConfigSchema;
+    // Cordis traces this Service through caller-context proxies. JavaScript #
+    // private brands reject those receivers; TS-private members preserve the
+    // proxy's ctx without binding methods back to the provider instance.
+    workItemsConfig;
+    workItemsEvaluation;
+    /** Host-registered followed-thread sources; empty means no follow can close. */
+    workItemsThreadSources = new Map();
+    workItemsFollowDegraded = null;
+    workItemsComponents;
+    workItemsClosed = false;
+    workItemsIntakeObserver;
+    /** Present only when `intakeLedger.evaluation` is enabled. */
+    workItemsIntakeEvaluation;
+    /** Present only when `intakeLedger.evaluation.admit` is enabled. */
+    workItemsIntakeAdmission;
+    workItemsDiagnosisKey = Object.freeze({});
+    workItemsContinuationKey = Object.freeze({});
+    workItemsReplyKey = Object.freeze({});
+    workItemsFeedbackKey = Object.freeze({});
+    workItemsDiagnosisError = null;
+    workItemsHasDiagnosisHistory = false;
+    workItemsSchedulerUnsubscribers = new Set();
+    workItemsSchedulerWaking = false;
+    workItemsSchedulerLastWakeAt = null;
+    workItemsSchedulerLastError = null;
+    /** In-memory round-robin position of `acceptance.autoSettle`; a restart rescans from the start. */
+    workItemsAutoSettleCursor = null;
+    /** In-memory round-robin position of `acceptance.bindWorkerRun`; a restart rescans from the start. */
+    workItemsBindWorkerRunCursor = null;
+    /** In-memory round-robin position of `acceptance.holdReport`; a restart rescans from the start. */
+    workItemsHeldReportCursor = null;
+    /** itemId → occurrenceId refused deterministically by `bindWorkerRun`; in memory, bounded, dropped on occurrence change. */
+    workItemsBindWorkerRunSkips = new Map();
+    /**
+     * itemId → consecutive `owner-route-drift` streak of `bindWorkerRun` for one
+     * occurrence; in memory, bounded. Any other outcome or a new occurrence
+     * drops it. Only for visibility: drift is re-read either way.
+     */
+    workItemsBindWorkerRunDrifts = new Map();
+    /** Whether the missing Delivery `inspectOwnerRouteBinding` was already warned about. */
+    workItemsOwnerRouteBindingWarned = false;
+    /** `itemId:row` malformed `acceptance-bound` rows already warned about. */
+    workItemsMalformedBindingWarned = new Set();
+    workItemsOwnerReads;
+    workItemsOwnerContinuations;
+    constructor(ctx, input) {
+        super(ctx, 'assistantWorkItems');
+        this.workItemsConfig = Object.freeze(normalizeConfig(input, Date.now()));
+        const ownerDependencies = { config: this.workItemsConfig,
+            store: () => this.workItemsClosed ? undefined : this.workItemsComponents?.store,
+            delivery: () => this.workItemsDelivery(), policy: () => this.workItemsPolicy() };
+        const access = new WorkItemOwnerAccess(ownerDependencies);
+        const intakeEvaluation = this.workItemsConfig.enabled ? this.workItemsConfig.intakeLedger?.evaluation : undefined;
+        this.workItemsIntakeEvaluation = intakeEvaluation === undefined ? undefined : new WorkItemIntakeEvaluationRuntime({
+            config: intakeEvaluation,
+            store: () => this.workItemsClosed ? undefined : this.workItemsComponents?.store,
+            log: message => ctx.logger.debug(message),
+        });
+        this.workItemsIntakeAdmission = intakeEvaluation?.admit === undefined ? undefined : new WorkItemIntakeAdmissionBridge({
+            config: intakeEvaluation.admit,
+            maxPerRun: intakeEvaluation.maxPerRun,
+            store: () => this.workItemsClosed ? undefined : this.workItemsComponents?.store,
+            // The public Host path, so an admitted item wakes its worker like any decision.
+            admit: decision => this.admitDecision(decision),
+            log: message => ctx.logger.debug(message),
+        });
+        this.workItemsOwnerReads = new WorkItemOwnerRecall({ ...ownerDependencies, access });
+        this.workItemsOwnerContinuations = new WorkItemOwnerContinuation({ ...ownerDependencies, access,
+            runtime: () => continuationRuntimes.get(this.workItemsContinuationKey),
+            admit: (input, continuation) => {
+                const components = this.workItemsRequired(), mint = continuationAdmissions.get(components);
+                if (!mint)
+                    fail('disabled', 'owner continuation admission is unavailable');
+                return mint(input, continuation);
+            } });
+        // The Evaluation outbox is service state, not ledger state: it exists even
+        // for a disabled intake so `assistant-evaluation` can bind a generation,
+        // and it never opens SQLite until an export pass actually runs.
+        this.workItemsEvaluation = new WorkItemEvaluationExporter({
+            store: () => this.workItemsComponents?.store,
+            scope: () => {
+                const scope = this.workItemsConfig.scope;
+                return scope === null ? null : Object.freeze({ workspace: scope.workspace, preset: scope.preset });
+            },
+            enabled: () => !this.workItemsClosed && isActive(this.workItemsConfig) && this.workItemsConfig.settlement.enabled,
+            now: () => Date.now(),
+            warn: message => this.ctx.logger.warn(message),
+        });
+        ctx.effect(() => () => this.close(), 'assistant-work-items.store');
+        ctx.inject(['tools'], toolsCtx => {
+            registerWorkItemTools(toolsCtx, this);
+            if (this.workItemsConfig.ownerContinuation) {
+                // The pinned native guard runs after extensible approval listeners and
+                // cannot be overridden by a later allow. Cover every tool at native
+                // dispatch preparation; the exclusive report tool is a scheduling barrier.
+                toolsCtx.tools.guard(execution => {
+                    const context = execution.agent?.ctx.get('assistantAutomationExecution');
+                    if (context?.automationId !== this.workItemsConfig.ownerContinuation.automationId)
+                        return undefined;
+                    try {
+                        const occurrenceId = this.workItemsOccurrenceId(execution.agent);
+                        const runtime = continuationRuntimes.get(this.workItemsContinuationKey);
+                        if (!runtime)
+                            return 'continuation invocation is unavailable';
+                        runtime.assertTool(occurrenceId, execution.name);
+                        return undefined;
+                    }
+                    catch {
+                        return 'continuation tool authority or execution phase changed';
+                    }
+                });
+            }
+        });
+        // The disabled default must not create a directory, lock a file or open a
+        // database, so persistence starts only for an explicitly enabled intake.
+        if (this.workItemsConfig.enabled)
+            this.workItemsOpen();
+        if (this.workItemsConfig.enabled && this.workItemsConfig.intakeLedger) {
+            // WP20 slice 2: inbound adapters reach the ledger only through Delivery's
+            // metadata-only observation. Observe and active modes behave the same;
+            // the observer writes the intake ledger and nothing else.
+            ctx.inject(['assistantDelivery'], intakeCtx => {
+                if (this.workItemsClosed)
+                    return;
+                const peer = intakeCtx.get('assistantDelivery');
+                if (typeof peer?.registerInboundIntakeObserver !== 'function') {
+                    intakeCtx.logger.warn('assistant-work-items: Delivery inbound intake observation is unavailable; the intake ledger stays Host-only');
+                    return;
+                }
+                const evaluation = this.workItemsIntakeEvaluation;
+                const observer = Object.freeze({ protocol: 1, observe: (signal) => {
+                        if (this.workItemsClosed || this.workItemsIntakeObserver !== observer)
+                            return;
+                        try {
+                            if (evaluation === undefined) {
+                                this.recordIntake(signal);
+                                return;
+                            }
+                            // The transient text never reaches the ledger: it is split off here and only hashed or held in memory.
+                            const { sourceText, ...metadata } = signal;
+                            this.recordIntake(metadata, typeof sourceText === 'string' ? sourceText : undefined);
+                        }
+                        catch (error) {
+                            intakeCtx.logger.debug(`assistant-work-items: intake observation not recorded: ${describe(error)}`);
+                        }
+                    }, ...(evaluation === undefined ? {} : { acceptsSourceText: true }) });
+                this.workItemsIntakeObserver = observer;
+                let unregister;
+                try {
+                    unregister = peer.registerInboundIntakeObserver(observer);
+                }
+                catch (error) {
+                    this.workItemsIntakeObserver = undefined;
+                    intakeCtx.logger.warn(`assistant-work-items: inbound intake observer unavailable: ${describe(error)}`);
+                    return;
+                }
+                intakeCtx.effect(() => () => {
+                    unregister();
+                    if (this.workItemsIntakeObserver === observer)
+                        this.workItemsIntakeObserver = undefined;
+                }, 'assistant-work-items.intake-observer');
+            });
+        }
+        if (this.workItemsConfig.enabled && this.workItemsConfig.follows?.eventTriggers === true) {
+            // Subscription pass-through: Event Triggers becomes a followed-thread
+            // source. Resolution is passive (settlement pass only); a re-provided
+            // Event Triggers service re-runs this callback with a fresh generation.
+            ctx.inject(['eventTriggers', 'assistantDelivery'], followCtx => {
+                if (this.workItemsClosed)
+                    return;
+                const reader = eventFollowReader(followCtx.get('eventTriggers'));
+                const scope = this.workItemsConfig.scope;
+                if (reader === undefined || scope === null) {
+                    followCtx.logger.warn('assistant-work-items: Event Triggers source reads are unavailable; event follows stay unregistered');
+                    return;
+                }
+                let unregister;
+                try {
+                    unregister = this.registerThreadSource(eventFollowRegistration({
+                        reader, owner: () => this.workItemsEventFollowOwner(scope),
+                        acceptHeadRef: this.workItemsConfig.follows?.eventTriggersAcceptHeadRef === true,
+                    }));
+                }
+                catch (error) {
+                    followCtx.logger.warn(`assistant-work-items: event follow source unavailable: ${describe(error)}`);
+                    return;
+                }
+                followCtx.effect(() => unregister, 'assistant-work-items.event-follows');
+            });
+        }
+        // Evaluation reuses the native scheduler wake; without it nothing new subscribes.
+        if (isActive(this.workItemsConfig) || this.workItemsIntakeEvaluation !== undefined) {
+            ctx.inject(['assistantAutomations'], wakeCtx => {
+                if (this.workItemsClosed)
+                    return;
+                const peer = wakeCtx.get('assistantAutomations');
+                if (typeof peer?.onSchedulerWake !== 'function') {
+                    wakeCtx.logger.warn('assistant-work-items: native scheduler wake is unavailable; waiting resumes retain startup/claim recovery');
+                    return;
+                }
+                // Resolve on the consumer Context so Automations owns this effect on
+                // the injecting Fiber, not on its own provider or a cached root proxy.
+                let active = true;
+                const unregister = peer.onSchedulerWake(() => {
+                    if (!active)
+                        return;
+                    this.workItemsOnSchedulerWake();
+                    if (!this.workItemsClosed)
+                        void this.workItemsIntakeEvaluation?.run().then(() => this.runIntakeAdmission());
+                });
+                const remove = () => {
+                    if (!active)
+                        return;
+                    active = false;
+                    this.workItemsSchedulerUnsubscribers.delete(remove);
+                    unregister();
+                };
+                if (this.workItemsClosed) {
+                    remove();
+                    return;
+                }
+                this.workItemsSchedulerUnsubscribers.add(remove);
+                wakeCtx.effect(() => remove, 'assistant-work-items.scheduler-wake');
+            });
+        }
+        if (isActive(this.workItemsConfig) && this.workItemsConfig.diagnosis) {
+            ctx.inject(['assistantAutomations', 'assistantDelivery', 'tools'], diagnosisCtx => {
+                if (this.workItemsClosed)
+                    return;
+                const components = this.workItemsOpen();
+                const mint = diagnosisAdmissions.get(components);
+                if (!mint)
+                    fail('storage', 'private diagnosis admission is unavailable');
+                const runtime = new WorkItemDiagnosis(diagnosisCtx, this.workItemsConfig, components.store, components.admission, components.dispatch, {
+                    admit: mint,
+                    assertOwner: item => {
+                        const receipt = this.workItemsAssertOwnerRoute(item);
+                        if (receipt.principalVersion !== item.owner.principalVersion || receipt.bindingVersion !== item.owner.bindingVersion
+                            || receipt.generation !== item.owner.generation)
+                            fail('owner-route-invalid', 'diagnosis owner generation changed');
+                        return receipt;
+                    },
+                    assertMandate: item => {
+                        const decision = components.authority.check(item);
+                        if (decision.kind !== 'allow')
+                            fail('authority-revoked', 'diagnosis admission mandate is unavailable');
+                    },
+                });
+                diagnosisRuntimes.set(this.workItemsDiagnosisKey, runtime);
+                try {
+                    runtime.start();
+                    this.workItemsDiagnosisError = null;
+                }
+                catch (error) {
+                    runtime.close();
+                    if (diagnosisRuntimes.get(this.workItemsDiagnosisKey) === runtime)
+                        diagnosisRuntimes.delete(this.workItemsDiagnosisKey);
+                    this.workItemsDiagnosisError = 'diagnosis-activation-unavailable';
+                    diagnosisCtx.logger.warn(`assistant-work-items: diagnosis activation unavailable: ${describe(error)}`);
+                }
+                diagnosisCtx.effect(() => () => {
+                    runtime.close();
+                    if (diagnosisRuntimes.get(this.workItemsDiagnosisKey) === runtime)
+                        diagnosisRuntimes.delete(this.workItemsDiagnosisKey);
+                }, 'assistant-work-items.diagnosis');
+            });
+        }
+        if (isActive(this.workItemsConfig) && this.workItemsConfig.ownerContinuation) {
+            ctx.inject(['assistantAutomations', 'assistantDelivery', 'tools'], continuationCtx => {
+                if (this.workItemsClosed)
+                    return;
+                const components = this.workItemsOpen(), dispatch = continuationDispatches.get(components);
+                if (!dispatch)
+                    fail('storage', 'continuation dispatch is unavailable');
+                const runtime = new WorkItemContinuation(continuationCtx, this.workItemsConfig, components.store, {
+                    assertOwner: item => {
+                        const receipt = this.workItemsAssertOwnerRoute(item);
+                        if (receipt.principalVersion !== item.owner.principalVersion || receipt.bindingVersion !== item.owner.bindingVersion
+                            || receipt.generation !== item.owner.generation)
+                            fail('owner-route-invalid', 'continuation owner generation changed');
+                        return receipt;
+                    },
+                    assertMandate: item => {
+                        if (components.authority.check(item).kind !== 'allow')
+                            fail('authority-revoked', 'continuation admission mandate is unavailable');
+                    },
+                    wake: item => dispatch.wake(item),
+                    isReplyConsumerCurrent: () => !this.workItemsClosed && replyConsumers.get(this.workItemsReplyKey)?.isCurrent() === true,
+                });
+                continuationRuntimes.set(this.workItemsContinuationKey, runtime);
+                try {
+                    runtime.start();
+                }
+                catch (error) {
+                    runtime.close();
+                    if (continuationRuntimes.get(this.workItemsContinuationKey) === runtime)
+                        continuationRuntimes.delete(this.workItemsContinuationKey);
+                    continuationCtx.logger.warn(`assistant-work-items: continuation activation unavailable: ${describe(error)}`);
+                }
+                continuationCtx.effect(() => () => {
+                    runtime.close();
+                    if (continuationRuntimes.get(this.workItemsContinuationKey) === runtime)
+                        continuationRuntimes.delete(this.workItemsContinuationKey);
+                }, 'assistant-work-items.continuation');
+            });
+        }
+        if (isActive(this.workItemsConfig) && (this.workItemsConfig.ownerReplyContinuation || this.workItemsConfig.ownerReportFeedback)) {
+            // Historical proof/report metadata survive an expired execution grant,
+            // a paused worker or an absent tools catalog. This owned read fiber is
+            // deliberately separate from continuation runtime.start().
+            ctx.inject(['assistantDelivery', 'assistantAutomations'], reportCtx => {
+                if (this.workItemsClosed)
+                    return;
+                const components = this.workItemsOpen();
+                let reader;
+                let engineering;
+                if (this.workItemsConfig.ownerReportFeedback) {
+                    const current = new WorkItemOwnerFeedbackTargets({ config: this.workItemsConfig,
+                        store: () => this.workItemsClosed ? undefined : components.store,
+                        delivery: () => reportCtx.get('assistantDelivery'),
+                        automations: () => reportCtx.get('assistantAutomations'),
+                        current: () => !this.workItemsClosed && feedbackReaders.get(this.workItemsFeedbackKey) === current });
+                    reader = current;
+                    feedbackReaders.set(this.workItemsFeedbackKey, current);
+                    const source = new WorkItemEngineeringTargets({ config: this.workItemsConfig,
+                        store: () => this.workItemsClosed ? undefined : components.store,
+                        feedback: () => feedbackReaders.get(this.workItemsFeedbackKey),
+                        current: () => !this.workItemsClosed && engineeringReaders.get(this.workItemsFeedbackKey) === source });
+                    engineering = source;
+                    engineeringReaders.set(this.workItemsFeedbackKey, source);
+                }
+                const replies = new WorkItemOwnerReplies({ config: this.workItemsConfig, store: components.store,
+                    delivery: () => reportCtx.get('assistantDelivery'),
+                    runtime: () => continuationRuntimes.get(this.workItemsContinuationKey),
+                    admit: (input, continuation) => {
+                        const mint = continuationAdmissions.get(components);
+                        if (!mint || this.workItemsClosed)
+                            fail('disabled', 'reply continuation admission unavailable');
+                        return mint(input, continuation);
+                    }, notification: (item, report) => components.dispatch.notification(item, report),
+                    ...(reader ? { inspectFeedbackReport: input => reader?.inspectReport(input, (item, report) => components.dispatch.notification(item, report)) } : {}),
+                    retire: ids => {
+                        for (const id of ids) {
+                            const item = components.store.findItemById(id);
+                            if (item && components.store.getContinuation(id))
+                                components.store.withdrawByDedupKey(item.dedupKey);
+                        }
+                        continuationRuntimes.get(this.workItemsContinuationKey)?.retire(ids);
+                    } });
+                replyConsumers.set(this.workItemsReplyKey, replies);
+                try {
+                    replies.start();
+                }
+                catch (error) {
+                    replies.close();
+                    reportCtx.logger.warn(`assistant-work-items: report consumer unavailable: ${describe(error)}`);
+                }
+                reportCtx.effect(() => () => {
+                    engineering?.close();
+                    if (engineeringReaders.get(this.workItemsFeedbackKey) === engineering)
+                        engineeringReaders.delete(this.workItemsFeedbackKey);
+                    reader?.close();
+                    if (feedbackReaders.get(this.workItemsFeedbackKey) === reader)
+                        feedbackReaders.delete(this.workItemsFeedbackKey);
+                    replies.close();
+                    if (replyConsumers.get(this.workItemsReplyKey) === replies)
+                        replyConsumers.delete(this.workItemsReplyKey);
+                }, 'assistant-work-items.owner-report-targets');
+            });
+        }
+    }
+    /** One native wake may admit at most ten already-due waiting occurrences. */
+    workItemsOnSchedulerWake() {
+        if (this.workItemsClosed || !isActive(this.workItemsConfig) || this.workItemsSchedulerWaking)
+            return;
+        const components = this.workItemsComponents;
+        if (components === undefined)
+            return;
+        this.workItemsSchedulerWaking = true;
+        this.workItemsSchedulerLastWakeAt = Date.now();
+        this.workItemsSchedulerLastError = null;
+        try {
+            for (const selected of components.store.listDueWaitingResumes(10)) {
+                if (this.workItemsClosed)
+                    break;
+                // Advance before examining authority, including on denied items. The
+                // next tick can reach later rows; pending rows remain available on wrap.
+                components.store.advanceWaitingResumeCursor(selected);
+                try {
+                    const dispatch = components.store.getDispatch(selected.itemId);
+                    const item = components.store.findItemById(selected.itemId);
+                    const scope = this.workItemsConfig.scope;
+                    if (dispatch === undefined || dispatch.state !== 'pending' || dispatch.reason !== 'waiting-resume'
+                        || dispatch.eventId !== selected.eventId || dispatch.generation !== selected.generation
+                        || dispatch.occurredAt > Date.now() || item === undefined || item.state !== 'waiting'
+                        || item.lastReportStatus !== 'waiting' || item.observed || item.leaseUntil !== null
+                        || components.store.activeClaim(item.id) !== undefined || item.attempt >= item.maxAttempts
+                        || item.authority === null || scope === null || scope.expiresAt <= Date.now()
+                        || item.scope.workspace !== scope.workspace || item.scope.preset !== scope.preset
+                        || item.scope.principalId !== scope.principalId || item.scope.ownerRouteId !== scope.ownerRouteId)
+                        continue;
+                    const owner = this.workItemsAssertOwnerRoute(item);
+                    if (owner.principalVersion !== item.owner.principalVersion
+                        || owner.bindingVersion !== item.owner.bindingVersion || owner.generation !== item.owner.generation)
+                        continue;
+                    // Reuse the existing mandate check, stable event identity, ingestion
+                    // Policy and unknown-outcome handling. This does not run an Agent.
+                    components.dispatch.wake(item);
+                }
+                catch (error) {
+                    this.workItemsSchedulerLastError = error instanceof WorkItemError ? error.code : 'scheduler-wake-failed';
+                    this.ctx.logger.warn(`assistant-work-items: waiting resume wake failed: ${describe(error)}`);
+                }
+            }
+            if (this.workItemsConfig.diagnosis)
+                diagnosisRuntimes.get(this.workItemsDiagnosisKey)?.sweep(false);
+            replyConsumers.get(this.workItemsReplyKey)?.drain();
+            continuationRuntimes.get(this.workItemsContinuationKey)?.wakePending();
+        }
+        catch (error) {
+            this.workItemsSchedulerLastError = error instanceof WorkItemError ? error.code : 'scheduler-wake-failed';
+            this.ctx.logger.warn(`assistant-work-items: waiting resume scan failed: ${describe(error)}`);
+        }
+        finally {
+            // Bind first so a run that already finished can settle on this same wake.
+            try {
+                this.workItemsBindWorkerRuns(components);
+            }
+            catch (error) {
+                this.ctx.logger.warn(`assistant-work-items: acceptance worker-run bind scan failed: ${describe(error)}`);
+            }
+            try {
+                this.workItemsAutoSettle(components);
+            }
+            catch (error) {
+                this.ctx.logger.warn(`assistant-work-items: acceptance auto-settle scan failed: ${describe(error)}`);
+            }
+            // Release only after auto-settle, so a verdict that arrived on this wake
+            // decides the same pass whether the held report is sent or blocked.
+            try {
+                this.workItemsReleaseHeldReports(components);
+            }
+            catch (error) {
+                this.ctx.logger.warn(`assistant-work-items: acceptance held-report scan failed: ${describe(error)}`);
+            }
+            this.workItemsSchedulerWaking = false;
+        }
+    }
+    /**
+     * WP21 slice 6: on the same native wake, bind at most `maxPerTick`
+     * dispatched items to the acceptance contract their own worker run froze.
+     * Automations only names the handle for the exact occurrence; the contract
+     * itself is re-read from the verifier and checked against the live owner
+     * route. Items whose mandate already binds a contract are never touched.
+     * Round-robin like auto-settle. A deterministic refusal parks the
+     * (item, occurrence) pair in memory so it is not re-read until the item's
+     * occurrence changes; transient ones (no contract yet, peer missing or
+     * throwing, Delivery failing other than `missing-binding`) are simply
+     * tried again on a later wake. Parked pairs do not consume the per-wake budget.
+     */
+    workItemsBindWorkerRuns(components) {
+        const bind = this.workItemsConfig.acceptanceBindWorkerRun;
+        const worker = this.workItemsConfig.workerAutomationId;
+        const automations = this.workItemsAutomations();
+        if (bind === undefined || worker === null || this.workItemsClosed || this.workItemsVerifier() === undefined
+            || typeof automations?.inspectOccurrenceAcceptance !== 'function')
+            return;
+        const limit = bind.maxPerTick;
+        const skips = this.workItemsBindWorkerRunSkips;
+        const seen = new Set();
+        let processed = 0, scanned = 0, wrapped = this.workItemsBindWorkerRunCursor === null, done = false;
+        while (!done && processed < limit && scanned < WORKER_RUN_BIND_SCAN_LIMIT && !this.workItemsClosed) {
+            const page = components.store.listLateAcceptanceCandidates(worker, this.workItemsBindWorkerRunCursor, 10);
+            if (page.length === 0) {
+                if (wrapped)
+                    break;
+                wrapped = true;
+                this.workItemsBindWorkerRunCursor = null;
+                continue;
+            }
+            for (const candidate of page) {
+                if (processed >= limit || scanned >= WORKER_RUN_BIND_SCAN_LIMIT || this.workItemsClosed) {
+                    done = true;
+                    break;
+                }
+                const { item, occurrenceId } = candidate;
+                if (seen.has(item.id)) {
+                    done = true;
+                    break;
+                }
+                seen.add(item.id);
+                scanned += 1;
+                this.workItemsBindWorkerRunCursor = Object.freeze({ createdAt: item.createdAt, id: item.id });
+                const parked = skips.get(item.id);
+                if (parked === occurrenceId)
+                    continue;
+                if (parked !== undefined)
+                    skips.delete(item.id);
+                processed += 1;
+                let outcome;
+                try {
+                    outcome = this.workItemsBindWorkerRun(components, automations, candidate);
+                }
+                catch (error) {
+                    if (this.workItemsWarnMalformedLateBinding(item.id, error))
+                        outcome = 'malformed-binding';
+                    else {
+                        outcome = error instanceof WorkItemError ? error.code : 'error';
+                        this.ctx.logger.debug(`assistant-work-items: acceptance worker-run bind for ${item.id} not recorded: ${describe(error)}`);
+                    }
+                }
+                this.workItemsTrackBindWorkerRunDrift(item.id, occurrenceId, outcome);
+                if (WORKER_RUN_BIND_TERMINAL.has(outcome)) {
+                    // Bounded: the oldest parked pair is forgotten first and simply re-read once.
+                    if (skips.size >= WORKER_RUN_BIND_SKIP_LIMIT)
+                        skips.delete(skips.keys().next().value);
+                    skips.set(item.id, occurrenceId);
+                }
+                if (outcome !== 'bound' && outcome !== 'no-contract') {
+                    this.ctx.logger.debug(`assistant-work-items: acceptance worker-run bind for ${item.id}: ${outcome}`);
+                }
+            }
+        }
+    }
+    /**
+     * Count consecutive `owner-route-drift` outcomes of one (item, occurrence)
+     * and warn once when the streak reaches `WORKER_RUN_DRIFT_WARN_AFTER`: a
+     * route that keeps moving between the two Delivery reads would otherwise be
+     * re-read silently forever. Any other outcome, including a successful bind,
+     * or a new occurrence restarts the streak. Never changes the re-read.
+     */
+    workItemsTrackBindWorkerRunDrift(itemId, occurrenceId, outcome) {
+        const drifts = this.workItemsBindWorkerRunDrifts;
+        if (outcome !== 'owner-route-drift') {
+            drifts.delete(itemId);
+            return;
+        }
+        const previous = drifts.get(itemId);
+        const count = previous?.occurrenceId === occurrenceId ? previous.count + 1 : 1;
+        if (previous === undefined && drifts.size >= WORKER_RUN_BIND_SKIP_LIMIT)
+            drifts.delete(drifts.keys().next().value);
+        drifts.set(itemId, { occurrenceId, count });
+        if (count === WORKER_RUN_DRIFT_WARN_AFTER) {
+            this.ctx.logger.warn(`assistant-work-items: work item ${itemId} occurrence ${occurrenceId} saw owner-route-drift on ${String(count)} consecutive bindWorkerRun reads; still re-reading, the owner route keeps moving between validateOwnerRoute and inspectOwnerRouteBinding`);
+        }
+    }
+    /**
+     * Warn once per (item, row) about a malformed latest `acceptance-bound`
+     * row. The item stays fail-closed (never bound or settled); later reads of
+     * the same row stay silent. Returns whether `error` was that condition.
+     */
+    workItemsWarnMalformedLateBinding(itemId, error) {
+        if (!(error instanceof WorkItemError) || error.code !== 'storage' || error.message !== MALFORMED_ACCEPTANCE_BINDING)
+            return false;
+        const key = `${itemId}:${error.detail ?? ''}`;
+        if (this.workItemsMalformedBindingWarned.has(key))
+            return true;
+        if (this.workItemsMalformedBindingWarned.size >= WORKER_RUN_BIND_SKIP_LIMIT)
+            this.workItemsMalformedBindingWarned.clear();
+        this.workItemsMalformedBindingWarned.add(key);
+        this.ctx.logger.warn(`assistant-work-items: work item ${itemId} has a malformed ${error.detail ?? 'acceptance-bound row'}; its acceptance stays unbound and unsettled`);
+        return true;
+    }
+    workItemsBindWorkerRun(components, automations, candidate) {
+        const { item, automationId, occurrenceId, notBefore } = candidate;
+        if (item.authority?.mandate?.acceptance !== undefined)
+            return 'mandate-bound';
+        if (typeof automations.inspectOccurrenceAcceptance !== 'function')
+            return 'automations-unsupported';
+        const handle = automations.inspectOccurrenceAcceptance({ automationId, occurrenceId, workspace: item.scope.workspace, agentPreset: item.scope.preset });
+        if (handle === undefined)
+            return 'no-contract';
+        // The contract owner must be this item's owner on the live route; any
+        // drift since admission leaves the item unbound. Delivery's
+        // `missing-binding` (`owner-route-invalid`) is deterministic for this
+        // item: a revoked binding never becomes active again and every re-link or
+        // `/new` gets a strictly higher generation, so the generation frozen at
+        // admission cannot come back. Other Delivery failures
+        // (`owner-route-unavailable`) stay transient and are re-read.
+        const owner = this.workItemsAssertOwnerRoute(item);
+        const route = this.workItemsOwnerRouteBindingId(item, owner);
+        if (owner.principalVersion !== item.owner.principalVersion
+            || owner.bindingVersion !== item.owner.bindingVersion || owner.generation !== item.owner.generation)
+            return 'owner-changed';
+        // A Delivery without the method, or a route that moved between the two
+        // reads, is re-read on a later wake instead of parking the pair; only a
+        // malformed answer is final for this occurrence.
+        if (route.kind !== 'bound') {
+            return route.kind === 'unsupported' ? 'owner-route-binding-unsupported'
+                : route.kind === 'drift' ? 'owner-route-drift' : 'owner-route-binding-unknown';
+        }
+        // The run must have been frozen under exactly this owner route's binding.
+        const bindingId = route.bindingId;
+        if (typeof handle.bindingId !== 'string' || handle.bindingId !== bindingId
+            || handle.bindingVersion !== owner.bindingVersion || handle.bindingGeneration !== owner.generation)
+            return 'binding-mismatch';
+        const binding = resolveAcceptanceBinding(this.workItemsVerifier(), handle, owner, Date.now(), { taskRef: workerRunTaskRef(occurrenceId), notBefore });
+        if (typeof binding === 'string')
+            return binding;
+        return components.store.recordLateAcceptanceBinding({ itemId: item.id, occurrenceId, binding }).created ? 'bound' : 'already-bound';
+    }
+    /**
+     * The exact Delivery binding id behind `owner`, read through Delivery's
+     * Host-only `inspectOwnerRouteBinding`. Its embedded receipt must equal
+     * `owner` field for field, so the id belongs to the very route state just
+     * validated. Fails closed without a binding id when Delivery lacks the
+     * method (`unsupported`), when the embedded receipt differs from `owner`
+     * (`drift`: the route moved between the two reads) or when the answer is
+     * malformed; Delivery errors propagate like `validateOwnerRoute`'s.
+     */
+    workItemsOwnerRouteBindingId(item, owner) {
+        const delivery = this.workItemsDelivery();
+        if (typeof delivery?.inspectOwnerRouteBinding !== 'function') {
+            if (!this.workItemsOwnerRouteBindingWarned) {
+                this.workItemsOwnerRouteBindingWarned = true;
+                this.ctx.logger.warn('assistant-work-items: acceptance.bindWorkerRun needs assistant-delivery with inspectOwnerRouteBinding; worker runs stay unbound');
+            }
+            return { kind: 'unsupported' };
+        }
+        // Warn again if a later Delivery drops the method once more.
+        this.workItemsOwnerRouteBindingWarned = false;
+        const scope = item.scope;
+        let read;
+        try {
+            read = delivery.inspectOwnerRouteBinding({ authorityId: scope.ownerRouteId, principalId: scope.principalId,
+                workspace: scope.workspace, agentPreset: scope.preset });
+        }
+        catch (error) {
+            const missing = error !== null && typeof error === 'object' && 'code' in error && error.code === 'missing-binding';
+            fail(missing ? 'owner-route-invalid' : 'owner-route-unavailable', 'owner route binding read failed', error instanceof Error ? error.message : String(error));
+        }
+        const receipt = read?.receipt;
+        const keys = ['receiptVersion', 'authorityId', 'authorityHash', 'principalId',
+            'principalRecordId', 'principalVersion', 'workspace', 'agentPreset', 'bindingVersion', 'generation'];
+        if (read === null || typeof read !== 'object' || read.protocol !== 'assistant-delivery/owner-route-binding/v1'
+            || receipt === null || typeof receipt !== 'object'
+            || typeof read.bindingId !== 'string' || read.bindingId === '' || read.bindingId.length > 256)
+            return { kind: 'malformed' };
+        // Only a well-formed receipt can drift; a missing or retyped field is a
+        // Delivery defect and must not be re-read forever.
+        if (!keys.every(key => typeof receipt[key] === typeof owner[key]))
+            return { kind: 'malformed' };
+        if (!keys.every(key => receipt[key] === owner[key]))
+            return { kind: 'drift' };
+        return { kind: 'bound', bindingId: read.bindingId };
+    }
+    /**
+     * WP21 slice 5: on the same native wake, read back at most `maxPerTick`
+     * executed, acceptance-bound items without a verdict through the Host-only
+     * `settleAcceptance`. Round-robin over an in-memory cursor so items still
+     * pending at the verifier cannot starve later ones. Anything short of a
+     * validated receipt writes nothing and is simply read again on a later wake.
+     */
+    workItemsAutoSettle(components) {
+        const autoSettle = this.workItemsConfig.acceptanceAutoSettle;
+        // A missing verifier peer cannot settle anything; skip the scan entirely.
+        if (autoSettle === undefined || this.workItemsClosed || this.workItemsVerifier() === undefined)
+            return;
+        const limit = autoSettle.maxPerTick;
+        const batch = [...components.store.listUnsettledAcceptanceItems(this.workItemsAutoSettleCursor, limit)];
+        if (batch.length < limit && this.workItemsAutoSettleCursor !== null) {
+            const seen = new Set(batch.map(item => item.id));
+            for (const item of components.store.listUnsettledAcceptanceItems(null, limit - batch.length))
+                if (!seen.has(item.id))
+                    batch.push(item);
+        }
+        for (const item of batch) {
+            if (this.workItemsClosed)
+                break;
+            this.workItemsAutoSettleCursor = Object.freeze({ createdAt: item.createdAt, id: item.id });
+            try {
+                const result = this.settleAcceptance(item.id);
+                if (result.outcome !== 'verified' && result.outcome !== 'pending') {
+                    this.ctx.logger.debug(`assistant-work-items: acceptance auto-settle for ${item.id}: ${result.outcome}`);
+                }
+            }
+            catch (error) {
+                if (!this.workItemsWarnMalformedLateBinding(item.id, error)) {
+                    this.ctx.logger.debug(`assistant-work-items: acceptance auto-settle for ${item.id} not recorded: ${describe(error)}`);
+                }
+            }
+        }
+    }
+    /**
+     * WP21 slice 8 (`acceptance.holdReport`): the mandate binding, or else the
+     * latest late binding while it still belongs to the item's current
+     * occurrence. A malformed late row throws `storage`; callers decide whether
+     * to hold (fail closed) or treat the item as unbound.
+     */
+    workItemsAcceptanceBinding(components, item) {
+        const mandate = item.authority?.mandate?.acceptance;
+        if (mandate !== undefined)
+            return mandate;
+        const late = components.store.lateAcceptanceBinding(item.id);
+        return late !== undefined && late.occurrenceId === item.occurrenceId ? late.binding : undefined;
+    }
+    /**
+     * Whether this report must be held instead of dispatched: `holdReport` is
+     * on, it is the terminal `ready` self-report of an executed item, the status
+     * is notifiable, and the item already has an independent acceptance binding.
+     * An item that has not been bound yet (for example a run that reports before
+     * the wake that binds it) is reported normally, exactly as today.
+     *
+     * A verdict recorded for an earlier generation can never settle this report
+     * (the store keeps at most one verdict per item and excludes settled items
+     * from auto-settle), so holding it would just wait out `holdTimeoutMs` before
+     * releasing it unverified. It is dispatched now, exactly like flag-off.
+     * An unreadable verdict row fails closed and holds, like a malformed binding.
+     */
+    workItemsHoldsReport(components, item, report) {
+        if (this.workItemsConfig.acceptanceHoldReport === undefined || this.workItemsClosed
+            || report.status !== 'ready' || item.state !== 'ready' || item.observed)
+            return false;
+        if (!components.dispatch.shouldNotify(report))
+            return false;
+        if (this.workItemsAcceptanceBinding(components, item) === undefined)
+            return false;
+        let verdict;
+        try {
+            verdict = components.store.acceptanceVerdict(item.id);
+        }
+        catch {
+            return true;
+        }
+        return verdict === undefined || (verdict.attempt === item.attempt && verdict.occurrenceId === item.occurrenceId);
+    }
+    /**
+     * Whether this `ready` report is still held. Used to imply the verdict gate
+     * for held items even when `acceptance.verdictGate` itself is off: the gate
+     * must move the item before the held report can be replaced by the blocked
+     * one. A malformed binding row fails closed (treated as bound).
+     */
+    workItemsReportIsHeld(components, item) {
+        if (this.workItemsConfig.acceptanceHoldReport === undefined || item.state !== 'ready' || item.observed)
+            return false;
+        const report = components.store.lastReport(item.id);
+        if (report === undefined || report.status !== 'ready' || report.deliveryState !== null)
+            return false;
+        try {
+            return this.workItemsAcceptanceBinding(components, item) !== undefined;
+        }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * WP21 slice 8: on the same native wake, release at most
+     * `HELD_REPORT_RELEASE_LIMIT` held reports through an in-memory
+     * `(recordedAt, itemId)` round-robin cursor. A full page advances the cursor
+     * past rows that are still waiting, so they cannot starve a releasable row
+     * behind them; a short page resets it and the next wake restarts from the
+     * oldest row. Achievement sends the ordinary report; any other settled
+     * verdict (or a verdict-gate `blocked` item) sends a blocked report instead;
+     * a still-pending item stays held, and one whose `holdTimeoutMs` elapsed is
+     * sent marked unverified. A row with no acceptance binding any more was never
+     * really held and is recovered as an ordinary report instead of stranded.
+     * One unreadable row (a malformed binding or verdict event) is warned about
+     * and skipped without aborting the remaining releases; the fail-closed hold
+     * itself is unchanged.
+     */
+    workItemsReleaseHeldReports(components) {
+        const hold = this.workItemsConfig.acceptanceHoldReport;
+        if (hold === undefined || this.workItemsClosed)
+            return;
+        const now = Date.now();
+        const page = components.store.listHeldAcceptanceReports(HELD_REPORT_RELEASE_LIMIT, this.workItemsHeldReportCursor ?? undefined);
+        // Only a full page proves there may be rows this wake did not examine; a
+        // short page ends the rotation so the next wake starts from the oldest.
+        if (page.length < HELD_REPORT_RELEASE_LIMIT)
+            this.workItemsHeldReportCursor = null;
+        else {
+            const last = page[page.length - 1];
+            this.workItemsHeldReportCursor = Object.freeze({ recordedAt: last.report.recordedAt, itemId: last.item.id });
+        }
+        for (const { item, report } of page) {
+            if (this.workItemsClosed)
+                break;
+            let release;
+            try {
+                let bound;
+                try {
+                    bound = this.workItemsAcceptanceBinding(components, item) !== undefined;
+                }
+                catch (error) {
+                    if (!this.workItemsWarnMalformedLateBinding(item.id, error)) {
+                        this.ctx.logger.debug(`assistant-work-items: held report of ${item.id} cannot read its acceptance binding: ${describe(error)}`);
+                    }
+                    bound = true;
+                }
+                // No binding any more means the row was never actually held (the report
+                // committed before its pending delivery write, Delivery was missing,
+                // `notifyOn` excluded `ready`, or a re-arm lost the binding). Recovery
+                // sends the ordinary report instead of leaving it undelivered forever.
+                release = bound
+                    ? this.workItemsHeldRelease(components, item, report, now, hold.holdTimeoutMs)
+                    : Object.freeze({ kind: 'plain' });
+            }
+            catch (error) {
+                // One poison row (a malformed binding or verdict event) must not abort
+                // the scan: warn and keep releasing the remaining rows.
+                if (!this.workItemsWarnMalformedLateBinding(item.id, error)) {
+                    this.ctx.logger.warn(`assistant-work-items: held report of ${item.id} cannot be decided: ${describe(error)}`);
+                }
+                continue;
+            }
+            if (release === undefined)
+                continue;
+            // A status the operator explicitly excluded from `notifyOn` cannot be
+            // sent; record the terminal no-send so every later wake stops rescanning it.
+            if (!this.workItemsConfig.notifyOn.includes(release.kind === 'blocked' ? 'blocked' : 'ready')) {
+                components.ledger.recordDelivery(item.id, report.revision, 'failed', null);
+                continue;
+            }
+            void components.dispatch.notifyHeld(item, report, release).catch(error => {
+                this.ctx.logger.warn(`assistant-work-items: held report release failed for ${item.id}: ${describe(error)}`);
+            });
+        }
+    }
+    /** Decide one held report without writing: release it, or wait for a later wake. */
+    workItemsHeldRelease(components, item, report, now, timeoutMs) {
+        if (item.state === 'blocked') {
+            // The store query only returns acceptance-gated blocked rows.
+            return { kind: 'blocked', reason: item.stateReason ?? 'acceptance-blocked' };
+        }
+        const verdict = components.store.acceptanceVerdict(item.id);
+        // Only the verdict of this executed generation decides this report; an
+        // older generation's verdict cannot be moved by the gate either, so the
+        // held report waits for this run's verdict or the timeout.
+        if (verdict !== undefined && verdict.attempt === item.attempt && verdict.occurrenceId === item.occurrenceId) {
+            return verdict.objectiveStatus === 'achieved'
+                ? { kind: 'achieved' }
+                : { kind: 'blocked', reason: `acceptance-${verdict.objectiveStatus}` };
+        }
+        // A released report is never held again; the owning revision records the send.
+        return now >= report.recordedAt + timeoutMs ? { kind: 'unverified', timeoutMs } : undefined;
+    }
+    get enabled() {
+        return this.workItemsConfig.enabled;
+    }
+    get mode() {
+        return this.workItemsConfig.mode;
+    }
+    get diagnosisEnabled() { return this.workItemsConfig.diagnosis !== undefined; }
+    get ownerContinuationEnabled() { return this.workItemsConfig.ownerContinuation !== undefined; }
+    /** Delivery's ownership fence for the single inbound intake observer. */
+    ownsInboundIntakeObserver = (observer) => !this.workItemsClosed && this.workItemsIntakeObserver !== undefined && observer === this.workItemsIntakeObserver;
+    ownsWorkItemReplyRegistration = (registration) => !this.workItemsClosed && replyConsumers.get(this.workItemsReplyKey)?.owns(registration) === true;
+    issueOwnerWorkItemFeedbackTarget = (input) => feedbackReaders.get(this.workItemsFeedbackKey)?.issue(input);
+    resolveOwnerWorkItemFeedbackTarget = (capability) => feedbackReaders.get(this.workItemsFeedbackKey)?.resolve(capability);
+    withOwnerWorkItemFeedbackTargetsFence = (capabilities, callback) => {
+        const reader = feedbackReaders.get(this.workItemsFeedbackKey);
+        if (this.workItemsClosed || !reader)
+            fail('missing-dependency', 'work-item feedback source fence is unavailable');
+        return reader.withTargetsFence(capabilities, callback);
+    };
+    issueOwnerWorkItemEngineeringTarget = (feedbackCapability) => engineeringReaders.get(this.workItemsFeedbackKey)?.issue(feedbackCapability);
+    resolveOwnerWorkItemEngineeringTarget = (capability) => engineeringReaders.get(this.workItemsFeedbackKey)?.resolve(capability);
+    withOwnerWorkItemEngineeringTargetsFence = (capabilities, callback) => {
+        const reader = engineeringReaders.get(this.workItemsFeedbackKey);
+        if (this.workItemsClosed || !reader)
+            fail('missing-dependency', 'work-item engineering source fence is unavailable');
+        return reader.withTargetsFence(capabilities, callback);
+    };
+    get ownerRecallEnabled() { return this.workItemsConfig.ownerRecall?.enabled === true; }
+    /** Foreground-only historical reads, independent of occurrence/worker authority. */
+    listForOwner = (execution, input) => this.workItemsOwnerReads.list(execution, input);
+    recallForOwner = (execution, input) => this.workItemsOwnerReads.recall(execution, input);
+    continueForOwner = (execution, input) => this.workItemsOwnerContinuations.continue(execution, input);
+    /** Bounded admission check; no work-item recovery, writes, dispatch or model. */
+    preauthorizeTool(execution) {
+        if (execution.name === 'work_item_continue')
+            return this.workItemsOwnerContinuations.preauthorize(execution);
+        if (execution.name === 'work_item_list' || execution.name === 'work_item_recall')
+            return this.workItemsOwnerReads.preauthorize(execution);
+        try {
+            if (execution.signal.aborted)
+                return false;
+            this.workItemsCheckToolExecution(execution, true);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Approval cannot extend the live occurrence/owner mandate at execution. */
+    assertToolExecution(execution) {
+        this.workItemsCheckToolExecution(execution, false);
+    }
+    workItemsCheckToolExecution(execution, requireModernMandate) {
+        const config = this.workItemsConfig;
+        if (execution.signal?.aborted)
+            fail('invalid-state', 'the work-item tool execution was cancelled');
+        if (this.workItemsClosed || !isActive(config))
+            fail('disabled', 'active work-item intake is required');
+        const components = this.workItemsComponents;
+        if (components === undefined)
+            fail('storage', 'the work-item ledger is unavailable');
+        const occurrenceId = this.workItemsOccurrenceId(execution.agent);
+        const item = components.store.findItemByOccurrence(occurrenceId);
+        if (item === undefined)
+            fail('not-found', 'no work item is bound to this automation occurrence');
+        const scope = config.scope;
+        const header = execution.agent?.session?.header;
+        if (scope === null || header?.cwd !== scope.workspace || header.agentPreset !== scope.preset
+            || item.scope.workspace !== scope.workspace || item.scope.preset !== scope.preset
+            || item.scope.principalId !== scope.principalId || item.scope.ownerRouteId !== scope.ownerRouteId
+            || item.owner.workspace !== scope.workspace || item.owner.agentPreset !== scope.preset) {
+            fail('identity-mismatch', 'work-item tool scope does not match the current worker and admitted owner');
+        }
+        if (scope.expiresAt <= Date.now())
+            fail('owner-route-expired', 'the configured work-item owner scope expired');
+        const owner = this.workItemsAssertOwnerRoute(item);
+        if (owner.principalVersion !== item.owner.principalVersion
+            || owner.bindingVersion !== item.owner.bindingVersion || owner.generation !== item.owner.generation) {
+            fail('owner-route-invalid', 'owner route generation changed since admission');
+        }
+        if (this.workItemsPolicy() === undefined)
+            fail('missing-dependency', 'assistantPolicy is required for work-item tools');
+        const authority = components.authority.check(item);
+        if (authority.kind === 'revoked')
+            fail('authority-revoked', 'admission mandate no longer permits this work-item tool');
+        if (authority.kind === 'unavailable')
+            fail('authority-unavailable', 'admission mandate could not be revalidated', authority.detail);
+        if (requireModernMandate && authority.kind !== 'allow')
+            fail('authority-unavailable', 'legacy work items require the ordinary approval path');
+        this.workItemsAssertRuntime(components, occurrenceId, execution.name);
+        const active = components.store.activeClaim(item.id);
+        if (active !== undefined && active.runId !== occurrenceId && active.leasedUntil > Date.now())
+            fail('claim-conflict', 'another occurrence owns this work item');
+        const allowed = execution.name === 'work_item_report' ? ['status', 'summary', 'artifacts']
+            : execution.name === 'work_item_read_report' ? ['revision', 'offset', 'max_bytes']
+                : execution.name === 'work_item_read_context' ? ['kind', 'revision', 'offset', 'max_bytes']
+                    : execution.name === 'work_item_read_source' ? ['offset', 'max_bytes']
+                        : execution.name === 'work_item_claim' || execution.name === 'work_item_status' ? [] : undefined;
+        if (allowed === undefined)
+            fail('invalid-input', 'unknown work-item tool');
+        const args = workItemToolArguments(execution.arguments, allowed);
+        if (execution.name === 'work_item_read_context') {
+            if (!['input', 'parent-brief', 'parent-report', 'parent-outcome'].includes(String(args.kind ?? 'input')))
+                fail('invalid-input', 'invalid continuation context kind');
+            this.readContext(execution.agent, { kind: (args.kind ?? 'input'),
+                ...(args.revision === undefined ? {} : { revision: args.revision }),
+                ...(args.offset === undefined ? {} : { offset: args.offset }),
+                ...(args.max_bytes === undefined ? {} : { maxBytes: args.max_bytes }) });
+            return;
+        }
+        if (execution.name === 'work_item_status')
+            return;
+        if (execution.name === 'work_item_read_source') {
+            if (!config.diagnosis)
+                fail('disabled', 'source recall requires diagnosis mode');
+            const offset = args.offset ?? 0, maximum = args.max_bytes ?? 4096;
+            if (!Number.isSafeInteger(offset) || Number(offset) < 0 || !Number.isSafeInteger(maximum)
+                || Number(maximum) < 4 || Number(maximum) > 8192)
+                fail('invalid-input', 'source byte window is invalid');
+            return;
+        }
+        if (execution.name === 'work_item_read_report') {
+            this.workItemsReadReportPage(components, item, {
+                revision: args.revision,
+                ...(args.offset === undefined ? {} : { offset: args.offset }),
+                ...(args.max_bytes === undefined ? {} : { maxBytes: args.max_bytes }),
+            });
+            return;
+        }
+        const now = Date.now();
+        const claim = components.store.findClaimByRun(occurrenceId);
+        if (execution.name === 'work_item_claim') {
+            if (item.observed)
+                fail('invalid-state', 'observed work items cannot be claimed');
+            if (claim?.itemId === item.id && claim.state === 'active' && claim.leasedUntil > now
+                && item.leaseRunId === occurrenceId && item.leaseUntil !== null && item.leaseUntil > now)
+                return;
+            if (item.attempt >= item.maxAttempts)
+                fail('retry-exhausted', 'work item exhausted its attempt budget');
+            const recoverable = ['claimed', 'working'].includes(item.state) && item.leaseUntil !== null
+                && item.leaseUntil <= now && (active === undefined || active.leasedUntil <= now);
+            if (!['queued', 'waiting'].includes(item.state) && !recoverable)
+                fail('claim-conflict', 'work item is not claimable');
+            return;
+        }
+        if (typeof args.status !== 'string' || !['progress', 'waiting', 'ready', 'blocked', 'failed'].includes(args.status)
+            || typeof args.summary !== 'string' || args.summary.trim().length === 0)
+            fail('invalid-input', 'work-item report requires a valid status and non-empty summary');
+        if (args.status === 'waiting' && components.store.getContinuation(item.id))
+            fail('invalid-input', 'continuation attempts cannot schedule waiting retries');
+        const artifacts = args.artifacts ?? [];
+        if (!Array.isArray(artifacts) || artifacts.some(path => typeof path !== 'string'))
+            fail('invalid-input', 'work-item report artifacts must be string paths');
+        const normalizedArtifacts = components.workspace.validateArtifacts(item, artifacts);
+        if (claim === undefined || claim.itemId !== item.id)
+            fail('claim-conflict', 'claim this item before reporting');
+        const reportCount = components.store.reportCount(item.id);
+        if (reportCount > 100)
+            fail('storage', 'work item exceeds the bounded report history');
+        const key = `work-item-report:${workItemReportKey(args.status, args.summary, artifacts)}\0${item.id}\0${String(claim.claimId)}`;
+        const summary = normalizeWorkItemReportSummary(args.summary, config.limits.maxReportBytes);
+        const replay = components.store.reportReplayState({ itemId: item.id, idempotencyKey: key,
+            status: args.status, ...summary, artifactPaths: normalizedArtifacts });
+        if (replay === 'match')
+            return;
+        if (replay === 'conflict')
+            fail('claim-conflict', 'idempotency key already belongs to a different persisted report');
+        if (claim.state !== 'active' || claim.leasedUntil <= now || item.leaseRunId !== occurrenceId
+            || item.leaseUntil === null || item.leaseUntil <= now)
+            fail('claim-expired', 'report requires the current active claim');
+        if (!['claimed', 'working'].includes(item.state))
+            fail('invalid-state', 'work item is not reportable');
+        if (reportCount >= config.limits.maxReportsPerItem)
+            fail('report-limit', 'work item reached maxReportsPerItem');
+    }
+    /**
+     * Admit one external work signal.
+     *
+     * Host-side entry point for a future external source plugin. It performs no
+     * dispatch work beyond the same bounded wake the ledger does on recovery, so
+     * observe mode stays free of external effects.
+     */
+    admit(input) {
+        const components = this.workItemsAvailable();
+        if (this.workItemsConfig.diagnosis)
+            fail('invalid-input', 'diagnosis worker accepts only its private builtin source');
+        const result = components.admission.admit(input);
+        if (result.created && isActive(this.workItemsConfig)) {
+            try {
+                components.dispatch.wake(result.item);
+            }
+            catch (error) {
+                // The item is durable evidence; a failed wake is recorded on the
+                // dispatch row and retried by the next bounded recovery pass.
+                this.ctx.logger.warn(`assistant-work-items: worker wake failed: ${describe(error)}`);
+            }
+            const dispatch = components.store.getDispatch(result.item.id);
+            if (dispatch !== undefined)
+                return Object.freeze({ ...result, dispatch });
+        }
+        return result;
+    }
+    /**
+     * Admit one execute decision under a frozen mandate (Host-only, never a tool).
+     *
+     * Same wake semantics as `admit(...)`. A replayed decision id returns its one
+     * existing item; a refusal is a value, not an error, and writes nothing.
+     */
+    admitDecision(decision) {
+        const components = this.workItemsAvailable();
+        if (this.workItemsConfig.diagnosis)
+            fail('invalid-input', 'diagnosis worker accepts only its private builtin source');
+        const result = components.admission.admitDecision(decision);
+        if (result.outcome !== 'admitted')
+            return result;
+        try {
+            components.dispatch.wake(result.item);
+        }
+        catch (error) {
+            this.ctx.logger.warn(`assistant-work-items: worker wake failed: ${describe(error)}`);
+        }
+        const dispatch = components.store.getDispatch(result.item.id);
+        return dispatch === undefined ? result : Object.freeze({ ...result, dispatch });
+    }
+    /**
+     * Host-only (WP21): the Policy peer now runs under `policyVersion`.
+     *
+     * Never cancels, parks or wakes work. Each live item whose frozen mandate
+     * basis the current Policy no longer upholds gets one durable notice per
+     * version; replaying the same version (for example after a restart) writes
+     * nothing new. Uses Policy `evaluate`, so no audit row or budget is spent.
+     */
+    noticePolicyChange(change) {
+        const normalized = normalizePolicyChange(change);
+        const components = this.workItemsAvailable();
+        return noticePolicyChange(components.store, components.authority, normalized);
+    }
+    /**
+     * Host-only (WP21 slice 4): read a bound item's verdict back from the
+     * independent verifier. Takes no verdict input; a worker report, the
+     * decision caller or this call's caller can never assert completion. Writes
+     * one append-only verdict event once the verifier's receipt validates
+     * against the frozen contract; anything short of that writes nothing.
+     */
+    settleAcceptance(itemId) {
+        const components = this.workItemsAvailable();
+        const item = components.store.findItemById(itemId);
+        if (item === undefined)
+            fail('not-found', 'work item does not exist');
+        let binding = item.authority?.mandate?.acceptance;
+        if (binding === undefined) {
+            // WP21 slice 6: the latest late binding, only for the current occurrence;
+            // an earlier generation's unsettled binding never settles re-armed work.
+            const late = components.store.lateAcceptanceBinding(item.id);
+            if (late !== undefined && late.occurrenceId !== item.occurrenceId)
+                fail('invalid-state', 'acceptance binding is for an earlier occurrence');
+            binding = late?.binding;
+        }
+        if (binding === undefined)
+            fail('invalid-state', 'work item has no independent acceptance binding');
+        // The stored mandate must still be intact for this exact item; checked
+        // locally so a pull-based settle never writes Policy audit.
+        if (!storedBasisHolds(item))
+            fail('invalid-state', 'work item authority basis is no longer usable');
+        // Only work that actually ran and reached `ready` can be accepted: never
+        // claimed, parked, blocked, failed or dropped items settle nothing.
+        if (item.attempt < 1 || item.state !== 'ready')
+            fail('invalid-state', `work item is ${item.state}, not executed`);
+        // `holdReport` implies the gate for a held report even when
+        // `acceptance.verdictGate` is off, so a non-achieved verdict can move the
+        // item before the held report is replaced by the blocked one.
+        const gate = this.workItemsConfig.acceptanceVerdictGate === true || this.workItemsReportIsHeld(components, item)
+            ? Object.freeze({ attempt: item.attempt, occurrenceId: item.occurrenceId }) : undefined;
+        const result = settleAcceptance(components.store, this.workItemsVerifier(), item, binding, gate);
+        // WP21 slice 7: the verifier's needs-attention writes no verdict, but with
+        // the gate on it still moves this executed generation to `blocked`.
+        if (gate !== undefined && result.outcome === 'needs-attention'
+            && components.store.blockForAcceptance(item.id, gate, 'acceptance-needs-attention', { contractId: binding.contractId, verifierReason: result.reason })) {
+            return Object.freeze({ ...result, blockedReason: 'acceptance-needs-attention' });
+        }
+        return result;
+    }
+    /** Host-only: the verifier verdict recorded for one item, or null. */
+    acceptanceVerdict(itemId) {
+        const components = this.workItemsAvailable();
+        if (components.store.findItemById(itemId) === undefined)
+            fail('not-found', 'work item does not exist');
+        return components.store.acceptanceVerdict(itemId) ?? null;
+    }
+    /** Host-only: every Policy-change notice recorded for one item. */
+    policyNotices(itemId) {
+        const components = this.workItemsAvailable();
+        if (components.store.findItemById(itemId) === undefined)
+            fail('not-found', 'work item does not exist');
+        return components.store.policyNotices(itemId);
+    }
+    /**
+     * Host-only (WP21): a human follow-up on an item's work thread is owned by
+     * that item while it is live. An ended item takes nothing (`item-ended`).
+     */
+    ownFollowUp(input) {
+        const normalized = normalizeFollowUp(input);
+        return this.workItemsAvailable().store.ownFollowUp(normalized);
+    }
+    /** Host-only: the live item processed one of its owned follow-ups. */
+    markFollowUpProcessed(itemId, messageId) {
+        return this.workItemsAvailable().store.markFollowUpProcessed(itemId, messageId);
+    }
+    /** Host-only: follow-ups owned by one item. */
+    followUps(itemId) {
+        return this.workItemsAvailable().store.followUps(itemId);
+    }
+    /**
+     * Host-only: release every unprocessed follow-up of an ended item back to
+     * judgment and return the newly released ones. No message is sent; the
+     * caller decides what judgment does with them.
+     */
+    releaseFollowUps(limit) {
+        return this.workItemsAvailable().store.releaseEndedFollowUps(limit);
+    }
+    /** Host-only: released follow-ups in release order (restart-safe re-read). */
+    listReleasedFollowUps(options = {}) {
+        return this.workItemsAvailable().store.listReleasedFollowUps(options);
+    }
+    /**
+     * Record one inbound item's deterministic intake decision (WP20 slice 1).
+     *
+     * Host-only and metadata-only: the input carries normalized booleans and an
+     * optional content digest, never a body. It works in observe mode, writes
+     * only the intake ledger, and never admits, wakes or delivers anything. A
+     * replay of the same `(source, sourceEventId)` returns the original row.
+     */
+    recordIntake(input, sourceText) {
+        const ledger = this.workItemsConfig.intakeLedger;
+        if (!this.workItemsConfig.enabled || ledger === undefined)
+            fail('disabled', 'the work-item intake ledger is disabled');
+        const candidate = classifyIntake(input, intakeSourcePolicy(ledger.sources, String(input?.source)));
+        // A Host caller gets the same bound and digest check Delivery applies before forwarding a text.
+        if (sourceText !== undefined && !authenticatesIntakeText(sourceText, candidate.contentDigest)) {
+            fail('invalid-input', 'intake source text must be at most 65,536 UTF-16 units and match the content digest');
+        }
+        const result = this.workItemsAvailable().store.recordIntake(candidate);
+        // `sourceText` is the authenticated text the content digest covers; with
+        // evaluation off it is ignored, with it on it is held in memory only.
+        if (sourceText !== undefined)
+            this.workItemsIntakeEvaluation?.observe(result.record, sourceText);
+        return result;
+    }
+    /**
+     * Host-only: register the injectable WP20 inferred-evaluation supplier
+     * (Policy snapshot + model call). Requires `intakeLedger.evaluation`.
+     */
+    registerIntakeEvaluator(registration) {
+        const evaluation = this.workItemsIntakeEvaluation;
+        if (evaluation === undefined || this.workItemsClosed)
+            fail('disabled', 'intake evaluation is disabled');
+        return evaluation.register(registration);
+    }
+    /** Host-only drive of one bounded evaluation run; the scheduler wake calls the same path. */
+    async runIntakeEvaluation() {
+        if (this.workItemsIntakeEvaluation === undefined || this.workItemsClosed)
+            return [];
+        return this.workItemsIntakeEvaluation.run();
+    }
+    /**
+     * Host-only drive of one bounded admission pass over persisted accepting
+     * evaluations (WP21); the scheduler wake calls it after each evaluation run.
+     * Requires `intakeLedger.evaluation.admit`; never throws.
+     */
+    runIntakeAdmission() {
+        if (this.workItemsIntakeAdmission === undefined || this.workItemsClosed)
+            return [];
+        return this.workItemsIntakeAdmission.run();
+    }
+    /** Durable admission outcomes (`would-admit`, `admitted`, `replayed`, `refused`) for one intake row. */
+    intakeAdmissions(source, sourceEventId) {
+        if (this.workItemsConfig.intakeLedger === undefined || !this.workItemsConfig.enabled)
+            fail('disabled', 'the work-item intake ledger is disabled');
+        return this.workItemsAvailable().store.listIntakeAdmissions(source, sourceEventId);
+    }
+    /**
+     * Host-only, read-only (WP22): the WP20 intake judgment that admitted one
+     * work item, for Evaluation's intake/attention agreement metric. Undefined
+     * when the item does not exist or was not admitted from intake
+     * (observe-mode `would-admit` never creates an item). Throws `disabled`
+     * when the intake ledger is off, so "cannot tell" is never read as "not
+     * intake". Carries the item's owner scope and no source text.
+     */
+    inspectIntakeProvenance(itemId) {
+        if (this.workItemsConfig.intakeLedger === undefined || !this.workItemsConfig.enabled)
+            fail('disabled', 'the work-item intake ledger is disabled');
+        if (typeof itemId !== 'string' || itemId === '' || itemId.length > 256)
+            fail('invalid-input', 'itemId is invalid');
+        const store = this.workItemsAvailable().store;
+        const found = store.intakeProvenance(itemId);
+        if (found === undefined)
+            return undefined;
+        const item = store.findItemById(itemId);
+        if (item === undefined)
+            fail('storage', 'intake admission names a missing work item');
+        const { admission, evaluation } = found;
+        return Object.freeze({
+            protocol: 'work-items/intake-provenance/v1',
+            itemId,
+            scope: Object.freeze({ workspace: item.scope.workspace, preset: item.scope.preset }),
+            source: admission.source,
+            sourceEventId: admission.sourceEventId,
+            ruleId: admission.ruleId,
+            policyVersion: admission.policyVersion,
+            mode: admission.mode,
+            level: evaluation.level,
+            wouldAccept: evaluation.wouldAccept,
+            admittedAt: admission.recordedAt,
+        });
+    }
+    /** Persisted evaluation results for one intake row; replay reads these, never re-evaluates. */
+    intakeEvaluations(source, sourceEventId) {
+        if (this.workItemsConfig.intakeLedger === undefined || !this.workItemsConfig.enabled)
+            fail('disabled', 'the work-item intake ledger is disabled');
+        return this.workItemsAvailable().store.listIntakeEvaluations(source, sourceEventId);
+    }
+    intakeEvaluationHealth() {
+        return this.workItemsIntakeEvaluation?.health();
+    }
+    /** Explicit Host-only reduction of a canonical work signal; never a model tool or a plan mint. */
+    withdraw(input) {
+        const result = this.workItemsAvailable().admission.withdraw(input);
+        if (this.workItemsConfig.diagnosis) {
+            const components = this.workItemsOpen();
+            for (const item of result.items)
+                if (components.store.readDiagnosisPlan(item.id))
+                    components.store.clearDiagnosisIntervention(item.id);
+            diagnosisRuntimes.get(this.workItemsDiagnosisKey)?.retire(result.items.map(item => item.id));
+        }
+        continuationRuntimes.get(this.workItemsContinuationKey)?.retire(result.items.map(item => item.id));
+        return result;
+    }
+    /**
+     * Claim the item bound to the calling automation occurrence.
+     *
+     * Identity comes exclusively from the frozen, production automation
+     * execution context installed by `assistant-automations`; a foreground
+     * session, a preview run and another automation all fail closed.
+     *
+     * An armed signal source is swept here (bounded by the persisted
+     * `sweepIntervalMs`) so ordinary use keeps producing work without a timer or
+     * developer orchestration. A sweep failure never fails the claim.
+     */
+    claim(agent) {
+        const components = this.workItemsRequired();
+        this.workItemsSweepQuietly(components);
+        this.workItemsSettleQuietly(components);
+        const occurrenceId = this.workItemsOccurrenceId(agent);
+        this.workItemsAssertRuntime(components, occurrenceId, 'work_item_claim');
+        if (!this.workItemsConfig.diagnosis)
+            components.ledger.recover();
+        // Lease-expiry and waiting resume are generic recovery work, so ordinary
+        // worker traffic is the lazy sweep that re-dispatches them. This is
+        // best-effort: a recovery failure never blocks the caller's own claim.
+        this.workItemsWakeQuietly(components);
+        const item = components.store.findItemByOccurrence(occurrenceId);
+        if (item === undefined)
+            fail('not-found', 'no work item is bound to this automation occurrence');
+        this.workItemsAssertOwnerRoute(item);
+        this.workItemsRevalidateAuthority(components, item);
+        const runId = occurrenceId;
+        const result = components.ledger.claim({ itemId: item.id, runId, occurrenceId });
+        // A claim can settle a prior window and unblock recovery, so it is a
+        // transaction boundary that may have produced a new exportable revision.
+        this.workItemsDrainEvaluation();
+        // The resume brief is derived only after the claim committed, from the same
+        // durable ledger; a missing row here means storage broke, so fail loudly
+        // instead of handing the model an invented empty context.
+        const resume = components.store.workItemResumeContext(result.item.id);
+        if (resume === undefined)
+            fail('storage', 'work item disappeared before its resume brief was derived');
+        return Object.freeze({
+            itemId: result.item.id,
+            runId: result.claim.runId,
+            state: result.item.state,
+            kind: result.item.kind,
+            externalId: result.item.externalId,
+            title: result.item.title,
+            brief: result.item.brief,
+            briefTruncated: result.item.briefTruncated,
+            acceptanceRef: result.item.acceptanceRef,
+            workDir: result.item.workDir,
+            attempt: result.item.attempt,
+            maxAttempts: result.item.maxAttempts,
+            leaseUntil: result.item.leaseUntil,
+            replayed: result.replayed,
+            resume,
+        });
+    }
+    /**
+     * Append one report revision under the caller's active claim.
+     *
+     * Reporting is the only worker write path. A terminal status additionally
+     * enqueues one owner notification through `assistant-delivery`; a delivery
+     * failure is recorded against the report instead of erasing report evidence.
+     */
+    async report(agent, input) {
+        const components = this.workItemsRequired();
+        const occurrenceId = this.workItemsOccurrenceId(agent);
+        this.workItemsAssertRuntime(components, occurrenceId, 'work_item_report');
+        if (!this.workItemsConfig.diagnosis)
+            components.ledger.recover();
+        const item = components.store.findItemByOccurrence(occurrenceId);
+        if (item === undefined)
+            fail('not-found', 'no work item is bound to this automation occurrence');
+        if (input.status === 'waiting' && components.store.getContinuation(item.id))
+            fail('invalid-input', 'continuation attempts cannot schedule waiting retries');
+        const result = components.ledger.report({
+            itemId: item.id,
+            runId: occurrenceId,
+            status: input.status,
+            summary: input.summary,
+            artifactPaths: input.artifactPaths ?? [],
+            idempotencyKey: input.idempotencyKey,
+        });
+        if (!result.replayed) {
+            if (components.store.getContinuation(item.id))
+                continuationRuntimes.get(this.workItemsContinuationKey)?.reported(occurrenceId, result.report.status, result.report.revision);
+            else
+                diagnosisRuntimes.get(this.workItemsDiagnosisKey)?.reported(occurrenceId, result.report.status, result.report.revision);
+        }
+        let notified = false;
+        if (!result.replayed) {
+            try {
+                // A held report is simply not dispatched this pass: the same scheduler
+                // wake that settles the binding releases it in `workItemsReleaseHeldReports`.
+                let held = false;
+                try {
+                    held = this.workItemsHoldsReport(components, result.item, result.report);
+                }
+                catch (error) {
+                    // A malformed late binding fails closed: keep holding; the timeout
+                    // still releases it unverified rather than dropping the report.
+                    if (!this.workItemsWarnMalformedLateBinding(item.id, error)) {
+                        this.ctx.logger.debug(`assistant-work-items: report hold for ${item.id} cannot read its acceptance binding: ${describe(error)}`);
+                    }
+                    held = this.workItemsConfig.acceptanceHoldReport !== undefined && result.report.status === 'ready';
+                }
+                notified = held ? false : await components.dispatch.notify(result.item, result.report);
+            }
+            catch (error) {
+                // `notify` already persisted the failed/unknown delivery state. Report
+                // evidence must survive a notification failure, so surface it in the
+                // log and keep the appended revision.
+                this.ctx.logger.warn(`assistant-work-items: owner notification failed: ${describe(error)}`);
+            }
+        }
+        const stored = components.store.reports(item.id).find(report => report.revision === result.report.revision);
+        // A terminal report appends the settlement outcome synchronously, so this
+        // is the main ordinary-use boundary that feeds the trusted lane.
+        this.workItemsDrainEvaluation();
+        return Object.freeze({
+            itemId: result.item.id,
+            revision: result.report.revision,
+            status: result.report.status,
+            state: result.item.state,
+            truncated: result.report.truncated,
+            artifactPaths: result.report.artifactPaths,
+            delivery: (stored ?? result.report).deliveryState ?? 'pending',
+            replayed: result.replayed,
+            notified,
+        });
+    }
+    /**
+     * Register one additional automatic source and return an idempotent disposer.
+     *
+     * This is the public extension point for an external signal producer (a
+     * repository watcher, a chat bridge, a scheduler): the producer supplies a
+     * read-only `WorkItemSignalSource`, gets the same bounded sweep, provenance,
+     * dedupe, cooldown and settled-item fence as the built-in adapter, and can be
+     * withdrawn by disposing the registration. Registration fails closed when the
+     * intake is disabled or already disposed, and never admits retroactively.
+     */
+    registerSignalSource(registration) {
+        if (this.workItemsConfig.diagnosis)
+            fail('invalid-input', 'diagnosis has an exclusive private builtin source; extension registration is unavailable');
+        const components = this.workItemsAvailable();
+        const dispose = components.signals.register(registration);
+        return () => {
+            dispose();
+        };
+    }
+    /**
+     * Register the only resolver for one followed-thread source.
+     *
+     * Host-only extension point. Registration is one-per-source, validated
+     * synchronously and revoked by the returned disposer. A follow recorded while
+     * a source is registered stores that source's generation, so replacing the
+     * source later degrades the follow to `unresolved` instead of trusting a
+     * stale closure. This adds resolution capability only: it is not authority to
+     * end an item, and a closure never claims an objective was achieved.
+     */
+    registerThreadSource(registration) {
+        if (!this.workItemsConfig.enabled || this.workItemsClosed)
+            fail('disabled', 'the work-item intake is disabled');
+        if (registration === null || typeof registration !== 'object' || Array.isArray(registration)) {
+            fail('invalid-input', 'thread source registration must be an object');
+        }
+        const allowed = ['source', 'generation', 'resolve', 'validate', 'canonicalize'];
+        for (const key of Object.keys(registration)) {
+            if (!allowed.includes(key))
+                fail('invalid-input', `thread source registration contains unknown field ${key}`);
+        }
+        const source = text(registration.source, 'thread source', 64);
+        if (!/^[a-z][a-z0-9-]{0,63}$/.test(source))
+            fail('invalid-input', 'thread source has an invalid shape');
+        text(registration.generation, 'thread source generation', 200);
+        if (typeof registration.resolve !== 'function')
+            fail('invalid-input', 'thread source must expose a resolve function');
+        if (registration.validate !== undefined && typeof registration.validate !== 'function')
+            fail('invalid-input', 'thread source validate must be a function');
+        if (registration.canonicalize !== undefined && typeof registration.canonicalize !== 'function')
+            fail('invalid-input', 'thread source canonicalize must be a function');
+        if (this.workItemsThreadSources.has(source))
+            fail('invalid-input', `thread source ${source} is already registered`);
+        const installed = registration;
+        this.workItemsThreadSources.set(source, installed);
+        return () => {
+            // Only the disposer of the live registration may revoke it, so a stale
+            // disposer from a replaced source cannot delete the current one.
+            if (this.workItemsThreadSources.get(source) === installed)
+                this.workItemsThreadSources.delete(source);
+        };
+    }
+    /**
+     * Trusted Evaluation producer generation (fourth trusted producer).
+     *
+     * `assistant-evaluation` reads this before registering a sink; returning a
+     * fresh value on a new service instance is what makes a stale capability
+     * fail closed instead of appending to the wrong host.
+     */
+    trustedWorkItemProducerGeneration() {
+        return this.workItemsEvaluation.generation;
+    }
+    /**
+     * Install the Evaluation-owned sink this plugin exports settled outcomes to.
+     *
+     * The registration is opaque: Evaluation passes its own capability and this
+     * plugin only validates the protocol, generation and ownership before using
+     * it. Exactly one sink is accepted; the returned disposer withdraws it.
+     */
+    registerTrustedWorkItemEvaluationSink(registration) {
+        if (this.workItemsClosed)
+            fail('storage', 'the work-item intake is disposed');
+        // The exporter itself runs one bounded catch-up pass the moment the sink is
+        // installed, so the service boundary must not queue a redundant one.
+        const dispose = this.workItemsEvaluation.registerTrustedWorkItemEvaluationSink(registration);
+        return () => {
+            dispose();
+        };
+    }
+    /**
+     * Sweep every armed automatic source once and report what it did.
+     *
+     * Explicit host entry point; `force` ignores the persisted interval. The
+     * disabled default and a missing optional peer both return an empty report,
+     * so a caller never has to special-case activation.
+     */
+    sweepSignals(force = true) {
+        if (!this.workItemsConfig.enabled || this.workItemsClosed)
+            return Object.freeze({ sources: [] });
+        try {
+            if (this.workItemsConfig.diagnosis)
+                return diagnosisRuntimes.get(this.workItemsDiagnosisKey)?.sweep(force) ?? Object.freeze({ sources: [] });
+            return this.workItemsOpen().signals.sweep(force);
+        }
+        catch (error) {
+            this.ctx.logger.warn(`assistant-work-items: signal sweep unavailable: ${describe(error)}`);
+            return Object.freeze({ sources: [] });
+        }
+    }
+    /**
+     * Run one bounded settlement pass over the pending outcome windows.
+     *
+     * Host-only by design: there is deliberately no model tool for this, so a
+     * worker can never settle or launder its own outcome. Returns a report instead
+     * of throwing, and a disabled intake returns `skipped: 'disabled'`.
+     */
+    settleOutcomes(force = true) {
+        if (!this.workItemsConfig.enabled || this.workItemsClosed || !this.workItemsConfig.settlement.enabled) {
+            return Object.freeze({
+                skipped: 'disabled',
+                degraded: null,
+                failed: false,
+                scanned: 0,
+                settled: 0,
+                expired: 0,
+                deferred: 0,
+                closedByThread: 0,
+                followDegraded: null,
+                observedItemIds: Object.freeze([]),
+            });
+        }
+        try {
+            const result = this.workItemsSettlement(this.workItemsOpen(), force);
+            this.workItemsDrainEvaluation();
+            return result.report;
+        }
+        catch (error) {
+            this.ctx.logger.warn(`assistant-work-items: settlement unavailable: ${describe(error)}`);
+            // Only a genuinely absent dependency is reported as such; any other
+            // failure is an undifferentiated degraded pass, never a silent success.
+            const degraded = error instanceof WorkItemError && error.code === 'missing-dependency'
+                ? 'missing-dependency'
+                : null;
+            return Object.freeze({
+                skipped: null,
+                degraded,
+                failed: true,
+                scanned: 0,
+                settled: 0,
+                expired: 0,
+                deferred: 0,
+                closedByThread: 0,
+                followDegraded: null,
+                observedItemIds: Object.freeze([]),
+            });
+        }
+    }
+    /**
+     * Read the latest outcome revision per item, newest first.
+     *
+     * Host-only projection for status/health consumers; the disabled default
+     * returns an empty list rather than opening the ledger.
+     */
+    outcomes(options = {}) {
+        const limit = options.limit ?? 20;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+            fail('invalid-input', 'limit must be an integer between 1 and 100');
+        if (!this.workItemsConfig.enabled || this.workItemsClosed)
+            return Object.freeze([]);
+        const components = this.workItemsOpen();
+        return components.store.listOutcomes({
+            limit,
+            ...(options.evidenceState === undefined ? {} : { evidenceState: options.evidenceState }),
+        });
+    }
+    /** Read-only status of the item bound to the calling occurrence. */
+    status(agent) {
+        const components = this.workItemsRequired();
+        const occurrenceId = this.workItemsOccurrenceId(agent);
+        this.workItemsAssertRuntime(components, occurrenceId, 'work_item_status');
+        if (!this.workItemsConfig.diagnosis)
+            components.ledger.recover();
+        const item = components.store.findItemByOccurrence(occurrenceId);
+        if (item === undefined)
+            fail('not-found', 'no work item is bound to this automation occurrence');
+        return Object.freeze({
+            item,
+            claim: components.store.activeClaim(item.id),
+            reports: components.store.reports(item.id),
+            openItems: components.store.countOpenItems(),
+            outcome: components.store.outcomeView(item.id),
+        });
+    }
+    /**
+     * Recall one report belonging to the caller's exact production occurrence.
+     * This path performs no recovery, parking, settlement or ledger mutation.
+     */
+    readReport(agent, input) {
+        const components = this.workItemsRequired();
+        const occurrenceId = this.workItemsOccurrenceId(agent);
+        this.workItemsAssertRuntime(components, occurrenceId, 'work_item_read_report');
+        const item = components.store.findItemByOccurrence(occurrenceId);
+        if (item === undefined)
+            fail('not-found', 'no work item is bound to this automation occurrence');
+        const receipt = this.workItemsAssertOwnerRoute(item);
+        if (receipt.principalVersion !== item.owner.principalVersion
+            || receipt.bindingVersion !== item.owner.bindingVersion
+            || receipt.generation !== item.owner.generation) {
+            fail('owner-route-invalid', 'owner route generation changed since admission');
+        }
+        const authority = components.authority.check(item);
+        if (authority.kind === 'revoked')
+            fail('authority-revoked', 'admission mandate no longer permits report recall');
+        if (authority.kind === 'unavailable')
+            fail('authority-unavailable', 'admission mandate could not be revalidated', authority.detail);
+        return this.workItemsReadReportPage(components, item, input);
+    }
+    readContext(agent, input) {
+        this.workItemsRequired();
+        const runtime = continuationRuntimes.get(this.workItemsContinuationKey);
+        if (!runtime)
+            fail('missing-dependency', 'continuation context runtime is unavailable');
+        return runtime.readContext(this.workItemsOccurrenceId(agent), input);
+    }
+    workItemsAssertRuntime(components, occurrenceId, name) {
+        const item = components.store.findItemByOccurrence(occurrenceId);
+        if (item && components.store.getContinuation(item.id)) {
+            const runtime = continuationRuntimes.get(this.workItemsContinuationKey);
+            if (!runtime)
+                fail('missing-dependency', 'continuation runtime is unavailable');
+            runtime.assertTool(occurrenceId, name);
+        }
+        else if (this.workItemsConfig.diagnosis) {
+            const runtime = diagnosisRuntimes.get(this.workItemsDiagnosisKey);
+            if (!runtime)
+                fail('missing-dependency', 'diagnosis runtime is unavailable');
+            runtime.assertTool(occurrenceId, name);
+        }
+        else if (name === 'work_item_read_context')
+            fail('invalid-state', 'continuation context requires its own invocation');
+    }
+    readSource(agent, input) {
+        this.workItemsRequired();
+        const runtime = diagnosisRuntimes.get(this.workItemsDiagnosisKey);
+        if (!runtime || !this.workItemsConfig.diagnosis)
+            fail('missing-dependency', 'diagnosis source runtime is unavailable');
+        return runtime.readSource(this.workItemsOccurrenceId(agent), input);
+    }
+    /** Pure SELECT/UTF-8 projection shared by preflight and the read tool. */
+    workItemsReadReportPage(components, item, input) {
+        const offset = input.offset ?? 0;
+        const maxBytes = input.maxBytes ?? 4_096;
+        if (!Number.isSafeInteger(input.revision) || input.revision < 1)
+            fail('invalid-input', 'revision must be a positive safe integer');
+        if (!Number.isSafeInteger(offset) || offset < 0)
+            fail('invalid-input', 'offset must be a non-negative UTF-8 byte offset');
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 4 || maxBytes > 8_192)
+            fail('invalid-input', 'maxBytes must be an integer between 4 and 8192');
+        const found = components.store.reportByRevision(item.id, input.revision);
+        if (found === undefined)
+            fail('not-found', 'no report with this revision belongs to the current work item');
+        const bytes = Buffer.from(found.report.summary, 'utf8');
+        if (offset > bytes.length || (offset < bytes.length && (bytes[offset] & 0xc0) === 0x80)) {
+            fail('invalid-input', 'offset must be within the stored summary at a UTF-8 character boundary');
+        }
+        let end = Math.min(offset + maxBytes, bytes.length);
+        while (end < bytes.length && (bytes[end] & 0xc0) === 0x80)
+            end -= 1;
+        return Object.freeze({
+            itemId: item.id,
+            revision: found.report.revision,
+            status: found.report.status,
+            summary: bytes.subarray(offset, end).toString('utf8'),
+            offset,
+            nextOffset: end < bytes.length ? end : null,
+            summaryBytes: bytes.length,
+            storedTruncated: found.report.truncated,
+            artifactPaths: found.report.artifactPaths,
+            recordedAt: found.report.recordedAt,
+            previousRevision: found.previousRevision,
+            nextRevision: found.nextRevision,
+        });
+    }
+    /** Bounded health projection; never creates the ledger when disabled. */
+    health() {
+        const config = this.workItemsConfig;
+        const empty = Object.freeze({
+            enabled: config.enabled,
+            mode: config.mode,
+            openItems: 0,
+            lastAdmitAt: null,
+            lastDispatchAt: null,
+            dispatchUnknown: 0,
+            workerConnected: config.enabled && this.workItemsAutomations() !== undefined,
+            ownerRouteValid: false,
+            follows: Object.freeze({ open: 0, closed: 0, unresolved: 0, degraded: null }),
+            authority: Object.freeze({ legacy: 0, parked: 0, lastDeniedAt: null, lastDeniedReason: null }),
+            settlement: Object.freeze({
+                enabled: config.enabled && config.settlement.enabled,
+                pending: 0,
+                observed: 0,
+                unverified: 0,
+                degraded: null,
+            }),
+            evaluation: Object.freeze({
+                enabled: this.workItemsEvaluationEnabled(),
+                connected: this.workItemsEvaluation.connected,
+                pending: 0,
+                exported: 0,
+                skipped: 0,
+                degraded: this.workItemsEvaluation.degraded,
+            }),
+        });
+        const diagnosis = config.diagnosis || this.workItemsHasDiagnosisHistory ? { diagnosis: diagnosisRuntimes.get(this.workItemsDiagnosisKey)?.health()
+                ?? { enabled: true, ready: false, running: 0, lastError: this.workItemsDiagnosisError ?? (this.workItemsHasDiagnosisHistory ? 'diagnosis-disabled-with-history' : 'diagnosis-runtime-unavailable'),
+                    interventionRequired: this.workItemsComponents ? persistedDiagnosisIntervention(this.workItemsComponents.store, true) : true } } : {};
+        const continuation = config.ownerContinuation ? { ownerContinuation: continuationRuntimes.get(this.workItemsContinuationKey)?.health()
+                ?? { enabled: true, ready: false, running: 0, interventionRequired: true, lastError: 'continuation-activation-unavailable' } } : {};
+        const replies = config.ownerReplyContinuation ? { ownerReplyContinuation: replyConsumers.get(this.workItemsReplyKey)?.health()
+                ?? { enabled: true, registered: false, draining: false, lastError: 'reply-consumer-unavailable' } } : {};
+        const feedback = config.ownerReportFeedback ? { ownerReportFeedback: { enabled: true,
+                available: feedbackReaders.get(this.workItemsFeedbackKey)?.available() === true,
+                registered: replyConsumers.get(this.workItemsReplyKey)?.isCurrent() === true } } : {};
+        const schedulerWake = Object.freeze({ subscribed: this.workItemsSchedulerUnsubscribers.size > 0,
+            lastWakeAt: this.workItemsSchedulerLastWakeAt, lastError: this.workItemsSchedulerLastError });
+        if (!config.enabled || this.workItemsClosed)
+            return Object.freeze({ ...empty, schedulerWake, ...diagnosis, ...continuation, ...replies, ...feedback });
+        let components;
+        try {
+            components = this.workItemsOpen();
+        }
+        catch (error) {
+            this.ctx.logger.warn(`assistant-work-items: ledger unavailable: ${describe(error)}`);
+            return Object.freeze({ ...empty, schedulerWake, ...diagnosis, ...continuation, ...replies, ...feedback });
+        }
+        return Object.freeze({
+            schedulerWake,
+            ...diagnosis,
+            ...continuation,
+            ...replies,
+            ...feedback,
+            enabled: true,
+            mode: config.mode,
+            openItems: components.store.countOpenItems(),
+            lastAdmitAt: components.store.lastAdmitAt(),
+            lastDispatchAt: components.store.lastDispatchedAt(),
+            dispatchUnknown: components.store.countDispatchUnknown(),
+            workerConnected: workerIsConnected(this.workItemsAutomations()),
+            ownerRouteValid: this.workItemsOwnerRouteValid(),
+            follows: this.workItemsFollowHealth(components.store),
+            authority: this.workItemsAuthorityHealth(components.store),
+            settlement: Object.freeze({
+                enabled: config.settlement.enabled,
+                pending: components.store.countLatestOutcomes('pending'),
+                observed: components.store.countLatestOutcomes('observed'),
+                unverified: components.store.countLatestOutcomes('unverified'),
+                degraded: this.workItemsSettlementDegraded(),
+            }),
+            evaluation: Object.freeze(this.workItemsEvaluationHealth(components)),
+        });
+    }
+    /** Close the ledger exactly once; safe on an intake that never opened. */
+    close() {
+        if (this.workItemsClosed)
+            return;
+        this.workItemsClosed = true;
+        engineeringReaders.get(this.workItemsFeedbackKey)?.close();
+        engineeringReaders.delete(this.workItemsFeedbackKey);
+        feedbackReaders.get(this.workItemsFeedbackKey)?.close();
+        feedbackReaders.delete(this.workItemsFeedbackKey);
+        replyConsumers.get(this.workItemsReplyKey)?.close();
+        replyConsumers.delete(this.workItemsReplyKey);
+        diagnosisRuntimes.get(this.workItemsDiagnosisKey)?.close();
+        diagnosisRuntimes.delete(this.workItemsDiagnosisKey);
+        continuationRuntimes.get(this.workItemsContinuationKey)?.close();
+        continuationRuntimes.delete(this.workItemsContinuationKey);
+        this.workItemsIntakeEvaluation?.close();
+        for (const unregister of this.workItemsSchedulerUnsubscribers) {
+            try {
+                unregister();
+            }
+            catch (error) {
+                this.ctx.logger.warn(`assistant-work-items: scheduler wake removal failed: ${describe(error)}`);
+            }
+        }
+        this.workItemsEvaluation.dispose();
+        const components = this.workItemsComponents;
+        this.workItemsComponents = undefined;
+        if (components === undefined)
+            return;
+        try {
+            components.store.close();
+        }
+        catch (error) {
+            this.ctx.logger.warn(`assistant-work-items: ledger close failed: ${describe(error)}`);
+        }
+    }
+    /** Export is possible only from an active intake with settlement armed. */
+    workItemsEvaluationEnabled() {
+        return !this.workItemsClosed && isActive(this.workItemsConfig) && this.workItemsConfig.settlement.enabled;
+    }
+    /** One bounded counts read for the export projection. */
+    workItemsEvaluationHealth(components) {
+        const counts = components.store.countEvaluations();
+        const enabled = this.workItemsEvaluationEnabled();
+        return {
+            enabled,
+            connected: this.workItemsEvaluation.connected,
+            pending: counts.pending,
+            exported: counts.exported,
+            skipped: counts.skipped,
+            degraded: this.workItemsEvaluationDegraded(counts.pending),
+        };
+    }
+    /**
+     * Health degradation: a settled revision can never reach the trusted lane.
+     *
+     * A missing optional sink is only a *gap* once something actually awaits
+     * export; a deployment that never installs Evaluation must not look degraded
+     * while it has nothing to export.
+     */
+    workItemsEvaluationDegraded(pending) {
+        if (!this.workItemsConfig.settlement.enabled)
+            return null;
+        if (this.workItemsConfig.scope === null)
+            return 'owner-route-unavailable';
+        if (!this.workItemsEvaluation.connected)
+            return pending > 0 ? 'sink-unavailable' : null;
+        return this.workItemsEvaluation.degraded;
+    }
+    /** Fire-and-forget bounded drain; export failures must never fail a caller. */
+    workItemsDrainEvaluation() {
+        void this.workItemsEvaluation.drain().catch(error => {
+            this.ctx.logger.warn(`assistant-work-items: Evaluation export failed: ${describe(error)}`);
+        });
+    }
+    workItemsAvailable() {
+        if (!this.workItemsConfig.enabled)
+            fail('disabled', 'the work-item intake is disabled');
+        return this.workItemsOpen();
+    }
+    /** Best-effort bounded sweep; log and continue on any failure. */
+    workItemsSweepQuietly(components) {
+        if (!components.signals.armed())
+            return;
+        try {
+            if (this.workItemsConfig.diagnosis)
+                diagnosisRuntimes.get(this.workItemsDiagnosisKey)?.sweep(false);
+            else
+                components.signals.sweep();
+        }
+        catch (error) {
+            this.ctx.logger.warn(`assistant-work-items: signal sweep failed: ${describe(error)}`);
+        }
+    }
+    /** Best-effort bounded re-dispatch sweep behind ordinary claim activity. */
+    workItemsWakeQuietly(components) {
+        try {
+            if (this.workItemsConfig.diagnosis)
+                diagnosisRuntimes.get(this.workItemsDiagnosisKey)?.wakePending();
+            else
+                components.dispatch.wakePending();
+            replyConsumers.get(this.workItemsReplyKey)?.drain();
+            continuationRuntimes.get(this.workItemsContinuationKey)?.wakePending();
+        }
+        catch (error) {
+            this.ctx.logger.warn(`assistant-work-items: dispatch recovery failed: ${describe(error)}`);
+        }
+    }
+    /** Best-effort settlement pass behind ordinary claim activity. */
+    workItemsSettleQuietly(components) {
+        if (!this.workItemsConfig.settlement.enabled)
+            return;
+        try {
+            this.workItemsSettlement(components, false);
+        }
+        catch (error) {
+            this.ctx.logger.warn(`assistant-work-items: settlement failed: ${describe(error)}`);
+        }
+    }
+    /** Build the bounded settlement pass from config; never admits or wakes. */
+    workItemsSettlement(components, force) {
+        const config = this.workItemsConfig;
+        const scope = config.scope;
+        const result = runSettlement({
+            store: components.store,
+            delivery: this.workItemsDelivery(),
+            scope: scope === null
+                ? null
+                : {
+                    ownerRouteId: scope.ownerRouteId,
+                    principalId: scope.principalId,
+                    workspace: scope.workspace,
+                    preset: scope.preset,
+                },
+            sweepIntervalMs: config.settlement.sweepIntervalMs,
+            maxSourcesPerSweep: config.settlement.maxSourcesPerSweep,
+            maxPendingPerSweep: config.settlement.maxPendingPerSweep,
+            maxSettlementsPerSweep: config.settlement.maxSettlementsPerSweep,
+            threads: follow => this.workItemsResolveThread(follow),
+            warn: message => this.ctx.logger.warn(message),
+        }, force);
+        this.workItemsFollowDegraded = result.report.followDegraded;
+        return result;
+    }
+    /**
+     * Resolve one open follow against its registered source.
+     *
+     * Synchronous and read-only: no timer, no promise, no write. Every refusal
+     * returns `unresolved` so the item stays parked and health can name the
+     * degradation, rather than a missing source or a stale generation being read
+     * as a closure.
+     */
+    workItemsResolveThread(follow) {
+        const registration = this.workItemsThreadSources.get(follow.source);
+        if (registration === undefined)
+            return { kind: 'unresolved', reason: 'source-missing' };
+        // A source that regenerated cannot vouch for a follow recorded under its
+        // old generation; the closure may still be true, but it is not observed.
+        if (registration.generation !== follow.sourceGeneration)
+            return { kind: 'unresolved', reason: 'generation-mismatch' };
+        let closure;
+        try {
+            closure = registration.resolve(follow.ref);
+        }
+        catch (error) {
+            this.ctx.logger.warn(`assistant-work-items: thread resolution failed for ${follow.source}: ${describe(error)}`);
+            return { kind: 'unresolved', reason: 'resolver-failed' };
+        }
+        if (closure === undefined)
+            return { kind: 'unresolved', reason: 'resolver-failed' };
+        if (closure === null || typeof closure !== 'object' || Array.isArray(closure)) {
+            return { kind: 'unresolved', reason: 'resolver-failed' };
+        }
+        if (closure.state === 'open')
+            return { kind: 'open' };
+        if (closure.state !== 'closed')
+            return { kind: 'unresolved', reason: 'resolver-failed' };
+        if (!['succeeded', 'failed', 'cancelled', 'unknown'].includes(closure.outcome)
+            || typeof closure.digest !== 'string' || closure.digest.trim().length === 0
+            || (closure.observedAt !== undefined && (!Number.isSafeInteger(closure.observedAt) || closure.observedAt <= 0))) {
+            // A malformed closure is never a closure: fail closed toward `waiting`.
+            return { kind: 'unresolved', reason: 'resolver-failed' };
+        }
+        return { kind: 'closed', outcome: closure.outcome, digest: closure.digest };
+    }
+    /** Live follow counts and degradation; never resolves or writes anything. */
+    workItemsFollowHealth(store) {
+        const counts = store.countFollows();
+        let unresolved = 0;
+        let missingSource = false;
+        let mismatched = false;
+        for (const identity of store.openFollowIdentities()) {
+            const registration = this.workItemsThreadSources.get(identity.source);
+            if (registration === undefined) {
+                unresolved += 1;
+                missingSource = true;
+            }
+            else if (registration.generation !== identity.sourceGeneration) {
+                unresolved += 1;
+                mismatched = true;
+            }
+        }
+        const degraded = missingSource
+            ? 'source-missing'
+            : mismatched ? 'generation-mismatch' : this.workItemsFollowDegraded;
+        return Object.freeze({ open: counts.open, closed: counts.closed, unresolved, degraded });
+    }
+    /** Degradation visible in health without running a pass or touching SQLite. */
+    workItemsSettlementDegraded() {
+        if (!this.workItemsConfig.settlement.enabled)
+            return null;
+        if (this.workItemsConfig.scope === null)
+            return 'owner-route-unavailable';
+        return this.workItemsDelivery() === undefined ? 'missing-dependency' : null;
+    }
+    workItemsRequired() {
+        const config = this.workItemsConfig;
+        if (!config.enabled)
+            fail('disabled', 'the work-item intake is disabled');
+        if (!isActive(config))
+            fail('observe-mode', 'the work-item intake is in observe mode; claim and report require mode: active');
+        return this.workItemsOpen();
+    }
+    workItemsOpen() {
+        const existing = this.workItemsComponents;
+        if (existing !== undefined)
+            return existing;
+        if (this.workItemsClosed)
+            fail('storage', 'the work-item intake is disposed');
+        const config = this.workItemsConfig;
+        const workspace = new WorkItemWorkspace(config.workRoot);
+        workspace.prepare();
+        const store = new WorkItemStore(config.databasePath);
+        let diagnosisHistory;
+        try {
+            diagnosisHistory = store.readCanonicalMeta('diagnosis.activation/v1') !== undefined;
+            if (diagnosisHistory && !config.diagnosis && isActive(config))
+                fail('invalid-state', 'a diagnosis ledger cannot be silently activated as a generic worker');
+        }
+        catch (error) {
+            store.close();
+            throw error;
+        }
+        this.workItemsHasDiagnosisHistory = diagnosisHistory;
+        const ledger = new WorkItemLedger({ store, workspace, limits: config.limits, ...(config.diagnosis || diagnosisHistory ? { diagnosis: true } : {}) });
+        // Admission and dispatch both take the same ledger and the same resolved
+        // peers, so one construction order keeps a single writer per durable file.
+        const builders = new WeakMap();
+        const admission = new WorkItemAdmission({
+            config,
+            store,
+            ledger,
+            workspace,
+            policy: this.workItemsPolicy(),
+            delivery: () => this.workItemsDelivery(),
+            verifier: () => this.workItemsVerifier(),
+            diagnosisPlanFor: input => builders.get(input),
+            threadSource: kind => {
+                const registration = this.workItemsThreadSources.get(kind);
+                return registration === undefined
+                    ? undefined
+                    : Object.freeze({
+                        source: registration.source,
+                        generation: registration.generation,
+                        ...(registration.validate === undefined ? {} : { validate: (ref) => registration.validate?.(ref) === true }),
+                        ...(registration.canonicalize === undefined ? {} : { canonicalize: (ref) => registration.canonicalize?.(ref) }),
+                    });
+            },
+        });
+        // One lazy policy resolver serves admission and revalidation: a peer that
+        // registers after this plugin becomes visible to both without a restart.
+        const authority = new WorkItemAuthority({ policy: () => this.workItemsPolicy() });
+        const dispatch = new WorkItemDispatch({
+            config,
+            store,
+            ledger,
+            automations: () => this.workItemsAutomations(),
+            delivery: () => this.workItemsDelivery(),
+            validateWake: item => !(config.ownerReportFeedback && config.scope && config.scope.expiresAt <= Date.now())
+                && (!config.diagnosis || diagnosisRuntimes.get(this.workItemsDiagnosisKey)?.validateWake(item) === true),
+            validateWakeLocal: () => !this.workItemsClosed && (!config.diagnosis || diagnosisRuntimes.get(this.workItemsDiagnosisKey)?.isWakeCurrent() === true),
+            replyReportEligible: (item, report, notification) => replyConsumers.get(this.workItemsReplyKey)?.canEnqueue(item, report, notification) === true,
+            authority,
+        });
+        // Signal sources are optional peers resolved lazily on every sweep, so a
+        // deployment without `assistant-delivery` (or with the source disabled)
+        // stays a no-op instead of failing activation or a claim.
+        const signals = new WorkItemSignalIntake({
+            config,
+            store,
+            admission,
+            delivery: () => this.workItemsDelivery(),
+            dispatch,
+            warn: message => this.ctx.logger.warn(message),
+        });
+        const installed = { workspace, store, ledger, admission, authority, dispatch, signals };
+        this.workItemsComponents = installed;
+        diagnosisAdmissions.set(installed, (input, builder) => {
+            if (!config.diagnosis || !isActive(config) || this.workItemsClosed)
+                fail('disabled', 'private diagnosis admission is unavailable');
+            builders.set(input, builder);
+            try {
+                return admission.admit(input);
+            }
+            finally {
+                builders.delete(input);
+            }
+        });
+        if (config.ownerContinuation) {
+            const { diagnosis: _diagnosis, ...sharedConfig } = config;
+            const continuationConfig = Object.freeze({ ...sharedConfig,
+                workerAutomationId: config.ownerContinuation.automationId,
+                limits: Object.freeze({ ...config.limits, maxAttempts: 1 }) });
+            const continuationBuilders = new WeakMap();
+            const continuationAdmission = new WorkItemAdmission({ config: continuationConfig, store, ledger, workspace,
+                policy: this.workItemsPolicy(), delivery: () => this.workItemsDelivery(),
+                continuationFor: input => continuationBuilders.get(input) });
+            continuationAdmissions.set(installed, (input, continuation) => {
+                if (this.workItemsClosed || !isActive(config))
+                    fail('disabled', 'continuation admission is unavailable');
+                continuationBuilders.set(input, continuation);
+                try {
+                    return continuationAdmission.admit(input);
+                }
+                finally {
+                    continuationBuilders.delete(input);
+                }
+            });
+            continuationDispatches.set(installed, new WorkItemDispatch({ config: continuationConfig, store, ledger,
+                automations: () => this.workItemsAutomations(), delivery: () => this.workItemsDelivery(), authority,
+                validateWake: item => continuationRuntimes.get(this.workItemsContinuationKey)?.validateWake(item) === true,
+                validateWakeLocal: item => !this.workItemsClosed && continuationRuntimes.get(this.workItemsContinuationKey)?.isWakeCurrent(item) === true }));
+        }
+        try {
+            // Bounded startup reconcile: lease reclaim is lazy forever, so a host that
+            // was down catches up on the first touch instead of on a timer.
+            if (!config.diagnosis && !diagnosisHistory)
+                installed.ledger.recover();
+            if (isActive(config) && !config.diagnosis) {
+                try {
+                    installed.dispatch.wakePending();
+                }
+                catch (error) {
+                    this.ctx.logger.warn(`assistant-work-items: pending wake failed: ${describe(error)}`);
+                }
+            }
+        }
+        catch (error) {
+            this.workItemsComponents = undefined;
+            store.close();
+            throw error;
+        }
+        return installed;
+    }
+    /** Resolve the exact production automation occurrence for this agent. */
+    workItemsOccurrenceId(agent) {
+        if (agent === undefined)
+            fail('identity-mismatch', 'work-item tools require the worker automation run');
+        const execution = agent.ctx.get('assistantAutomationExecution');
+        if (typeof execution !== 'object' || execution === null || Array.isArray(execution)
+            || !Object.isFrozen(execution)
+            || Object.keys(execution).sort().join(',') !== 'automationId,mode,occurrenceId') {
+            fail('identity-mismatch', 'work-item tools require the immutable automation execution context');
+        }
+        const installed = execution;
+        if (installed.mode !== 'production'
+            || typeof installed.automationId !== 'string'
+            || typeof installed.occurrenceId !== 'string') {
+            fail('identity-mismatch', 'work-item tools are restricted to a production automation run');
+        }
+        const automationId = text(installed.automationId, 'automationId', 500);
+        const occurrenceId = text(installed.occurrenceId, 'occurrenceId', 500);
+        if (automationId !== this.workItemsConfig.workerAutomationId && automationId !== this.workItemsConfig.ownerContinuation?.automationId) {
+            fail('identity-mismatch', 'this automation is not the configured work-item worker');
+        }
+        if (automationId === this.workItemsConfig.ownerContinuation?.automationId) {
+            const item = this.workItemsComponents?.store.findItemByOccurrence(occurrenceId);
+            if (!item || item.workerAutomationId !== automationId || !this.workItemsComponents?.store.getContinuation(item.id)) {
+                fail('identity-mismatch', 'continuation occurrence does not own its persisted item');
+            }
+        }
+        return occurrenceId;
+    }
+    /** Re-anchor a claim against the live owner route above the stored receipt. */
+    workItemsAssertOwnerRoute(item) {
+        const config = this.workItemsConfig;
+        const delivery = this.workItemsDelivery();
+        if (delivery === undefined)
+            fail('owner-route-unavailable', 'assistantDelivery is required to validate the owner route');
+        const scope = item.scope;
+        if (scope.expiresAt <= Date.now())
+            fail('owner-route-expired', 'the work-item owner scope expired');
+        let receipt;
+        try {
+            receipt = delivery.validateOwnerRoute({
+                authorityId: scope.ownerRouteId,
+                principalId: scope.principalId,
+                workspace: scope.workspace,
+                agentPreset: scope.preset,
+            });
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            const missing = error !== null && typeof error === 'object' && 'code' in error && error.code === 'missing-binding';
+            fail(missing ? 'owner-route-invalid' : 'owner-route-unavailable', 'owner route validation failed', detail);
+        }
+        if (receipt.receiptVersion !== 2
+            || receipt.workspace !== scope.workspace
+            || receipt.agentPreset !== scope.preset
+            || receipt.principalId !== scope.principalId
+            || receipt.authorityId !== scope.ownerRouteId) {
+            fail('owner-route-invalid', 'owner route receipt does not match the admitted scope');
+        }
+        if (receipt.principalRecordId !== item.owner.principalRecordId) {
+            fail('owner-route-invalid', 'owner principal changed since admission');
+        }
+        if (config.workerAutomationId !== item.workerAutomationId
+            && (config.ownerContinuation?.automationId !== item.workerAutomationId || !this.workItemsComponents?.store.getContinuation(item.id))) {
+            fail('identity-mismatch', 'item was dispatched to a different worker automation');
+        }
+        return receipt;
+    }
+    /**
+     * Re-validate the stored admission mandate before this claim is allowed.
+     *
+     * Policy remains the only authority: the exact admission request is replayed
+     * against the live policy under the same idempotency key. A denied, failing
+     * or malformed decision parks the item in `waiting` with a typed reason and
+     * fails the claim closed; the item is never claimed and never marked failed.
+     * A later allow resumes it through the same wake path.
+     */
+    workItemsRevalidateAuthority(components, item) {
+        // A terminal item is not claimable; the ledger refuses it. Revalidating
+        // first would park and re-arm finished work into a new generation.
+        if (TERMINAL_STATES.includes(item.state))
+            return;
+        const check = components.authority.check(item);
+        if (check.kind === 'legacy')
+            return;
+        if (check.kind === 'allow') {
+            components.ledger.restoreAuthority(item);
+            return;
+        }
+        if (check.kind === 'revoked') {
+            components.ledger.parkAuthority(item, 'authority-revoked', { reason: check.reasonCode, phase: 'claim' });
+            components.ledger.rearmAuthority(item);
+            fail('authority-revoked', `admission mandate no longer holds (${check.reasonCode})`);
+        }
+        components.ledger.parkAuthority(item, 'authority-unavailable', { reason: check.detail, phase: 'claim' });
+        components.ledger.rearmAuthority(item);
+        fail('authority-unavailable', 'admission mandate could not be revalidated', check.detail);
+    }
+    workItemsAuthorityHealth(store) {
+        const denied = store.lastAuthorityDenial();
+        return Object.freeze({
+            legacy: store.countAuthorityLegacy(),
+            parked: store.countAuthorityParked(),
+            lastDeniedAt: denied === null ? null : denied.at,
+            lastDeniedReason: denied === null ? null : denied.reason,
+        });
+    }
+    workItemsOwnerRouteValid() {
+        const config = this.workItemsConfig;
+        const scope = config.scope;
+        if (scope === null)
+            return false;
+        const delivery = this.workItemsDelivery();
+        if (delivery === undefined)
+            return false;
+        if (scope.expiresAt <= Date.now())
+            return false;
+        try {
+            const receipt = delivery.validateOwnerRoute({
+                authorityId: scope.ownerRouteId,
+                principalId: scope.principalId,
+                workspace: scope.workspace,
+                agentPreset: scope.preset,
+            });
+            return receipt.receiptVersion === 2 && receipt.workspace === scope.workspace;
+        }
+        catch {
+            return false;
+        }
+    }
+    workItemsPolicy() {
+        return this.ctx.get('assistantPolicy');
+    }
+    /** Live owner scope for Event Triggers reads; throws when the owner route is unavailable. */
+    workItemsEventFollowOwner(scope) {
+        const delivery = this.workItemsDelivery();
+        if (typeof delivery?.validateOwnerRoute !== 'function')
+            fail('disabled', 'owner route is unavailable for event follows');
+        const receipt = delivery.validateOwnerRoute({ authorityId: scope.ownerRouteId, principalId: scope.principalId, workspace: scope.workspace, agentPreset: scope.preset });
+        if (receipt.principalId !== scope.principalId || receipt.workspace !== scope.workspace || receipt.agentPreset !== scope.preset) {
+            fail('disabled', 'owner route does not match the configured scope');
+        }
+        return Object.freeze({ principalId: receipt.principalId, principalRecordId: receipt.principalRecordId,
+            principalVersion: receipt.principalVersion, workspace: scope.workspace, preset: scope.preset });
+    }
+    workItemsDelivery() {
+        return this.ctx.get('assistantDelivery');
+    }
+    workItemsVerifier() {
+        return this.ctx.get('assistantVerifier');
+    }
+    workItemsAutomations() {
+        return this.ctx.get('assistantAutomations');
+    }
+}
+function workerIsConnected(automations) {
+    return automations !== undefined;
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=service.js.map