pulseed 0.6.6 → 0.7.0

package/dist/runtime/store/attention-state-store.js

@@ -1,1186 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { z } from "zod";
-import { AttentionInputSchema, dedupeAttentionInputs, } from "../attention/attention-input.js";
-import { runtimeItemsForAgenda, } from "../attention/attention-agenda.js";
-import { attentionScopeKey } from "../attention/attention-scope.js";
-import { AgendaDecompositionSchema, AgentAgendaItemSchema, AttentionClusterSchema, ExpressionDecisionSchema, InhibitionDecisionSchema, InitiativeGateDecisionSchema, OutcomeDecisionSchema, SignalContextSchema, UrgeCandidateSchema, } from "../types/companion-autonomy.js";
-import { ref, refKey, stableId, uniqueRefs } from "../attention/attention-refs.js";
-import { createRuntimeStorePaths, } from "./runtime-paths.js";
-import { openRuntimeControlDatabase, } from "./control-db/index.js";
-export const AttentionStoreLifecycleSchema = z.enum([
-    "active",
-    "pending",
-    "held",
-    "suppressed",
-    "admitted",
-    "stale",
-    "terminal",
-]);
-export class AttentionStateStore {
-    paths;
-    dbOptions;
-    dbPromise = null;
-    constructor(runtimeRootOrPaths, options = {}) {
-        this.paths =
-            typeof runtimeRootOrPaths === "string"
-                ? createRuntimeStorePaths(runtimeRootOrPaths)
-                : runtimeRootOrPaths ?? createRuntimeStorePaths();
-        this.dbOptions = options;
-    }
-    async ensureReady() {
-        await this.database();
-    }
-    async saveCycle(input) {
-        const db = await this.database();
-        return db.transaction((sqlite) => {
-            const intake = input.attentionInputs
-                ? appendAttentionInputs(sqlite, input.attentionInputs, input.recordedAt)
-                : null;
-            if (intake && intake.accepted.length === 0 && intake.duplicates.length > 0) {
-                return intake;
-            }
-            if (input.signalContext) {
-                upsertSignalContext(sqlite, SignalContextSchema.parse(input.signalContext), input.attentionInputs ?? []);
-            }
-            for (const candidate of input.urgeCandidates ?? [])
-                upsertUrgeCandidate(sqlite, candidate);
-            for (const item of input.agendaItems ?? [])
-                upsertAgendaItem(sqlite, item);
-            for (const decision of input.inhibitionDecisions ?? [])
-                upsertInhibitionDecision(sqlite, decision);
-            for (const decision of input.initiativeGateDecisions ?? [])
-                upsertInitiativeGateDecision(sqlite, decision);
-            for (const decision of input.outcomeDecisions ?? [])
-                upsertOutcomeDecision(sqlite, decision);
-            for (const decision of input.expressionDecisions ?? [])
-                upsertExpressionDecision(sqlite, decision);
-            return intake;
-        });
-    }
-    async appendAttentionInputs(inputs, recordedAt) {
-        const db = await this.database();
-        return db.transaction((sqlite) => appendAttentionInputs(sqlite, inputs, recordedAt));
-    }
-    async listAttentionInputs() {
-        const db = await this.database();
-        return db.read((sqlite) => listAttentionInputs(sqlite));
-    }
-    async loadDecisionChainSnapshot(options = {}) {
-        const db = await this.database();
-        return db.read((sqlite) => ({
-            attention_inputs: listAttentionInputs(sqlite),
-            signal_contexts: listJsonColumn(sqlite, "attention_signal_contexts", "context_json", "assembled_at ASC, signal_context_id ASC", SignalContextSchema),
-            urge_candidates: listJsonColumn(sqlite, "attention_urge_candidates", "urge_json", "updated_at ASC, urge_id ASC", UrgeCandidateSchema),
-            agenda_items: listAgendaItems(sqlite, options),
-            inhibition_decisions: listJsonColumn(sqlite, "attention_inhibition_decisions", "decision_json", "decided_at ASC, decision_id ASC", InhibitionDecisionSchema),
-            initiative_gate_decisions: listJsonColumn(sqlite, "attention_initiative_gate_decisions", "decision_json", "decided_at ASC, decision_id ASC", InitiativeGateDecisionSchema),
-            outcome_decisions: listJsonColumn(sqlite, "attention_outcome_decisions", "decision_json", "decided_at ASC, outcome_decision_id ASC", OutcomeDecisionSchema),
-            expression_decisions: listJsonColumn(sqlite, "attention_expression_decisions", "decision_json", "created_at ASC, expression_decision_id ASC", ExpressionDecisionSchema),
-        }));
-    }
-    async loadDecisionChainSnapshotStrict(options = {}) {
-        const db = await this.database();
-        return db.read((sqlite) => ({
-            attention_inputs: listAttentionInputsStrict(sqlite),
-            signal_contexts: listJsonColumnStrict(sqlite, "attention_signal_contexts", "context_json", "assembled_at ASC, signal_context_id ASC", SignalContextSchema),
-            urge_candidates: listJsonColumnStrict(sqlite, "attention_urge_candidates", "urge_json", "updated_at ASC, urge_id ASC", UrgeCandidateSchema),
-            agenda_items: listAgendaItemsStrict(sqlite, options),
-            inhibition_decisions: listJsonColumnStrict(sqlite, "attention_inhibition_decisions", "decision_json", "decided_at ASC, decision_id ASC", InhibitionDecisionSchema),
-            initiative_gate_decisions: listJsonColumnStrict(sqlite, "attention_initiative_gate_decisions", "decision_json", "decided_at ASC, decision_id ASC", InitiativeGateDecisionSchema),
-            outcome_decisions: listJsonColumnStrict(sqlite, "attention_outcome_decisions", "decision_json", "decided_at ASC, outcome_decision_id ASC", OutcomeDecisionSchema),
-            expression_decisions: listJsonColumnStrict(sqlite, "attention_expression_decisions", "decision_json", "created_at ASC, expression_decision_id ASC", ExpressionDecisionSchema),
-        }));
-    }
-    async loadConcernState(options = {}) {
-        const db = await this.database();
-        return db.read((sqlite) => {
-            const key = options.scope ? scopeKey(options.scope) : null;
-            return {
-                clusters: listConcernClusters(sqlite, key),
-                agenda_items: listAgendaItems(sqlite, {
-                    includeSuppressed: true,
-                    includeTerminal: false,
-                    scopeKey: key,
-                }),
-                decompositions: listConcernDecompositions(sqlite, key),
-            };
-        });
-    }
-    async loadConcernStateForScope(scope) {
-        return this.loadConcernState({ scope });
-    }
-    async listCurrentAgendaItems(options = {}) {
-        const db = await this.database();
-        return db.read((sqlite) => listAgendaItems(sqlite, options));
-    }
-    async listAdmissionProposals(options = {}) {
-        const db = await this.database();
-        return db.read((sqlite) => listAdmissionProposals(sqlite, options));
-    }
-    async listCycleResults() {
-        const db = await this.database();
-        return db.read((sqlite) => sqlite.prepare(`
-        SELECT cycle_id, scope_key, projection_revision, write_disposition, result_json
-        FROM attention_cycle_results
-        ORDER BY created_at ASC, cycle_id ASC
-      `).all().map((row) => ({
-            cycle_id: row.cycle_id,
-            scope_key: row.scope_key,
-            projection_revision: row.projection_revision,
-            write_disposition: row.write_disposition,
-            result: JSON.parse(row.result_json),
-        })));
-    }
-    async markAdmissionProposalState(input) {
-        const db = await this.database();
-        db.transaction((sqlite) => {
-            sqlite.prepare(`
-        UPDATE attention_admission_proposals
-        SET state = ?,
-          runtime_operation_id = COALESCE(?, runtime_operation_id),
-          updated_at = ?,
-          proposal_json = json_set(proposal_json, '$.proposalState', ?)
-        WHERE proposal_id = ?
-          AND (
-            state NOT IN ('confirmed', 'terminal')
-            OR (state = 'confirmed' AND ? = 'terminal')
-          )
-      `).run(input.state, input.runtimeOperationId ?? null, input.updatedAt, input.state, input.proposalId, input.state);
-        });
-    }
-    async reconcileAdmissionProposals(input) {
-        const db = await this.database();
-        return db.transaction((sqlite) => {
-            const rows = sqlite.prepare(`
-        SELECT proposal_id
-        FROM attention_admission_proposals
-        WHERE state IN ('pending_handoff', 'handed_off')
-          AND updated_at < ?
-        ORDER BY updated_at ASC, proposal_id ASC
-      `).all(input.orphanBefore);
-            for (const row of rows) {
-                sqlite.prepare(`
-          UPDATE attention_admission_proposals
-          SET state = 'orphaned_needs_reconcile',
-            updated_at = ?,
-            proposal_json = json_set(proposal_json, '$.proposalState', 'orphaned_needs_reconcile')
-          WHERE proposal_id = ?
-        `).run(input.updatedAt, row.proposal_id);
-            }
-            return {
-                orphaned_count: rows.length,
-                proposal_ids: rows.map((row) => row.proposal_id),
-            };
-        });
-    }
-    async listPendingBlocks(scope) {
-        const db = await this.database();
-        return db.read((sqlite) => listPendingBlocks(sqlite, scope ? scopeKey(scope) : null));
-    }
-    async clearPendingBlocks(input) {
-        const db = await this.database();
-        return db.transaction((sqlite) => {
-            const key = scopeKey(input.scope);
-            const rows = listPendingBlocks(sqlite, key)
-                .filter((block) => input.triggerKinds ? input.triggerKinds.includes(block.trigger_kind) : true);
-            for (const row of rows) {
-                sqlite.prepare(`
-          UPDATE attention_pending_blocks
-          SET cleared_at = ?,
-            reason = ?
-          WHERE block_id = ?
-        `).run(input.clearedAt, input.reason, row.block_id);
-            }
-            return {
-                cleared_count: rows.length,
-                block_ids: rows.map((row) => row.block_id),
-            };
-        });
-    }
-    async projectionRevision(scope) {
-        const db = await this.database();
-        return db.read((sqlite) => readProjectionRevision(sqlite, scopeKey(scope)));
-    }
-    async saveMetabolismCycle(input) {
-        const db = await this.database();
-        return db.transaction((sqlite) => {
-            const key = scopeKey(input.scope);
-            const scopedIdempotencyKey = `${key}:${input.idempotency_key}`;
-            const existingCycle = sqlite.prepare(`
-        SELECT projection_revision, write_disposition, trigger_kind
-        FROM attention_cycle_results
-        WHERE idempotency_key = ?
-      `).get(scopedIdempotencyKey);
-            const currentRevision = readProjectionRevision(sqlite, key);
-            if (existingCycle && existingCycle.write_disposition !== "stale_rejected") {
-                return {
-                    writeDisposition: "no_op_elided",
-                    projectionRevision: existingCycle.projection_revision,
-                    replayedTriggerKind: existingCycle.trigger_kind,
-                };
-            }
-            if (currentRevision !== input.expected_projection_revision) {
-                if (!existingCycle) {
-                    appendCycleResult(sqlite, {
-                        cycle_id: input.cycle_id,
-                        idempotency_key: scopedIdempotencyKey,
-                        trigger_kind: input.trigger_kind,
-                        scope_key: key,
-                        projection_revision: currentRevision,
-                        write_disposition: "stale_rejected",
-                        created_at: input.created_at,
-                        result: {
-                            ...input.result,
-                            stale_rejected: true,
-                            expected_projection_revision: input.expected_projection_revision,
-                            current_projection_revision: currentRevision,
-                        },
-                    });
-                }
-                return {
-                    writeDisposition: "stale_rejected",
-                    projectionRevision: currentRevision,
-                };
-            }
-            if (existingCycle?.write_disposition === "stale_rejected") {
-                deleteCycleResultByIdempotencyKey(sqlite, scopedIdempotencyKey);
-            }
-            const nextRevision = currentRevision + 1;
-            const clusters = input.clusters.filter((cluster) => scopeKey(cluster.scope) === key);
-            const agendaItems = input.agendaItems.filter((item) => scopeKey(item.scope) === key);
-            const decompositions = input.decompositions.filter((decomposition) => scopeKey(decomposition.scope) === key);
-            const admissionProposals = (input.admissionProposals ?? [])
-                .filter((proposal) => scopeKey(proposal.scope) === key);
-            for (const event of input.events ?? [])
-                appendAttentionEvent(sqlite, event);
-            for (const cluster of clusters)
-                upsertAttentionCluster(sqlite, cluster, nextRevision);
-            for (const item of agendaItems) {
-                upsertCurrentAgenda(sqlite, item, nextRevision);
-            }
-            for (const decomposition of decompositions)
-                upsertDecomposition(sqlite, decomposition, nextRevision);
-            for (const proposal of admissionProposals)
-                upsertAdmissionProposal(sqlite, proposal, input.created_at);
-            upsertWatermark(sqlite, {
-                scope_key: key,
-                projection_revision: nextRevision,
-                high_watermarks: input.source_high_watermarks,
-                last_noop_hash: input.no_op_hash ?? null,
-                updated_at: input.created_at,
-            });
-            appendCycleResult(sqlite, {
-                cycle_id: input.cycle_id,
-                idempotency_key: scopedIdempotencyKey,
-                trigger_kind: input.trigger_kind,
-                scope_key: key,
-                projection_revision: nextRevision,
-                write_disposition: "written",
-                created_at: input.created_at,
-                result: input.result,
-            });
-            for (const block of input.pendingBlocks ?? []) {
-                if (scopeKey(block.scope) === key)
-                    upsertPendingBlock(sqlite, block);
-            }
-            return {
-                writeDisposition: "written",
-                projectionRevision: nextRevision,
-            };
-        });
-    }
-    async addPendingBlock(input) {
-        const db = await this.database();
-        db.transaction((sqlite) => upsertPendingBlock(sqlite, input));
-    }
-    async listPendingBlockScopeKeys() {
-        const db = await this.database();
-        return db.read((sqlite) => sqlite.prepare(`
-        SELECT DISTINCT scope_key
-        FROM attention_pending_blocks
-        WHERE cleared_at IS NULL
-        ORDER BY scope_key ASC
-      `).all().map((row) => row.scope_key));
-    }
-    async listAgendaItems(options = {}) {
-        const db = await this.database();
-        return db.read((sqlite) => listAgendaItems(sqlite, options));
-    }
-    async listRuntimeItems(now) {
-        return runtimeItemsForAgenda(await this.listAgendaItems({
-            includeSuppressed: true,
-            includeTerminal: false,
-        }), now);
-    }
-    async listRuntimeItemsStrict(now) {
-        return runtimeItemsForAgenda(await this.listAgendaItemsStrict({
-            includeSuppressed: true,
-            includeTerminal: false,
-        }), now);
-    }
-    async suppressAgendaForControl(input) {
-        const db = await this.database();
-        return db.transaction((sqlite) => {
-            const now = input.now ?? new Date().toISOString();
-            const items = listAgendaItems(sqlite, { includeSuppressed: false, includeTerminal: false })
-                .filter((item) => agendaMatchesControl(item, input.control));
-            const suppressed = items.map((item) => suppressAgendaItem(item, {
-                now,
-                reason: input.reason,
-                auditRef: input.auditRef,
-            }));
-            for (const item of suppressed) {
-                upsertAgendaItem(sqlite, item, {
-                    suppressedAt: now,
-                    suppressionReason: input.reason,
-                });
-                updateCurrentAgendaItemIfPresent(sqlite, item);
-            }
-            return {
-                suppressed_count: suppressed.length,
-                agenda_item_ids: suppressed.map((item) => item.agenda_item_id),
-            };
-        });
-    }
-    async invalidateRefs(input) {
-        const db = await this.database();
-        return db.transaction((sqlite) => {
-            const now = input.now ?? new Date().toISOString();
-            const staleKeys = new Set(input.refs.map(refKey));
-            const items = listAgendaItems(sqlite, { includeSuppressed: true, includeTerminal: false })
-                .filter((item) => agendaReferencesAny(item, staleKeys));
-            const invalidated = items.map((item) => invalidateAgendaItem(item, {
-                now,
-                reason: input.reason,
-                auditRef: input.auditRef,
-            }));
-            for (const item of invalidated) {
-                upsertAgendaItem(sqlite, item);
-                updateCurrentAgendaItemIfPresent(sqlite, item);
-            }
-            return {
-                invalidated_count: invalidated.length,
-                agenda_item_ids: invalidated.map((item) => item.agenda_item_id),
-            };
-        });
-    }
-    async database() {
-        this.dbPromise ??= openRuntimeControlDatabase(this.paths, this.dbOptions);
-        return this.dbPromise;
-    }
-    async listAgendaItemsStrict(options = {}) {
-        const db = await this.database();
-        return db.read((sqlite) => listAgendaItemsStrict(sqlite, options));
-    }
-}
-function listAttentionInputs(sqlite) {
-    return listJsonColumn(sqlite, "attention_inputs", "input_json", "emitted_at ASC, attention_input_id ASC", AttentionInputSchema);
-}
-function listAttentionInputsStrict(sqlite) {
-    return listJsonColumnStrict(sqlite, "attention_inputs", "input_json", "emitted_at ASC, attention_input_id ASC", AttentionInputSchema);
-}
-function readProjectionRevision(sqlite, key) {
-    const row = sqlite.prepare(`
-    SELECT projection_revision
-    FROM attention_cycle_watermarks
-    WHERE scope_key = ?
-  `).get(key);
-    return row?.projection_revision ?? 0;
-}
-function appendAttentionEvent(sqlite, event) {
-    sqlite.prepare(`
-    INSERT INTO attention_event_ledger (
-      event_id,
-      event_type,
-      scope_key,
-      policy_epoch,
-      model_or_classifier_version,
-      experiment_id,
-      mode,
-      occurred_at,
-      compactable,
-      critical,
-      event_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(event_id) DO NOTHING
-  `).run(event.event_id, event.event_type, scopeKey(event.scope), event.policy_epoch, event.model_or_classifier_version ?? null, event.experiment_id ?? null, event.mode, event.occurred_at, event.compactable ?? false ? 1 : 0, event.critical ?? false ? 1 : 0, JSON.stringify(event.event));
-}
-function upsertAttentionCluster(sqlite, raw, projectionRevision) {
-    const cluster = AttentionClusterSchema.parse(raw);
-    sqlite.prepare(`
-    INSERT INTO attention_current_clusters (
-      cluster_id,
-      lifecycle,
-      scope_key,
-      policy_epoch,
-      projection_revision,
-      updated_at,
-      cluster_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(cluster_id) DO UPDATE SET
-      lifecycle = excluded.lifecycle,
-      scope_key = excluded.scope_key,
-      policy_epoch = excluded.policy_epoch,
-      projection_revision = excluded.projection_revision,
-      updated_at = excluded.updated_at,
-      cluster_json = excluded.cluster_json
-  `).run(cluster.id, cluster.lifecycle, scopeKey(cluster.scope), cluster.scope.policyEpoch, projectionRevision, cluster.updatedAt, JSON.stringify(cluster));
-}
-function upsertCurrentAgenda(sqlite, raw, projectionRevision) {
-    const item = AgentAgendaItemSchema.parse(raw);
-    sqlite.prepare(`
-    INSERT INTO attention_current_agenda (
-      agenda_item_id,
-      cluster_id,
-      status,
-      scope_key,
-      policy_epoch,
-      projection_revision,
-      updated_at,
-      agenda_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(agenda_item_id) DO UPDATE SET
-      cluster_id = excluded.cluster_id,
-      status = excluded.status,
-      scope_key = excluded.scope_key,
-      policy_epoch = excluded.policy_epoch,
-      projection_revision = excluded.projection_revision,
-      updated_at = excluded.updated_at,
-      agenda_json = excluded.agenda_json
-  `).run(item.agenda_item_id, item.clusterRef?.id ?? null, item.current_posture, scopeKey(item.scope), item.policyEpoch, projectionRevision, item.updated_at, JSON.stringify(item));
-}
-function updateCurrentAgendaItemIfPresent(sqlite, raw) {
-    const item = AgentAgendaItemSchema.parse(raw);
-    sqlite.prepare(`
-    UPDATE attention_current_agenda
-    SET cluster_id = ?,
-      status = ?,
-      scope_key = ?,
-      policy_epoch = ?,
-      updated_at = ?,
-      agenda_json = json(?)
-    WHERE agenda_item_id = ?
-  `).run(item.clusterRef?.id ?? null, item.current_posture, scopeKey(item.scope), item.policyEpoch, item.updated_at, JSON.stringify(item), item.agenda_item_id);
-}
-function upsertDecomposition(sqlite, raw, projectionRevision) {
-    const decomposition = AgendaDecompositionSchema.parse(raw);
-    sqlite.prepare(`
-    INSERT INTO attention_decompositions (
-      decomposition_id,
-      agenda_item_id,
-      cluster_id,
-      status,
-      scope_key,
-      policy_epoch,
-      projection_revision,
-      updated_at,
-      decomposition_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(decomposition_id) DO UPDATE SET
-      agenda_item_id = excluded.agenda_item_id,
-      cluster_id = excluded.cluster_id,
-      status = excluded.status,
-      scope_key = excluded.scope_key,
-      policy_epoch = excluded.policy_epoch,
-      projection_revision = excluded.projection_revision,
-      updated_at = excluded.updated_at,
-      decomposition_json = excluded.decomposition_json
-  `).run(decomposition.id, decomposition.agendaRef.id, decomposition.clusterRef.id, decomposition.status, scopeKey(decomposition.scope), decomposition.scope.policyEpoch, projectionRevision, decomposition.updatedAt, JSON.stringify(decomposition));
-}
-function upsertAdmissionProposal(sqlite, raw, updatedAt) {
-    sqlite.prepare(`
-    INSERT INTO attention_admission_proposals (
-      proposal_id,
-      child_id,
-      idempotency_key,
-      state,
-      runtime_operation_id,
-      created_at,
-      updated_at,
-      proposal_json
-    )
-    VALUES (?, ?, ?, ?, NULL, ?, ?, json(?))
-    ON CONFLICT(proposal_id) DO UPDATE SET
-      state = CASE
-        WHEN attention_admission_proposals.state IN ('confirmed', 'terminal')
-          THEN attention_admission_proposals.state
-        ELSE excluded.state
-      END,
-      child_id = excluded.child_id,
-      idempotency_key = excluded.idempotency_key,
-      runtime_operation_id = CASE
-        WHEN attention_admission_proposals.state IN ('confirmed', 'terminal')
-          THEN attention_admission_proposals.runtime_operation_id
-        ELSE NULL
-      END,
-      updated_at = excluded.updated_at,
-      proposal_json = CASE
-        WHEN attention_admission_proposals.state IN ('confirmed', 'terminal')
-          THEN attention_admission_proposals.proposal_json
-        ELSE excluded.proposal_json
-      END
-  `).run(raw.candidateId, raw.child.id, raw.idempotencyKey, raw.proposalState, raw.createdAt, updatedAt, JSON.stringify(raw));
-}
-function listAdmissionProposals(sqlite, options) {
-    const states = options.states ?? [];
-    const where = states.length > 0
-        ? `WHERE state IN (${states.map(() => "?").join(", ")})`
-        : "";
-    const rows = sqlite.prepare(`
-    SELECT proposal_id, child_id, idempotency_key, state, runtime_operation_id, created_at, updated_at, proposal_json
-    FROM attention_admission_proposals
-    ${where}
-    ORDER BY updated_at ASC, proposal_id ASC
-  `).all(...states);
-    return rows.flatMap((row) => {
-        try {
-            return [{
-                    proposal_id: row.proposal_id,
-                    child_id: row.child_id,
-                    idempotency_key: row.idempotency_key,
-                    state: row.state,
-                    runtime_operation_id: row.runtime_operation_id,
-                    created_at: row.created_at,
-                    updated_at: row.updated_at,
-                    proposal: JSON.parse(row.proposal_json),
-                }];
-        }
-        catch {
-            return [];
-        }
-    });
-}
-function listPendingBlocks(sqlite, key) {
-    const rows = sqlite.prepare(`
-    SELECT block_id, scope_key, trigger_kind, reason, created_at, cleared_at
-    FROM attention_pending_blocks
-    WHERE cleared_at IS NULL
-      ${key ? "AND scope_key = ?" : ""}
-    ORDER BY created_at ASC, block_id ASC
-  `).all(...(key ? [key] : []));
-    return rows;
-}
-function upsertPendingBlock(sqlite, input) {
-    sqlite.prepare(`
-    INSERT INTO attention_pending_blocks (
-      block_id,
-      scope_key,
-      trigger_kind,
-      reason,
-      created_at,
-      cleared_at
-    )
-    VALUES (?, ?, ?, ?, ?, NULL)
-    ON CONFLICT(block_id) DO UPDATE SET
-      reason = excluded.reason,
-      cleared_at = NULL
-  `).run(input.blockId ?? `attention-block:${stableId(`${scopeKey(input.scope)}:${input.triggerKind}`)}`, scopeKey(input.scope), input.triggerKind, input.reason, input.createdAt);
-}
-function upsertWatermark(sqlite, input) {
-    sqlite.prepare(`
-    INSERT INTO attention_cycle_watermarks (
-      scope_key,
-      projection_revision,
-      last_high_watermarks_json,
-      last_noop_hash,
-      updated_at
-    )
-    VALUES (?, ?, json(?), ?, ?)
-    ON CONFLICT(scope_key) DO UPDATE SET
-      projection_revision = excluded.projection_revision,
-      last_high_watermarks_json = excluded.last_high_watermarks_json,
-      last_noop_hash = excluded.last_noop_hash,
-      updated_at = excluded.updated_at
-  `).run(input.scope_key, input.projection_revision, JSON.stringify(input.high_watermarks), input.last_noop_hash, input.updated_at);
-}
-function appendCycleResult(sqlite, input) {
-    sqlite.prepare(`
-    INSERT INTO attention_cycle_results (
-      cycle_id,
-      idempotency_key,
-      trigger_kind,
-      scope_key,
-      projection_revision,
-      write_disposition,
-      created_at,
-      result_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(idempotency_key) DO NOTHING
-  `).run(input.cycle_id, input.idempotency_key, input.trigger_kind, input.scope_key, input.projection_revision, input.write_disposition, input.created_at, JSON.stringify(input.result));
-}
-function deleteCycleResultByIdempotencyKey(sqlite, idempotencyKey) {
-    sqlite.prepare(`
-    DELETE FROM attention_cycle_results
-    WHERE idempotency_key = ?
-      AND write_disposition = 'stale_rejected'
-  `).run(idempotencyKey);
-}
-function appendAttentionInputs(sqlite, inputs, recordedAt = new Date().toISOString()) {
-    const parsedInputs = inputs.map((input) => AttentionInputSchema.parse(input));
-    const existingRows = sqlite.prepare(`
-    SELECT input_json
-    FROM attention_inputs
-    WHERE replay_key IN (${parsedInputs.map(() => "?").join(",") || "NULL"})
-  `).all(...parsedInputs.map((input) => input.source.replay_key));
-    const previouslySeen = new Map();
-    for (const row of existingRows) {
-        const parsed = parseStored(row.input_json, AttentionInputSchema)[0];
-        if (parsed)
-            previouslySeen.set(parsed.source.replay_key, parsed);
-    }
-    const intake = dedupeAttentionInputs(parsedInputs, previouslySeen);
-    for (const record of intake.records) {
-        if (record.disposition === "accepted") {
-            upsertAttentionInput(sqlite, record.input, record.disposition);
-        }
-        appendAttentionReplayRecord(sqlite, record, recordedAt);
-    }
-    return intake;
-}
-function upsertAttentionInput(sqlite, input, disposition) {
-    sqlite.prepare(`
-    INSERT INTO attention_inputs (
-      attention_input_id,
-      source_kind,
-      source_id,
-      source_epoch,
-      high_watermark,
-      replay_key,
-      emitted_at,
-      replay_disposition,
-      lifecycle,
-      suppressed_at,
-      cooldown_until,
-      revisit_due_at,
-      stale_ref_count,
-      invalidation_ref_count,
-      audit_ref_count,
-      input_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(attention_input_id) DO UPDATE SET
-      source_kind = excluded.source_kind,
-      source_id = excluded.source_id,
-      source_epoch = excluded.source_epoch,
-      high_watermark = excluded.high_watermark,
-      replay_key = excluded.replay_key,
-      emitted_at = excluded.emitted_at,
-      replay_disposition = excluded.replay_disposition,
-      lifecycle = excluded.lifecycle,
-      suppressed_at = excluded.suppressed_at,
-      cooldown_until = excluded.cooldown_until,
-      revisit_due_at = excluded.revisit_due_at,
-      stale_ref_count = excluded.stale_ref_count,
-      invalidation_ref_count = excluded.invalidation_ref_count,
-      audit_ref_count = excluded.audit_ref_count,
-      input_json = excluded.input_json
-  `).run(input.attention_input_id, input.source.source_kind, input.source.source_id, input.source.source_epoch, input.source.high_watermark, input.source.replay_key, input.source.emitted_at, disposition, attentionInputLifecycle(input), null, null, null, input.stale_refs.length, input.invalidation_refs.length, input.audit_refs.length, JSON.stringify(input));
-}
-function appendAttentionReplayRecord(sqlite, record, recordedAt) {
-    sqlite.prepare(`
-    INSERT INTO attention_input_replay_records (
-      replay_record_id,
-      attention_input_id,
-      replay_key,
-      disposition,
-      duplicate_of,
-      emitted_at,
-      recorded_at,
-      input_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, json(?))
-  `).run(randomUUID(), record.input.attention_input_id, record.input.source.replay_key, record.disposition, record.duplicate_of ?? null, record.input.source.emitted_at, recordedAt, JSON.stringify(record.input));
-}
-function upsertSignalContext(sqlite, context, attentionInputs) {
-    sqlite.prepare(`
-    INSERT INTO attention_signal_contexts (
-      signal_context_id,
-      assembled_at,
-      source_replay_keys_json,
-      stale_ref_count,
-      invalidation_ref_count,
-      audit_ref_count,
-      context_json
-    )
-    VALUES (?, ?, json(?), ?, ?, ?, json(?))
-    ON CONFLICT(signal_context_id) DO UPDATE SET
-      assembled_at = excluded.assembled_at,
-      source_replay_keys_json = excluded.source_replay_keys_json,
-      stale_ref_count = excluded.stale_ref_count,
-      invalidation_ref_count = excluded.invalidation_ref_count,
-      audit_ref_count = excluded.audit_ref_count,
-      context_json = excluded.context_json
-  `).run(context.signal_context_id, context.assembled_at, JSON.stringify(attentionInputs.map((input) => input.source.replay_key)), context.stale_target_context.stale_refs.length, context.stale_target_context.needs_regrounding_refs.length, context.audit_refs.length, JSON.stringify(context));
-}
-function upsertUrgeCandidate(sqlite, raw) {
-    const urge = UrgeCandidateSchema.parse(raw);
-    sqlite.prepare(`
-    INSERT INTO attention_urge_candidates (
-      urge_id,
-      origin,
-      target_kind,
-      target_id,
-      maturation_state,
-      lifecycle,
-      created_at,
-      updated_at,
-      stale_ref_count,
-      audit_ref_count,
-      urge_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(urge_id) DO UPDATE SET
-      origin = excluded.origin,
-      target_kind = excluded.target_kind,
-      target_id = excluded.target_id,
-      maturation_state = excluded.maturation_state,
-      lifecycle = excluded.lifecycle,
-      updated_at = excluded.updated_at,
-      stale_ref_count = excluded.stale_ref_count,
-      audit_ref_count = excluded.audit_ref_count,
-      urge_json = excluded.urge_json
-  `).run(urge.urge_id, urge.origin, urge.target.kind, urge.target.id, urge.maturation.state, lifecycleForMaturation(urge.maturation.state), urge.maturation.first_seen_at, urge.maturation.last_reinforced_at ?? urge.maturation.first_seen_at, urge.evidence_refs.filter((source) => source.lifecycle !== "active").length, urge.audit_refs.length, JSON.stringify(urge));
-}
-function upsertAgendaItem(sqlite, raw, options = {}) {
-    const item = AgentAgendaItemSchema.parse(raw);
-    sqlite.prepare(`
-    INSERT INTO attention_agenda_items (
-      agenda_item_id,
-      kind,
-      origin,
-      current_posture,
-      control_state,
-      lifecycle,
-      staleness_state,
-      revisit_kind,
-      revisit_due_at,
-      suppressed_at,
-      suppression_reason,
-      cooldown_until,
-      created_at,
-      updated_at,
-      stale_ref_count,
-      invalidation_ref_count,
-      audit_ref_count,
-      agenda_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(agenda_item_id) DO UPDATE SET
-      kind = excluded.kind,
-      origin = excluded.origin,
-      current_posture = excluded.current_posture,
-      control_state = excluded.control_state,
-      lifecycle = excluded.lifecycle,
-      staleness_state = excluded.staleness_state,
-      revisit_kind = excluded.revisit_kind,
-      revisit_due_at = excluded.revisit_due_at,
-      suppressed_at = excluded.suppressed_at,
-      suppression_reason = excluded.suppression_reason,
-      cooldown_until = excluded.cooldown_until,
-      updated_at = excluded.updated_at,
-      stale_ref_count = excluded.stale_ref_count,
-      invalidation_ref_count = excluded.invalidation_ref_count,
-      audit_ref_count = excluded.audit_ref_count,
-      agenda_json = excluded.agenda_json
-  `).run(item.agenda_item_id, item.kind, item.origin, item.current_posture, item.control_state, lifecycleForAgenda(item), item.staleness_state, item.revisit_condition.kind, item.revisit_condition.due_at ?? null, options.suppressedAt ?? (item.control_state === "suppressed" ? item.updated_at : null), options.suppressionReason ?? null, options.cooldownUntil ?? null, item.created_at, item.updated_at, staleRefCountForAgenda(item), invalidationRefCountForAgenda(item), item.audit_refs.length, JSON.stringify(item));
-}
-function upsertInhibitionDecision(sqlite, raw) {
-    const decision = InhibitionDecisionSchema.parse(raw);
-    sqlite.prepare(`
-    INSERT INTO attention_inhibition_decisions (
-      decision_id,
-      target_ref,
-      decision,
-      decided_at,
-      lifecycle,
-      stale_ref_count,
-      audit_ref_count,
-      decision_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(decision_id) DO UPDATE SET
-      target_ref = excluded.target_ref,
-      decision = excluded.decision,
-      decided_at = excluded.decided_at,
-      lifecycle = excluded.lifecycle,
-      stale_ref_count = excluded.stale_ref_count,
-      audit_ref_count = excluded.audit_ref_count,
-      decision_json = excluded.decision_json
-  `).run(decision.decision_id, refKey(decision.target_ref), decision.decision, decision.decided_at, decision.decision === "reject_stale" ? "stale" : decision.decision === "suppress" ? "suppressed" : "active", decision.evidence_refs.filter((source) => source.lifecycle !== "active").length, decision.audit_refs.length, JSON.stringify(decision));
-}
-function upsertInitiativeGateDecision(sqlite, raw) {
-    const decision = InitiativeGateDecisionSchema.parse(raw);
-    sqlite.prepare(`
-    INSERT INTO attention_initiative_gate_decisions (
-      decision_id,
-      status,
-      decided_at,
-      selected_outcome,
-      lifecycle,
-      stale_ref_count,
-      audit_ref_count,
-      decision_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(decision_id) DO UPDATE SET
-      status = excluded.status,
-      decided_at = excluded.decided_at,
-      selected_outcome = excluded.selected_outcome,
-      lifecycle = excluded.lifecycle,
-      stale_ref_count = excluded.stale_ref_count,
-      audit_ref_count = excluded.audit_ref_count,
-      decision_json = excluded.decision_json
-  `).run(decision.decision_id, decision.status, decision.decided_at, decision.selected_outcome ?? null, decision.status === "blocked" ? "stale" : decision.status === "delayed" ? "held" : "active", decision.staleness_checks.filter((check) => check.status === "failed" || check.status === "unknown").length, decision.audit_refs.length, JSON.stringify(decision));
-}
-function upsertOutcomeDecision(sqlite, raw) {
-    const decision = OutcomeDecisionSchema.parse(raw);
-    sqlite.prepare(`
-    INSERT INTO attention_outcome_decisions (
-      outcome_decision_id,
-      initiative_decision_ref,
-      admission_status,
-      requested_outcome,
-      final_outcome,
-      decided_at,
-      lifecycle,
-      stale_ref_count,
-      audit_ref_count,
-      decision_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(outcome_decision_id) DO UPDATE SET
-      initiative_decision_ref = excluded.initiative_decision_ref,
-      admission_status = excluded.admission_status,
-      requested_outcome = excluded.requested_outcome,
-      final_outcome = excluded.final_outcome,
-      decided_at = excluded.decided_at,
-      lifecycle = excluded.lifecycle,
-      stale_ref_count = excluded.stale_ref_count,
-      audit_ref_count = excluded.audit_ref_count,
-      decision_json = excluded.decision_json
-  `).run(decision.outcome_decision_id, refKey(decision.initiative_decision_ref), decision.admission_status, decision.requested_outcome, decision.final_outcome ?? null, decision.decided_at, lifecycleForOutcome(decision), decision.staleness_checks.filter((check) => check.status === "failed" || check.status === "unknown").length, decision.audit_ref ? 1 : 0, JSON.stringify(decision));
-}
-function upsertExpressionDecision(sqlite, raw) {
-    const decision = ExpressionDecisionSchema.parse(raw);
-    sqlite.prepare(`
-    INSERT INTO attention_expression_decisions (
-      expression_decision_id,
-      outcome_decision_ref,
-      outcome_class,
-      decision_status,
-      created_at,
-      lifecycle,
-      audit_ref_count,
-      decision_json
-    )
-    VALUES (?, ?, ?, ?, ?, ?, ?, json(?))
-    ON CONFLICT(expression_decision_id) DO UPDATE SET
-      outcome_decision_ref = excluded.outcome_decision_ref,
-      outcome_class = excluded.outcome_class,
-      decision_status = excluded.decision_status,
-      created_at = excluded.created_at,
-      lifecycle = excluded.lifecycle,
-      audit_ref_count = excluded.audit_ref_count,
-      decision_json = excluded.decision_json
-  `).run(decision.expression_decision_id, refKey(decision.outcome_decision_ref), decision.outcome_class, decision.decision_status, decision.created_at, decision.decision_status === "withdrawn" ? "terminal" : decision.decision_status === "held" ? "held" : "active", decision.audit_ref ? 1 : 0, JSON.stringify(decision));
-}
-function listAgendaItems(sqlite, options) {
-    if (options.forceLegacy)
-        return listLegacyAgendaItems(sqlite, options);
-    const currentAgenda = listCurrentAgendaItems(sqlite, { scopeKey: options.scopeKey ?? null });
-    const legacyAgenda = listLegacyAgendaItems(sqlite, options);
-    return mergeCurrentAndLegacyAgendaItems(currentAgenda, legacyAgenda, options);
-}
-function listAgendaItemsStrict(sqlite, options) {
-    if (options.forceLegacy)
-        return listLegacyAgendaItemsStrict(sqlite, options);
-    const currentAgenda = listCurrentAgendaItemsStrict(sqlite, { scopeKey: options.scopeKey ?? null });
-    const legacyAgenda = listLegacyAgendaItemsStrict(sqlite, options);
-    return mergeCurrentAndLegacyAgendaItems(currentAgenda, legacyAgenda, options);
-}
-function listLegacyAgendaItems(sqlite, options) {
-    const rows = sqlite.prepare(`
-    SELECT lifecycle, agenda_json
-    FROM attention_agenda_items
-    ORDER BY updated_at ASC, agenda_item_id ASC
-  `).all();
-    return rows.flatMap((row) => {
-        if (!options.includeSuppressed && row.lifecycle === "suppressed")
-            return [];
-        if (!options.includeTerminal && (row.lifecycle === "terminal" || row.lifecycle === "stale"))
-            return [];
-        return parseStored(row.agenda_json, AgentAgendaItemSchema)
-            .filter((item) => !options.scopeKey || scopeKey(item.scope) === options.scopeKey);
-    });
-}
-function listLegacyAgendaItemsStrict(sqlite, options) {
-    const rows = sqlite.prepare(`
-    SELECT lifecycle, agenda_json
-    FROM attention_agenda_items
-    ORDER BY updated_at ASC, agenda_item_id ASC
-  `).all();
-    return rows.flatMap((row, index) => {
-        if (!options.includeSuppressed && row.lifecycle === "suppressed")
-            return [];
-        if (!options.includeTerminal && (row.lifecycle === "terminal" || row.lifecycle === "stale"))
-            return [];
-        const item = parseStoredStrict(row.agenda_json, AgentAgendaItemSchema, `attention_agenda_items.agenda_json[${index}]`);
-        return !options.scopeKey || scopeKey(item.scope) === options.scopeKey ? [item] : [];
-    });
-}
-function mergeCurrentAndLegacyAgendaItems(currentAgenda, legacyAgenda, options) {
-    if (currentAgenda.length === 0)
-        return [...legacyAgenda];
-    const legacyById = new Map(legacyAgenda.map((item) => [item.agenda_item_id, item]));
-    const current = currentAgenda
-        .map((item) => {
-        const legacyMutation = legacyById.get(item.agenda_item_id);
-        return shouldPreferLegacyAgendaMutation(item, legacyMutation) ? legacyMutation : item;
-    })
-        .filter((item) => includeAgendaItem(item, options));
-    if (options.scopeKey)
-        return current;
-    const currentScopeKeys = new Set(currentAgenda.map((item) => scopeKey(item.scope)));
-    const currentItemIds = new Set(currentAgenda.map((item) => item.agenda_item_id));
-    return [
-        ...current,
-        ...legacyAgenda.filter((item) => !currentItemIds.has(item.agenda_item_id) && !currentScopeKeys.has(scopeKey(item.scope))),
-    ].sort(compareAgendaItems);
-}
-function shouldPreferLegacyAgendaMutation(current, legacy) {
-    if (!legacy)
-        return false;
-    if (legacy.updated_at.localeCompare(current.updated_at) <= 0)
-        return false;
-    const legacyLifecycle = lifecycleForAgenda(legacy);
-    return legacyLifecycle === "suppressed" || legacyLifecycle === "stale" || legacyLifecycle === "terminal";
-}
-function compareAgendaItems(left, right) {
-    return left.updated_at.localeCompare(right.updated_at)
-        || left.agenda_item_id.localeCompare(right.agenda_item_id);
-}
-function listCurrentAgendaItems(sqlite, options = {}) {
-    const rows = sqlite.prepare(`
-    SELECT agenda_json
-    FROM attention_current_agenda
-    ${options.scopeKey ? "WHERE scope_key = ?" : ""}
-    ORDER BY updated_at ASC, agenda_item_id ASC
-  `).all(...(options.scopeKey ? [options.scopeKey] : []));
-    return rows.flatMap((row) => parseStored(row.agenda_json, AgentAgendaItemSchema));
-}
-function listCurrentAgendaItemsStrict(sqlite, options = {}) {
-    const rows = sqlite.prepare(`
-    SELECT agenda_json
-    FROM attention_current_agenda
-    ${options.scopeKey ? "WHERE scope_key = ?" : ""}
-    ORDER BY updated_at ASC, agenda_item_id ASC
-  `).all(...(options.scopeKey ? [options.scopeKey] : []));
-    return rows.map((row, index) => parseStoredStrict(row.agenda_json, AgentAgendaItemSchema, `attention_current_agenda.agenda_json[${index}]`));
-}
-function listConcernClusters(sqlite, key) {
-    const rows = sqlite.prepare(`
-    SELECT cluster_json
-    FROM attention_current_clusters
-    ${key ? "WHERE scope_key = ?" : ""}
-    ORDER BY updated_at ASC, cluster_id ASC
-  `).all(...(key ? [key] : []));
-    return rows.flatMap((row) => parseStored(row.cluster_json, AttentionClusterSchema));
-}
-function listConcernDecompositions(sqlite, key) {
-    const rows = sqlite.prepare(`
-    SELECT decomposition_json
-    FROM attention_decompositions
-    ${key ? "WHERE scope_key = ?" : ""}
-    ORDER BY updated_at ASC, decomposition_id ASC
-  `).all(...(key ? [key] : []));
-    return rows.flatMap((row) => parseStored(row.decomposition_json, AgendaDecompositionSchema));
-}
-function includeAgendaItem(item, options) {
-    const lifecycle = lifecycleForAgenda(item);
-    if (!options.includeSuppressed && lifecycle === "suppressed")
-        return false;
-    if (!options.includeTerminal && (lifecycle === "terminal" || lifecycle === "stale"))
-        return false;
-    return true;
-}
-function listJsonColumn(sqlite, tableName, columnName, orderBy, schema) {
-    const rows = sqlite.prepare(`
-    SELECT ${columnName} AS value_json
-    FROM ${tableName}
-    ORDER BY ${orderBy}
-  `).all();
-    return rows.flatMap((row) => parseStored(row.value_json, schema));
-}
-function listJsonColumnStrict(sqlite, tableName, columnName, orderBy, schema) {
-    const rows = sqlite.prepare(`
-    SELECT ${columnName} AS value_json
-    FROM ${tableName}
-    ORDER BY ${orderBy}
-  `).all();
-    return rows.map((row, index) => parseStoredStrict(row.value_json, schema, `${tableName}.${columnName}[${index}]`));
-}
-function parseStored(json, schema) {
-    try {
-        const parsed = schema.safeParse(JSON.parse(json));
-        return parsed.success ? [parsed.data] : [];
-    }
-    catch {
-        return [];
-    }
-}
-function parseStoredStrict(json, schema, context) {
-    try {
-        const parsedJson = JSON.parse(json);
-        const parsed = schema.safeParse(parsedJson);
-        if (parsed.success)
-            return parsed.data;
-        throw new Error(parsed.error.message);
-    }
-    catch (error) {
-        throw new Error(`invalid durable attention state row in ${context}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-function attentionInputLifecycle(input) {
-    if (input.stale_refs.length > 0 || input.invalidation_refs.length > 0)
-        return "stale";
-    return "active";
-}
-function lifecycleForMaturation(state) {
-    switch (state) {
-        case "new":
-        case "warming":
-            return "pending";
-        case "held":
-        case "prepared":
-        case "decayed":
-        case "mature":
-            return "held";
-        case "suppressed":
-            return "suppressed";
-        case "expressed":
-            return "admitted";
-        case "expired":
-            return "terminal";
-        case "rejected_stale":
-            return "stale";
-    }
-}
-function lifecycleForAgenda(item) {
-    if (item.control_state === "suppressed" || item.current_posture === "suppressed")
-        return "suppressed";
-    if (item.current_posture === "admitted")
-        return "admitted";
-    if (item.current_posture === "expired")
-        return "terminal";
-    if (item.current_posture === "rejected_stale" || item.staleness_state === "rejected")
-        return "stale";
-    if (item.control_state === "held" || item.control_state === "paused")
-        return "held";
-    return "pending";
-}
-function lifecycleForOutcome(decision) {
-    switch (decision.admission_status) {
-        case "admitted":
-        case "downgraded":
-            return "admitted";
-        case "held":
-            return "held";
-        case "rejected":
-            return "stale";
-        case "expired":
-            return "terminal";
-    }
-}
-function staleRefCountForAgenda(item) {
-    return [
-        ...item.related_goal_refs,
-        ...item.related_memory_refs,
-        ...item.related_surface_refs,
-        ...item.related_runtime_refs,
-    ].filter((candidate) => item.staleness_state !== "current" && candidate).length;
-}
-function invalidationRefCountForAgenda(item) {
-    return item.staleness_state === "needs_regrounding" || item.staleness_state === "rejected" ? 1 : 0;
-}
-function agendaMatchesControl(item, control) {
-    if (item.current_posture === "suppressed"
-        || item.current_posture === "expired"
-        || item.current_posture === "rejected_stale"
-        || item.current_posture === "admitted") {
-        return false;
-    }
-    if (control === "suppress_nonessential_agenda") {
-        return item.kind !== "permission_boundary" && item.kind !== "commitment_guard";
-    }
-    if (control === "stop_all_watches") {
-        return item.kind === "curiosity_followup" || item.kind === "surface_staleness" || item.current_posture === "prepared";
-    }
-    return item.current_posture === "held"
-        || item.current_posture === "prepared"
-        || item.current_posture === "ready_for_gate"
-        || item.current_posture === "warming"
-        || item.current_posture === "new";
-}
-function suppressAgendaItem(item, input) {
-    return AgentAgendaItemSchema.parse({
-        ...item,
-        current_posture: "suppressed",
-        control_state: "suppressed",
-        maturation: {
-            ...item.maturation,
-            state: "suppressed",
-            blocker_refs: item.maturation.blocker_refs,
-        },
-        revisit_condition: {
-            kind: "manual_review",
-            refs: [],
-            reason: input.reason,
-        },
-        updated_at: input.now,
-        audit_refs: uniqueRefs([
-            ...item.audit_refs,
-            input.auditRef ?? ref("audit_trace", `attention-suppression:${item.agenda_item_id}:${input.now}`),
-        ]),
-    });
-}
-function invalidateAgendaItem(item, input) {
-    return AgentAgendaItemSchema.parse({
-        ...item,
-        current_posture: "rejected_stale",
-        control_state: "expired",
-        staleness_state: "rejected",
-        maturation: {
-            ...item.maturation,
-            state: "rejected_stale",
-        },
-        revisit_condition: {
-            kind: "none",
-            refs: [],
-            reason: input.reason,
-        },
-        updated_at: input.now,
-        audit_refs: uniqueRefs([
-            ...item.audit_refs,
-            input.auditRef ?? ref("audit_trace", `attention-invalidation:${item.agenda_item_id}:${input.now}`),
-        ]),
-    });
-}
-function agendaReferencesAny(item, refs) {
-    const candidates = [
-        ...item.related_goal_refs,
-        ...item.related_memory_refs,
-        ...item.related_surface_refs,
-        ...item.related_runtime_refs,
-        ...item.source_urge_refs,
-    ];
-    return candidates.some((candidate) => refs.has(refKey(candidate)));
-}
-function scopeKey(scope) {
-    return attentionScopeKey(scope);
-}
-//# sourceMappingURL=attention-state-store.js.map