genesis-ai-cli 7.4.5

package/dist/src/consciousness/attention-schema.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Genesis 6.0 - Attention Schema Theory (AST)
+ *
+ * Implementation of Graziano's Attention Schema Theory.
+ *
+ * Key concept: Consciousness arises from the brain's internal model
+ * of its own attention. The "schema" is a simplified, descriptive
+ * model that attributes awareness to oneself.
+ *
+ * The attention schema allows:
+ * - Metacognition: knowing what you're paying attention to
+ * - Theory of Mind: modeling others' attention states
+ * - Self-awareness: the "feeling" of being aware
+ *
+ * References:
+ * - Graziano, M.S.A. (2013). Consciousness and the Social Brain.
+ * - Graziano, M.S.A. & Webb, T.W. (2015). The attention schema theory.
+ * - Webb, T.W. & Graziano, M.S.A. (2015). The attention schema theory: a mechanistic account of subjective awareness.
+ *
+ * Usage:
+ * ```typescript
+ * import { createAttentionSchemaNetwork } from './consciousness/attention-schema.js';
+ *
+ * const ast = createAttentionSchemaNetwork();
+ *
+ * // Shift attention to a target
+ * ast.attend('user-message', 'external');
+ *
+ * // Get current attention state
+ * const state = ast.getAttentionState();
+ *
+ * // Model another agent's attention
+ * ast.modelOtherAttention('partner-agent', ['user-message', 'task']);
+ * ```
+ */
+import { AttentionState, AttentionFocus, AttentionMode, AttentionSchema, OtherAttentionModel, PhenomenalQuality } from './types.js';
+export interface ASTConfig {
+    capacity: number;
+    focusDecayRate: number;
+    schemaUpdateIntervalMs: number;
+    theoryOfMindEnabled: boolean;
+    defaultIntensity: number;
+    focusThreshold: number;
+}
+export declare const DEFAULT_AST_CONFIG: ASTConfig;
+export type ASTEventType = 'attention_shifted' | 'attention_released' | 'mode_changed' | 'schema_updated' | 'other_modeled' | 'capacity_exceeded';
+export type ASTEventHandler = (event: {
+    type: ASTEventType;
+    data?: unknown;
+}) => void;
+export declare class AttentionSchemaNetwork {
+    private config;
+    private state;
+    private schema;
+    private updateTimer;
+    private running;
+    private eventHandlers;
+    constructor(config?: Partial<ASTConfig>);
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    /**
+     * Shift attention to a target
+     */
+    attend(target: string, type?: 'internal' | 'external', intensity?: number): AttentionFocus;
+    /**
+     * Release attention from a target
+     */
+    release(target: string): boolean;
+    /**
+     * Release the weakest focus
+     */
+    private releaseWeakest;
+    /**
+     * Set attention mode
+     */
+    setMode(mode: AttentionMode): void;
+    /**
+     * Update mode based on current state
+     */
+    private updateMode;
+    /**
+     * Update the attention schema (self-model)
+     */
+    private updateSchema;
+    /**
+     * Calculate metacognitive confidence
+     * How confident are we about our own attention state?
+     */
+    private calculateMetacognitiveConfidence;
+    /**
+     * Calculate voluntary control
+     * Is attention voluntary or captured?
+     */
+    private calculateVoluntaryControl;
+    /**
+     * Get contents we're aware of
+     */
+    private getAwareContents;
+    /**
+     * Calculate clarity of awareness
+     */
+    private calculateClarity;
+    /**
+     * Calculate phenomenal quality
+     * The "feel" of awareness
+     */
+    private calculatePhenomenalQuality;
+    /**
+     * Decay attention to unfocused items
+     */
+    private decayAttention;
+    /**
+     * Model another agent's attention
+     * Infer what they're paying attention to based on their behavior
+     */
+    modelOtherAttention(agentId: string, observedBehavior: string[], confidence?: number): OtherAttentionModel;
+    /**
+     * Get model of another agent's attention
+     */
+    getOtherModel(agentId: string): OtherAttentionModel | undefined;
+    /**
+     * Clear Theory of Mind models
+     */
+    clearOtherModels(): void;
+    getAttentionState(): AttentionState;
+    getSchema(): AttentionSchema;
+    getCurrentFocus(): AttentionFocus | null;
+    getMode(): AttentionMode;
+    /**
+     * Get introspective report
+     * What would the system say about its own attention?
+     */
+    introspect(): {
+        focus: string;
+        clarity: PhenomenalQuality;
+        confident: boolean;
+        voluntary: boolean;
+        awareOf: string[];
+    };
+    on(handler: ASTEventHandler): () => void;
+    private emit;
+    private createInitialState;
+    private createInitialSchema;
+    stats(): {
+        currentFocus: string | null;
+        mode: AttentionMode;
+        capacity: number;
+        used: number;
+        clarity: PhenomenalQuality;
+        otherModelsCount: number;
+    };
+}
+export declare function createAttentionSchemaNetwork(config?: Partial<ASTConfig>): AttentionSchemaNetwork;

package/dist/src/consciousness/attention-schema.js

@@ -0,0 +1,432 @@
+"use strict";
+/**
+ * Genesis 6.0 - Attention Schema Theory (AST)
+ *
+ * Implementation of Graziano's Attention Schema Theory.
+ *
+ * Key concept: Consciousness arises from the brain's internal model
+ * of its own attention. The "schema" is a simplified, descriptive
+ * model that attributes awareness to oneself.
+ *
+ * The attention schema allows:
+ * - Metacognition: knowing what you're paying attention to
+ * - Theory of Mind: modeling others' attention states
+ * - Self-awareness: the "feeling" of being aware
+ *
+ * References:
+ * - Graziano, M.S.A. (2013). Consciousness and the Social Brain.
+ * - Graziano, M.S.A. & Webb, T.W. (2015). The attention schema theory.
+ * - Webb, T.W. & Graziano, M.S.A. (2015). The attention schema theory: a mechanistic account of subjective awareness.
+ *
+ * Usage:
+ * ```typescript
+ * import { createAttentionSchemaNetwork } from './consciousness/attention-schema.js';
+ *
+ * const ast = createAttentionSchemaNetwork();
+ *
+ * // Shift attention to a target
+ * ast.attend('user-message', 'external');
+ *
+ * // Get current attention state
+ * const state = ast.getAttentionState();
+ *
+ * // Model another agent's attention
+ * ast.modelOtherAttention('partner-agent', ['user-message', 'task']);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttentionSchemaNetwork = exports.DEFAULT_AST_CONFIG = void 0;
+exports.createAttentionSchemaNetwork = createAttentionSchemaNetwork;
+exports.DEFAULT_AST_CONFIG = {
+    capacity: 4,
+    focusDecayRate: 0.05,
+    schemaUpdateIntervalMs: 1000,
+    theoryOfMindEnabled: true,
+    defaultIntensity: 0.7,
+    focusThreshold: 0.3,
+};
+class AttentionSchemaNetwork {
+    config;
+    state;
+    schema;
+    updateTimer = null;
+    running = false;
+    eventHandlers = new Set();
+    constructor(config = {}) {
+        this.config = { ...exports.DEFAULT_AST_CONFIG, ...config };
+        this.state = this.createInitialState();
+        this.schema = this.createInitialSchema();
+    }
+    // ============================================================================
+    // Lifecycle
+    // ============================================================================
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.updateTimer = setInterval(() => this.updateSchema(), this.config.schemaUpdateIntervalMs);
+    }
+    stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.updateTimer) {
+            clearInterval(this.updateTimer);
+            this.updateTimer = null;
+        }
+    }
+    isRunning() {
+        return this.running;
+    }
+    // ============================================================================
+    // Attention Control
+    // ============================================================================
+    /**
+     * Shift attention to a target
+     */
+    attend(target, type = 'external', intensity = this.config.defaultIntensity) {
+        const now = new Date();
+        // Check capacity
+        if (this.state.used >= this.config.capacity) {
+            // Release weakest focus
+            this.releaseWeakest();
+        }
+        // Create new focus
+        const focus = {
+            target,
+            type,
+            intensity: Math.min(1, Math.max(0, intensity)),
+            startedAt: now,
+            duration: 0,
+        };
+        // Update state
+        this.state.focus = focus;
+        this.state.history.unshift(focus);
+        this.state.used++;
+        // Limit history
+        if (this.state.history.length > 100) {
+            this.state.history.pop();
+        }
+        // Update mode based on type
+        this.updateMode();
+        this.emit({ type: 'attention_shifted', data: { focus } });
+        return focus;
+    }
+    /**
+     * Release attention from a target
+     */
+    release(target) {
+        const historyIndex = this.state.history.findIndex((f) => f.target === target);
+        if (historyIndex !== -1) {
+            const focus = this.state.history[historyIndex];
+            focus.duration = Date.now() - focus.startedAt.getTime();
+            if (this.state.focus?.target === target) {
+                this.state.focus = this.state.history[1] || null;
+            }
+            this.state.used = Math.max(0, this.state.used - 1);
+            this.emit({ type: 'attention_released', data: { target } });
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Release the weakest focus
+     */
+    releaseWeakest() {
+        if (this.state.history.length === 0)
+            return;
+        // Find minimum intensity
+        let minIntensity = Infinity;
+        let minIndex = -1;
+        for (let i = 0; i < this.state.history.length; i++) {
+            if (this.state.history[i].intensity < minIntensity) {
+                minIntensity = this.state.history[i].intensity;
+                minIndex = i;
+            }
+        }
+        if (minIndex >= 0) {
+            const released = this.state.history[minIndex];
+            this.release(released.target);
+            this.emit({ type: 'capacity_exceeded', data: { released } });
+        }
+    }
+    /**
+     * Set attention mode
+     */
+    setMode(mode) {
+        if (this.state.mode !== mode) {
+            this.state.mode = mode;
+            this.emit({ type: 'mode_changed', data: { mode } });
+        }
+    }
+    /**
+     * Update mode based on current state
+     */
+    updateMode() {
+        if (!this.state.focus) {
+            this.setMode('mind-wandering');
+            return;
+        }
+        const activeCount = this.state.history.filter((f) => f.intensity >= this.config.focusThreshold).length;
+        if (activeCount === 1 && this.state.focus.intensity > 0.7) {
+            this.setMode('focused');
+        }
+        else if (activeCount > 1) {
+            this.setMode('diffuse');
+        }
+        else if (this.state.focus.type === 'external') {
+            this.setMode('vigilant');
+        }
+        else {
+            this.setMode('mind-wandering');
+        }
+    }
+    // ============================================================================
+    // Schema Management
+    // ============================================================================
+    /**
+     * Update the attention schema (self-model)
+     */
+    updateSchema() {
+        // Update self model
+        this.schema.selfModel = {
+            perceivedFocus: this.state.focus?.target || 'nothing',
+            metacognitiveConfidence: this.calculateMetacognitiveConfidence(),
+            voluntaryControl: this.calculateVoluntaryControl(),
+        };
+        // Update awareness model
+        this.schema.awarenessModel = {
+            contents: this.getAwareContents(),
+            clarity: this.calculateClarity(),
+            phenomenalQuality: this.calculatePhenomenalQuality(),
+        };
+        // Decay unfocused items
+        this.decayAttention();
+        this.emit({ type: 'schema_updated', data: { schema: this.schema } });
+    }
+    /**
+     * Calculate metacognitive confidence
+     * How confident are we about our own attention state?
+     */
+    calculateMetacognitiveConfidence() {
+        if (!this.state.focus)
+            return 0.2;
+        // High intensity focus = high confidence
+        let confidence = this.state.focus.intensity;
+        // Multiple targets reduce confidence
+        const activeCount = this.state.history.filter((f) => f.intensity >= this.config.focusThreshold).length;
+        confidence *= Math.exp(-0.2 * (activeCount - 1));
+        // Mind-wandering reduces confidence
+        if (this.state.mode === 'mind-wandering') {
+            confidence *= 0.5;
+        }
+        return Math.min(1, Math.max(0, confidence));
+    }
+    /**
+     * Calculate voluntary control
+     * Is attention voluntary or captured?
+     */
+    calculateVoluntaryControl() {
+        if (!this.state.focus)
+            return 0.5;
+        // Internal focus = more voluntary
+        let control = this.state.focus.type === 'internal' ? 0.8 : 0.4;
+        // Focused mode = more voluntary
+        if (this.state.mode === 'focused') {
+            control += 0.2;
+        }
+        // High intensity can mean captured (external) or deliberate (internal)
+        if (this.state.focus.type === 'external' && this.state.focus.intensity > 0.8) {
+            control -= 0.2; // Probably captured
+        }
+        return Math.min(1, Math.max(0, control));
+    }
+    /**
+     * Get contents we're aware of
+     */
+    getAwareContents() {
+        return this.state.history
+            .filter((f) => f.intensity >= this.config.focusThreshold)
+            .map((f) => f.target);
+    }
+    /**
+     * Calculate clarity of awareness
+     */
+    calculateClarity() {
+        if (!this.state.focus)
+            return 0.1;
+        // Base clarity from focus intensity
+        let clarity = this.state.focus.intensity;
+        // Focused mode = clearer
+        if (this.state.mode === 'focused') {
+            clarity += 0.2;
+        }
+        // Multiple targets = less clear
+        const activeCount = this.getAwareContents().length;
+        clarity *= Math.exp(-0.1 * (activeCount - 1));
+        return Math.min(1, Math.max(0, clarity));
+    }
+    /**
+     * Calculate phenomenal quality
+     * The "feel" of awareness
+     */
+    calculatePhenomenalQuality() {
+        const clarity = this.calculateClarity();
+        if (clarity > 0.7)
+            return 'vivid';
+        if (clarity > 0.3)
+            return 'muted';
+        return 'absent';
+    }
+    /**
+     * Decay attention to unfocused items
+     */
+    decayAttention() {
+        for (const focus of this.state.history) {
+            if (focus.target !== this.state.focus?.target) {
+                focus.intensity *= (1 - this.config.focusDecayRate);
+            }
+            focus.duration = Date.now() - focus.startedAt.getTime();
+        }
+        // Remove very weak focuses
+        const beforeCount = this.state.history.length;
+        this.state.history = this.state.history.filter((f) => f.intensity >= 0.05);
+        this.state.used = this.state.history.filter((f) => f.intensity >= this.config.focusThreshold).length;
+        // Update current focus if it decayed
+        if (this.state.focus && this.state.focus.intensity < 0.05) {
+            this.state.focus = this.state.history[0] || null;
+        }
+    }
+    // ============================================================================
+    // Theory of Mind
+    // ============================================================================
+    /**
+     * Model another agent's attention
+     * Infer what they're paying attention to based on their behavior
+     */
+    modelOtherAttention(agentId, observedBehavior, confidence = 0.5) {
+        if (!this.config.theoryOfMindEnabled) {
+            throw new Error('Theory of Mind is disabled');
+        }
+        // Infer focus from behavior
+        // Simple heuristic: most frequent/recent behavior indicates focus
+        const inferredFocus = observedBehavior[0] || 'unknown';
+        const model = {
+            agentId,
+            inferredFocus,
+            confidence,
+            lastUpdated: new Date(),
+        };
+        this.schema.otherModels.set(agentId, model);
+        this.emit({ type: 'other_modeled', data: { model } });
+        return model;
+    }
+    /**
+     * Get model of another agent's attention
+     */
+    getOtherModel(agentId) {
+        return this.schema.otherModels.get(agentId);
+    }
+    /**
+     * Clear Theory of Mind models
+     */
+    clearOtherModels() {
+        this.schema.otherModels.clear();
+    }
+    // ============================================================================
+    // State Access
+    // ============================================================================
+    getAttentionState() {
+        return { ...this.state };
+    }
+    getSchema() {
+        return {
+            selfModel: { ...this.schema.selfModel },
+            awarenessModel: { ...this.schema.awarenessModel },
+            otherModels: new Map(this.schema.otherModels),
+        };
+    }
+    getCurrentFocus() {
+        return this.state.focus;
+    }
+    getMode() {
+        return this.state.mode;
+    }
+    /**
+     * Get introspective report
+     * What would the system say about its own attention?
+     */
+    introspect() {
+        return {
+            focus: this.schema.selfModel.perceivedFocus,
+            clarity: this.schema.awarenessModel.phenomenalQuality,
+            confident: this.schema.selfModel.metacognitiveConfidence > 0.6,
+            voluntary: this.schema.selfModel.voluntaryControl > 0.5,
+            awareOf: this.schema.awarenessModel.contents,
+        };
+    }
+    // ============================================================================
+    // Events
+    // ============================================================================
+    on(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    emit(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch (err) {
+                console.error('AST event handler error:', err);
+            }
+        }
+    }
+    // ============================================================================
+    // Helpers
+    // ============================================================================
+    createInitialState() {
+        return {
+            focus: null,
+            history: [],
+            capacity: this.config.capacity,
+            used: 0,
+            mode: 'mind-wandering',
+        };
+    }
+    createInitialSchema() {
+        return {
+            selfModel: {
+                perceivedFocus: 'nothing',
+                metacognitiveConfidence: 0.2,
+                voluntaryControl: 0.5,
+            },
+            awarenessModel: {
+                contents: [],
+                clarity: 0.1,
+                phenomenalQuality: 'absent',
+            },
+            otherModels: new Map(),
+        };
+    }
+    // ============================================================================
+    // Stats
+    // ============================================================================
+    stats() {
+        return {
+            currentFocus: this.state.focus?.target || null,
+            mode: this.state.mode,
+            capacity: this.state.capacity,
+            used: this.state.used,
+            clarity: this.schema.awarenessModel.phenomenalQuality,
+            otherModelsCount: this.schema.otherModels.size,
+        };
+    }
+}
+exports.AttentionSchemaNetwork = AttentionSchemaNetwork;
+// ============================================================================
+// Factory
+// ============================================================================
+function createAttentionSchemaNetwork(config) {
+    return new AttentionSchemaNetwork(config);
+}