@noopolis/daimon 0.1.0 → 0.1.1

package/README.md

@@ -15,6 +15,28 @@ should not know what an org is.
 npm install @noopolis/daimon
 ```
 
+For Pi agents with memory enabled, install Mneme too:
+
+```bash
+npm install @noopolis/daimon @noopolis/mneme
+```
+
+During local incubation, use the sibling Mneme checkout:
+
+```json
+{
+  "devDependencies": {
+    "@noopolis/mneme": "file:../mneme"
+  }
+}
+```
+
+Pi-specific exports live under the Pi subpath:
+
+```ts
+import { PiHarnessAdapter } from "@noopolis/daimon/pi";
+```
+
 ## Tests
 
 The package has a non-live test suite for auth seeding and Pi model config
@@ -49,8 +71,78 @@ The Pi E2E uses the local Codex CLI subscription auth file to seed an ignored Pi
 ```bash
 npm install
 npm run e2e:pi-agent
+npm run e2e:pi-memory-org
+npm run e2e:mixed-engine-org
+npm run e2e:jungian-play-org
+npm run e2e:jungian-triad-org
 ```
 
 The example starts two harnessed Pi agents from plain caller code. The example
 creates the workspaces and shared resource itself to demonstrate the intended
 boundary: the caller prepares files, the harness runs agent turns.
+
+The memory-org example starts three harnessed Pi agents, gives each agent a
+private marker memory, clears Pi session history, then runs a room-style recall
+conversation. It restarts one agent again before the final check, so the final
+answer must come from Daimon's persisted memory rather than Pi's live chat
+session.
+
+The mixed-engine example starts a small org backed by real local CLIs:
+Navigator uses Codex, Cartographer uses Grok, and Sentinel uses Agy. Each engine
+invents its own private signal, then the room conversation verifies that later
+turns recall those LLM-generated signals through Daimon memory.
+
+The Jungian play example starts two selves as characters in a play. Each self
+has archetype voices such as Persona, Shadow, Anima/Animus, Wise One, Great
+Mother, Hero, and Trickster. The inner voices run first, the representative self
+then speaks externally, and the run writes play traces plus memory/latency
+telemetry under `.runtime/jungian-play-org/`.
+
+The Jungian triad example uses three complete Jungian selves in one
+conversation: Maya speaks through Codex CLI, Leo speaks through Grok, and Priya
+speaks through a Pi agent seeded from local Codex subscription auth. All three
+selves carry the same full archetype set, rotated through the run so every
+archetype gets consulted.
+
+## Design Notes
+
+- `MEMORY-SYSTEM.md` describes the implemented scoped memory runtime.
+- `ENGINE-SYSTEM.md` describes the next engine abstraction plan: Pi, Ollama,
+  API providers, and CLI-backed engines such as `agy`, `grok`, and `gemini`.
+- Mneme is a sibling package, `@noopolis/mneme`, published separately and used
+  by Daimon in-process for Pi agents. Other runtimes can use Mneme through its
+  MCP server. The agent-facing tools stay named `memory_search`,
+  `memory_register`, and `memory.*` at the protocol boundary because those names
+  are clearer to agents.
+
+## Runtime Artifact Image
+
+Daimon can build a local copy-only runtime artifact image for Spawnfile:
+
+```bash
+npm run image:runtime:local
+```
+
+This creates:
+
+```text
+noopolis/spawnfile-runtime-daimon:0.1.1-local
+```
+
+The image is not a full organization image and is not intended to be run
+directly. It contains only:
+
+```text
+/opt/spawnfile/runtime-installs/daimon
+```
+
+Spawnfile can copy that path into generated organization images:
+
+```bash
+SPAWNFILE_DAIMON_RUNTIME_IMAGE=noopolis/spawnfile-runtime-daimon:0.1.1-local \
+  spawnfile build ./agentic-org
+```
+
+This keeps mixed-runtime organizations composable: a generated image can copy
+Daimon, OpenClaw, PicoClaw, or any future runtime artifact independently instead
+of depending on one prebuilt image for every runtime combination.

package/dist/core/types.d.ts

@@ -25,6 +25,16 @@ export interface WakeEvent {
     kind: "manual" | "message" | "schedule";
     from?: string;
     text: string;
+    context?: {
+        networkId?: string;
+        roomId?: string;
+        teamId?: string;
+        taskId?: string;
+        roleId?: string;
+        from?: string;
+        pairPeers?: string[];
+        artifactPaths?: string[];
+    };
 }
 export interface WakeResult {
     agentId: AgentId;

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,WAAW,GAAG,QAAQ,CAAC;CACvC;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;KACtD,CAAC;IACF,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5C,MAAM,IAAI,WAAW,CAAC;IACtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC1D"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,WAAW,GAAG,QAAQ,CAAC;CACvC;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;KACtD,CAAC;IACF,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;KAC1B,CAAC;CACH;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5C,MAAM,IAAI,WAAW,CAAC;IACtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC1D"}

package/dist/examples/jungian-play-org.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jungian-play-org.d.ts.map

package/dist/examples/jungian-play-org.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jungian-play-org.d.ts","sourceRoot":"","sources":["../../src/examples/jungian-play-org.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,280 @@
+import { 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 { beatsFor, defaultDialogueTurns, selectVoicesForBeat } from "./jungianConversationPlan.js";
+import { JungianVoice, runLimited } from "./jungianPlayAgent.js";
+import { jungianSelves, playScenario } from "./jungianProfiles.js";
+import { JungianTrace, parseInnerUsed, parseSpeakLine } from "./jungianTrace.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const daimonRoot = path.resolve(__dirname, "../..");
+const runtimeRoot = path.join(daimonRoot, ".runtime", "jungian-play-org");
+const runId = `run-${Date.now().toString(36)}`;
+const councilConcurrency = Number.parseInt(process.env.DAIMON_JUNGIAN_COUNCIL_CONCURRENCY ?? "3", 10);
+const dialogueTurnCount = Math.max(10, Number.parseInt(process.env.DAIMON_JUNGIAN_TURNS ?? String(defaultDialogueTurns), 10));
+const voicesPerTurn = Math.max(1, Number.parseInt(process.env.DAIMON_JUNGIAN_VOICES_PER_TURN ?? "2", 10));
+const observer = new OrgObserver({ orgId: "jungian-play-org", runId });
+const trace = new JungianTrace({ runId, title: playScenario.title });
+const roomContext = {
+    networkId: "jungian-sitcom",
+    roomId: "community-kitchen",
+    teamId: "jungian-play-org",
+    participants: jungianSelves.map((self) => self.representative.id)
+};
+const observeTurn = (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 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}`,
+    "You are an inner counselor, not the public speaker.",
+    "Keep counsel psychologically specific but grounded in ordinary human behavior.",
+    "No mythic language, no grand symbols, no fantasy imagery.",
+    "Use recalled memory if the same conversation pattern returns."
+];
+const representativeInstructions = (self) => [
+    `You are ${self.representative.name}, the outward speaking Self for ${self.name}.`,
+    `Play role: ${self.playRole}`,
+    `Public mask: ${self.publicMask}`,
+    `Backstory: ${self.backstory}`,
+    `Core conflict: ${self.conflict}`,
+    `Secret want: ${self.secretWant}`,
+    `Style: ${self.representative.style}`,
+    "You speak externally after listening to inner archetypal counsel.",
+    "Sound like a real person in a grounded TV drama or workplace sitcom.",
+    "Use short, conversational lines. No speeches. No poetic metaphors.",
+    "Do not mention the machinery of prompts, engines, memory, or tests.",
+    "Return the requested SPEAK/STAGE/INNER_USED shape exactly."
+];
+const buildSelf = (profile) => ({
+    profile,
+    representative: 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 selves = jungianSelves.map(buildSelf);
+const transcriptText = (transcript) => transcript.length === 0 ? "(no external dialogue yet)" : transcript.join("\n");
+const councilPrompt = (self, focus, transcript) => [
+    `Scene: ${playScenario.title}`,
+    `Premise: ${playScenario.premise}`,
+    `Set: ${playScenario.openingImage}`,
+    "",
+    `Self under counsel: ${self.name}`,
+    `Current focus: ${focus}`,
+    "",
+    "External dialogue so far:",
+    transcriptText(transcript),
+    "",
+    "Respond as this archetype only.",
+    "Keep it plain and practical. No poetic stage images.",
+    "Use exactly this shape:",
+    "ARCHETYPE: <archetype name>",
+    "COUNSEL: <one short practical note>",
+    "RISK: <what could go wrong emotionally>",
+    "LINE_NOTE: <what the representative should sound like>"
+].join("\n");
+const representativePrompt = (self, focus, transcript, counsel) => [
+    `Scene: ${playScenario.title}`,
+    `Premise: ${playScenario.premise}`,
+    `Set: ${playScenario.openingImage}`,
+    "",
+    "External dialogue so far:",
+    transcriptText(transcript),
+    "",
+    `Current focus: ${focus}`,
+    "",
+    "Inner council counsel:",
+    ...counsel.map((turn) => `- ${turn.voice.id}: ${turn.outputText.replace(/\n/g, " ")}`),
+    "",
+    "Choose one natural next line of dialogue.",
+    "The line must sound like a normal person, not a symbol or narrator.",
+    "Keep SPEAK under 22 words. Avoid words like ledger, mercy, truth, blood, crown, soul, destiny, wound unless the transcript already used them.",
+    "Do not use Markdown, bullets, bold markers, or quotation marks inside SPEAK.",
+    "Use exactly this shape:",
+    "SPEAK: <one natural spoken line, without wrapping quotation marks>",
+    "STAGE: <one tiny normal action>",
+    `INNER_USED: <comma-separated ids from ${self.voices.map((voice) => voice.id).join(", ")}>`
+].join("\n");
+const runCouncil = async (self, eventId, focus, transcript, voices) => {
+    console.log(`\n== ${self.profile.name} inner council: ${focus} ==`);
+    const turns = await runLimited(voices, councilConcurrency, async (voice) => {
+        const event = {
+            id: `${eventId}-${voice.config.id}`,
+            kind: "manual",
+            context: roomContext,
+            text: councilPrompt(self.profile, focus, transcript)
+        };
+        const turn = await voice.wake(event);
+        observeTurn(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;
+    });
+    return turns;
+};
+const runRepresentative = async (self, eventId, focus, transcript, counsel) => {
+    const event = {
+        id: eventId,
+        kind: "manual",
+        context: roomContext,
+        text: representativePrompt(self.profile, focus, transcript, counsel)
+    };
+    const turn = await self.representative.wake(event);
+    observeTurn(turn);
+    const used = parseInnerUsed(turn.outputText);
+    const selectedVoiceIds = new Set(counsel.flatMap((entry) => [
+        entry.voice.id,
+        entry.voice.id.replace(`${self.profile.id}-`, "")
+    ]));
+    const passed = used.some((voiceId) => selectedVoiceIds.has(voiceId));
+    observer.recordAssertion({
+        detail: `${self.profile.representative.id} should declare at least one selected inner voice used`,
+        event: event.id,
+        kind: "consultation",
+        passed
+    });
+    if (!passed) {
+        throw new Error(`${self.profile.representative.id} did not declare a selected INNER_USED voice:\n${turn.outputText}`);
+    }
+    trace.addDialogue({
+        engine: self.profile.engine,
+        event: event.id,
+        innerUsed: used,
+        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}`);
+    return line;
+};
+const prepareAll = async () => {
+    await rm(runtimeRoot, { recursive: true, force: true });
+    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: playScenario,
+        selves: jungianSelves.map((self) => ({
+            id: self.id,
+            name: self.name,
+            engine: self.engine,
+            representative: self.representative,
+            voices: self.voices.map((voice) => ({
+                id: voice.id,
+                archetype: voice.archetype,
+                engine: voice.engine,
+                name: voice.name
+            }))
+        }))
+    }, null, 2));
+};
+const writeMemoryCounts = async () => {
+    const rows = await Promise.all(selves.flatMap((self) => [
+        self.representative,
+        ...self.archetypes
+    ]).map(async (voice) => {
+        const events = await new JsonlMemoryStore(voice.runtimeHomePath).read();
+        const counts = events.reduce((memo, event) => {
+            memo[event.type] = (memo[event.type] ?? 0) + 1;
+            return memo;
+        }, {});
+        return {
+            voice: voice.config.id,
+            self: voice.config.selfId,
+            engine: voice.config.engine,
+            counts
+        };
+    }));
+    await writeFile(path.join(runtimeRoot, "play-memory-counts.jsonl"), `${rows.map((row) => JSON.stringify(row)).join("\n")}\n`);
+};
+const writePlaySummary = async () => {
+    const behavior = observer.behaviorSummary();
+    const byRole = observer.turns.reduce((memo, turn) => {
+        const role = turn.agent.endsWith("-self") ? "representative" : "archetype";
+        const current = memo[role] ?? { count: 0, engineMs: 0, recallSelected: 0 };
+        current.count += 1;
+        current.engineMs += turn.engineMs;
+        current.recallSelected += turn.recallSelected;
+        memo[role] = current;
+        return memo;
+    }, {});
+    await writeFile(path.join(runtimeRoot, "play-summary.json"), `${JSON.stringify({ behavior, by_role: byRole, run_id: runId, schema: "daimon.jungian-play.summary/v1" }, null, 2)}\n`);
+};
+const run = async () => {
+    await prepareAll();
+    const selfById = new Map(selves.map((self) => [self.profile.id, self]));
+    const transcript = [];
+    const beats = beatsFor(dialogueTurnCount);
+    for (const [index, beat] of beats.entries()) {
+        const self = selfById.get(beat.speakerId);
+        if (!self) {
+            throw new Error(`Unknown Jungian self ${beat.speakerId}`);
+        }
+        const selectedProfiles = selectVoicesForBeat(self.profile, index, voicesPerTurn);
+        const selectedIds = new Set(selectedProfiles.map((voice) => `${self.profile.id}-${voice.id}`));
+        const selectedVoices = self.archetypes.filter((voice) => selectedIds.has(voice.config.id));
+        const eventBase = `${self.profile.id}-turn-${String(index + 1).padStart(2, "0")}`;
+        const counsel = await runCouncil(self, `${eventBase}-council`, beat.focus, transcript, selectedVoices);
+        await runRepresentative(self, `${eventBase}-speaks`, beat.focus, transcript, counsel);
+    }
+    await observer.write(runtimeRoot);
+    await trace.write(runtimeRoot);
+    await writeMemoryCounts();
+    await writePlaySummary();
+    console.log("\nExternal dialogue:");
+    for (const line of transcript) {
+        console.log(line);
+    }
+    console.log(`\nTrace: ${path.join(runtimeRoot, "jungian-trace.md")}`);
+    console.log(`Telemetry: ${path.join(runtimeRoot, "trace.md")}`);
+    console.log("\ne2e:jungian-play-org ok");
+};
+run().catch((error) => {
+    console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/examples/jungian-triad-org.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jungian-triad-org.d.ts.map

package/dist/examples/jungian-triad-org.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jungian-triad-org.d.ts","sourceRoot":"","sources":["../../src/examples/jungian-triad-org.ts"],"names":[],"mappings":""}