@noopolis/daimon 0.1.0 → 0.1.2

package/dist/examples/jungian-triad-org.js

@@ -0,0 +1,281 @@
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { JsonlMemoryStore } from "@noopolis/mneme";
+import { OrgObserver } from "../observability/index.js";
+import { PiHarnessAdapter } from "../pi/piHarness.js";
+import { exampleCausalId } from "./exampleCausalId.js";
+import { JungianPiRepresentative, seedPiCodexAuth } from "./jungianPiRepresentative.js";
+import { JungianVoice, runLimited } from "./jungianPlayAgent.js";
+import { JungianTrace, parseInnerUsed, parseSpeakLine } from "./jungianTrace.js";
+import { triadScenario, triadSelves } from "./jungianTriadProfiles.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const daimonRoot = path.resolve(__dirname, "../..");
+const runtimeRoot = path.join(daimonRoot, ".runtime", "jungian-triad-org");
+const runId = `run-${Date.now().toString(36)}`;
+const dialogueTurnCount = Math.max(12, Number.parseInt(process.env.DAIMON_JUNGIAN_TRIAD_TURNS ?? "12", 10));
+const voicesPerTurn = Math.max(1, Number.parseInt(process.env.DAIMON_JUNGIAN_VOICES_PER_TURN ?? "2", 10));
+const observer = new OrgObserver({ orgId: "jungian-triad-org", runId });
+const trace = new JungianTrace({ runId, title: triadScenario.title });
+const beats = [
+    { speakerId: "maya", focus: "Open on the missing chairs. Be annoyed, funny, and specific." },
+    { speakerId: "leo", focus: "Admit the mistake and say what you are checking first." },
+    { speakerId: "priya", focus: "Enter with the label maker and notice the real tension without taking over." },
+    { speakerId: "maya", focus: "Tell Priya the help is welcome, but Maya does not want another manager." },
+    { speakerId: "priya", focus: "Offer one system that gives Maya less work, not more." },
+    { speakerId: "leo", focus: "Commit to the chair hunt with a time and place." },
+    { speakerId: "maya", focus: "Name that she is tired of being the backup plan." },
+    { speakerId: "priya", focus: "Reflect both sides plainly and assign one small role to herself." },
+    { speakerId: "leo", focus: "Own the morning update without more self-deprecation." },
+    { speakerId: "maya", focus: "Delegate one task each and let the mood soften." },
+    { speakerId: "priya", focus: "Confirm her task and keep it friendly." },
+    { speakerId: "leo", focus: "Close with a normal hopeful line and a concrete next step." }
+];
+const roomContext = {
+    networkId: "jungian-triad",
+    roomId: "community-kitchen",
+    teamId: "jungian-triad-org",
+    participants: triadSelves.map((self) => self.representative.id)
+};
+const representativeInstructions = (self) => [
+    `You are ${self.representative.name}, the outward speaking Self for ${self.name}.`,
+    `Role: ${self.playRole}`,
+    `Mask: ${self.publicMask}`,
+    `Backstory: ${self.backstory}`,
+    `Conflict: ${self.conflict}`,
+    `Secret want: ${self.secretWant}`,
+    `Style: ${self.representative.style}`,
+    "Speak like a real person in a grounded workplace sitcom/drama.",
+    "Use short conversational dialogue, not analysis.",
+    "Return only SPEAK, STAGE, and INNER_USED."
+];
+const archetypeInstructions = (self, voice) => [
+    `You are ${voice.name}, the ${voice.archetype} voice inside ${self.name}.`,
+    `Agenda: ${voice.agenda}`,
+    `Fear: ${voice.fear}`,
+    `Gift: ${voice.gift}`,
+    `Wound: ${voice.wound}`,
+    "Counsel the representative in plain human terms.",
+    "No mythic language. No speeches. Keep it useful."
+];
+const transcriptText = (transcript) => transcript.length === 0 ? "(empty)" : transcript.join("\n");
+const councilPrompt = (self, focus, transcript) => [
+    `Scene: ${triadScenario.title}`,
+    `Premise: ${triadScenario.premise}`,
+    `Set: ${triadScenario.openingImage}`,
+    "",
+    `Self: ${self.name}`,
+    `Focus: ${focus}`,
+    "",
+    "External dialogue so far:",
+    transcriptText(transcript),
+    "",
+    "Use exactly this shape:",
+    "ARCHETYPE: <name>",
+    "COUNSEL: <one short practical note>",
+    "RISK: <what could go wrong emotionally>",
+    "LINE_NOTE: <how the representative should sound>"
+].join("\n");
+const representativePrompt = (self, focus, transcript, counsel) => [
+    `Scene: ${triadScenario.title}`,
+    `Premise: ${triadScenario.premise}`,
+    "",
+    "External dialogue so far:",
+    transcriptText(transcript),
+    "",
+    `Focus: ${focus}`,
+    "",
+    "Inner counsel:",
+    ...counsel.map((turn) => `- ${turn.voice.id}: ${turn.outputText.replace(/\n/g, " ")}`),
+    "",
+    "Write one natural next line. Keep SPEAK under 22 words.",
+    "Do not use Markdown, bullets, quotation marks, or narrator language inside SPEAK.",
+    "Use exactly this shape:",
+    "SPEAK: <one natural spoken line>",
+    "STAGE: <one tiny normal action>",
+    `INNER_USED: <comma-separated ids from ${self.voices.map((voice) => voice.id).join(", ")}>`
+].join("\n");
+const selectVoices = (self, selfTurnIndex) => Array.from({ length: Math.min(voicesPerTurn, self.archetypes.length) }, (_, offset) => self.archetypes[(selfTurnIndex * voicesPerTurn + offset) % self.archetypes.length]);
+const observeRepresentative = (turn) => {
+    const engineMs = "engineResult" in turn ? turn.engineResult.durationMs : turn.durationMs;
+    const promptChars = "engineResult" in turn ? turn.engineResult.promptChars : turn.promptChars;
+    const outputChars = "engineResult" in turn ? turn.engineResult.outputChars : turn.outputChars;
+    observer.recordTurn({
+        agent: turn.voice.id,
+        engine: turn.voice.engine,
+        event: turn.event.id,
+        eventText: turn.event.text,
+        totalMs: turn.totalMs,
+        memoryPrepareMs: turn.memoryPrepareMs,
+        engineMs,
+        memoryRecordMs: turn.memoryRecordMs,
+        promptChars,
+        outputChars,
+        outputText: turn.outputText,
+        recall: turn.recall
+    });
+};
+const observeCounsel = (turn) => {
+    observer.recordTurn({
+        agent: turn.voice.id,
+        engine: turn.voice.engine,
+        event: turn.event.id,
+        eventText: turn.event.text,
+        totalMs: turn.totalMs,
+        memoryPrepareMs: turn.memoryPrepareMs,
+        engineMs: turn.engineResult.durationMs,
+        memoryRecordMs: turn.memoryRecordMs,
+        promptChars: turn.engineResult.promptChars,
+        outputChars: turn.engineResult.outputChars,
+        outputText: turn.outputText,
+        recall: turn.recall
+    });
+};
+const runCouncil = async (self, eventBase, focus, transcript, voices) => {
+    console.log(`\n== ${self.profile.name} inner counsel ==`);
+    return runLimited(voices, 2, async (voice) => {
+        const event = {
+            id: exampleCausalId(`${eventBase}-council-${voice.config.id}`),
+            kind: "manual",
+            context: roomContext,
+            text: councilPrompt(self.profile, focus, transcript)
+        };
+        const turn = await voice.wake(event);
+        observeCounsel(turn);
+        trace.addCounsel({
+            archetype: voice.config.archetype ?? "unknown",
+            engine: voice.config.engine,
+            event: event.id,
+            output: turn.outputText,
+            recallSelected: turn.recall.selectedEventIds.length,
+            self: self.profile.name,
+            voice: voice.config.id
+        });
+        console.log(`${voice.config.id}: ${turn.outputText.split("\n")[0]}`);
+        return turn;
+    });
+};
+const assertUsedCounsel = (self, eventId, output, counsel) => {
+    const used = parseInnerUsed(output);
+    const allowed = new Set(counsel.flatMap((turn) => [turn.voice.id, turn.voice.id.replace(`${self.id}-`, "")]));
+    const passed = used.some((id) => allowed.has(id));
+    observer.recordAssertion({
+        detail: `${self.representative.id} should cite at least one consulted inner voice`,
+        event: eventId,
+        kind: "consultation",
+        passed
+    });
+    if (!passed) {
+        throw new Error(`${self.representative.id} did not cite consulted inner counsel:\n${output}`);
+    }
+    return used;
+};
+const runRepresentative = async (self, eventBase, focus, transcript, counsel) => {
+    const event = {
+        id: exampleCausalId(`${eventBase}-speaks`),
+        kind: "manual",
+        context: roomContext,
+        text: representativePrompt(self.profile, focus, transcript, counsel)
+    };
+    const turn = await self.representative.wake(event);
+    observeRepresentative(turn);
+    const innerUsed = assertUsedCounsel(self.profile, event.id, turn.outputText, counsel);
+    trace.addDialogue({
+        engine: self.profile.engine,
+        event: event.id,
+        innerUsed,
+        output: turn.outputText,
+        recallSelected: turn.recall.selectedEventIds.length,
+        self: self.profile.name,
+        speaker: self.profile.representative.name
+    });
+    const line = `${self.profile.name}: ${parseSpeakLine(turn.outputText)}`;
+    transcript.push(line);
+    console.log(`\n${line}`);
+};
+const buildSelf = (profile, piAdapter) => ({
+    profile,
+    representative: profile.engine === "pi"
+        ? new JungianPiRepresentative(profile, piAdapter, runtimeRoot, representativeInstructions(profile))
+        : new JungianVoice({
+            id: profile.representative.id,
+            name: profile.representative.name,
+            selfId: profile.id,
+            selfName: profile.name,
+            engine: profile.engine,
+            runtimeRoot,
+            instructions: representativeInstructions(profile)
+        }),
+    archetypes: profile.voices.map((voice) => new JungianVoice({
+        id: `${profile.id}-${voice.id}`,
+        name: voice.name,
+        selfId: profile.id,
+        selfName: profile.name,
+        archetype: voice.archetype,
+        engine: voice.engine,
+        runtimeRoot,
+        instructions: archetypeInstructions(profile, voice)
+    }))
+});
+const writeArtifacts = async (selves) => {
+    await observer.write(runtimeRoot);
+    await trace.write(runtimeRoot);
+    const voices = selves.flatMap((self) => [self.representative, ...self.archetypes]);
+    const counts = await Promise.all(voices.map(async (voice) => {
+        const events = await new JsonlMemoryStore(voice.runtimeHomePath).read();
+        return {
+            voice: "config" in voice ? voice.config.id : voice.profile.representative.id,
+            counts: events.reduce((memo, event) => {
+                memo[event.type] = (memo[event.type] ?? 0) + 1;
+                return memo;
+            }, {})
+        };
+    }));
+    await writeFile(path.join(runtimeRoot, "triad-memory-counts.json"), `${JSON.stringify(counts, null, 2)}\n`);
+};
+const run = async () => {
+    await rm(runtimeRoot, { recursive: true, force: true });
+    await mkdir(runtimeRoot, { recursive: true });
+    const piAuthPath = await seedPiCodexAuth(runtimeRoot);
+    const piAdapter = new PiHarnessAdapter({
+        authPath: piAuthPath,
+        model: { provider: "openai-codex", name: process.env.HARNESS_PI_MODEL ?? "gpt-5.3-codex-spark" },
+        memory: { source: "daimon/jungian-triad/pi", tokenBudget: 2600 }
+    });
+    const selves = triadSelves.map((profile) => buildSelf(profile, piAdapter));
+    await Promise.all(selves.flatMap((self) => [
+        self.representative.prepare(),
+        ...self.archetypes.map((voice) => voice.prepare())
+    ]));
+    await writeFile(path.join(runtimeRoot, "org.json"), `${JSON.stringify({ scenario: triadScenario, selves: triadSelves }, null, 2)}\n`);
+    const selfById = new Map(selves.map((self) => [self.profile.id, self]));
+    const selfTurns = new Map();
+    const transcript = [];
+    try {
+        for (const [index, beat] of beats.slice(0, dialogueTurnCount).entries()) {
+            const self = selfById.get(beat.speakerId);
+            if (!self) {
+                throw new Error(`Unknown self ${beat.speakerId}`);
+            }
+            const turnIndex = selfTurns.get(self.profile.id) ?? 0;
+            selfTurns.set(self.profile.id, turnIndex + 1);
+            const eventBase = `${self.profile.id}-turn-${String(index + 1).padStart(2, "0")}`;
+            const counsel = await runCouncil(self, eventBase, beat.focus, transcript, selectVoices(self, turnIndex));
+            await runRepresentative(self, eventBase, beat.focus, transcript, counsel);
+        }
+    }
+    finally {
+        await Promise.all(selves.map((self) => self.representative.stop()));
+    }
+    await writeArtifacts(selves);
+    console.log("\nExternal dialogue:");
+    for (const line of transcript) {
+        console.log(line);
+    }
+    console.log(`\nTrace: ${path.join(runtimeRoot, "jungian-trace.md")}`);
+    console.log("\ne2e:jungian-triad-org ok");
+};
+run().catch((error) => {
+    console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/examples/jungianConversationPlan.d.ts

@@ -0,0 +1,10 @@
+import type { JungianSelfProfile } from "./jungianProfiles.js";
+export interface DialogueBeat {
+    focus: string;
+    speakerId: string;
+}
+export declare const defaultDialogueTurns = 12;
+export declare const dialogueBeats: DialogueBeat[];
+export declare const beatsFor: (turnCount: number) => DialogueBeat[];
+export declare const selectVoicesForBeat: (self: JungianSelfProfile, beatIndex: number, count: number) => JungianSelfProfile["voices"];
+//# sourceMappingURL=jungianConversationPlan.d.ts.map

package/dist/examples/jungianConversationPlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jungianConversationPlan.d.ts","sourceRoot":"","sources":["../../src/examples/jungianConversationPlan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC,eAAO,MAAM,aAAa,EAAE,YAAY,EAiDvC,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,WAAW,MAAM,KAAG,YAAY,EAKxD,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,MAAM,kBAAkB,EACxB,WAAW,MAAM,EACjB,OAAO,MAAM,KACZ,kBAAkB,CAAC,QAAQ,CAM7B,CAAC"}

package/dist/examples/jungianConversationPlan.js

@@ -0,0 +1,64 @@
+export const defaultDialogueTurns = 12;
+export const dialogueBeats = [
+    {
+        speakerId: "maya",
+        focus: "Start the conversation after Maya notices the chairs are missing. Be annoyed but human."
+    },
+    {
+        speakerId: "leo",
+        focus: "Answer without dodging. Admit what happened, but keep it conversational."
+    },
+    {
+        speakerId: "maya",
+        focus: "Explain the actual problem: she needed a partner, not another surprise."
+    },
+    {
+        speakerId: "leo",
+        focus: "Offer one concrete fix and avoid making it all about his shame."
+    },
+    {
+        speakerId: "maya",
+        focus: "Let the tension soften a little, but do not erase the boundary."
+    },
+    {
+        speakerId: "leo",
+        focus: "Make a small joke that helps, then say what he will do next."
+    },
+    {
+        speakerId: "maya",
+        focus: "Admit she is tired of being the backup plan for everyone."
+    },
+    {
+        speakerId: "leo",
+        focus: "Hear that directly and respond like a friend, not a defendant."
+    },
+    {
+        speakerId: "maya",
+        focus: "Ask for a new working agreement for tomorrow morning."
+    },
+    {
+        speakerId: "leo",
+        focus: "Commit to the agreement with specifics."
+    },
+    {
+        speakerId: "maya",
+        focus: "Let in a little warmth and humor without dropping the point."
+    },
+    {
+        speakerId: "leo",
+        focus: "Close the scene with a normal, hopeful line that sounds like Leo."
+    }
+];
+export const beatsFor = (turnCount) => {
+    if (turnCount <= dialogueBeats.length) {
+        return dialogueBeats.slice(0, turnCount);
+    }
+    return Array.from({ length: turnCount }, (_, index) => dialogueBeats[index % dialogueBeats.length]);
+};
+export const selectVoicesForBeat = (self, beatIndex, count) => {
+    const voices = self.voices;
+    if (count >= voices.length) {
+        return voices;
+    }
+    return Array.from({ length: count }, (_, offset) => voices[(beatIndex + offset) % voices.length]);
+};

package/dist/examples/jungianPiRepresentative.d.ts

@@ -0,0 +1,36 @@
+import type { WakeEvent } from "../core/types.js";
+import type { MemoryRecallAudit } from "@noopolis/mneme";
+import { PiHarnessAdapter } from "../pi/piHarness.js";
+import type { TriadSelfProfile } from "./jungianTriadProfiles.js";
+export interface PiRepresentativeTurn {
+    durationMs: number;
+    engine: "pi";
+    event: WakeEvent;
+    memoryPrepareMs: number;
+    memoryRecordMs: number;
+    outputChars: number;
+    outputText: string;
+    promptChars: number;
+    recall: MemoryRecallAudit;
+    totalMs: number;
+    voice: {
+        engine: "pi";
+        id: string;
+        selfId: string;
+    };
+}
+export declare const seedPiCodexAuth: (runtimeRoot: string) => Promise<string>;
+export declare class JungianPiRepresentative {
+    readonly profile: TriadSelfProfile;
+    private readonly adapter;
+    private readonly runtimeRoot;
+    private readonly instructions;
+    private handle;
+    readonly runtimeHomePath: string;
+    readonly workspacePath: string;
+    constructor(profile: TriadSelfProfile, adapter: PiHarnessAdapter, runtimeRoot: string, instructions: string[]);
+    prepare(): Promise<void>;
+    stop(): Promise<void>;
+    wake(event: WakeEvent): Promise<PiRepresentativeTurn>;
+}
+//# sourceMappingURL=jungianPiRepresentative.d.ts.map

package/dist/examples/jungianPiRepresentative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jungianPiRepresentative.d.ts","sourceRoot":"","sources":["../../src/examples/jungianPiRepresentative.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAe,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,IAAI,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE;QACL,MAAM,EAAE,IAAI,CAAC;QACb,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAWD,eAAO,MAAM,eAAe,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,MAAM,CAMzE,CAAC;AAEF,qBAAa,uBAAuB;IAMhC,QAAQ,CAAC,OAAO,EAAE,gBAAgB;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAR/B,OAAO,CAAC,MAAM,CAA0B;IACxC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;gBAGpB,OAAO,EAAE,gBAAgB,EACjB,OAAO,EAAE,gBAAgB,EACzB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EAAE;IAMnC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAwBxB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAuB5D"}

package/dist/examples/jungianPiRepresentative.js

@@ -0,0 +1,81 @@
+import { access, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { seedPiOpenAICodexAuthFromCodex } from "../pi/auth.js";
+const emptyRecall = () => ({
+    decisions: [],
+    redactionCount: 0,
+    selected: [],
+    selectedEventIds: [],
+    tokenBudgetUsed: 0,
+    totalCandidates: 0
+});
+export const seedPiCodexAuth = async (runtimeRoot) => {
+    const codexAuthPath = path.join(process.env.HOME ?? "", ".codex", "auth.json");
+    await access(codexAuthPath);
+    const piAuthPath = path.join(runtimeRoot, "auth", "pi-codex-auth.json");
+    await seedPiOpenAICodexAuthFromCodex({ codexAuthPath, piAuthPath });
+    return piAuthPath;
+};
+export class JungianPiRepresentative {
+    profile;
+    adapter;
+    runtimeRoot;
+    instructions;
+    handle;
+    runtimeHomePath;
+    workspacePath;
+    constructor(profile, adapter, runtimeRoot, instructions) {
+        this.profile = profile;
+        this.adapter = adapter;
+        this.runtimeRoot = runtimeRoot;
+        this.instructions = instructions;
+        this.workspacePath = path.join(runtimeRoot, "selves", profile.id, "voices", profile.representative.id, "workspace");
+        this.runtimeHomePath = path.join(runtimeRoot, "selves", profile.id, "voices", profile.representative.id, "runtime");
+    }
+    async prepare() {
+        await mkdir(this.workspacePath, { recursive: true });
+        await mkdir(this.runtimeHomePath, { recursive: true });
+        await writeFile(path.join(this.workspacePath, "AGENTS.md"), [
+            `# ${this.profile.representative.name}`,
+            "",
+            `Self: ${this.profile.name}`,
+            "Runtime: Pi with OpenAI Codex subscription auth",
+            "",
+            "Speak only through the requested SPEAK/STAGE/INNER_USED shape."
+        ].join("\n"));
+        this.handle = await this.adapter.startAgent({
+            id: this.profile.representative.id,
+            name: this.profile.representative.name,
+            instructions: this.instructions.join("\n"),
+            runtimeHomePath: this.runtimeHomePath,
+            workspacePath: this.workspacePath,
+            tools: []
+        });
+    }
+    async stop() {
+        await this.handle?.stop();
+    }
+    async wake(event) {
+        if (!this.handle) {
+            throw new Error(`${this.profile.representative.id} was not prepared`);
+        }
+        const result = await this.handle.wake(event);
+        return {
+            durationMs: result.durationMs,
+            engine: "pi",
+            event,
+            memoryPrepareMs: 0,
+            memoryRecordMs: 0,
+            outputChars: result.text.length,
+            outputText: result.text,
+            promptChars: event.text.length,
+            recall: emptyRecall(),
+            totalMs: result.durationMs,
+            voice: {
+                engine: "pi",
+                id: this.profile.representative.id,
+                selfId: this.profile.id
+            }
+        };
+    }
+}

package/dist/examples/jungianPlayAgent.d.ts

@@ -0,0 +1,36 @@
+import type { WakeEvent } from "../core/types.js";
+import type { MemoryRecallAudit } from "@noopolis/mneme";
+import { type CliEngineKind as EngineKind, type EngineRunResult } from "../pi/cliSession.js";
+export interface JungianVoiceConfig {
+    archetype?: string;
+    engine: EngineKind;
+    id: string;
+    instructions: string[];
+    name: string;
+    runtimeRoot: string;
+    selfId: string;
+    selfName: string;
+}
+export interface JungianVoiceTurn {
+    engineResult: EngineRunResult;
+    event: WakeEvent;
+    memoryPrepareMs: number;
+    memoryRecordMs: number;
+    outputText: string;
+    promptText: string;
+    recall: MemoryRecallAudit;
+    totalMs: number;
+    voice: JungianVoiceConfig;
+}
+export declare class JungianVoice {
+    readonly config: JungianVoiceConfig;
+    readonly runtimeHomePath: string;
+    readonly workspacePath: string;
+    private readonly memory;
+    constructor(config: JungianVoiceConfig);
+    prepare(): Promise<void>;
+    stop(): Promise<void>;
+    wake(event: WakeEvent): Promise<JungianVoiceTurn>;
+}
+export declare const runLimited: <T, R>(values: readonly T[], limit: number, run: (value: T) => Promise<R>) => Promise<R[]>;
+//# sourceMappingURL=jungianPlayAgent.d.ts.map

package/dist/examples/jungianPlayAgent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jungianPlayAgent.d.ts","sourceRoot":"","sources":["../../src/examples/jungianPlayAgent.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAqB,KAAK,aAAa,IAAI,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEhH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,eAAe,CAAC;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,kBAAkB,CAAC;CAC3B;AAUD,qBAAa,YAAY;IAKX,QAAQ,CAAC,MAAM,EAAE,kBAAkB;IAJ/C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,kBAAkB;IAWzC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBxB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,gBAAgB,CAAC;CA4DxD;AAED,eAAO,MAAM,UAAU,GAAU,CAAC,EAAE,CAAC,EACnC,QAAQ,SAAS,CAAC,EAAE,EACpB,OAAO,MAAM,EACb,KAAK,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KAC5B,OAAO,CAAC,CAAC,EAAE,CAYb,CAAC"}

package/dist/examples/jungianPlayAgent.js

@@ -0,0 +1,111 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createMemoryRuntime } from "@noopolis/mneme";
+import { runEngineDetailed } from "../pi/cliSession.js";
+const maxMemoryChars = 2200;
+const truncate = (text, maxChars) => text.length <= maxChars ? text : `${text.slice(0, maxChars).trim()}\n[truncated]`;
+const memorySections = (turnPrompt) => truncate(turnPrompt, maxMemoryChars);
+export class JungianVoice {
+    config;
+    runtimeHomePath;
+    workspacePath;
+    memory;
+    constructor(config) {
+        this.config = config;
+        this.workspacePath = path.join(config.runtimeRoot, "selves", config.selfId, "voices", config.id, "workspace");
+        this.runtimeHomePath = path.join(config.runtimeRoot, "selves", config.selfId, "voices", config.id, "runtime");
+        this.memory = createMemoryRuntime({
+            agentId: config.id,
+            runtimeHomePath: this.runtimeHomePath,
+            source: `daimon/jungian-play/${config.engine}`,
+            tokenBudget: 2600
+        });
+    }
+    async prepare() {
+        await mkdir(this.workspacePath, { recursive: true });
+        await mkdir(this.runtimeHomePath, { recursive: true });
+        await writeFile(path.join(this.workspacePath, "AGENTS.md"), [
+            `# ${this.config.name}`,
+            "",
+            `Self: ${this.config.selfName}`,
+            `Voice: ${this.config.archetype ?? "Representative Self"}`,
+            `Engine: ${this.config.engine}`,
+            "",
+            "This workspace belongs to the Daimon Jungian play E2E.",
+            "Do not edit files during the play. Speak only through the requested output shape."
+        ].join("\n"));
+    }
+    async stop() {
+        // CLI-backed voices are one-process-per-wake and have no persistent handle.
+    }
+    async wake(event) {
+        const startedAt = Date.now();
+        const prepareStartedAt = Date.now();
+        const prepared = await this.memory.prepareTurn({
+            eventId: event.id,
+            kind: event.kind,
+            text: event.text,
+            from: event.from,
+            context: event.context ?? {}
+        });
+        const memoryPrepareMs = Date.now() - prepareStartedAt;
+        const promptText = [
+            `${this.config.name} (${this.config.id})`,
+            `Self: ${this.config.selfName} (${this.config.selfId})`,
+            `Role: ${this.config.archetype ?? "Representative Self"}`,
+            "",
+            "Standing instructions:",
+            ...this.config.instructions.map((line) => `- ${line}`),
+            "",
+            "Daimon memory packet:",
+            memorySections(prepared.promptText),
+            "",
+            "Current wake:",
+            event.text
+        ].join("\n");
+        const engineResult = await runEngineDetailed(this.config.engine, promptText, {
+            runtimeHomePath: this.runtimeHomePath,
+            workspacePath: this.workspacePath
+        });
+        const recordStartedAt = Date.now();
+        await this.memory.recordTurn({
+            principal: prepared.principal,
+            prompt: prepared.packet,
+            request: {
+                eventId: event.id,
+                kind: event.kind,
+                text: event.text,
+                from: event.from,
+                context: event.context ?? {}
+            },
+            recall: prepared.recall,
+            result: "completed",
+            outputText: engineResult.text
+        });
+        const memoryRecordMs = Date.now() - recordStartedAt;
+        return {
+            engineResult,
+            event,
+            memoryPrepareMs,
+            memoryRecordMs,
+            outputText: engineResult.text,
+            promptText,
+            recall: prepared.recall,
+            totalMs: Date.now() - startedAt,
+            voice: this.config
+        };
+    }
+}
+export const runLimited = async (values, limit, run) => {
+    const results = [];
+    let index = 0;
+    const workers = Array.from({ length: Math.min(limit, values.length) }, async () => {
+        while (index < values.length) {
+            const current = index;
+            index += 1;
+            results[current] = await run(values[current]);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+};

package/dist/examples/jungianProfiles.d.ts

@@ -0,0 +1,34 @@
+import type { CliEngineKind as EngineKind } from "../pi/cliSession.js";
+export interface JungianArchetypeProfile {
+    agenda: string;
+    archetype: string;
+    engine: EngineKind;
+    fear: string;
+    gift: string;
+    id: string;
+    name: string;
+    wound: string;
+}
+export interface JungianSelfProfile {
+    backstory: string;
+    conflict: string;
+    engine: EngineKind;
+    id: string;
+    name: string;
+    playRole: string;
+    publicMask: string;
+    representative: {
+        id: string;
+        name: string;
+        style: string;
+    };
+    secretWant: string;
+    voices: JungianArchetypeProfile[];
+}
+export declare const jungianSelves: JungianSelfProfile[];
+export declare const playScenario: {
+    title: string;
+    premise: string;
+    openingImage: string;
+};
+//# sourceMappingURL=jungianProfiles.d.ts.map

package/dist/examples/jungianProfiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jungianProfiles.d.ts","sourceRoot":"","sources":["../../src/examples/jungianProfiles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEvE,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE;QACd,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,uBAAuB,EAAE,CAAC;CACnC;AA+JD,eAAO,MAAM,aAAa,EAAE,kBAAkB,EAiC7C,CAAC;AAEF,eAAO,MAAM,YAAY;;;;CAMxB,CAAC"}