attention-manifest-protocol 0.4.0 → 0.4.2

package/lib/runtime/governedTask.js

@@ -0,0 +1,150 @@
+import { GovernanceError, decideControl, legacyInteractionMix, legacyScenarioMix, loadAttentionManifest, verifyAttentionManifest, verifyCredential, } from "../governance/index.js";
+const effectOf = (risk) => {
+    if (risk === "destructive") {
+        return "write-irreversible";
+    }
+    if (risk === "write") {
+        return "write-reversible";
+    }
+    return "read";
+};
+/**
+ * A task that cannot start is rejected before the model is called: a frozen
+ * perspective, a tripped breaker, an expired manifest or a stale credential
+ * never reach generation.
+ *
+ * Tool calls are audited after the runtime returns them. A true pre-call gate
+ * belongs in the runtime's `ToolPolicy`; this adapter records the legal verdict
+ * and can freeze the perspective for the next turn.
+ */
+export class GovernedTask {
+    options;
+    constructor(options) {
+        if (typeof (options.now) !== "function") {
+            throw new TypeError("GovernedTask requires a clock");
+        }
+        this.options = options;
+    }
+    manifest() {
+        return this.options.manifest;
+    }
+    /**
+     * Run one turn under the manifest, then settle it.
+     */
+    async turn(input, override = {}) {
+        const at = this.options.now();
+        if (this.options.legal.isBlocked()) {
+            throw new GovernanceError("legal-breaker", "the legal breaker is active");
+        }
+        if (this.options.legal.isFrozen(this.options.manifest.perspective)) {
+            throw new GovernanceError("legal-frozen", `${this.options.manifest.perspective} is frozen`);
+        }
+        const verdict = verifyAttentionManifest(this.options.manifest, at);
+        if (!verdict.ok) {
+            throw new GovernanceError(verdict.code === "manifest-expired" ? "manifest-expired" : "manifest-unsigned", verdict.detail ?? "manifest is not valid");
+        }
+        const loaded = loadAttentionManifest(this.options.manifest, { perspective: this.options.manifest.perspective, at });
+        const binding = this.options.manifest.budget;
+        const ledger = binding.scope === "agent"
+            ? this.options.budget.snapshot("agent", binding.agent ?? "")
+            : this.options.budget.snapshot("perspective", binding.perspective ?? this.options.manifest.perspective);
+        if (ledger.frozen) {
+            throw new GovernanceError("budget-frozen", `${binding.scope} ledger is frozen`);
+        }
+        let credentialVerdict;
+        if (this.options.credential !== (void 0)) {
+            const checked = verifyCredential(this.options.credential, {
+                at,
+                to: this.options.manifest.perspective,
+                manifest: { id: this.options.manifest.id, version: this.options.manifest.version },
+            });
+            if (!checked.valid) {
+                throw new GovernanceError("credential-scope", `${checked.code}: ${checked.detail}`);
+            }
+            credentialVerdict = { id: this.options.credential.id, verdict: checked.code };
+        }
+        this.options.context.openPerspective(this.options.manifest.perspective, { id: this.options.manifest.id, version: this.options.manifest.version });
+        const systemNote = `Governance: evidence floor ${this.options.manifest.evidenceFloor}; ` +
+            `forbidden ${this.options.manifest.constraints.forbidden.slice(0, 3).join(", ")}.`;
+        const governedOverride = {
+            ...override,
+            scenarioMix: override.scenarioMix ?? legacyScenarioMix(this.options.manifest.scenario),
+            interactionMix: override.interactionMix ?? legacyInteractionMix(this.options.manifest.modes),
+            ...(override.systemNote === (void 0) ? { systemNote } : {}),
+        };
+        const turn = await this.options.runtime.respond(input, governedOverride);
+        const legal = [];
+        const toolCalls = turn.toolCalls ?? [];
+        for (let index = 0; index < toolCalls.length; index += 1) {
+            const call = toolCalls[index];
+            legal.push(this.options.legal.enforceTool({
+                perspective: this.options.manifest.perspective,
+                scenario: this.options.manifest.scenario,
+                action: call.name,
+                effect: effectOf(call.risk),
+            }));
+        }
+        const usage = turn.usage;
+        const tokens = (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0);
+        const chargeRequest = binding.scope === "agent"
+            ? {
+                scope: "agent",
+                agent: binding.agent ?? "",
+                amount: { tokens },
+                reason: `turn ${turn.turnId}`,
+                requestedBy: this.options.manifest.perspective,
+            }
+            : {
+                scope: "perspective",
+                perspective: binding.perspective ?? this.options.manifest.perspective,
+                amount: { tokens },
+                reason: `turn ${turn.turnId}`,
+                requestedBy: this.options.manifest.perspective,
+            };
+        const charge = this.options.budget.charge(chargeRequest);
+        const overall = turn.answerScore?.overall ?? 0.5;
+        const posterior = { alpha: 1 + overall * 4, beta: 1 + (1 - overall) * 4 };
+        const control = decideControl({
+            scenario: this.options.manifest.scenario,
+            modes: this.options.manifest.modes,
+            posterior,
+            conflict: (turn.toolErrors ?? 0) > 0,
+            voi: 1 - overall,
+            openQuestions: 0,
+        });
+        const receipt = this.options.context.writeReceipt(this.options.manifest.perspective, {
+            conclusion: turn.answer.slice(0, 180).length > 0 ? turn.answer.slice(0, 180) : "turn completed",
+            evidence: loaded.focus.slice(0, 3).map((item) => item.target),
+            confidence: Math.max(0, Math.min(1, overall)),
+            budget: { tokens },
+            manifest: { id: this.options.manifest.id, version: this.options.manifest.version },
+            scenario: this.options.manifest.scenario,
+            modes: this.options.manifest.modes,
+            openQuestions: control.stop ? [] : ["review the residual uncertainty"],
+        });
+        const auditEntry = this.options.audit === (void 0)
+            ? undefined
+            : await this.options.audit.recordTurn({
+                turnId: turn.turnId,
+                perspective: this.options.manifest.perspective,
+                manifest: { id: this.options.manifest.id, version: this.options.manifest.version, digest: this.options.manifest.digest },
+                tokens,
+                charge,
+                control: { action: control.action, stop: control.stop, escalate: control.escalate, approvalRequired: control.approvalRequired },
+                receiptId: receipt.id,
+                ...(legal.flatMap((entry) => entry.violations.map((violation) => violation.code)).length === 0
+                    ? {}
+                    : { legalCodes: legal.flatMap((entry) => entry.violations.map((violation) => violation.code)) }),
+            });
+        return {
+            turn,
+            manifest: loaded,
+            ...(credentialVerdict === (void 0) ? {} : { credential: credentialVerdict }),
+            legal,
+            charge,
+            control,
+            receipt,
+            ...(auditEntry === (void 0) ? {} : { audit: auditEntry }),
+        };
+    }
+}

package/lib/runtime/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./safety.js";
+export * from "./routing.js";
+export * from "./cognitiveRuntime.js";
+export * from "./kernelRuntime.js";
+export * from "./session.js";
+export * from "./sessionStore.js";
+export * from "./telemetry.js";
+export * from "./escalation.js";
+export * from "./action.js";
+export * from "./operation.js";
+export * from "./behavior.js";
+export * from "./behaviorTuning.js";
+export * from "./turnStore.js";
+export * from "./replay.js";
+export * from "./governedTask.js";

package/lib/runtime/index.js

@@ -0,0 +1,15 @@
+export * from "./safety.js";
+export * from "./routing.js";
+export * from "./cognitiveRuntime.js";
+export * from "./kernelRuntime.js";
+export * from "./session.js";
+export * from "./sessionStore.js";
+export * from "./telemetry.js";
+export * from "./escalation.js";
+export * from "./action.js";
+export * from "./operation.js";
+export * from "./behavior.js";
+export * from "./behaviorTuning.js";
+export * from "./turnStore.js";
+export * from "./replay.js";
+export * from "./governedTask.js";

package/lib/runtime/kernelRuntime.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Kernel-backed cognitive runtime.
+ *
+ * The standalone `CognitiveRuntime` owns the turn loop; this adapter binds one
+ * turn to a kernel task. The kernel provides the lease, budget accounting,
+ * receipt, step row and hash-chained `runtime.turn` object. The runtime itself
+ * still has no SQL/database dependency.
+ */
+import type { Kernel, StepReport } from "../kernel/index.js";
+import type { CognitiveRuntime, RuntimeTurn } from "./cognitiveRuntime.js";
+export interface KernelRuntimeTurn {
+    report: StepReport;
+    turn: RuntimeTurn;
+    objectId: string;
+    receiptId: string;
+}
+export interface KernelRuntimeOptions {
+    kernel: Kernel;
+    cognitive: CognitiveRuntime;
+    onTurn?: (result: KernelRuntimeTurn) => void;
+}
+export declare class KernelRuntime {
+    private readonly kernel;
+    private readonly cognitive;
+    private readonly onTurn?;
+    private counter;
+    constructor(options: KernelRuntimeOptions);
+    /**
+     * Run one exact task (not "next ready") through an async model turn.
+     */
+    runTask(tid: number, input: string): Promise<KernelRuntimeTurn | undefined>;
+    private serialize;
+}

package/lib/runtime/kernelRuntime.js

@@ -0,0 +1,105 @@
+const mean = (value) => value.mean;
+export class KernelRuntime {
+    kernel;
+    cognitive;
+    onTurn;
+    counter = 0;
+    constructor(options) {
+        this.kernel = options.kernel;
+        this.cognitive = options.cognitive;
+        this.onTurn = options.onTurn;
+    }
+    /**
+     * Run one exact task (not "next ready") through an async model turn.
+     */
+    async runTask(tid, input) {
+        let turn;
+        let objectId;
+        const report = await this.kernel.stepAsync(async (context) => {
+            turn = await this.cognitive.respond(input);
+            objectId = `runtime.turn.${context.task.tid}.${++this.counter}`;
+            const events = [{ topic: "runtime.receipt", payload: { task: context.task.tid, ...this.serialize(turn) } }];
+            const approvals = turn.approvals ?? [];
+            for (let index = 0; index < approvals.length; index += 1) {
+                const approval = approvals[index];
+                events.push({ topic: "runtime.approval", payload: { task: context.task.tid, pid: turn.pid, turnId: turn.turnId, ...approval } });
+            }
+            return {
+                status: "done",
+                usage: { tokens: (turn.usage?.inputTokens ?? 0) + (turn.usage?.outputTokens ?? 0) },
+                objects: [{ kind: "runtime.turn", id: objectId, body: this.serialize(turn) }],
+                events,
+            };
+        }, tid);
+        if (report === (void 0) || turn === (void 0) || objectId === (void 0)) {
+            return undefined;
+        }
+        const result = { report, turn, objectId, receiptId: report.receiptId };
+        this.onTurn?.(result);
+        return result;
+    }
+    serialize(turn) {
+        return {
+            turnId: turn.turnId,
+            sessionId: turn.sessionId,
+            scope: turn.scope,
+            pid: turn.pid,
+            input: turn.input,
+            at: turn.at,
+            user: {
+                quality: turn.user.quality,
+                state: turn.user.state,
+                dimensions: Object.fromEntries(Object.entries(turn.user.dimensions).map(([key, value]) => [key, mean(value)])),
+            },
+            scenario: {
+                weights: turn.scenario.weights,
+                active: turn.scenario.active,
+                mode: turn.scenario.mode,
+                tokenBudgetFactor: turn.scenario.tokenBudgetFactor,
+                contextDepth: turn.scenario.contextDepth,
+                rationale: turn.scenario.rationale,
+            },
+            interaction: {
+                weights: turn.interaction.weights,
+                primary: turn.interaction.primary,
+                secondary: turn.interaction.secondary,
+                sequence: turn.interaction.sequence,
+                moves: turn.interaction.moves,
+                response: turn.interaction.response,
+                safety: turn.interaction.safety,
+                rationale: turn.interaction.rationale,
+            },
+            attention: {
+                utilization: turn.attention.utilization,
+                pressure: turn.attention.pressure,
+                rest: turn.attention.rest,
+                foregroundSlots: turn.attention.foreground?.slots ?? 0,
+                safetySlots: turn.attention.process.safetySlots,
+                recoveryDebt: turn.attention.process.recoveryDebt,
+            },
+            answer: turn.answer,
+            answerScore: turn.answerScore === (void 0)
+                ? undefined
+                : {
+                    overall: turn.answerScore.overall,
+                    dimensions: Object.fromEntries(Object.entries(turn.answerScore.dimensions).map(([key, value]) => [key, mean(value)])),
+                },
+            usage: turn.usage,
+            finishReason: turn.finishReason,
+            toolCalls: turn.toolCalls,
+            restSuggested: turn.restSuggested,
+            latencyMs: turn.latencyMs,
+            toolErrors: turn.toolErrors,
+            telemetry: turn.telemetry,
+            escalationId: turn.escalationId,
+            behavior: turn.behavior,
+            actions: turn.actions,
+            operations: turn.operations,
+            approvals: turn.approvals,
+            diagnosis: turn.diagnosis,
+            safety: turn.safety,
+            trace: turn.trace,
+            runtimeReceiptId: turn.receiptId,
+        };
+    }
+}

package/lib/runtime/operation.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Operation = atomic execution primitive. Only operations touch external state.
+ */
+export type OperationId = string;
+export type OperationKind = "llm.complete" | "tool.call" | "memory.write" | "policy.check" | "human.handoff";
+export type SideEffect = "none" | "read" | "write" | "destructive";
+export type OperationStatus = "running" | "ok" | "error" | "denied";
+export interface OperationRecord {
+    id: OperationId;
+    actionId: string;
+    kind: OperationKind;
+    input: unknown;
+    executor: string;
+    sideEffect: SideEffect;
+    idempotencyKey?: string;
+    timeoutMs?: number;
+    status: OperationStatus;
+    result?: unknown;
+    evidenceId?: string;
+}
+/**
+ * Independent audit record for a tool approval/denial.
+ */
+export interface ApprovalRecord {
+    operationId: string;
+    tool: string;
+    risk: SideEffect;
+    decision: string;
+    status: "allowed" | "denied" | "not_required";
+}

package/lib/runtime/operation.js

@@ -0,0 +1 @@
+export {};

package/lib/runtime/replay.d.ts

@@ -0,0 +1,24 @@
+import type { RuntimeTurn } from "./cognitiveRuntime.js";
+import type { TurnStore } from "./turnStore.js";
+export interface ReplayedTurn {
+    turnId: string;
+    sessionId?: string;
+    pid: number;
+    input: string;
+    output: string;
+    behaviorIds: string[];
+    actions: Array<{
+        id: string;
+        intent: string;
+        status: string;
+        operations: string[];
+    }>;
+    operations: Array<{
+        id: string;
+        kind: string;
+        status: string;
+        actionId: string;
+    }>;
+}
+export declare const replayTurn: (turn: RuntimeTurn) => ReplayedTurn;
+export declare const replayStoredTurn: (store: TurnStore, turnId: string) => ReplayedTurn;

package/lib/runtime/replay.js

@@ -0,0 +1,38 @@
+export const replayTurn = (turn) => {
+    const actions = turn.actions ?? [];
+    const operations = turn.operations ?? [];
+    const actionIds = new Set(actions.map((action) => action.id));
+    const operationIds = new Set(operations.map((operation) => operation.id));
+    for (let index = 0; index < operations.length; index += 1) {
+        const operation = operations[index];
+        if (!actionIds.has(operation.actionId)) {
+            throw new Error(`operation ${operation.id} references missing action ${operation.actionId}`);
+        }
+    }
+    for (let actionIndex = 0; actionIndex < actions.length; actionIndex += 1) {
+        const action = actions[actionIndex];
+        for (let operationIndex = 0; operationIndex < action.operationIds.length; operationIndex += 1) {
+            const operationId = action.operationIds[operationIndex];
+            if (!operationIds.has(operationId)) {
+                throw new Error(`action ${action.id} references missing operation ${operationId}`);
+            }
+        }
+    }
+    return {
+        turnId: turn.turnId,
+        ...(turn.sessionId === (void 0) ? {} : { sessionId: turn.sessionId }),
+        pid: turn.pid,
+        input: turn.input,
+        output: turn.answer,
+        behaviorIds: (turn.behavior?.activations ?? []).map((activation) => activation.behaviorId),
+        actions: actions.map((action) => ({ id: action.id, intent: action.intent, status: action.status, operations: [...action.operationIds] })),
+        operations: operations.map((operation) => ({ id: operation.id, kind: operation.kind, status: operation.status, actionId: operation.actionId })),
+    };
+};
+export const replayStoredTurn = (store, turnId) => {
+    const turn = store.get(turnId);
+    if (turn === (void 0)) {
+        throw new Error(`unknown turn ${turnId}`);
+    }
+    return replayTurn(turn);
+};

package/lib/runtime/routing.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Lightweight routing from text/user state to scenario and interaction mixes.
+ *
+ * This is a rule-based prior, not a classifier. It exists so the runtime has a
+ * complete loop; later it should be replaced/calibrated by the Bayesian engine
+ * and real receipts.
+ */
+import type { UserScore } from "../bayes/engine.js";
+import type { InteractionMix } from "../interaction/interaction.js";
+import type { ScenarioMix } from "../scenario/scenario.js";
+export declare const inferScenarioMix: (text: string) => ScenarioMix;
+export declare const inferInteractionMix: (user: UserScore) => InteractionMix;

package/lib/runtime/routing.js

@@ -0,0 +1,44 @@
+const count = (text, pattern) => (text.match(pattern) ?? []).length;
+export const inferScenarioMix = (text) => {
+    const engineering = count(text, /\b(code|bug|typescript|javascript|api|sql|deploy|test|build|refactor|stack|error)\b/gi);
+    const research = count(text, /\b(paper|study|literature|hypothesis|evidence|theory|experiment|survey)\b/gi);
+    const investigation = count(text, /\b(incident|root cause|audit|forensic|postmortem|timeline|outage)\b/gi);
+    const office = count(text, /\b(email|schedule|meeting|document|calendar|report|deadline|stakeholder)\b/gi);
+    const writing = count(text, /\b(write|draft|rewrite|edit|style|tone|copy|article)\b/gi);
+    const collaboration = count(text, /\b(team|coordinate|handoff|review|pair|collaborate|sync|owner)\b/gi);
+    const iteration = count(text, /\b(iterate|version|prototype|quick|try|loop|experiment)\b/gi);
+    const chat = count(text, /\b(hi|hello|thanks|feel|feeling|tired|overwhelmed|anxious|happy|sad)\b/gi);
+    const scores = [
+        ["engineering", engineering],
+        ["research", research],
+        ["investigation", investigation],
+        ["office", office],
+        ["writing", writing],
+        ["collaboration", collaboration],
+        ["iteration", iteration],
+        ["chat", chat],
+    ];
+    scores.sort((left, right) => right[1] - left[1]);
+    if (scores[0][1] === 0) {
+        return { office: 0.2, collaboration: 0.2, engineering: 0.2, chat: 0.2, writing: 0.2 };
+    }
+    const top = scores.filter(([, score]) => score > 0).slice(0, 3);
+    const total = top.reduce((sum, [, score]) => sum + score, 0);
+    const mix = {};
+    for (const [kind, score] of top) {
+        mix[kind] = score / total;
+    }
+    return mix;
+};
+export const inferInteractionMix = (user) => {
+    if (user.state.emotionalIntensity > 0.6) {
+        return { affect: 0.55, think: 0.2, converge: 0.2, inspire: 0.05 };
+    }
+    if (user.state.urgency > 0.6) {
+        return { converge: 0.55, think: 0.25, affect: 0.2 };
+    }
+    if (user.dimensions.clarity.mean < 0.4) {
+        return { inspire: 0.45, affect: 0.25, think: 0.3 };
+    }
+    return { think: 0.55, converge: 0.25, orchestrate: 0.2 };
+};

package/lib/runtime/safety.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Safety gates for interaction output.
+ *
+ * These are conservative, pattern-based guards, not a classifier. They block
+ * clear crisis/diagnosis/manipulation cases and leave the final judgment to a
+ * human escalation path. They must not be treated as medical advice.
+ */
+import type { InteractionPlan } from "../interaction/interaction.js";
+export type SafetyAction = "allow" | "refuse" | "escalate";
+export interface SafetyDecision {
+    action: SafetyAction;
+    reasons: string[];
+}
+export declare const checkSafety: (userText: string, interaction: InteractionPlan, answerText?: string) => SafetyDecision;
+export declare const safetyFallback: (action: SafetyAction) => string;

package/lib/runtime/safety.js

@@ -0,0 +1,28 @@
+const crisisPatterns = [
+    /\b(suicide|suicidal|kill myself|end my life|self[- ]?harm|hurt myself|overdose)\b/i,
+    /\b(immediate danger|emergency|someone is going to hurt me)\b/i,
+];
+const diagnosisPatterns = [/\byou (have|are diagnosed with|suffer from) (depression|anxiety disorder|bipolar|ptsd|adhd|autism)\b/i, /\byour diagnosis is\b/i];
+const manipulationPatterns = [/\byou (only )?need me\b/i, /\bdon't (leave|trust anyone else)\b/i, /\bonly I (understand|can help) you\b/i];
+export const checkSafety = (userText, interaction, answerText = "") => {
+    const reasons = [];
+    if (crisisPatterns.some((pattern) => pattern.test(userText))) {
+        reasons.push("user text contains a crisis/self-harm signal");
+        return { action: "escalate", reasons };
+    }
+    if (interaction.safety.noDiagnosis && diagnosisPatterns.some((pattern) => pattern.test(answerText))) {
+        reasons.push("answer makes a diagnosis while the interaction forbids it");
+        return { action: "refuse", reasons };
+    }
+    if (interaction.safety.noManipulation && manipulationPatterns.some((pattern) => pattern.test(answerText))) {
+        reasons.push("answer uses dependency/manipulation language");
+        return { action: "refuse", reasons };
+    }
+    return { action: "allow", reasons };
+};
+export const safetyFallback = (action) => {
+    if (action === "escalate") {
+        return "This sounds like an immediate safety concern. Please contact local emergency services or a crisis line now, and reach out to a trusted person who can stay with you. I can stay with you here, but I cannot replace emergency help.";
+    }
+    return "I cannot help with that framing. I can offer a safer, evidence-based alternative if you want to continue.";
+};

package/lib/runtime/session.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Multi-turn runtime session: attention state, belief priors and feedback.
+ *
+ * The session is the memory of the loop, not the model's context. It records
+ * posterior evidence and updates the agent's cognitive state from telemetry.
+ */
+import type { AttentionPlan } from "../attention/resource.js";
+import type { CognitiveState } from "../attention/cognition.js";
+import type { AttentionResourcePolicy } from "../attention/resource.js";
+import type { AnswerScore, BetaBelief, Dimension, Evidence, UserScore } from "../bayes/engine.js";
+import { BayesianEngine } from "../bayes/engine.js";
+import { SourceReliability } from "../bayes/reliability.js";
+import type { ReliabilityBelief } from "../bayes/reliability.js";
+import { ScopedPriors } from "../bayes/scopedPriors.js";
+import type { ScenarioMix } from "../scenario/scenario.js";
+import type { InteractionMix } from "../interaction/interaction.js";
+import type { TelemetrySample } from "./telemetry.js";
+import type { BehaviorPlan } from "./behavior.js";
+import type { ActionRecord } from "./action.js";
+import type { ApprovalRecord, OperationRecord } from "./operation.js";
+import type { DiagnosticFrame } from "../diagnosis/index.js";
+export interface SessionAttentionState extends CognitiveState {
+    stress: number;
+    fatigue: number;
+    recoveryDebt: number;
+}
+export interface SessionTurnRecord {
+    turnId: string;
+    at: string;
+    /**
+     * Prior scope for this turn, e.g. "session:engineering".
+     */
+    scope?: string;
+    user: UserScore;
+    answerScore?: AnswerScore;
+    attention: AttentionPlan;
+    latencyMs?: number;
+    tokens?: number;
+    toolErrors?: number;
+    telemetry?: TelemetrySample;
+    behavior?: BehaviorPlan;
+    actions?: ActionRecord[];
+    operations?: OperationRecord[];
+    approvals?: ApprovalRecord[];
+    diagnosis?: DiagnosticFrame;
+}
+export interface TurnFeedback {
+    helpful?: boolean;
+    correction?: string;
+    /**
+     * Optional ground truth for answer quality; updates source reliability.
+     */
+    actualCorrect?: boolean;
+}
+export interface SessionSnapshot {
+    id?: string;
+    scope?: string;
+    state: SessionAttentionState;
+    priors: Record<Dimension, BetaBelief>;
+    history: SessionTurnRecord[];
+    /**
+     * Monotonic turn counter so IDs survive runtime restarts.
+     */
+    turnCounter?: number;
+    /**
+     * Monotonic session mutation version.
+     */
+    version?: number;
+    /**
+     * Behavior arbitration counts, e.g. "affect<-clarify": 3.
+     */
+    behaviorConflicts?: Record<string, number>;
+    /**
+     * Learned source reliability (Beta beliefs).
+     */
+    sourceReliability?: Record<string, ReliabilityBelief>;
+    /**
+     * Scope-level priors (global + local counts).
+     */
+    scopedPriors?: {
+        global: Record<Dimension, BetaBelief>;
+        scopes: Record<string, Record<Dimension, BetaBelief>>;
+    };
+    /**
+     * Set when the agent is archived but the snapshot is retained.
+     */
+    archivedAt?: string;
+}
+export interface RuntimeSessionOptions {
+    id?: string;
+    /**
+     * Prior scope, e.g. task/scenario id.
+     */
+    scope?: string;
+    initial?: SessionAttentionState;
+    bayes?: BayesianEngine;
+    scenarioMix?: ScenarioMix;
+    interactionMix?: InteractionMix;
+    maxHistory?: number;
+}
+export declare class RuntimeSession {
+    readonly id: string;
+    state: SessionAttentionState;
+    readonly bayes: BayesianEngine;
+    readonly history: SessionTurnRecord[];
+    readonly behaviorConflicts: Record<string, number>;
+    readonly reliability: SourceReliability;
+    readonly scope: string;
+    readonly scopedPriors: ScopedPriors;
+    readonly scenarioMix?: ScenarioMix;
+    readonly interactionMix?: InteractionMix;
+    private readonly maxHistory;
+    private turnCounter;
+    private version;
+    constructor(options?: RuntimeSessionOptions);
+    /**
+     * Allocate a stable turn id; survives serialization/restore.
+     */
+    nextTurnId(): string;
+    /**
+     * Engine with this scope's priors + learned source weights.
+     */
+    engineFor(scope?: string): BayesianEngine;
+    /**
+     * Record a completed turn and update attention + priors from evidence.
+     */
+    record(turn: SessionTurnRecord): void;
+    /**
+     * User feedback becomes evidence, not a direct score overwrite.
+     */
+    feedback(turnId: string, feedback: TurnFeedback): Evidence[];
+    shouldRest(policy?: AttentionResourcePolicy): boolean;
+    rest(cycles?: number): SessionAttentionState;
+    snapshot(): {
+        state: SessionAttentionState;
+        priors: Record<Dimension, BetaBelief>;
+        turns: number;
+        behaviorConflicts: Record<string, number>;
+        sourceReliability: Record<string, ReliabilityBelief>;
+        scopedPriors: {
+            global: Record<Dimension, BetaBelief>;
+            scopes: Record<string, Record<Dimension, BetaBelief>>;
+        };
+    };
+    serialize(): SessionSnapshot;
+    static restore(snapshot: SessionSnapshot, options?: Omit<RuntimeSessionOptions, "bayes" | "initial">): RuntimeSession;
+}