@hazeljs/organism 2.0.6

package/dist/core/organism-runtime.js

@@ -0,0 +1,1016 @@
+"use strict";
+/**
+ * OrganismRuntime — mission-defined self-organizing agent society control plane.
+ * Composes AgentRuntime; does not replace the Agent OS kernel.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganismRuntime = void 0;
+exports.createOrganism = createOrganism;
+const agent_1 = require("@hazeljs/agent");
+const organism_types_1 = require("../types/organism.types");
+const organism_errors_1 = require("../errors/organism.errors");
+const organism_events_1 = require("../events/organism-events");
+const organism_repository_1 = require("../persistence/organism-repository");
+const decorators_1 = require("../decorators");
+const constitution_1 = require("../governance/constitution");
+const resource_allocator_1 = require("../economy/resource-allocator");
+const utility_engine_1 = require("../economy/utility-engine");
+const utility_forecaster_1 = require("../economy/utility-forecaster");
+const market_engine_1 = require("../economy/market-engine");
+const capability_registry_1 = require("./capability-registry");
+const perception_engine_1 = require("../perception/perception-engine");
+const decision_engine_1 = require("../lifecycle/decision-engine");
+const birth_engine_1 = require("../lifecycle/birth-engine");
+const survival_engine_1 = require("../lifecycle/survival-engine");
+const reproduction_engine_1 = require("../lifecycle/reproduction-engine");
+const genealogy_manager_1 = require("../genealogy/genealogy-manager");
+const mutation_engine_1 = require("../evolution/mutation-engine");
+const evolution_engine_1 = require("../evolution/evolution-engine");
+const mission_1 = require("./mission");
+const organism_context_1 = require("./organism-context");
+const clock_1 = require("./clock");
+const metrics_1 = require("../observability/metrics");
+class OrganismRuntime {
+    constructor(options) {
+        this.metrics = new metrics_1.OrganismMetrics();
+        this.capabilities = new capability_registry_1.CapabilityRegistry();
+        this.clock = new clock_1.OrganismClock();
+        this.cycleTimers = [];
+        this.pendingApprovals = new Map();
+        this.agentCache = new Map();
+        this.reproductionConfig = reproduction_engine_1.DEFAULT_REPRODUCTION_CONFIG;
+        this.id = options.id ?? `org_${Date.now().toString(36)}`;
+        this.events = new organism_events_1.OrganismEventEmitter();
+        this.repo = options.repository ?? new organism_repository_1.InMemoryOrganismRepository();
+        this.debug = options.debug ?? false;
+        this.log = (line) => {
+            if (this.debug || options.simulation) {
+                // eslint-disable-next-line no-console
+                console.log(line);
+            }
+        };
+        this.perception = new perception_engine_1.PerceptionEngine(options.relevanceThreshold ?? 0.3);
+        this.needDetector = new perception_engine_1.NeedDetector(options.signalNeedMappings ?? []);
+        this.decisionEngine = new decision_engine_1.DecisionEngine(this.capabilities);
+        this.allocator = new resource_allocator_1.ResourceAllocator(this.events, this.id, () => this.clock.now());
+        this.forecaster = new utility_forecaster_1.UtilityForecaster(this.events, this.id);
+        this.utilityEngine = new utility_engine_1.UtilityEngine(this.events, this.id, {
+            ...organism_types_1.DEFAULT_UTILITY_WEIGHTS,
+            ...options.utilityWeights,
+        });
+        this.reputationEngine = new utility_engine_1.ReputationEngine(this.events, this.id);
+        this.survivalEngine = new survival_engine_1.SurvivalEngine({ ...organism_types_1.DEFAULT_SURVIVAL_CONFIG, ...options.survival }, () => this.clock.now());
+        this.reproductionConfig = {
+            ...reproduction_engine_1.DEFAULT_REPRODUCTION_CONFIG,
+            ...options.reproduction,
+        };
+        this.marketEngine = new market_engine_1.MarketEngine(this.events, this.allocator, this.forecaster, this.id, () => this.clock.now(), options.market);
+        this.agentRuntime =
+            options.agentRuntime ??
+                new agent_1.AgentRuntime({
+                    llmProvider: options.llmProvider ?? (0, agent_1.createMockLlmProvider)(),
+                    enableMetrics: true,
+                    enableRetry: false,
+                    enableCircuitBreaker: false,
+                });
+    }
+    static async create(options) {
+        const runtime = new OrganismRuntime(options);
+        await runtime.initialize(options);
+        return runtime;
+    }
+    /** Resolve decorator-decorated organism class into create options. */
+    static async fromClass(target, overrides = {}) {
+        const meta = (await Promise.resolve().then(() => __importStar(require('../decorators')))).getOrganismMetadata(target);
+        if (!meta) {
+            throw new organism_errors_1.OrganismStateError(`Class ${target.name} is not decorated with @Organism`);
+        }
+        const opts = OrganismRuntime.mergeDecoratorOptions(meta, overrides);
+        return OrganismRuntime.create(opts);
+    }
+    static mergeDecoratorOptions(meta, overrides) {
+        if (!meta.mission && !overrides.mission) {
+            throw new organism_errors_1.OrganismStateError('@Organism requires a mission');
+        }
+        return {
+            mission: overrides.mission ?? meta.mission,
+            genes: overrides.genes ?? meta.genes,
+            environment: overrides.environment ?? meta.environment,
+            constitution: overrides.constitution ?? meta.constitution,
+            resources: overrides.resources ?? meta.resources,
+            id: overrides.id ?? meta.id,
+            ...overrides,
+        };
+    }
+    async initialize(options) {
+        const existing = options.id ? await this.repo.getOrganism(this.id) : undefined;
+        if (existing) {
+            this.record = normalizeOrganismRecord(existing);
+            this.wireEngines(this.record.constitution, options);
+            await this.hydrateAgentsFromRepository();
+            await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_RESTORED, this.id, {
+                missionId: this.record.mission.id,
+                objective: this.record.mission.objective,
+                agentCount: this.agentCache.size,
+            });
+            this.log(`[ORGANISM] Restored ${this.id} with ${this.agentCache.size} agents`);
+            return;
+        }
+        const mission = (0, decorators_1.resolveMission)(options.mission);
+        const genes = (options.genes ?? []).map(decorators_1.resolveGene);
+        const environment = options.environment ? (0, decorators_1.resolveEnvironment)(options.environment) : undefined;
+        const constitution = options.constitution
+            ? (0, decorators_1.resolveConstitution)(options.constitution)
+            : undefined;
+        const resources = options.resources
+            ? (0, decorators_1.resolveResource)(options.resources)
+            : {
+                tokenBudget: 5000000,
+                monthlyBudget: { amount: 1000, currency: 'USD' },
+            };
+        const limits = { ...organism_types_1.DEFAULT_ORGANISM_LIMITS, ...options.limits };
+        const now = this.clock.now();
+        this.record = {
+            id: this.id,
+            status: 'created',
+            mission,
+            constitution,
+            environment,
+            genes,
+            resources,
+            limits,
+            cycles: options.cycles ?? {
+                perception: '5s',
+                evaluation: '1m',
+                survival: '10m',
+                missionEvaluation: '1m',
+            },
+            missionProgress: (0, mission_1.createMissionProgress)(mission),
+            pool: {
+                tokensRemaining: resources.tokenBudget ?? 5000000,
+                moneyRemaining: {
+                    amount: resources.monthlyBudget?.amount ?? 1000,
+                    currency: resources.monthlyBudget?.currency ?? 'USD',
+                },
+                costSpentThisHour: 0,
+            },
+            debug: this.debug,
+            simulation: options.simulation ?? false,
+            createdAt: now,
+            updatedAt: now,
+            emergencyStopped: false,
+        };
+        this.wireEngines(constitution, options);
+        await this.repo.saveOrganism(this.record);
+        await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_CREATED, this.id, {
+            missionId: mission.id,
+            objective: mission.objective,
+        });
+    }
+    wireEngines(constitution, options) {
+        this.constitutionEnforcer = new constitution_1.ConstitutionEnforcer(constitution, this.events, this.id);
+        const policyRules = this.constitutionEnforcer.toPolicyRules();
+        if (policyRules.length) {
+            this.agentRuntime = new agent_1.AgentRuntime({
+                llmProvider: options.llmProvider ?? (0, agent_1.createMockLlmProvider)(),
+                enableMetrics: true,
+                enableRetry: false,
+                enableCircuitBreaker: false,
+                policyEngine: new agent_1.PolicyEngine(policyRules),
+            });
+        }
+        this.birthEngine = new birth_engine_1.BirthEngine(this.events, this.repo, this.capabilities, this.id, this.agentRuntime);
+        this.terminationEngine = new birth_engine_1.TerminationEngine(this.events, this.repo, this.capabilities, this.id, (agent) => this.allocator.release(this.record, agent));
+        this.genealogyManager = new genealogy_manager_1.GenealogyManager(this.repo, this.id);
+        this.reproductionEngine = new reproduction_engine_1.ReproductionEngine(this.events, this.repo, this.birthEngine, this.genealogyManager, this.constitutionEnforcer, this.id, () => this.clock.now(), this.reproductionConfig);
+        this.mutationEngine = new mutation_engine_1.MutationEngine(this.events, this.repo, this.id, () => this.clock.now());
+        this.generationManager = new evolution_engine_1.GenerationManager();
+        this.evolutionEngine = new evolution_engine_1.EvolutionEngine(this.events, this.repo, this.generationManager, this.mutationEngine, this.id, { ...organism_types_1.DEFAULT_UTILITY_WEIGHTS }, () => this.clock.now());
+    }
+    /** Rebuild agent cache + capability index from durable repository (multi-replica hydrate). */
+    async hydrateAgentsFromRepository() {
+        const agents = await this.repo.listAgents(this.id);
+        for (const raw of agents) {
+            const agent = normalizeAgentRecord(raw);
+            this.agentCache.set(agent.id, agent);
+            this.capabilities.register(agent.id, agent.capabilities);
+            this.reregisterAgentDna(agent);
+        }
+    }
+    reregisterAgentDna(agent) {
+        if (!this.agentRuntime || !agent.dnaAgentName)
+            return;
+        try {
+            const dna = (0, agent_1.exportAgentDna)({
+                name: agent.dnaAgentName,
+                description: agent.objective,
+                systemPrompt: agent.systemPrompt ??
+                    `You are ${agent.dnaAgentName}. Objective: ${agent.objective}. Capabilities: ${agent.capabilities.join(', ')}.`,
+                tools: [],
+                mission: { goal: agent.objective },
+                metadata: {
+                    capabilities: agent.capabilities,
+                    organismId: this.id,
+                    geneId: agent.geneId,
+                    needId: agent.birthProposal?.needId,
+                    terminationCriteria: agent.terminationCriteria,
+                },
+                version: '1.0.0',
+            });
+            const AgentClass = (0, agent_1.createAgentClassFromDna)(dna);
+            this.agentRuntime.registerAgent(AgentClass);
+        }
+        catch {
+            // DNA re-registration is best-effort; observe/spawn still work via capabilities.
+        }
+    }
+    get status() {
+        return this.record.status;
+    }
+    getMission() {
+        return this.record.mission;
+    }
+    async start() {
+        if (this.record.emergencyStopped) {
+            throw new organism_errors_1.OrganismStateError('Cannot start after emergency stop');
+        }
+        this.record.status = 'initializing';
+        await this.persist();
+        this.record.status = 'operating';
+        await this.persist();
+        this.startCycles();
+        await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_STARTED, this.id, {
+            status: this.record.status,
+        });
+        this.log(`[ORGANISM] Mission started: ${this.record.mission.objective}`);
+    }
+    async pause() {
+        this.stopCycles();
+        this.record.status = 'paused';
+        await this.persist();
+        await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_PAUSED, this.id, {});
+        this.log('[ORGANISM] Paused');
+    }
+    async resume() {
+        if (this.record.emergencyStopped) {
+            throw new organism_errors_1.OrganismStateError('Cannot resume after emergency stop');
+        }
+        this.record.status = 'operating';
+        await this.persist();
+        this.startCycles();
+        await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_RESUMED, this.id, {});
+        this.log('[ORGANISM] Resumed');
+    }
+    async terminate() {
+        this.stopCycles();
+        const agents = await this.liveAgents();
+        for (const agent of agents) {
+            await this.terminationEngine.terminate(agent.id, 'manual');
+            this.metrics.recordTermination();
+        }
+        this.record.status = 'terminated';
+        await this.persist();
+        await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_TERMINATED, this.id, {});
+        this.log('[ORGANISM] Terminated');
+    }
+    async emergencyStop() {
+        this.record.emergencyStopped = true;
+        this.stopCycles();
+        this.record.status = 'terminated';
+        await this.persist();
+        await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_EMERGENCY_STOP, this.id, {});
+        this.log('[ORGANISM] Emergency stop');
+    }
+    async observe(raw) {
+        if (this.record.status === 'paused' || this.record.emergencyStopped) {
+            return undefined;
+        }
+        this.record.status = 'observing';
+        const signal = this.perception.normalize({
+            ...raw,
+            timestamp: raw.timestamp ?? this.clock.now(),
+        });
+        const filtered = this.perception.filter(signal, this.record.mission);
+        await this.repo.appendSignal(this.id, filtered.signal);
+        await this.events.emit(organism_events_1.OrganismEventType.ENVIRONMENT_SIGNAL_RECEIVED, this.id, filtered.signal);
+        this.log(`[ENVIRONMENT] ${signal.type} ${filtered.accepted ? 'accepted' : 'ignored'}`);
+        if (!filtered.accepted) {
+            this.record.status = 'operating';
+            await this.persist();
+            return {
+                action: 'observe',
+                reasoningSummary: filtered.reason,
+                confidence: 1,
+            };
+        }
+        const need = this.needDetector.detect(filtered.signal, this.record.mission);
+        if (!need) {
+            this.record.status = 'operating';
+            await this.persist();
+            return {
+                action: 'observe',
+                reasoningSummary: `No need detected for ${signal.type}`,
+                confidence: 0.7,
+            };
+        }
+        await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_NEED_DETECTED, this.id, need);
+        this.log(`[NEED] ${need.need} — ${need.reason}`);
+        this.record.status = 'planning';
+        const live = await this.liveAgents();
+        const spawnCheck = this.allocator.canSpawn(this.record, live.length);
+        const decision = this.decisionEngine.decide({
+            need,
+            liveAgents: live,
+            genes: this.record.genes,
+            canSpawn: spawnCheck.ok,
+            spawnBlockReason: spawnCheck.reason,
+        });
+        await this.repo.appendDecision(this.id, decision);
+        await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_DECISION, this.id, decision);
+        if (this.debug) {
+            this.log(`[DECISION] ${decision.action}: ${decision.reasoningSummary} (confidence=${decision.confidence})`);
+        }
+        await this.applyDecision(decision);
+        this.record.status = 'operating';
+        await this.persist();
+        return decision;
+    }
+    async applyDecision(decision) {
+        if (decision.action === 'delegate' && decision.targetAgentId) {
+            await this.delegateInternal(decision.targetAgentId, decision.needId ?? 'task');
+            return;
+        }
+        if ((decision.action === 'spawn' || decision.action === 'specialize') &&
+            decision.birthProposal) {
+            await this.spawnFromProposal(decision);
+            return;
+        }
+        if (decision.action === 'reproduce' && decision.birthProposal?.parentAgentId) {
+            await this.reproduceAgent(decision.birthProposal.parentAgentId, {
+                reason: decision.birthProposal.reason,
+                specialization: decision.birthProposal.specialize,
+                objective: decision.birthProposal.expectedOutcome,
+                needId: decision.birthProposal.needId,
+                confidence: decision.confidence,
+                tokens: decision.resourceRequest?.tokens,
+                terminationCriteria: decision.birthProposal.terminationCriteria,
+            });
+        }
+    }
+    async spawnFromProposal(decision) {
+        const proposal = decision.birthProposal;
+        this.constitutionEnforcer.assertAllows('spawn', {});
+        const live = await this.liveAgents();
+        const spawnCheck = this.allocator.canSpawn(this.record, live.length);
+        if (!spawnCheck.ok) {
+            throw new organism_errors_1.OrganismStateError(spawnCheck.reason);
+        }
+        const geneId = proposal.geneId ?? this.record.genes[0]?.id;
+        const gene = this.record.genes.find((g) => g.id === geneId);
+        if (!gene) {
+            throw new organism_errors_1.OrganismStateError(`Gene not found: ${geneId}`);
+        }
+        const agentId = `pending_${Date.now()}`;
+        const allocation = this.allocator.allocate(this.record, {
+            agentId,
+            requestedResources: decision.resourceRequest ?? { tokens: 50000 },
+            expectedUtility: proposal.expectedUtility ?? 0.5,
+            confidence: proposal.confidence,
+            urgency: 0.7,
+        });
+        if (!allocation.approved) {
+            await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_RESOURCE_DENIED, this.id, allocation);
+            throw new organism_errors_1.OrganismStateError(allocation.reason);
+        }
+        this.allocator.recordSpawn();
+        const parentGeneration = proposal.parentAgentId
+            ? ((await this.repo.getAgent(this.id, proposal.parentAgentId))?.generation ?? 0)
+            : 0;
+        const generation = parentGeneration + 1;
+        if (generation > this.record.limits.maxGenerationDepth) {
+            this.record.pool.tokensRemaining += allocation.wallet.tokensRemaining ?? 0;
+            this.record.pool.moneyRemaining.amount += allocation.wallet.moneyRemaining?.amount ?? 0;
+            throw new organism_errors_1.OrganismStateError(`maxGenerationDepth (${this.record.limits.maxGenerationDepth}) exceeded`);
+        }
+        const agent = await this.birthEngine.spawn({
+            proposal,
+            gene,
+            wallet: allocation.wallet,
+            generation,
+            parentAgentId: proposal.parentAgentId,
+        });
+        this.agentCache.set(agent.id, agent);
+        this.metrics.recordSpawn();
+        this.metrics.recordTokens(allocation.wallet.tokensRemaining ?? 0);
+        this.log(`[BIRTH] ${agent.name}#${agent.id} born parent: ${agent.parentAgentId ?? agent.geneId} generation: ${agent.generation}`);
+        this.log(`[RESOURCE] allocated ${(allocation.wallet.tokensRemaining ?? 0).toLocaleString()} tokens`);
+        if (decision.action === 'specialize') {
+            await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_AGENT_SPECIALIZED, this.id, {
+                agentId: agent.id,
+                specialize: agent.specialize,
+            });
+        }
+        await this.persist();
+        return agent;
+    }
+    /** Public spawn API for explicit births (still requires structured proposal). */
+    async spawnAgent(input) {
+        const gene = this.record.genes.find((g) => g.id === input.geneId) ??
+            this.decisionEngine.selectGene(input.requiredCapabilities, this.record.genes);
+        if (!gene)
+            throw new organism_errors_1.OrganismStateError('No gene available for spawn');
+        const decision = {
+            action: input.specialize?.length ? 'specialize' : 'spawn',
+            reasoningSummary: input.reason,
+            confidence: input.confidence ?? 0.8,
+            resourceRequest: { tokens: input.tokens ?? 50000 },
+            birthProposal: {
+                reason: input.reason,
+                needId: input.needId,
+                requiredCapabilities: input.requiredCapabilities,
+                expectedOutcome: input.objective,
+                confidence: input.confidence ?? 0.8,
+                geneId: gene.id,
+                specialize: input.specialize,
+                parentAgentId: input.parentAgentId,
+                terminationCriteria: input.terminationCriteria,
+            },
+        };
+        await this.repo.appendDecision(this.id, decision);
+        return this.spawnFromProposal(decision);
+    }
+    async terminateAgent(agentId, opts = { reason: 'manual' }) {
+        const agent = await this.terminationEngine.terminate(agentId, opts.reason);
+        if (agent) {
+            this.metrics.recordTermination();
+            this.log(`[DEATH] ${agent.name}#${agent.id} terminated (${opts.reason})`);
+            if ((agent.wallet.tokensRemaining ?? 0) === 0) {
+                this.log(`[RESOURCE] unused tokens returned to pool`);
+            }
+        }
+        await this.persist();
+    }
+    async reportOutcome(agentId, report) {
+        const agent = await this.repo.getAgent(this.id, agentId);
+        if (!agent)
+            throw new organism_errors_1.OrganismStateError(`Agent not found: ${agentId}`);
+        agent.valueGenerated += report.metrics?.valueGenerated ?? 0;
+        agent.costConsumed += report.metrics?.cost ?? 0;
+        agent.tokensConsumed += report.metrics?.cost
+            ? Math.floor((report.metrics.cost ?? 0) * 1000)
+            : 0;
+        agent.reputation = this.reputationEngine.update(agent, report);
+        agent.utility = this.utilityEngine.evaluate(agent, report);
+        agent.evaluationCount += 1;
+        agent.lastEvaluatedAt = this.clock.now();
+        await this.repo.saveAgent(this.id, agent);
+        this.agentCache.set(agent.id, agent);
+        if (report.missionMetricUpdates) {
+            this.record.missionProgress = (0, mission_1.applyMissionMetricUpdates)(this.record.missionProgress, this.record.mission, report.missionMetricUpdates);
+            await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_MISSION_PROGRESS, this.id, this.record.missionProgress);
+            if (this.record.missionProgress.completed) {
+                this.record.status = 'completed';
+                await this.events.emit(organism_events_1.OrganismEventType.ORGANISM_MISSION_COMPLETED, this.id, this.record.missionProgress);
+                this.log('[MISSION] Mission completed');
+            }
+        }
+        this.log(`[RESULT] ${report.result}`);
+        await this.persist();
+    }
+    async runSurvivalCycle() {
+        const agents = await this.liveAgents();
+        const reports = [];
+        for (const agent of agents) {
+            const verdict = this.survivalEngine.evaluate(agent);
+            reports.push(verdict);
+            if (verdict.shouldTerminate) {
+                this.log(`[SURVIVAL] ${agent.name}#${agent.id} ${verdict.reason}`);
+                await this.terminateAgent(agent.id, { reason: 'low_value' });
+            }
+        }
+        return reports;
+    }
+    async inspect() {
+        const agents = await this.repo.listAgents(this.id);
+        return {
+            mission: this.record.mission,
+            missionProgress: this.record.missionProgress,
+            status: this.record.status,
+            agents: agents.map((a) => ({
+                id: a.id,
+                objective: a.objective,
+                capabilities: a.capabilities,
+                parentId: a.parentAgentId,
+                generation: a.generation,
+                status: a.status,
+                reputation: a.reputation,
+                utility: a.utility,
+                resourceConsumption: { tokens: a.tokensConsumed, cost: a.costConsumed },
+            })),
+            resources: {
+                pool: this.record.pool,
+                limits: this.record.limits,
+            },
+            recentSignals: await this.repo.listSignals(this.id, 20),
+            recentDecisions: await this.repo.listDecisions(this.id, 20),
+            genealogy: await this.repo.listGenealogy(this.id),
+        };
+    }
+    async getGenealogy() {
+        return this.repo.listGenealogy(this.id);
+    }
+    async formatGenealogy() {
+        const [agents, genealogy] = await Promise.all([
+            this.repo.listAgents(this.id),
+            this.genealogyManager.list(),
+        ]);
+        return this.genealogyManager.formatTree(agents, genealogy);
+    }
+    /**
+     * Phase 2 — create a specialized descendant from an existing agent.
+     */
+    async reproduceAgent(parentAgentId, request) {
+        const parent = await this.repo.getAgent(this.id, parentAgentId);
+        if (!parent)
+            throw new organism_errors_1.OrganismStateError(`Parent agent not found: ${parentAgentId}`);
+        const gene = this.record.genes.find((g) => g.id === parent.geneId);
+        if (!gene)
+            throw new organism_errors_1.OrganismStateError(`Gene not found for parent: ${parent.geneId}`);
+        const live = await this.liveAgents();
+        const spawnCheck = this.allocator.canSpawn(this.record, live.length);
+        if (!spawnCheck.ok) {
+            throw new organism_errors_1.OrganismStateError(spawnCheck.reason);
+        }
+        // Prefer parent wallet transfer; optionally top up from pool if parent has no tokens
+        const parentTokens = parent.wallet.tokensRemaining ?? 0;
+        let poolWallet;
+        if (parentTokens <= 0 || request.tokens) {
+            const allocation = this.allocator.allocate(this.record, {
+                agentId: `repro_${parentAgentId}`,
+                requestedResources: { tokens: request.tokens ?? 25000 },
+                expectedUtility: parent.utility.score,
+                confidence: request.confidence ?? 0.8,
+                urgency: 0.6,
+                reputationScore: parent.reputation.score,
+            });
+            if (!allocation.approved) {
+                throw new organism_errors_1.OrganismStateError(allocation.reason);
+            }
+            poolWallet = allocation.wallet;
+        }
+        this.allocator.recordSpawn();
+        const { child, parent: updatedParent } = await this.reproductionEngine.reproduce({
+            parent,
+            gene,
+            request,
+            limits: this.record.limits,
+            liveAgents: live,
+            poolWallet,
+        });
+        this.agentCache.set(child.id, child);
+        this.agentCache.set(updatedParent.id, updatedParent);
+        this.capabilities.register(child.id, child.capabilities);
+        this.metrics.recordReproduction();
+        this.metrics.recordTokens(child.wallet.tokensRemaining ?? 0);
+        this.log(`[REPRODUCTION] ${child.name}#${child.id} born parent: ${parent.name}#${parent.id} generation: ${child.generation}`);
+        await this.persist();
+        return child;
+    }
+    /**
+     * Phase 3 — apply a constrained, auditable mutation.
+     */
+    async mutateAgent(agentId, input) {
+        const agent = await this.repo.getAgent(this.id, agentId);
+        if (!agent)
+            throw new organism_errors_1.OrganismStateError(`Agent not found: ${agentId}`);
+        const gene = this.record.genes.find((g) => g.id === agent.geneId);
+        if (!gene)
+            throw new organism_errors_1.OrganismStateError(`Gene not found: ${agent.geneId}`);
+        this.constitutionEnforcer.assertAllows('mutate', {});
+        const updated = await this.mutationEngine.mutate(agent, input, gene);
+        this.capabilities.register(updated.id, updated.capabilities);
+        this.agentCache.set(updated.id, updated);
+        this.metrics.recordMutation();
+        this.log(`[MUTATION] ${updated.name}#${updated.id}: ${input.reason}`);
+        await this.persist();
+        return updated;
+    }
+    /**
+     * Phase 3 — evaluate a competing population and promote the winner's strategy id.
+     */
+    async evaluateGeneration(input) {
+        const result = await this.evolutionEngine.evaluateGeneration(input);
+        this.log(`[EVOLUTION] population=${result.populationId} winner=${result.winner} scores=${JSON.stringify(result.scores)}`);
+        if (input.promoteToLosers && result.winner) {
+            const winner = await this.repo.getAgent(this.id, result.winner);
+            const gene = winner ? this.record.genes.find((g) => g.id === winner.geneId) : undefined;
+            if (winner && gene) {
+                for (const member of result.members) {
+                    if (member.agentId === result.winner)
+                        continue;
+                    await this.evolutionEngine.promoteStrategy({
+                        winnerId: result.winner,
+                        targetId: member.agentId,
+                        gene,
+                    });
+                    this.metrics.recordMutation();
+                }
+            }
+        }
+        await this.persist();
+        return result;
+    }
+    getEvolutionaryHistory(limit = 50) {
+        return this.generationManager.getHistory(limit);
+    }
+    /** Phase 4 — forecast expected utility / opportunity cost for a resource request. */
+    async forecastUtility(input) {
+        const agent = await this.repo.getAgent(this.id, input.agentId);
+        if (!agent)
+            throw new organism_errors_1.OrganismStateError(`Agent not found: ${input.agentId}`);
+        return this.forecaster.forecast({
+            agent,
+            record: this.record,
+            requested: input.requested,
+            expectedValue: input.expectedValue,
+            confidence: input.confidence,
+            urgency: input.urgency,
+        });
+    }
+    /** Phase 4 — place a resource bid into the internal market. */
+    placeBid(input) {
+        const bid = this.marketEngine.placeBid(input);
+        this.log(`[BID] ${bid.id} agent=${bid.agentId} value=${bid.expectedValue} tokens=${bid.requested.tokens ?? 0}`);
+        return bid;
+    }
+    listOpenBids() {
+        return this.marketEngine.listOpenBids();
+    }
+    /** Phase 4 — clear open bids against the organism pool. */
+    async clearMarket() {
+        const agents = await this.repo.listAgents(this.id);
+        const map = new Map(agents.map((a) => [a.id, a]));
+        const result = this.marketEngine.clearMarket({ record: this.record, agents: map });
+        for (const win of result.awarded) {
+            const agent = map.get(win.agentId);
+            if (!agent)
+                continue;
+            agent.wallet = {
+                tokensRemaining: (agent.wallet.tokensRemaining ?? 0) + (win.wallet.tokensRemaining ?? 0),
+                moneyRemaining: {
+                    amount: (agent.wallet.moneyRemaining?.amount ?? 0) + (win.wallet.moneyRemaining?.amount ?? 0),
+                    currency: this.record.pool.moneyRemaining.currency,
+                },
+            };
+            await this.repo.saveAgent(this.id, agent);
+            this.agentCache.set(agent.id, agent);
+            this.metrics.recordTokens(win.wallet.tokensRemaining ?? 0);
+        }
+        // Persist any bid-price charges on losers/winners wallets
+        for (const agent of map.values()) {
+            await this.repo.saveAgent(this.id, agent);
+            this.agentCache.set(agent.id, agent);
+        }
+        this.log(`[MARKET] cleared ${result.roundId}: awarded=${result.awarded.length} denied=${result.denied.length}`);
+        await this.persist();
+        return result;
+    }
+    /** Phase 4 — peer resource negotiation between two agents. */
+    async negotiate(offer) {
+        const from = await this.repo.getAgent(this.id, offer.fromAgentId);
+        const to = await this.repo.getAgent(this.id, offer.toAgentId);
+        if (!from || !to) {
+            return { approved: false, reason: 'Agent not found' };
+        }
+        const result = this.marketEngine.negotiate({
+            offer,
+            from,
+            to,
+            record: this.record,
+        });
+        if (result.approved) {
+            await this.repo.saveAgent(this.id, from);
+            await this.repo.saveAgent(this.id, to);
+            this.agentCache.set(from.id, from);
+            this.agentCache.set(to.id, to);
+            this.log(`[NEGOTIATION] ${from.id} → ${to.id} tokens=${offer.transfer.tokens ?? 0} money=${offer.transfer.money ?? 0}`);
+        }
+        await this.persist();
+        return result;
+    }
+    /**
+     * Phase 4 — negotiate-aware resource request (forecast first, then allocate).
+     */
+    async requestResourcesForAgent(agentId, input) {
+        const agent = await this.repo.getAgent(this.id, agentId);
+        if (!agent)
+            return { approved: false, reason: `Agent not found: ${agentId}` };
+        const expectedValue = input.expectedValue ?? 100;
+        const confidence = input.confidence ?? 0.5;
+        const forecast = this.forecaster.forecast({
+            agent,
+            record: this.record,
+            requested: input.requested,
+            expectedValue,
+            confidence,
+            urgency: input.urgency,
+        });
+        if (input.useMarket) {
+            this.placeBid({
+                agentId,
+                reason: input.reason,
+                requested: input.requested,
+                expectedValue,
+                confidence,
+                urgency: input.urgency,
+            });
+            const cleared = await this.clearMarket();
+            const win = cleared.awarded.find((a) => a.agentId === agentId);
+            if (win) {
+                return {
+                    approved: true,
+                    reason: 'Won market clearing',
+                    wallet: win.wallet,
+                    forecast,
+                };
+            }
+            const denial = cleared.denied.find((d) => d.agentId === agentId);
+            return {
+                approved: false,
+                reason: denial?.reason ?? 'Lost market clearing',
+                forecast,
+            };
+        }
+        if (forecast.netExpectedValue < 0 && expectedValue > 0) {
+            return {
+                approved: false,
+                reason: `Forecast net value negative (${forecast.netExpectedValue.toFixed(2)})`,
+                forecast,
+            };
+        }
+        const allocation = this.allocator.allocate(this.record, {
+            agentId,
+            requestedResources: input.requested,
+            expectedUtility: forecast.expectedUtility,
+            confidence,
+            urgency: input.urgency ?? 0.5,
+            reputationScore: agent.reputation.score,
+        });
+        if (allocation.approved) {
+            agent.wallet = {
+                tokensRemaining: (agent.wallet.tokensRemaining ?? 0) + (allocation.wallet.tokensRemaining ?? 0),
+                moneyRemaining: {
+                    amount: (agent.wallet.moneyRemaining?.amount ?? 0) +
+                        (allocation.wallet.moneyRemaining?.amount ?? 0),
+                    currency: this.record.pool.moneyRemaining.currency,
+                },
+            };
+            await this.repo.saveAgent(this.id, agent);
+            this.agentCache.set(agent.id, agent);
+            await this.persist();
+        }
+        return {
+            approved: allocation.approved,
+            reason: allocation.reason,
+            wallet: allocation.wallet,
+            forecast,
+        };
+    }
+    getMarketHistory(limit = 20) {
+        return this.marketEngine.getHistory(limit);
+    }
+    async getGraph() {
+        const agents = await this.repo.listAgents(this.id);
+        const nodes = agents.map((a) => ({
+            id: a.id,
+            label: a.name,
+            status: a.status,
+            generation: a.generation,
+            utility: a.utility.score,
+            reputation: a.reputation.score,
+            cost: a.costConsumed,
+            tokens: a.tokensConsumed,
+            objective: a.objective,
+            geneId: a.geneId,
+            parentId: a.parentAgentId,
+        }));
+        const edges = agents
+            .filter((a) => a.parentAgentId)
+            .map((a) => ({
+            from: a.parentAgentId,
+            to: a.id,
+            kind: 'parent',
+        }));
+        return { nodes, edges };
+    }
+    createAgentContext(agentId) {
+        return new organism_context_1.OrganismAgentContext({
+            getMission: () => this.record.mission,
+            getConstitution: () => this.record.constitution,
+            getWallet: () => {
+                const agent = this.syncGetAgent(agentId);
+                return agent?.wallet ?? {};
+            },
+            findAgents: async (query) => {
+                const all = await this.liveAgents();
+                if (!query.capabilities?.length)
+                    return all;
+                return this.capabilities.findCapableAgents(query.capabilities, all);
+            },
+            delegate: async (input) => this.delegateInternal(input.to, input.task),
+            requestResources: async (input) => this.requestResourcesForAgent(agentId, input),
+            placeBid: (input) => this.placeBid({
+                agentId,
+                ...input,
+            }),
+            negotiate: async (input) => this.negotiate({
+                fromAgentId: agentId,
+                toAgentId: input.toAgentId,
+                reason: input.reason,
+                transfer: input.transfer,
+                expectedValue: input.expectedValue,
+                confidence: input.confidence,
+            }),
+            reportOutcome: async (report) => this.reportOutcome(agentId, report),
+            requestApproval: async (input) => {
+                const key = `${input.action}:${input.reason}`;
+                if (this.pendingApprovals.has(key)) {
+                    return {
+                        approved: this.pendingApprovals.get(key),
+                        reason: 'Cached approval decision',
+                    };
+                }
+                const approved = (input.risk ?? 0) < 0.5;
+                this.pendingApprovals.set(key, approved);
+                return {
+                    approved,
+                    reason: approved ? 'Auto-approved low risk' : 'Requires human approval',
+                };
+            },
+            spawn: async (input) => this.spawnAgent({
+                ...input,
+                parentAgentId: agentId,
+            }),
+            reproduce: async (request) => this.reproduceAgent(agentId, request),
+            mutate: async (input) => this.mutateAgent(agentId, input),
+        });
+    }
+    /** Grant/deny a pending human approval key (for tests / HITL bridge). */
+    setApproval(action, reason, approved) {
+        this.pendingApprovals.set(`${action}:${reason}`, approved);
+    }
+    async simulate(options) {
+        this.record.simulation = true;
+        if (options.environment?.clock !== 'real') {
+            this.clock.useAccelerated(this.clock.now().getTime());
+        }
+        const log = options.onEvent ?? ((line) => this.log(line));
+        const prevLog = this.log;
+        this.log = log;
+        if (this.record.status === 'created') {
+            await this.start();
+        }
+        const durationMs = (0, clock_1.parseDurationMs)(options.duration, 86400000);
+        const stepMs = options.stepMs ?? Math.max(1000, Math.floor(durationMs / 20));
+        const signals = options.signals ?? [];
+        let elapsed = 0;
+        let signalIndex = 0;
+        while (elapsed < durationMs && this.record.status !== 'terminated') {
+            this.clock.advance(stepMs);
+            elapsed += stepMs;
+            if (signalIndex < signals.length) {
+                const at = (signalIndex + 1) * (durationMs / (signals.length + 1));
+                if (elapsed >= at) {
+                    await this.observe(signals[signalIndex]);
+                    signalIndex += 1;
+                }
+            }
+            if (elapsed % (0, clock_1.parseDurationMs)(this.record.cycles.survival, 600000) < stepMs) {
+                await this.runSurvivalCycle();
+            }
+        }
+        this.log = prevLog;
+        return this.inspect();
+    }
+    getAgentRuntime() {
+        return this.agentRuntime;
+    }
+    getRecord() {
+        return { ...this.record };
+    }
+    async listAgents() {
+        return this.repo.listAgents(this.id);
+    }
+    async listEvents(limit = 50) {
+        return this.events.getHistory(limit);
+    }
+    syncGetAgent(agentId) {
+        return this.agentCache.get(agentId);
+    }
+    async liveAgents() {
+        const all = await this.repo.listAgents(this.id);
+        for (const a of all)
+            this.agentCache.set(a.id, a);
+        return all.filter((a) => a.status !== 'terminated' && a.status !== 'failed');
+    }
+    async delegateInternal(to, task) {
+        const agent = await this.repo.getAgent(this.id, to);
+        if (!agent || agent.status === 'terminated') {
+            return { ok: false, result: 'Agent not available' };
+        }
+        agent.status = 'active';
+        await this.repo.saveAgent(this.id, agent);
+        this.agentCache.set(agent.id, agent);
+        this.log(`[DELEGATE] task to ${agent.name}#${agent.id}: ${task}`);
+        try {
+            if (this.agentRuntime.getAgentMetadata(agent.dnaAgentName)) {
+                await this.agentRuntime.execute(agent.dnaAgentName, task);
+            }
+        }
+        catch {
+            // mock / missing agent — still count as delegated assignment
+        }
+        return { ok: true, result: `Assigned: ${task}` };
+    }
+    startCycles() {
+        this.stopCycles();
+        if (this.record.simulation || this.clock.isAccelerated) {
+            // simulation drives cycles explicitly
+            return;
+        }
+        const survivalMs = (0, clock_1.parseDurationMs)(this.record.cycles.survival, 600000);
+        const timer = setInterval(() => {
+            void this.runSurvivalCycle();
+        }, survivalMs);
+        if (typeof timer.unref === 'function')
+            timer.unref();
+        this.cycleTimers.push(timer);
+    }
+    stopCycles() {
+        for (const t of this.cycleTimers)
+            clearInterval(t);
+        this.cycleTimers = [];
+    }
+    async persist() {
+        this.record.updatedAt = this.clock.now();
+        await this.repo.saveOrganism(this.record);
+    }
+}
+exports.OrganismRuntime = OrganismRuntime;
+function asDate(value) {
+    return value instanceof Date ? value : new Date(value);
+}
+function normalizeOrganismRecord(record) {
+    return {
+        ...record,
+        createdAt: asDate(record.createdAt),
+        updatedAt: asDate(record.updatedAt),
+    };
+}
+function normalizeAgentRecord(agent) {
+    return {
+        ...agent,
+        createdAt: asDate(agent.createdAt),
+        terminatedAt: agent.terminatedAt ? asDate(agent.terminatedAt) : undefined,
+        lastEvaluatedAt: agent.lastEvaluatedAt ? asDate(agent.lastEvaluatedAt) : undefined,
+        lastReproductionAt: agent.lastReproductionAt ? asDate(agent.lastReproductionAt) : undefined,
+        lastMutationAt: agent.lastMutationAt ? asDate(agent.lastMutationAt) : undefined,
+    };
+}
+async function createOrganism(options) {
+    return OrganismRuntime.create(options);
+}
+//# sourceMappingURL=organism-runtime.js.map