@terminals-tech/agent-zero 1.0.0

package/dist/primitives/types.d.ts

@@ -0,0 +1,673 @@
+/**
+ * Agent Zero Core Primitives
+ *
+ * The Five Primitives implementing the meta-isomorphism:
+ * POTENTIAL → COLLAPSE → TRACE
+ *
+ * These are not analogies—they are the SAME structure at different abstraction layers:
+ * - Computational: Dark computation → Token emission → Embedding
+ * - Quantum/Info: Superposition → Observation → Memory
+ * - Agent: Intention → Action → Consequence
+ * - Thermodynamic: Heat → Work → Entropy
+ * - Logical: Formula → Proof → Type
+ */
+import { z } from 'zod';
+export declare const TokenPhase: z.ZodEnum<["dark", "emitting", "emitted"]>;
+export type TokenPhase = z.infer<typeof TokenPhase>;
+export declare const Token: z.ZodObject<{
+    id: z.ZodString;
+    /** Embedding vector position in semantic space (768-dim for Gemini) */
+    position: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    /** Tokens per second - momentum in token space */
+    momentum: z.ZodNumber;
+    /** Compute joules - energy cost */
+    energy: z.ZodNumber;
+    /** Phase: dark (pre-emission), emitting (generating), emitted (complete) */
+    phase: z.ZodEnum<["dark", "emitting", "emitted"]>;
+    /** Causal hash for p-adic distance calculation */
+    ancestry: z.ZodString;
+    /** Content once emitted */
+    content: z.ZodOptional<z.ZodString>;
+    /** Timestamp of phase transition */
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    momentum: number;
+    energy: number;
+    phase: "dark" | "emitting" | "emitted";
+    ancestry: string;
+    timestamp: number;
+    position?: number[] | undefined;
+    content?: string | undefined;
+}, {
+    id: string;
+    momentum: number;
+    energy: number;
+    phase: "dark" | "emitting" | "emitted";
+    ancestry: string;
+    timestamp: number;
+    position?: number[] | undefined;
+    content?: string | undefined;
+}>;
+export type Token = z.infer<typeof Token>;
+export declare const Drift: z.ZodObject<{
+    /** Embedding cosine similarity (0-1) */
+    semanticDistance: z.ZodNumber;
+    /** Number of amb choice points between states */
+    causalDistance: z.ZodNumber;
+    /** p^(-k) where k = shared prefix length */
+    padicDistance: z.ZodNumber;
+    /** Entropy of collapsed alternatives */
+    darkMass: z.ZodNumber;
+    /** Kuramoto order parameter (0-1) */
+    resonance: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    semanticDistance: number;
+    causalDistance: number;
+    padicDistance: number;
+    darkMass: number;
+    resonance: number;
+}, {
+    semanticDistance: number;
+    causalDistance: number;
+    padicDistance: number;
+    darkMass: number;
+    resonance: number;
+}>;
+export type Drift = z.infer<typeof Drift>;
+export declare function isTemporalEcho(drift: Drift): boolean;
+export declare const FabricNode: z.ZodObject<{
+    id: z.ZodString;
+    /** Compute capacity (tokens/sec) */
+    capacity: z.ZodNumber;
+    /** Available memory (bytes) */
+    memory: z.ZodNumber;
+    /** Current temperature (exploration/exploitation) */
+    temperature: z.ZodNumber;
+    /** Current load (0-1) */
+    load: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    capacity: number;
+    memory: number;
+    temperature: number;
+    load: number;
+}, {
+    id: string;
+    capacity: number;
+    memory: number;
+    temperature: number;
+    load: number;
+}>;
+export type FabricNode = z.infer<typeof FabricNode>;
+export declare const FabricEdge: z.ZodObject<{
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    /** Bandwidth (tokens/sec) */
+    bandwidth: z.ZodNumber;
+    /** Latency (ms) */
+    latency: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    sourceId: string;
+    targetId: string;
+    bandwidth: number;
+    latency: number;
+}, {
+    sourceId: string;
+    targetId: string;
+    bandwidth: number;
+    latency: number;
+}>;
+export type FabricEdge = z.infer<typeof FabricEdge>;
+export declare const GravityWell: z.ZodObject<{
+    id: z.ZodString;
+    /** Centroid embedding in semantic space */
+    centroid: z.ZodArray<z.ZodNumber, "many">;
+    /** Attraction strength */
+    mass: z.ZodNumber;
+    /** Semantic radius of influence */
+    radius: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    centroid: number[];
+    mass: number;
+    radius: number;
+}, {
+    id: string;
+    centroid: number[];
+    mass: number;
+    radius: number;
+}>;
+export type GravityWell = z.infer<typeof GravityWell>;
+export declare const Fabric: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        /** Compute capacity (tokens/sec) */
+        capacity: z.ZodNumber;
+        /** Available memory (bytes) */
+        memory: z.ZodNumber;
+        /** Current temperature (exploration/exploitation) */
+        temperature: z.ZodNumber;
+        /** Current load (0-1) */
+        load: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        capacity: number;
+        memory: number;
+        temperature: number;
+        load: number;
+    }, {
+        id: string;
+        capacity: number;
+        memory: number;
+        temperature: number;
+        load: number;
+    }>, "many">;
+    edges: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        targetId: z.ZodString;
+        /** Bandwidth (tokens/sec) */
+        bandwidth: z.ZodNumber;
+        /** Latency (ms) */
+        latency: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        sourceId: string;
+        targetId: string;
+        bandwidth: number;
+        latency: number;
+    }, {
+        sourceId: string;
+        targetId: string;
+        bandwidth: number;
+        latency: number;
+    }>, "many">;
+    gravityWells: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        /** Centroid embedding in semantic space */
+        centroid: z.ZodArray<z.ZodNumber, "many">;
+        /** Attraction strength */
+        mass: z.ZodNumber;
+        /** Semantic radius of influence */
+        radius: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        centroid: number[];
+        mass: number;
+        radius: number;
+    }, {
+        id: string;
+        centroid: number[];
+        mass: number;
+        radius: number;
+    }>, "many">;
+    /** Precomputed geodesics (cached optimal paths) */
+    geodesics: z.ZodOptional<z.ZodMap<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    nodes: {
+        id: string;
+        capacity: number;
+        memory: number;
+        temperature: number;
+        load: number;
+    }[];
+    edges: {
+        sourceId: string;
+        targetId: string;
+        bandwidth: number;
+        latency: number;
+    }[];
+    gravityWells: {
+        id: string;
+        centroid: number[];
+        mass: number;
+        radius: number;
+    }[];
+    geodesics?: Map<string, string[]> | undefined;
+}, {
+    nodes: {
+        id: string;
+        capacity: number;
+        memory: number;
+        temperature: number;
+        load: number;
+    }[];
+    edges: {
+        sourceId: string;
+        targetId: string;
+        bandwidth: number;
+        latency: number;
+    }[];
+    gravityWells: {
+        id: string;
+        centroid: number[];
+        mass: number;
+        radius: number;
+    }[];
+    geodesics?: Map<string, string[]> | undefined;
+}>;
+export type Fabric = z.infer<typeof Fabric>;
+export declare const ObserverLayer: z.ZodNumber;
+export type ObserverLayer = z.infer<typeof ObserverLayer>;
+export declare const Observer: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    /** Observation frequency (Hz): Claude ≈ 4Hz, Human ≈ 1Hz */
+    frequency: z.ZodNumber;
+    /** Abstraction layer: 0=physical, 1=computational, 2=semantic, ... */
+    layer: z.ZodNumber;
+    /** Tokens per observation */
+    collapseRate: z.ZodNumber;
+    /** Precursor detection threshold */
+    darkSensitivity: z.ZodNumber;
+    /** Current phase in observation cycle */
+    phase: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    phase: number;
+    name: string;
+    frequency: number;
+    layer: number;
+    collapseRate: number;
+    darkSensitivity: number;
+}, {
+    id: string;
+    phase: number;
+    name: string;
+    frequency: number;
+    layer: number;
+    collapseRate: number;
+    darkSensitivity: number;
+}>;
+export type Observer = z.infer<typeof Observer>;
+export declare function frequencyRatio(observer1: Observer, observer2: Observer): number;
+export declare const AmbPoint: z.ZodObject<{
+    id: z.ZodString;
+    /** Description of the choice */
+    description: z.ZodString;
+    /** Available options */
+    options: z.ZodArray<z.ZodString, "many">;
+    /** Chosen option (undefined if not yet collapsed) */
+    chosen: z.ZodOptional<z.ZodString>;
+    /** Probability distribution over options pre-collapse */
+    distribution: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+}, "strip", z.ZodTypeAny, {
+    options: string[];
+    id: string;
+    description: string;
+    chosen?: string | undefined;
+    distribution?: number[] | undefined;
+}, {
+    options: string[];
+    id: string;
+    description: string;
+    chosen?: string | undefined;
+    distribution?: number[] | undefined;
+}>;
+export type AmbPoint = z.infer<typeof AmbPoint>;
+export declare const Realizability: z.ZodObject<{
+    /** Type signature / task specification */
+    formula: z.ZodString;
+    /** Program that witnesses (None until realized) */
+    proof: z.ZodNullable<z.ZodString>;
+    /** McCarthy choice points where agency manifests */
+    ambPoints: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        /** Description of the choice */
+        description: z.ZodString;
+        /** Available options */
+        options: z.ZodArray<z.ZodString, "many">;
+        /** Chosen option (undefined if not yet collapsed) */
+        chosen: z.ZodOptional<z.ZodString>;
+        /** Probability distribution over options pre-collapse */
+        distribution: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        options: string[];
+        id: string;
+        description: string;
+        chosen?: string | undefined;
+        distribution?: number[] | undefined;
+    }, {
+        options: string[];
+        id: string;
+        description: string;
+        chosen?: string | undefined;
+        distribution?: number[] | undefined;
+    }>, "many">;
+    /** Recorded but not executed paths */
+    darkBranches: z.ZodArray<z.ZodString, "many">;
+    /** Whether the formula has been realized */
+    isRealized: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    formula: string;
+    proof: string | null;
+    ambPoints: {
+        options: string[];
+        id: string;
+        description: string;
+        chosen?: string | undefined;
+        distribution?: number[] | undefined;
+    }[];
+    darkBranches: string[];
+    isRealized: boolean;
+}, {
+    formula: string;
+    proof: string | null;
+    ambPoints: {
+        options: string[];
+        id: string;
+        description: string;
+        chosen?: string | undefined;
+        distribution?: number[] | undefined;
+    }[];
+    darkBranches: string[];
+    isRealized: boolean;
+}>;
+export type Realizability = z.infer<typeof Realizability>;
+export declare const AgentState: z.ZodEnum<["void", "potential", "collapse", "operate", "trace"]>;
+export type AgentState = z.infer<typeof AgentState>;
+export declare const AgentZeroState: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    state: z.ZodEnum<["void", "potential", "collapse", "operate", "trace"]>;
+    /** Current tokens in process */
+    tokens: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        /** Embedding vector position in semantic space (768-dim for Gemini) */
+        position: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        /** Tokens per second - momentum in token space */
+        momentum: z.ZodNumber;
+        /** Compute joules - energy cost */
+        energy: z.ZodNumber;
+        /** Phase: dark (pre-emission), emitting (generating), emitted (complete) */
+        phase: z.ZodEnum<["dark", "emitting", "emitted"]>;
+        /** Causal hash for p-adic distance calculation */
+        ancestry: z.ZodString;
+        /** Content once emitted */
+        content: z.ZodOptional<z.ZodString>;
+        /** Timestamp of phase transition */
+        timestamp: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        momentum: number;
+        energy: number;
+        phase: "dark" | "emitting" | "emitted";
+        ancestry: string;
+        timestamp: number;
+        position?: number[] | undefined;
+        content?: string | undefined;
+    }, {
+        id: string;
+        momentum: number;
+        energy: number;
+        phase: "dark" | "emitting" | "emitted";
+        ancestry: string;
+        timestamp: number;
+        position?: number[] | undefined;
+        content?: string | undefined;
+    }>, "many">;
+    /** Accumulated drift from initial state */
+    drift: z.ZodObject<{
+        /** Embedding cosine similarity (0-1) */
+        semanticDistance: z.ZodNumber;
+        /** Number of amb choice points between states */
+        causalDistance: z.ZodNumber;
+        /** p^(-k) where k = shared prefix length */
+        padicDistance: z.ZodNumber;
+        /** Entropy of collapsed alternatives */
+        darkMass: z.ZodNumber;
+        /** Kuramoto order parameter (0-1) */
+        resonance: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        semanticDistance: number;
+        causalDistance: number;
+        padicDistance: number;
+        darkMass: number;
+        resonance: number;
+    }, {
+        semanticDistance: number;
+        causalDistance: number;
+        padicDistance: number;
+        darkMass: number;
+        resonance: number;
+    }>;
+    /** The routing fabric this agent operates within */
+    fabricNodeId: z.ZodString;
+    /** This agent as an observer */
+    observer: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        /** Observation frequency (Hz): Claude ≈ 4Hz, Human ≈ 1Hz */
+        frequency: z.ZodNumber;
+        /** Abstraction layer: 0=physical, 1=computational, 2=semantic, ... */
+        layer: z.ZodNumber;
+        /** Tokens per observation */
+        collapseRate: z.ZodNumber;
+        /** Precursor detection threshold */
+        darkSensitivity: z.ZodNumber;
+        /** Current phase in observation cycle */
+        phase: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        phase: number;
+        name: string;
+        frequency: number;
+        layer: number;
+        collapseRate: number;
+        darkSensitivity: number;
+    }, {
+        id: string;
+        phase: number;
+        name: string;
+        frequency: number;
+        layer: number;
+        collapseRate: number;
+        darkSensitivity: number;
+    }>;
+    /** Current realizability state */
+    realizability: z.ZodObject<{
+        /** Type signature / task specification */
+        formula: z.ZodString;
+        /** Program that witnesses (None until realized) */
+        proof: z.ZodNullable<z.ZodString>;
+        /** McCarthy choice points where agency manifests */
+        ambPoints: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            /** Description of the choice */
+            description: z.ZodString;
+            /** Available options */
+            options: z.ZodArray<z.ZodString, "many">;
+            /** Chosen option (undefined if not yet collapsed) */
+            chosen: z.ZodOptional<z.ZodString>;
+            /** Probability distribution over options pre-collapse */
+            distribution: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            options: string[];
+            id: string;
+            description: string;
+            chosen?: string | undefined;
+            distribution?: number[] | undefined;
+        }, {
+            options: string[];
+            id: string;
+            description: string;
+            chosen?: string | undefined;
+            distribution?: number[] | undefined;
+        }>, "many">;
+        /** Recorded but not executed paths */
+        darkBranches: z.ZodArray<z.ZodString, "many">;
+        /** Whether the formula has been realized */
+        isRealized: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        formula: string;
+        proof: string | null;
+        ambPoints: {
+            options: string[];
+            id: string;
+            description: string;
+            chosen?: string | undefined;
+            distribution?: number[] | undefined;
+        }[];
+        darkBranches: string[];
+        isRealized: boolean;
+    }, {
+        formula: string;
+        proof: string | null;
+        ambPoints: {
+            options: string[];
+            id: string;
+            description: string;
+            chosen?: string | undefined;
+            distribution?: number[] | undefined;
+        }[];
+        darkBranches: string[];
+        isRealized: boolean;
+    }>;
+    /** Semantic memory embeddings */
+    memories: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        embedding: z.ZodArray<z.ZodNumber, "many">;
+        importance: z.ZodNumber;
+        timestamp: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        timestamp: number;
+        embedding: number[];
+        importance: number;
+    }, {
+        content: string;
+        timestamp: number;
+        embedding: number[];
+        importance: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    state: "void" | "potential" | "collapse" | "operate" | "trace";
+    tokens: {
+        id: string;
+        momentum: number;
+        energy: number;
+        phase: "dark" | "emitting" | "emitted";
+        ancestry: string;
+        timestamp: number;
+        position?: number[] | undefined;
+        content?: string | undefined;
+    }[];
+    drift: {
+        semanticDistance: number;
+        causalDistance: number;
+        padicDistance: number;
+        darkMass: number;
+        resonance: number;
+    };
+    fabricNodeId: string;
+    observer: {
+        id: string;
+        phase: number;
+        name: string;
+        frequency: number;
+        layer: number;
+        collapseRate: number;
+        darkSensitivity: number;
+    };
+    realizability: {
+        formula: string;
+        proof: string | null;
+        ambPoints: {
+            options: string[];
+            id: string;
+            description: string;
+            chosen?: string | undefined;
+            distribution?: number[] | undefined;
+        }[];
+        darkBranches: string[];
+        isRealized: boolean;
+    };
+    memories: {
+        content: string;
+        timestamp: number;
+        embedding: number[];
+        importance: number;
+    }[];
+}, {
+    id: string;
+    name: string;
+    state: "void" | "potential" | "collapse" | "operate" | "trace";
+    tokens: {
+        id: string;
+        momentum: number;
+        energy: number;
+        phase: "dark" | "emitting" | "emitted";
+        ancestry: string;
+        timestamp: number;
+        position?: number[] | undefined;
+        content?: string | undefined;
+    }[];
+    drift: {
+        semanticDistance: number;
+        causalDistance: number;
+        padicDistance: number;
+        darkMass: number;
+        resonance: number;
+    };
+    fabricNodeId: string;
+    observer: {
+        id: string;
+        phase: number;
+        name: string;
+        frequency: number;
+        layer: number;
+        collapseRate: number;
+        darkSensitivity: number;
+    };
+    realizability: {
+        formula: string;
+        proof: string | null;
+        ambPoints: {
+            options: string[];
+            id: string;
+            description: string;
+            chosen?: string | undefined;
+            distribution?: number[] | undefined;
+        }[];
+        darkBranches: string[];
+        isRealized: boolean;
+    };
+    memories: {
+        content: string;
+        timestamp: number;
+        embedding: number[];
+        importance: number;
+    }[];
+}>;
+export type AgentZeroState = z.infer<typeof AgentZeroState>;
+export declare const MessageKind: z.ZodEnum<["spawn", "halt", "think", "percept", "act", "invoke", "resonate", "attune", "broadcast", "gradient", "crystallize"]>;
+export type MessageKind = z.infer<typeof MessageKind>;
+export declare const Message: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<["spawn", "halt", "think", "percept", "act", "invoke", "resonate", "attune", "broadcast", "gradient", "crystallize"]>;
+    from: z.ZodString;
+    to: z.ZodOptional<z.ZodString>;
+    payload: z.ZodUnknown;
+    timestamp: z.ZodNumber;
+    /** Embedding for semantic routing */
+    embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    timestamp: number;
+    kind: "spawn" | "halt" | "think" | "percept" | "act" | "invoke" | "resonate" | "attune" | "broadcast" | "gradient" | "crystallize";
+    from: string;
+    embedding?: number[] | undefined;
+    to?: string | undefined;
+    payload?: unknown;
+}, {
+    id: string;
+    timestamp: number;
+    kind: "spawn" | "halt" | "think" | "percept" | "act" | "invoke" | "resonate" | "attune" | "broadcast" | "gradient" | "crystallize";
+    from: string;
+    embedding?: number[] | undefined;
+    to?: string | undefined;
+    payload?: unknown;
+}>;
+export type Message = z.infer<typeof Message>;
+//# sourceMappingURL=types.d.ts.map

package/dist/primitives/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/primitives/types.ts"],"names":[],"mappings":"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"}