@agents-uni/zhenhuan 0.1.0

package/dist/palace/ceremonies.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Palace Ceremonies - 宫廷典礼
+ *
+ * Handles formal palace events: court assemblies, selections,
+ * promotions, demotions, and eliminations.
+ */
+import type { AgentRegistry, EventBus } from '@agents-uni/core';
+import type { AgentDefinition } from '@agents-uni/core';
+export interface CeremonyResult {
+    type: 'court_assembly' | 'selection' | 'promotion' | 'demotion' | 'elimination';
+    timestamp: string;
+    participants: string[];
+    outcomes: CeremonyOutcome[];
+    narrative: string;
+}
+export interface CeremonyOutcome {
+    agentId: string;
+    action: string;
+    details: Record<string, unknown>;
+}
+/**
+ * Manages formal palace ceremonies and rituals.
+ */
+export declare class PalaceCeremonies {
+    private registry;
+    private events;
+    private ceremonyHistory;
+    constructor(registry: AgentRegistry, events: EventBus);
+    /**
+     * Conduct monthly court assembly (朝会).
+     * Reviews rankings and triggers promotions/demotions.
+     */
+    conductCourtAssembly(agentPerformances: Map<string, number>, eloRatings: Map<string, number>): Promise<CeremonyResult>;
+    /**
+     * Conduct selection ceremony (选秀) for new consorts.
+     */
+    conductSelection(newAgents: AgentDefinition[]): Promise<CeremonyResult>;
+    /**
+     * Conduct promotion ceremony (晋升典礼).
+     */
+    conductPromotion(agentId: string, newRankLevel: number): Promise<CeremonyResult>;
+    /**
+     * Conduct demotion (贬谪).
+     */
+    conductDemotion(agentId: string, newRankLevel: number): Promise<CeremonyResult>;
+    /**
+     * Conduct elimination (打入冷宫).
+     */
+    conductElimination(agentId: string): Promise<CeremonyResult>;
+    /** Get ceremony history */
+    getHistory(): CeremonyResult[];
+    /** Extract a numeric rank level from an agent definition */
+    private extractRankLevel;
+    private generateCourtNarrative;
+}

package/dist/palace/ceremonies.js

@@ -0,0 +1,263 @@
+/**
+ * Palace Ceremonies - 宫廷典礼
+ *
+ * Handles formal palace events: court assemblies, selections,
+ * promotions, demotions, and eliminations.
+ */
+import { getRankByLevel, getRankByTitle, getNextRank, getPreviousRank, canPromote, isRankFull } from './ranks.js';
+/**
+ * Manages formal palace ceremonies and rituals.
+ */
+export class PalaceCeremonies {
+    registry;
+    events;
+    ceremonyHistory;
+    constructor(registry, events) {
+        this.registry = registry;
+        this.events = events;
+        this.ceremonyHistory = [];
+    }
+    /**
+     * Conduct monthly court assembly (朝会).
+     * Reviews rankings and triggers promotions/demotions.
+     */
+    async conductCourtAssembly(agentPerformances, eloRatings) {
+        const outcomes = [];
+        const participants = [];
+        // Evaluate each active consort
+        const citizens = this.registry.getAll().filter(c => c.status === 'active' || c.status === 'idle');
+        for (const citizen of citizens) {
+            const agentId = citizen.definition.id;
+            participants.push(agentId);
+            const performance = agentPerformances.get(agentId) ?? 50;
+            const elo = eloRatings.get(agentId) ?? 1200;
+            const currentRankLevel = this.extractRankLevel(citizen.definition);
+            // Check for promotion eligibility
+            if (performance >= 75 && canPromote(currentRankLevel, elo)) {
+                const nextRank = getNextRank(currentRankLevel);
+                if (nextRank) {
+                    // Count current occupants at next rank
+                    const occupantsAtNextRank = citizens.filter(c => this.extractRankLevel(c.definition) === nextRank.level).length;
+                    if (!isRankFull(nextRank.level, occupantsAtNextRank)) {
+                        outcomes.push({
+                            agentId,
+                            action: 'promotion_eligible',
+                            details: {
+                                currentLevel: currentRankLevel,
+                                targetLevel: nextRank.level,
+                                targetTitle: nextRank.title,
+                                elo,
+                                performance,
+                            },
+                        });
+                    }
+                }
+            }
+            // Check for demotion
+            if (performance < 30 && currentRankLevel > 1) {
+                const prevRank = getPreviousRank(currentRankLevel);
+                if (prevRank) {
+                    outcomes.push({
+                        agentId,
+                        action: 'demotion_recommended',
+                        details: {
+                            currentLevel: currentRankLevel,
+                            targetLevel: prevRank.level,
+                            targetTitle: prevRank.title,
+                            performance,
+                        },
+                    });
+                }
+            }
+        }
+        const result = {
+            type: 'court_assembly',
+            timestamp: new Date().toISOString(),
+            participants,
+            outcomes,
+            narrative: this.generateCourtNarrative(outcomes),
+        };
+        this.ceremonyHistory.push(result);
+        await this.events.emitSimple('custom', participants, result.narrative, { ceremonyType: 'court_assembly', outcomeCount: outcomes.length });
+        return result;
+    }
+    /**
+     * Conduct selection ceremony (选秀) for new consorts.
+     */
+    async conductSelection(newAgents) {
+        const outcomes = [];
+        const participants = [];
+        for (const agent of newAgents) {
+            try {
+                this.registry.register(agent);
+                this.registry.setStatus(agent.id, 'idle');
+                participants.push(agent.id);
+                outcomes.push({
+                    agentId: agent.id,
+                    action: 'selected',
+                    details: {
+                        name: agent.name,
+                        role: agent.role.title,
+                        rank: agent.rank,
+                    },
+                });
+                await this.events.emitSimple('agent.joined', [agent.id], `${agent.name}通过选秀入宫，初封${agent.role.title}`, { agentId: agent.id });
+            }
+            catch (error) {
+                outcomes.push({
+                    agentId: agent.id,
+                    action: 'selection_failed',
+                    details: {
+                        reason: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                });
+            }
+        }
+        const result = {
+            type: 'selection',
+            timestamp: new Date().toISOString(),
+            participants,
+            outcomes,
+            narrative: `选秀大典：${newAgents.length}位秀女参选，${outcomes.filter(o => o.action === 'selected').length}位入选。`,
+        };
+        this.ceremonyHistory.push(result);
+        return result;
+    }
+    /**
+     * Conduct promotion ceremony (晋升典礼).
+     */
+    async conductPromotion(agentId, newRankLevel) {
+        const citizen = this.registry.get(agentId);
+        if (!citizen) {
+            throw new Error(`Agent "${agentId}" not found`);
+        }
+        const newRank = getRankByLevel(newRankLevel);
+        if (!newRank) {
+            throw new Error(`Invalid rank level: ${newRankLevel}`);
+        }
+        const oldRankLevel = this.extractRankLevel(citizen.definition);
+        const oldRank = getRankByLevel(oldRankLevel);
+        // Update the agent's role title and rank
+        citizen.definition.role.title = newRank.title;
+        citizen.definition.rank = newRankLevel * 10;
+        const outcome = {
+            agentId,
+            action: 'promoted',
+            details: {
+                oldRank: oldRank?.title ?? '未知',
+                oldLevel: oldRankLevel,
+                newRank: newRank.title,
+                newLevel: newRankLevel,
+            },
+        };
+        const narrative = `晋升典礼：${citizen.definition.name}由${oldRank?.title ?? '未知'}晋升为${newRank.title}，恩泽浩荡。`;
+        await this.events.emitSimple('agent.promoted', [agentId], narrative, outcome.details);
+        const result = {
+            type: 'promotion',
+            timestamp: new Date().toISOString(),
+            participants: [agentId],
+            outcomes: [outcome],
+            narrative,
+        };
+        this.ceremonyHistory.push(result);
+        return result;
+    }
+    /**
+     * Conduct demotion (贬谪).
+     */
+    async conductDemotion(agentId, newRankLevel) {
+        const citizen = this.registry.get(agentId);
+        if (!citizen) {
+            throw new Error(`Agent "${agentId}" not found`);
+        }
+        const newRank = getRankByLevel(newRankLevel);
+        if (!newRank) {
+            throw new Error(`Invalid rank level: ${newRankLevel}`);
+        }
+        const oldRankLevel = this.extractRankLevel(citizen.definition);
+        const oldRank = getRankByLevel(oldRankLevel);
+        citizen.definition.role.title = newRank.title;
+        citizen.definition.rank = newRankLevel * 10;
+        const outcome = {
+            agentId,
+            action: 'demoted',
+            details: {
+                oldRank: oldRank?.title ?? '未知',
+                oldLevel: oldRankLevel,
+                newRank: newRank.title,
+                newLevel: newRankLevel,
+            },
+        };
+        const narrative = `贬谪旨意：${citizen.definition.name}由${oldRank?.title ?? '未知'}贬为${newRank.title}，以儆效尤。`;
+        await this.events.emitSimple('agent.demoted', [agentId], narrative, outcome.details);
+        const result = {
+            type: 'demotion',
+            timestamp: new Date().toISOString(),
+            participants: [agentId],
+            outcomes: [outcome],
+            narrative,
+        };
+        this.ceremonyHistory.push(result);
+        return result;
+    }
+    /**
+     * Conduct elimination (打入冷宫).
+     */
+    async conductElimination(agentId) {
+        const citizen = this.registry.get(agentId);
+        if (!citizen) {
+            throw new Error(`Agent "${agentId}" not found`);
+        }
+        this.registry.setStatus(agentId, 'suspended');
+        const outcome = {
+            agentId,
+            action: 'eliminated',
+            details: {
+                name: citizen.definition.name,
+                formerRank: citizen.definition.role.title,
+            },
+        };
+        const narrative = `${citizen.definition.name}被打入冷宫，昔日荣华尽失。`;
+        await this.events.emitSimple('agent.suspended', [agentId], narrative, outcome.details);
+        const result = {
+            type: 'elimination',
+            timestamp: new Date().toISOString(),
+            participants: [agentId],
+            outcomes: [outcome],
+            narrative,
+        };
+        this.ceremonyHistory.push(result);
+        return result;
+    }
+    /** Get ceremony history */
+    getHistory() {
+        return [...this.ceremonyHistory];
+    }
+    /** Extract a numeric rank level from an agent definition */
+    extractRankLevel(definition) {
+        // Derive level from rank value (rank / 10), or look up by title
+        if (definition.rank !== undefined) {
+            const level = Math.round(definition.rank / 10);
+            if (level >= 1 && level <= 8)
+                return level;
+        }
+        // Fallback: match by title
+        const match = getRankByTitle(definition.role.title);
+        return match?.level ?? 1;
+    }
+    generateCourtNarrative(outcomes) {
+        const promotions = outcomes.filter(o => o.action === 'promotion_eligible');
+        const demotions = outcomes.filter(o => o.action === 'demotion_recommended');
+        const parts = ['朝会已毕。'];
+        if (promotions.length > 0) {
+            parts.push(`${promotions.length}人表现优异，可堪晋升。`);
+        }
+        if (demotions.length > 0) {
+            parts.push(`${demotions.length}人表现不佳，建议贬谪。`);
+        }
+        if (promotions.length === 0 && demotions.length === 0) {
+            parts.push('众妃嫔表现平稳，无需调整品级。');
+        }
+        return parts.join('');
+    }
+}

package/dist/palace/cold-palace.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Cold Palace (冷宫) - Elimination Zone
+ *
+ * Manages agents who have been banished from the palace.
+ * Some may be rehabilitated, others permanently eliminated.
+ */
+import type { AgentRegistry, EventBus } from '@agents-uni/core';
+export interface ColdPalaceInmate {
+    agentId: string;
+    name: string;
+    reason: string;
+    banishedAt: string;
+    /** Duration in milliseconds. Undefined means indefinite. */
+    duration?: number;
+    /** When the sentence expires */
+    expiresAt?: string;
+    status: 'serving' | 'rehabilitated' | 'eliminated';
+}
+/**
+ * The Cold Palace - where disgraced consorts are banished.
+ */
+export declare class ColdPalace {
+    private inmates;
+    private registry;
+    private events;
+    constructor(registry: AgentRegistry, events: EventBus);
+    /** Banish an agent to the cold palace */
+    banish(agentId: string, reason: string, durationMs?: number): Promise<boolean>;
+    /** Rehabilitate an agent from the cold palace */
+    rehabilitate(agentId: string): Promise<boolean>;
+    /** Permanently eliminate an agent */
+    eliminate(agentId: string): Promise<boolean>;
+    /** Get all current inmates (those still serving) */
+    getInmates(): ColdPalaceInmate[];
+    /** Get all records (including rehabilitated and eliminated) */
+    getAllRecords(): ColdPalaceInmate[];
+    /** Check if any inmates have served their time and can be paroled */
+    checkParole(): ColdPalaceInmate[];
+    /** Check if an agent is currently in the cold palace */
+    isInColdPalace(agentId: string): boolean;
+}

package/dist/palace/cold-palace.js

@@ -0,0 +1,106 @@
+/**
+ * Cold Palace (冷宫) - Elimination Zone
+ *
+ * Manages agents who have been banished from the palace.
+ * Some may be rehabilitated, others permanently eliminated.
+ */
+/**
+ * The Cold Palace - where disgraced consorts are banished.
+ */
+export class ColdPalace {
+    inmates;
+    registry;
+    events;
+    constructor(registry, events) {
+        this.inmates = new Map();
+        this.registry = registry;
+        this.events = events;
+    }
+    /** Banish an agent to the cold palace */
+    async banish(agentId, reason, durationMs) {
+        const citizen = this.registry.get(agentId);
+        if (!citizen)
+            return false;
+        if (citizen.status === 'eliminated')
+            return false;
+        if (this.inmates.has(agentId) && this.inmates.get(agentId).status === 'serving') {
+            return false;
+        }
+        const now = new Date();
+        const inmate = {
+            agentId,
+            name: citizen.definition.name,
+            reason,
+            banishedAt: now.toISOString(),
+            duration: durationMs,
+            expiresAt: durationMs
+                ? new Date(now.getTime() + durationMs).toISOString()
+                : undefined,
+            status: 'serving',
+        };
+        this.inmates.set(agentId, inmate);
+        this.registry.setStatus(agentId, 'suspended');
+        await this.events.emitSimple('agent.suspended', [agentId], `${citizen.definition.name}被打入冷宫：${reason}`, { reason, duration: durationMs });
+        return true;
+    }
+    /** Rehabilitate an agent from the cold palace */
+    async rehabilitate(agentId) {
+        const inmate = this.inmates.get(agentId);
+        if (!inmate || inmate.status !== 'serving')
+            return false;
+        inmate.status = 'rehabilitated';
+        this.registry.setStatus(agentId, 'idle');
+        await this.events.emitSimple('agent.reinstated', [agentId], `${inmate.name}重获恩宠，从冷宫复出`, { agentId });
+        return true;
+    }
+    /** Permanently eliminate an agent */
+    async eliminate(agentId) {
+        const inmate = this.inmates.get(agentId);
+        if (!inmate) {
+            // Agent might not be in cold palace yet; banish first
+            const citizen = this.registry.get(agentId);
+            if (!citizen)
+                return false;
+            this.inmates.set(agentId, {
+                agentId,
+                name: citizen.definition.name,
+                reason: '永久除名',
+                banishedAt: new Date().toISOString(),
+                status: 'eliminated',
+            });
+        }
+        else {
+            inmate.status = 'eliminated';
+        }
+        this.registry.setStatus(agentId, 'eliminated');
+        const name = inmate?.name ?? agentId;
+        await this.events.emitSimple('agent.eliminated', [agentId], `${name}被永久除名，再无翻身之日`, { agentId });
+        return true;
+    }
+    /** Get all current inmates (those still serving) */
+    getInmates() {
+        return [...this.inmates.values()].filter(i => i.status === 'serving');
+    }
+    /** Get all records (including rehabilitated and eliminated) */
+    getAllRecords() {
+        return [...this.inmates.values()];
+    }
+    /** Check if any inmates have served their time and can be paroled */
+    checkParole() {
+        const now = new Date().toISOString();
+        const eligible = [];
+        for (const inmate of this.inmates.values()) {
+            if (inmate.status === 'serving' &&
+                inmate.expiresAt &&
+                inmate.expiresAt <= now) {
+                eligible.push(inmate);
+            }
+        }
+        return eligible;
+    }
+    /** Check if an agent is currently in the cold palace */
+    isInColdPalace(agentId) {
+        const inmate = this.inmates.get(agentId);
+        return inmate !== undefined && inmate.status === 'serving';
+    }
+}

package/dist/palace/dynamics.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Palace Dynamics - 后宫势力与关系
+ *
+ * Manages alliances, betrayals, factions, and influence calculations
+ * within the palace hierarchy.
+ */
+import type { RelationshipGraph } from '@agents-uni/core';
+import type { AgentRegistry } from '@agents-uni/core';
+import type { ResourcePool } from '@agents-uni/core';
+export interface AllianceRecord {
+    agent1: string;
+    agent2: string;
+    reason: string;
+    formedAt: string;
+}
+export interface BetrayalRecord {
+    betrayer: string;
+    betrayed: string;
+    reason: string;
+    occurredAt: string;
+}
+export interface Faction {
+    id: string;
+    members: string[];
+    leader: string;
+    influence: number;
+}
+/**
+ * Manages the complex political dynamics of the palace.
+ */
+export declare class PalaceDynamics {
+    private graph;
+    private registry;
+    private resources;
+    private allianceHistory;
+    private betrayalHistory;
+    constructor(graph: RelationshipGraph, registry: AgentRegistry, resources: ResourcePool);
+    /** Form an alliance between two agents */
+    formAlliance(agent1: string, agent2: string, reason: string): boolean;
+    /** Betray an alliance, creating a rivalry */
+    betrayAlliance(betrayer: string, betrayed: string, reason: string): boolean;
+    /** Calculate an agent's influence based on rank, allies, and favor */
+    calculateInfluence(agentId: string): number;
+    /** Get all factions (groups of allied agents) */
+    getFactions(): Faction[];
+    /** Check if a challenger can challenge a target (adjacent ranks only) */
+    canChallenge(challengerId: string, targetId: string): boolean;
+    /** Get alliance history */
+    getAllianceHistory(): AllianceRecord[];
+    /** Get betrayal history */
+    getBetrayalHistory(): BetrayalRecord[];
+}