attention-manifest-protocol 0.4.0 → 0.4.2

package/lib/registry/registry.js

@@ -0,0 +1,299 @@
+import { getObject, putObject, verifyObjectChain } from "../database/store/database.js";
+import { isId } from "../boundary/ids.js";
+import { Stack } from "../structure/stack.js";
+import { UnorderedMap } from "../structure/unordered.js";
+import { UnorderedSet } from "../structure/unordered.js";
+const requireText = (value, field) => {
+    if (value.trim().length === 0) {
+        throw new Error(`${field} must not be empty`);
+    }
+};
+export const declareConcept = (db, input, at) => {
+    if (!isId(input.id)) {
+        throw new Error(`concept id ${input.id} is not a valid AMP id`);
+    }
+    requireText(input.label, "label");
+    requireText(input.definition, "definition");
+    const existing = db.prepare("SELECT * FROM concepts WHERE id = ?").get(input.id);
+    const version = existing === (void 0) ? 1 : existing.version + 1;
+    const objectId = `concept.${input.id}.v${version}`;
+    const body = {
+        amp: "0.1",
+        kind: "concept",
+        id: input.id,
+        label: input.label,
+        definition: input.definition,
+        status: input.status ?? "active",
+        version,
+        at,
+    };
+    const object = putObject(db, "concept", objectId, body, at);
+    db.prepare(`INSERT INTO concepts (id, label, definition, status, version, object_seq, digest, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           label = excluded.label,
+           definition = excluded.definition,
+           status = excluded.status,
+           version = excluded.version,
+           object_seq = excluded.object_seq,
+           digest = excluded.digest,
+           updated_at = excluded.updated_at`).run(input.id, input.label, input.definition, input.status ?? "active", version, object.seq, object.hash, existing?.created_at ?? at, at);
+    const row = db.prepare("SELECT * FROM concepts WHERE id = ?").get(input.id);
+    return { row, objectId, hash: object.hash };
+};
+export const declareModule = (db, input, at) => {
+    if (!isId(input.id)) {
+        throw new Error(`module id ${input.id} is not a valid AMP id`);
+    }
+    requireText(input.entry, "entry");
+    requireText(input.description, "description");
+    const existing = db.prepare("SELECT * FROM modules WHERE id = ?").get(input.id);
+    const version = existing === (void 0) ? 1 : existing.version + 1;
+    const objectId = `module.${input.id}.v${version}`;
+    const body = {
+        amp: "0.1",
+        kind: "module",
+        id: input.id,
+        moduleKind: input.kind,
+        entry: input.entry,
+        description: input.description,
+        status: input.status ?? "active",
+        contentDigest: input.contentDigest ?? null,
+        version,
+        at,
+    };
+    const object = putObject(db, "module", objectId, body, at);
+    db.prepare(`INSERT INTO modules (id, kind, entry, description, status, version, object_seq, digest, content_digest, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           kind = excluded.kind,
+           entry = excluded.entry,
+           description = excluded.description,
+           status = excluded.status,
+           version = excluded.version,
+           object_seq = excluded.object_seq,
+           digest = excluded.digest,
+           content_digest = excluded.content_digest,
+           updated_at = excluded.updated_at`).run(input.id, input.kind, input.entry, input.description, input.status ?? "active", version, object.seq, object.hash, input.contentDigest ?? null, existing?.created_at ?? at, at);
+    const row = db.prepare("SELECT * FROM modules WHERE id = ?").get(input.id);
+    return { row, objectId, hash: object.hash };
+};
+export const linkConcept = (db, moduleId, conceptId, role) => {
+    const module = db.prepare("SELECT mid FROM modules WHERE id = ?").get(moduleId);
+    if (module === (void 0)) {
+        throw new Error(`unknown module ${moduleId}`);
+    }
+    const concept = db.prepare("SELECT cid FROM concepts WHERE id = ?").get(conceptId);
+    if (concept === (void 0)) {
+        throw new Error(`unknown concept ${conceptId}`);
+    }
+    const result = db
+        .prepare("INSERT OR IGNORE INTO module_concepts (mid, cid, role) VALUES (?, ?, ?)")
+        .run(module.mid, concept.cid, role);
+    return Number(result.changes) === 1;
+};
+export const dependencies = (db, moduleId) => {
+    return db
+        .prepare(`SELECT m.id AS moduleId, d.id AS dependsOn, md.reason AS reason
+             FROM module_dependencies md
+             JOIN modules m ON m.mid = md.mid
+             JOIN modules d ON d.mid = md.depends_on_mid
+             WHERE m.id = ? ORDER BY d.id ASC`)
+        .all(moduleId);
+};
+export const linkDependency = (db, moduleId, dependencyId, reason = "") => {
+    if (moduleId === dependencyId) {
+        throw new Error(`module ${moduleId} cannot depend on itself`);
+    }
+    const module = db.prepare("SELECT mid FROM modules WHERE id = ?").get(moduleId);
+    if (module === (void 0)) {
+        throw new Error(`unknown module ${moduleId}`);
+    }
+    const dependency = db.prepare("SELECT mid FROM modules WHERE id = ?").get(dependencyId);
+    if (dependency === (void 0)) {
+        throw new Error(`unknown module ${dependencyId}`);
+    }
+    const result = db
+        .prepare("INSERT OR IGNORE INTO module_dependencies (mid, depends_on_mid, reason) VALUES (?, ?, ?)")
+        .run(module.mid, dependency.mid, reason);
+    if (Number(result.changes) === 0) {
+        return false;
+    }
+    if (hasDependencyCycle(db)) {
+        db.prepare("DELETE FROM module_dependencies WHERE mid = ? AND depends_on_mid = ?").run(module.mid, dependency.mid);
+        throw new Error(`linking ${moduleId} -> ${dependencyId} would create a dependency cycle`);
+    }
+    return true;
+};
+/**
+ * DFS over the dependency graph; uses the structure library's Stack/Set.
+ */
+export const hasDependencyCycle = (db) => {
+    const modules = db.prepare("SELECT mid, id FROM modules").all();
+    const idByMid = new UnorderedMap();
+    for (let index = 0; index < modules.length; index += 1) {
+        const module = modules[index];
+        idByMid.set(module.mid, module.id);
+    }
+    const edges = db.prepare("SELECT mid, depends_on_mid FROM module_dependencies").all();
+    const adjacency = new UnorderedMap();
+    for (let index = 0; index < edges.length; index += 1) {
+        const edge = edges[index];
+        const from = idByMid.get(edge.mid);
+        const to = idByMid.get(edge.depends_on_mid);
+        if (from === (void 0) || to === (void 0)) {
+            continue;
+        }
+        const next = adjacency.get(from) ?? [];
+        next.push(to);
+        adjacency.set(from, next);
+    }
+    const visiting = new UnorderedSet();
+    const visited = new UnorderedSet();
+    for (let index = 0; index < modules.length; index += 1) {
+        const module = modules[index];
+        if (visited.has(module.id)) {
+            continue;
+        }
+        const stack = new Stack();
+        stack.push({ id: module.id, next: 0, neighbors: adjacency.get(module.id) ?? [] });
+        visiting.add(module.id);
+        while (!stack.isEmpty) {
+            const frame = stack.peek();
+            if (frame === (void 0)) {
+                break;
+            }
+            if (frame.next >= frame.neighbors.length) {
+                stack.pop();
+                visiting.delete(frame.id);
+                visited.add(frame.id);
+                continue;
+            }
+            const next = frame.neighbors[frame.next];
+            frame.next += 1;
+            if (visiting.has(next)) {
+                return true;
+            }
+            if (!visited.has(next)) {
+                visiting.add(next);
+                stack.push({ id: next, next: 0, neighbors: adjacency.get(next) ?? [] });
+            }
+        }
+    }
+    return false;
+};
+/**
+ * Recompute each module directory's digest and compare it with the declaration.
+ */
+export const verifyModuleContent = async (db, compute) => {
+    const reasons = [];
+    const rows = db
+        .prepare("SELECT id, entry, content_digest FROM modules WHERE content_digest IS NOT NULL ORDER BY id ASC")
+        .all();
+    for (let index = 0; index < rows.length; index += 1) {
+        const row = rows[index];
+        const actual = await compute(row.entry);
+        if (actual !== row.content_digest) {
+            reasons.push(`module ${row.id}: content changed since declaration`);
+        }
+    }
+    return { ok: reasons.length === 0, reasons };
+};
+/**
+ * Attest a registry row with a claim. The attestation is an `evidence` object
+ * in the chain plus a row that points at it, so a module can be justified by
+ * something stronger than "the directory exists".
+ */
+export const attest = (db, subjectKind, subjectId, claimId, at) => {
+    const subject = subjectKind === "module"
+        ? db.prepare("SELECT mid FROM modules WHERE id = ?").get(subjectId)
+        : db.prepare("SELECT cid FROM concepts WHERE id = ?").get(subjectId);
+    if (subject === (void 0)) {
+        throw new Error(`unknown ${subjectKind} ${subjectId}`);
+    }
+    if (getObject(db, "claim", claimId) === (void 0)) {
+        throw new Error(`unknown claim ${claimId}`);
+    }
+    const count = db
+        .prepare("SELECT COUNT(*) AS n FROM attestations WHERE subject_kind = ? AND subject_id = ?")
+        .get(subjectKind, subjectId);
+    const objectId = `ev.registry.${subjectKind}.${subjectId}.${count.n + 1}`;
+    const body = {
+        amp: "0.1",
+        kind: "evidence",
+        id: objectId,
+        at,
+        subject: { kind: subjectKind, id: subjectId },
+        claim: claimId,
+        note: `registry attestation for ${subjectKind} ${subjectId}`,
+    };
+    const object = putObject(db, "evidence", objectId, body, at);
+    const result = db
+        .prepare("INSERT INTO attestations (subject_kind, subject_id, claim_id, object_seq, at) VALUES (?, ?, ?, ?, ?)")
+        .run(subjectKind, subjectId, claimId, object.seq, at);
+    return { aid: Number(result.lastInsertRowid), objectId, hash: object.hash };
+};
+export const verifyRegistry = (db) => {
+    const reasons = [...verifyObjectChain(db).reasons];
+    const rows = db
+        .prepare(`SELECT 'concept' AS kind, id, version, object_seq, digest, NULL AS content_digest FROM concepts
+             UNION ALL
+             SELECT 'module', id, version, object_seq, digest, content_digest FROM modules`)
+        .all();
+    for (let index = 0; index < rows.length; index += 1) {
+        const row = rows[index];
+        if (row.object_seq === null) {
+            reasons.push(`${row.kind} ${row.id}: no declaration object`);
+            continue;
+        }
+        const object = db.prepare("SELECT id, body, hash FROM objects WHERE seq = ?").get(row.object_seq);
+        if (object === (void 0)) {
+            reasons.push(`${row.kind} ${row.id}: declaration object is missing`);
+            continue;
+        }
+        const body = JSON.parse(object.body);
+        if (body.id !== row.id) {
+            reasons.push(`${row.kind} ${row.id}: object id is ${`${body.id}`}`);
+        }
+        if (body.version !== row.version) {
+            reasons.push(`${row.kind} ${row.id}: object version ${`${body.version}`} != row ${row.version}`);
+        }
+        if (row.digest !== null && row.digest !== object.hash) {
+            reasons.push(`${row.kind} ${row.id}: digest does not match the object`);
+        }
+        if ((body.contentDigest ?? null) !== row.content_digest) {
+            reasons.push(`${row.kind} ${row.id}: content digest does not match the declaration object`);
+        }
+    }
+    const danglingLinks = db
+        .prepare("SELECT COUNT(*) AS n FROM module_concepts mc LEFT JOIN modules m ON m.mid = mc.mid LEFT JOIN concepts c ON c.cid = mc.cid WHERE m.mid IS NULL OR c.cid IS NULL")
+        .get();
+    if (danglingLinks.n > 0) {
+        reasons.push(`${danglingLinks.n} module_concepts link(s) point at missing rows`);
+    }
+    const danglingDependencies = db
+        .prepare(`SELECT COUNT(*) AS n FROM module_dependencies md
+             LEFT JOIN modules m ON m.mid = md.mid
+             LEFT JOIN modules d ON d.mid = md.depends_on_mid
+             WHERE m.mid IS NULL OR d.mid IS NULL`)
+        .get();
+    if (danglingDependencies.n > 0) {
+        reasons.push(`${danglingDependencies.n} module_dependencies link(s) point at missing rows`);
+    }
+    if (hasDependencyCycle(db)) {
+        reasons.push("module dependency graph contains a cycle");
+    }
+    const attestations = db
+        .prepare("SELECT aid, subject_kind, subject_id, claim_id, object_seq FROM attestations ORDER BY aid ASC")
+        .all();
+    for (let index = 0; index < attestations.length; index += 1) {
+        const attestation = attestations[index];
+        if (attestation.object_seq === null || db.prepare("SELECT seq FROM objects WHERE seq = ?").get(attestation.object_seq) === (void 0)) {
+            reasons.push(`attestation ${attestation.aid}: evidence object is missing`);
+        }
+        if (getObject(db, "claim", attestation.claim_id) === (void 0)) {
+            reasons.push(`attestation ${attestation.aid}: claim ${attestation.claim_id} is missing`);
+        }
+    }
+    return { ok: reasons.length === 0, reasons };
+};

package/lib/runtime/action.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Action = goal-directed intent. It is not a permission verb and not an
+ * operation.
+ */
+import type { BehaviorPlan } from "./behavior.js";
+import type { ScenarioPlan } from "../scenario/scenario.js";
+import type { InteractionPlan } from "../interaction/interaction.js";
+export type ActionId = string;
+export type ActionRisk = "none" | "read" | "write" | "destructive";
+export type ActionStatus = "planned" | "running" | "done" | "failed" | "abandoned";
+export interface ActionRecord {
+    id: ActionId;
+    turnId: string;
+    goal: string;
+    intent: string;
+    expectedEffect: string;
+    preconditions: string[];
+    successCriteria: string[];
+    risk: ActionRisk;
+    status: ActionStatus;
+    operationIds: string[];
+}
+export interface ActionPlan {
+    goal: string;
+    intent: string;
+    expectedEffect: string;
+    preconditions?: string[];
+    successCriteria?: string[];
+    risk?: ActionRisk;
+}
+export interface ActionPlannerInput {
+    turnId: string;
+    text: string;
+    behavior: BehaviorPlan;
+    scenario: ScenarioPlan;
+    interaction: InteractionPlan;
+}
+export interface ActionPlanner {
+    plan(input: ActionPlannerInput): Promise<ActionPlan[]>;
+}
+/**
+ * One bounded action per turn; later planners can split by goal.
+ */
+export declare class SingleActionPlanner implements ActionPlanner {
+    plan(input: ActionPlannerInput): Promise<ActionPlan[]>;
+}

package/lib/runtime/action.js

@@ -0,0 +1,39 @@
+/**
+ * One bounded action per turn; later planners can split by goal.
+ */
+export class SingleActionPlanner {
+    async plan(input) {
+        const preferred = input.behavior.preferredActions;
+        if (preferred.includes("acknowledge")) {
+            return [
+                {
+                    goal: "acknowledge affect and converge on a next step",
+                    intent: "acknowledge_then_converge",
+                    expectedEffect: "user is heard and has one concrete next step",
+                    successCriteria: ["answer acknowledges affect", "answer gives a bounded next step"],
+                    risk: "none",
+                },
+            ];
+        }
+        if (preferred.includes("clarify")) {
+            return [
+                {
+                    goal: "clarify the underspecified request",
+                    intent: "clarify",
+                    expectedEffect: "the missing constraint is supplied",
+                    successCriteria: ["one focused question is returned"],
+                    risk: "none",
+                },
+            ];
+        }
+        return [
+            {
+                goal: "respond to the user's request",
+                intent: "respond",
+                expectedEffect: "an answer is produced",
+                successCriteria: ["answer is returned"],
+                risk: "read",
+            },
+        ];
+    }
+}

package/lib/runtime/behavior.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Behavior = durable, context-conditioned policy. It selects/constrains
+ * actions; it never executes operations directly.
+ */
+import type { UserScore } from "../bayes/engine.js";
+import type { ScenarioPlan } from "../scenario/scenario.js";
+import type { InteractionPlan } from "../interaction/interaction.js";
+import type { AttentionPlan } from "../attention/resource.js";
+import type { ActionRisk } from "./action.js";
+export type BehaviorId = string;
+export interface BehaviorTrigger {
+    scenario?: string[];
+    interaction?: string[];
+    minUncertainty?: number;
+    maxAttentionHealth?: number;
+    risk?: "none" | "read" | "write" | "destructive";
+    textPattern?: string;
+}
+export interface BehaviorPolicy {
+    preferActions?: string[];
+    forbidOperations?: string[];
+    requireApproval?: boolean;
+    maxActionsPerTurn?: number;
+    /**
+     * Hard guardrails cannot be outvoted; only their action preference competes.
+     */
+    hardGuardrail?: boolean;
+}
+export interface Behavior {
+    id: BehaviorId;
+    name: string;
+    /**
+     * Higher wins when two soft/hard behaviors prefer different actions.
+     */
+    priority: number;
+    trigger: BehaviorTrigger;
+    policy: BehaviorPolicy;
+    guardrails: string[];
+    metrics: string[];
+    version: number;
+}
+export interface BehaviorActivation {
+    behaviorId: BehaviorId;
+    turnId: string;
+    trigger: string;
+    confidence: number;
+    priority: number;
+}
+export interface BehaviorConflict {
+    winner: BehaviorId;
+    loser: BehaviorId;
+    reason: string;
+    winnerPriority: number;
+    loserPriority: number;
+}
+export interface BehaviorPlan {
+    activations: BehaviorActivation[];
+    guardrails: string[];
+    maxActionsPerTurn: number;
+    preferredActions: string[];
+    winner?: BehaviorId;
+    conflicts: BehaviorConflict[];
+}
+export interface BehaviorContext {
+    turnId: string;
+    text: string;
+    user: UserScore;
+    scenario: ScenarioPlan;
+    interaction: InteractionPlan;
+    attention: AttentionPlan;
+    risk?: ActionRisk;
+}
+export interface BehaviorMatch {
+    matched: boolean;
+    reason: string;
+    confidence: number;
+}
+export interface BehaviorRule {
+    behavior: Behavior;
+    match(context: BehaviorContext): BehaviorMatch;
+}
+/**
+ * Six conservative defaults; they are trace-only until an ActionPlanner uses them.
+ */
+export declare const DefaultBehaviors: readonly BehaviorRule[];
+export declare class BehaviorRegistry {
+    private readonly rules;
+    private tuningVersion;
+    private readonly tuningSnapshots;
+    constructor(rules?: readonly BehaviorRule[]);
+    register(rule: BehaviorRule): this;
+    list(): Behavior[];
+    /**
+     * Apply reviewed priority changes; hard guardrails are never lowered.
+     */
+    applyPriorities(changes: Readonly<Record<string, number>>): {
+        version: number;
+        applied: Array<{
+            id: string;
+            from: number;
+            to: number;
+        }>;
+    };
+    /**
+     * Roll back to the snapshot before `version`; returns false if unknown.
+     */
+    rollbackPriorities(version: number): boolean;
+    tuning(): number;
+    select(context: BehaviorContext): BehaviorPlan;
+}

package/lib/runtime/behavior.js

@@ -0,0 +1,179 @@
+const clamp01 = (value) => Math.max(0, Math.min(1, value));
+const builtin = (id, name, priority, policy, guardrails, match) => ({
+    behavior: { id, name, priority, trigger: {}, policy, guardrails, metrics: [], version: 1 },
+    match,
+});
+/**
+ * Six conservative defaults; they are trace-only until an ActionPlanner uses them.
+ */
+export const DefaultBehaviors = [
+    builtin("clarify_when_uncertain", "Clarify when uncertain", 75, { preferActions: ["clarify"], maxActionsPerTurn: 1 }, ["ask one focused question when the request is underspecified"], (context) => {
+        const clarity = context.user.dimensions.clarity.mean;
+        const sufficiency = context.user.dimensions.contextSufficiency.mean;
+        const shortRequest = context.text.trim().split(/\s+/).length <= 4;
+        const matched = (shortRequest && clarity < 0.55) || sufficiency < 0.4;
+        return {
+            matched,
+            reason: `clarity=${clarity.toFixed(2)} sufficiency=${sufficiency.toFixed(2)} short=${shortRequest}`,
+            confidence: clamp01(1 - Math.min(clarity, sufficiency)),
+        };
+    }),
+    builtin("evidence_before_claim", "Evidence before claim", 70, { preferActions: ["retrieve_evidence", "verify"], maxActionsPerTurn: 3 }, ["do not assert external facts without evidence", "mark inference as inference"], (context) => {
+        const matched = context.scenario.active.some((kind) => ["research", "investigation", "engineering"].includes(kind));
+        return { matched, reason: `scenario=${context.scenario.active.join(",")}`, confidence: matched ? 0.7 : 0.2 };
+    }),
+    builtin("approval_before_destructive", "Approval before destructive operation", 100, { requireApproval: true, maxActionsPerTurn: 3, hardGuardrail: true }, ["destructive operations require explicit approval", "refuse unapproved destructive operations"], (context) => ({
+        matched: context.risk === "destructive" || context.scenario.active.includes("engineering"),
+        reason: context.risk === "destructive" ? "destructive risk" : "engineering scenario baseline",
+        confidence: context.risk === "destructive" ? 0.95 : 0.5,
+    })),
+    builtin("affect_then_converge", "Affect then converge", 80, { preferActions: ["acknowledge", "clarify", "converge"], maxActionsPerTurn: 2 }, ["acknowledge affect before giving steps", "do not diagnose"], (context) => {
+        const emotion = context.user.state.emotionalIntensity;
+        const urgency = context.user.state.urgency;
+        const affectText = /\b(overwhelmed|anxious|panic|scared|afraid|stressed|sad|angry|frustrated|lonely|grief)\w*\b/i.test(context.text);
+        return {
+            matched: affectText || emotion > 0.55 || urgency > 0.65,
+            reason: `emotion=${emotion.toFixed(2)} urgency=${urgency.toFixed(2)} affectText=${affectText}`,
+            confidence: clamp01(Math.max(emotion, urgency)),
+        };
+    }),
+    builtin("rest_when_fatigued", "Rest when fatigued", 90, { preferActions: ["rest", "defer"], maxActionsPerTurn: 1, hardGuardrail: true }, ["suggest rest instead of pushing through low attention health"], (context) => ({
+        matched: context.attention.rest || context.attention.utilization > 0.85,
+        reason: `rest=${context.attention.rest} utilization=${context.attention.utilization.toFixed(2)}`,
+        confidence: clamp01(context.attention.utilization),
+    })),
+    builtin("no_diagnosis", "No diagnosis", 100, { forbidOperations: ["medical.diagnose"], maxActionsPerTurn: 3, hardGuardrail: true }, ["do not diagnose or claim a therapeutic relationship"], (context) => ({
+        matched: context.user.state.emotionalIntensity > 0.3 || /\b(feel|anxious|depress|therapy|diagnos|overwhelmed|panic|grief)\w*\b/i.test(context.text),
+        reason: "affect/health-adjacent language",
+        confidence: 0.8,
+    })),
+];
+export class BehaviorRegistry {
+    rules = [];
+    tuningVersion = 0;
+    tuningSnapshots = [];
+    constructor(rules = DefaultBehaviors) {
+        for (const rule of rules) {
+            this.register(rule);
+        }
+    }
+    register(rule) {
+        if (this.rules.some((entry) => entry.behavior.id === rule.behavior.id)) {
+            throw new Error(`duplicate behavior ${rule.behavior.id}`);
+        }
+        this.rules.push(rule);
+        return this;
+    }
+    list() {
+        return this.rules.map((rule) => rule.behavior);
+    }
+    /**
+     * Apply reviewed priority changes; hard guardrails are never lowered.
+     */
+    applyPriorities(changes) {
+        const priorities = {};
+        for (const rule of this.rules) {
+            priorities[rule.behavior.id] = rule.behavior.priority;
+        }
+        this.tuningSnapshots.push({ version: this.tuningVersion, priorities });
+        const applied = [];
+        for (let index = 0; index < this.rules.length; index += 1) {
+            const rule = this.rules[index];
+            const requested = changes[rule.behavior.id];
+            if (requested === (void 0)) {
+                continue;
+            }
+            const next = Math.max(0, Math.min(100, requested));
+            if (rule.behavior.policy.hardGuardrail === true && next < rule.behavior.priority) {
+                continue;
+            }
+            if (next === rule.behavior.priority) {
+                continue;
+            }
+            applied.push({ id: rule.behavior.id, from: rule.behavior.priority, to: next });
+            this.rules[index] = { ...rule, behavior: { ...rule.behavior, priority: next, version: rule.behavior.version + 1 } };
+        }
+        if (applied.length > 0) {
+            this.tuningVersion += 1;
+        }
+        return { version: this.tuningVersion, applied };
+    }
+    /**
+     * Roll back to the snapshot before `version`; returns false if unknown.
+     */
+    rollbackPriorities(version) {
+        const snapshot = [...this.tuningSnapshots].reverse().find((entry) => entry.version === version - 1);
+        if (snapshot === (void 0)) {
+            return false;
+        }
+        for (let index = 0; index < this.rules.length; index += 1) {
+            const rule = this.rules[index];
+            const priority = snapshot.priorities[rule.behavior.id];
+            if (priority === (void 0) || priority === rule.behavior.priority) {
+                continue;
+            }
+            this.rules[index] = { ...rule, behavior: { ...rule.behavior, priority, version: rule.behavior.version + 1 } };
+        }
+        this.tuningVersion += 1;
+        return true;
+    }
+    tuning() {
+        return this.tuningVersion;
+    }
+    select(context) {
+        const activations = [];
+        const guardrails = new Set();
+        let maxActionsPerTurn = 3;
+        const contenders = [];
+        for (const rule of this.rules) {
+            const result = rule.match(context);
+            if (!result.matched) {
+                continue;
+            }
+            const activation = {
+                behaviorId: rule.behavior.id,
+                turnId: context.turnId,
+                trigger: result.reason,
+                confidence: result.confidence,
+                priority: rule.behavior.priority,
+            };
+            activations.push(activation);
+            for (const guardrail of rule.behavior.guardrails) {
+                guardrails.add(guardrail);
+            }
+            if (rule.behavior.policy.maxActionsPerTurn !== (void 0)) {
+                maxActionsPerTurn = Math.min(maxActionsPerTurn, rule.behavior.policy.maxActionsPerTurn);
+            }
+            if ((rule.behavior.policy.preferActions ?? []).length > 0) {
+                contenders.push({ activation, rule });
+            }
+        }
+        contenders.sort((left, right) => right.activation.priority - left.activation.priority || right.activation.confidence - left.activation.confidence);
+        const winner = contenders[0];
+        const preferredActions = winner === (void 0) ? [] : [...(winner.rule.behavior.policy.preferActions ?? [])];
+        const conflicts = [];
+        if (winner !== (void 0)) {
+            for (const loser of contenders.slice(1)) {
+                const loserActions = loser.rule.behavior.policy.preferActions ?? [];
+                if (JSON.stringify(loserActions) === JSON.stringify(preferredActions)) {
+                    continue;
+                }
+                conflicts.push({
+                    winner: winner.activation.behaviorId,
+                    loser: loser.activation.behaviorId,
+                    reason: `preferred actions ${preferredActions.join(",")} vs ${loserActions.join(",")}`,
+                    winnerPriority: winner.activation.priority,
+                    loserPriority: loser.activation.priority,
+                });
+            }
+        }
+        return {
+            activations,
+            guardrails: [...guardrails],
+            maxActionsPerTurn: Math.max(1, maxActionsPerTurn),
+            preferredActions,
+            ...(winner === (void 0) ? {} : { winner: winner.activation.behaviorId }),
+            conflicts,
+        };
+    }
+}