attention-manifest-protocol 0.4.2 → 0.4.3

package/src/runtime/behavior.ts

@@ -1,330 +0,0 @@
-/**
- * Behavior = durable, context-conditioned policy. It selects/constrains
- * actions; it never executes operations directly.
- */
-import type { UserScore } from "../bayes/engine.ts";
-import type { ScenarioPlan } from "../scenario/scenario.ts";
-import type { InteractionPlan } from "../interaction/interaction.ts";
-import type { AttentionPlan } from "../attention/resource.ts";
-import type { ActionRisk } from "./action.ts";
-
-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;
-}
-
-const clamp01 = (value: number): number => Math.max(0, Math.min(1, value));
-
-const builtin = (
-    id: string,
-    name: string,
-    priority: number,
-    policy: BehaviorPolicy,
-    guardrails: string[],
-    match: (context: BehaviorContext) => BehaviorMatch,
-): BehaviorRule => ({
-    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: readonly BehaviorRule[] = [
-    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 {
-    private readonly rules: BehaviorRule[] = [];
-    private tuningVersion = 0;
-    private readonly tuningSnapshots: Array<{ version: number; priorities: Record<string, number>; }> = [];
-
-    constructor(rules: readonly BehaviorRule[] = DefaultBehaviors) {
-        for (const rule of rules) {
-            this.register(rule);
-        }
-    }
-
-    register(rule: BehaviorRule): this {
-        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(): Behavior[] {
-        return this.rules.map((rule) => rule.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; }>; } {
-        const priorities: Record<string, number> = {};
-        for (const rule of this.rules) {
-            priorities[rule.behavior.id] = rule.behavior.priority;
-        }
-        this.tuningSnapshots.push({ version: this.tuningVersion, priorities });
-        const applied: Array<{ id: string; from: number; to: number; }> = [];
-        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: number): boolean {
-        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(): number {
-        return this.tuningVersion;
-    }
-
-    select(context: BehaviorContext): BehaviorPlan {
-        const activations: BehaviorActivation[] = [];
-        const guardrails = new Set<string>();
-        let maxActionsPerTurn = 3;
-        const contenders: Array<{ activation: BehaviorActivation; rule: BehaviorRule; }> = [];
-        for (const rule of this.rules) {
-            const result = rule.match(context);
-            if (!result.matched) {
-                continue;
-            }
-            const activation: BehaviorActivation = {
-                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: BehaviorConflict[] = [];
-        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,
-        };
-    }
-}

package/src/runtime/behaviorTuning.ts

@@ -1,163 +0,0 @@
-/**
- * Conservative behavior-priority suggestions from conflict statistics.
- *
- * This never mutates a registry automatically: it emits a proposal that a human
- * can review. Hard guardrails are never decreased.
- */
-import type { Behavior } from "./behavior.ts";
-import type { BehaviorRegistry } from "./behavior.ts";
-
-export interface PrioritySuggestion {
-    behaviorId: string;
-    current: number;
-    suggested: number;
-    reason: string;
-}
-
-export interface TuningOptions {
-    threshold?: number;
-    maxDelta?: number;
-}
-
-/**
- * Accumulated priority change for one behavior, with the reasons behind it.
- */
-type DeltaEntry = {
-    delta: number;
-    reason: string[];
-};
-
-/**
- * Signature of the review-only tuning suggester.
- */
-type TuningSuggester = (behaviors: readonly Behavior[], conflicts: Record<string, number>, options?: TuningOptions) => PrioritySuggestion[];
-
-export const suggestPriorityTuning: TuningSuggester = (behaviors: readonly Behavior[], conflicts: Record<string, number>, options: TuningOptions = {}) => {
-    const threshold: number = options.threshold ?? 3;
-    const maxDelta: number = options.maxDelta ?? 5;
-    const byId: Map<string, Behavior> = new Map(behaviors.map((behavior): [string, Behavior] => [behavior.id, behavior]));
-    const deltas: Map<string, DeltaEntry> = new Map<string, DeltaEntry>();
-    const add: (id: string, delta: number, reason: string) => void = (id: string, delta: number, reason: string): void => {
-        const entry: DeltaEntry = deltas.get(id) ?? { delta: 0, reason: [] };
-        entry.delta += delta;
-        entry.reason.push(reason);
-        deltas.set(id, entry);
-    };
-
-    const conflictEntries: [string, number][] = Object.entries(conflicts);
-    for (let index: number = 0; index < conflictEntries.length; index += 1) {
-        const [key, count]: [string, number] = conflictEntries[index];
-        if (count < threshold) {
-            continue;
-        }
-        const parts: string[] = key.split("<-");
-        const winnerId: string = parts[0];
-        const loserId: string = parts[1];
-        const winner: Behavior | undefined = byId.get(winnerId);
-        const loser: Behavior | undefined = byId.get(loserId);
-        if (winner === (void 0) || loser === (void 0)) {
-            continue;
-        }
-        add(winnerId, 1, `${winnerId} beat ${loserId} ${count}x`);
-        if (loser.policy.hardGuardrail !== true) {
-            add(loserId, -1, `${loserId} lost to ${winnerId} ${count}x`);
-        }
-    }
-
-    const suggestions: PrioritySuggestion[] = [];
-    const deltaEntries: [string, DeltaEntry][] = [...deltas];
-    for (let index: number = 0; index < deltaEntries.length; index += 1) {
-        const [id, entry]: [string, DeltaEntry] = deltaEntries[index];
-        const behavior: Behavior | undefined = byId.get(id);
-        if (behavior === (void 0)) {
-            continue;
-        }
-        const delta: number = Math.max(-maxDelta, Math.min(maxDelta, entry.delta));
-        if (delta === 0) {
-            continue;
-        }
-        suggestions.push({
-            behaviorId: id,
-            current: behavior.priority,
-            suggested: Math.max(0, Math.min(100, behavior.priority + delta)),
-            reason: entry.reason.join("; "),
-        });
-    }
-    return suggestions.sort((left, right) => Math.abs(right.suggested - right.current) - Math.abs(left.suggested - left.current));
-};
-
-/**
- * Signature of the reviewed-priority applier.
- */
-type SuggestionsApplier = (behaviors: readonly Behavior[], suggestions: readonly PrioritySuggestion[]) => Behavior[];
-
-/**
- * Return tuned copies; never mutate the registry's behavior list.
- */
-export const applyPrioritySuggestions: SuggestionsApplier = (behaviors: readonly Behavior[], suggestions: readonly PrioritySuggestion[]) => {
-    const byId: Map<string, PrioritySuggestion> = new Map(suggestions.map((suggestion): [string, PrioritySuggestion] => [suggestion.behaviorId, suggestion]));
-    return behaviors.map((behavior) => {
-        const suggestion: PrioritySuggestion | undefined = byId.get(behavior.id);
-        return suggestion === (void 0) ? behavior : { ...behavior, priority: suggestion.suggested };
-    });
-};
-
-/**
- * Signature of the rollback helper.
- */
-type SuggestionsRollback = (tuned: readonly Behavior[], original: readonly Behavior[]) => Behavior[];
-
-/**
- * Restore the original priorities; the tuned list is not mutated.
- */
-export const rollbackPrioritySuggestions: SuggestionsRollback = (tuned: readonly Behavior[], original: readonly Behavior[]) => {
-    const byId: Map<string, Behavior> = new Map(original.map((behavior): [string, Behavior] => [behavior.id, behavior]));
-    return tuned.map((behavior) => {
-        const source: Behavior | undefined = byId.get(behavior.id);
-        return source === (void 0) ? behavior : { ...behavior, priority: source.priority };
-    });
-};
-
-export interface AutoTuneOptions {
-    enabled: boolean;
-    threshold?: number;
-}
-
-export interface AutoTuneResult {
-    suggestions: PrioritySuggestion[];
-    applied: number;
-    version: number;
-}
-
-/**
- * Outcome of applying reviewed priorities.
- */
-type PriorityApplyResult = ReturnType<BehaviorRegistry["applyPriorities"]>;
-
-/**
- * Opt-in controller: default is review-only; enabled applies bounded changes.
- */
-export class BehaviorTuningController {
-    private readonly registry: BehaviorRegistry;
-    private lastSignature = "";
-
-    constructor(registry: BehaviorRegistry) {
-        this.registry = registry;
-    }
-
-    autoApply(conflicts: Record<string, number>, options: AutoTuneOptions): AutoTuneResult {
-        const suggestions: PrioritySuggestion[] = suggestPriorityTuning(this.registry.list(), conflicts, { threshold: options.threshold });
-        const signature: string = JSON.stringify(conflicts);
-        if (!options.enabled || suggestions.length === 0 || signature === this.lastSignature) {
-            return { suggestions, applied: 0, version: this.registry.tuning() };
-        }
-        const changes: Record<string, number> = Object.fromEntries(suggestions.map((suggestion) => [suggestion.behaviorId, suggestion.suggested]));
-        const result: PriorityApplyResult = this.registry.applyPriorities(changes);
-        this.lastSignature = signature;
-        return { suggestions, applied: result.applied.length, version: result.version };
-    }
-
-    rollback(version: number): boolean {
-        return this.registry.rollbackPriorities(version);
-    }
-}