@noopolis/daimon 0.1.0 → 0.1.2

package/README.md

@@ -5,9 +5,19 @@ Daimon is the Noopolis-native per-agent runtime harness.
 It defines a small per-agent contract and currently implements that contract on
 top of Pi. A Daimon runs one harnessed agent inside a caller-prepared workspace.
 
-Spawnfile should own orgs, nested teams, schedules, Moltnet wiring, workspace
-resource compilation, and the app that starts many harnessed agents. This package
-should not know what an org is.
+Spawnfile compiles and deploys orgs, nested teams, member-owned schedules,
+Moltnet wiring, and workspace resources. Daimon executes one agent runtime: it
+accepts a wake selected by that runtime's organization policy and runs one
+turn. It does not know the org graph, schedule other agents, or let Simfile or
+a world service trigger cognition.
+
+For a world-capable `kind: every` wake, the harness starts without a decision
+token and privately calls `world_claim` before exposing any other world tool.
+The claim binds authority to the schedule wake's run/request/wake identity; the
+opaque token stays inside the harness. Subsequent observe/affordance/action
+calls carry it without placing it in the model prompt or tool schema. Optional
+world recommendations are ordinary observation fields discovered after the
+independent wake and claim—they are never Daimon wake inputs.
 
 ## Install
 
@@ -15,10 +25,55 @@ should not know what an org is.
 npm install @noopolis/daimon
 ```
 
+The latest published version is 0.1.1; this README describes the source tree (0.1.2).
+
+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";
+```
+
+By default, the in-process Mneme runtime uses the same path as each agent's
+`runtimeHomePath`. If you need agents to keep separate Pi/runtime directories but
+share one memory bank, pass an explicit `memory.runtimeHomePath` in
+`PiHarnessOptions`.
+
+```ts
+const adapter = new PiHarnessAdapter({
+  authPath: "/tmp/daimon-auth.json",
+  memory: {
+    runtimeHomePath: "/shared/memory/bank"
+  }
+});
+```
+
+Pi agents receive Mneme tools in awake mode for normal work. Dream wakes use a
+fresh one-off Pi session under `sessions/dream/<wake-id>-<random>` and inject
+the Mneme dream guidance instead. Daimon does not automatically record every
+turn as memory; agents write memories only by calling Mneme tools such as
+`memory_register`, `memory_summarize`, and `memory_forget`.
+
 ## Tests
 
-The package has a non-live test suite for auth seeding and Pi model config
-generation:
+The package has a non-live test suite covering auth seeding, Pi model config
+generation, the harness contract, memory tool wiring, wake and turn traces, and
+the org observer:
 
 ```bash
 npm test
@@ -46,11 +101,92 @@ upstream-documented dummy `ollama` value.
 The Pi E2E uses the local Codex CLI subscription auth file to seed an ignored Pi
 `auth.json` under `.runtime/`.
 
+These are live runs: they spend real tokens and require local engine auth
+(`~/.codex/auth.json` for Pi/Codex; mixed-engine and triad additionally need
+authenticated `grok` and `agy` CLIs on PATH). They are not part of `npm test`.
+
 ```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 engine abstraction plan: Pi, local/API
+  model providers, and CLI-backed engines such as `codex`, `claude`, `grok`,
+  and `agy`.
+- 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 defines a local copy-only runtime artifact image build for Spawnfile:
+
+```bash
+npm run image:runtime:local
+```
+
+Status: this build currently fails against the public npm registry. The
+Dockerfile pins `@noopolis/daimon@0.1.2` and `@noopolis/mneme@0.1.1`, and
+neither is published yet (registry has daimon 0.1.1 and mneme 0.1.0). Works
+only after those versions publish or against a registry that has them. Treat
+as pending publish.
+
+This creates:
+
+```text
+noopolis/spawnfile-runtime-daimon:0.1.2-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.2-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/siblingBuildFreshness.d.ts

@@ -0,0 +1,21 @@
+export type SiblingFileFact = {
+    path: string;
+    mtimeMs: number;
+};
+export type SiblingBuildFacts = {
+    packageName: string;
+    packageDirectory: string;
+    hasSourceDirectory: boolean;
+    sourceFiles: SiblingFileFact[];
+    outputFiles: SiblingFileFact[];
+};
+export type SiblingBuildFreshness = {
+    packageName: string;
+    linked: boolean;
+    sourcesScanned: number;
+    outputsScanned: number;
+    ok: boolean;
+    message?: string;
+};
+export declare function checkSiblingBuildFreshness(facts: SiblingBuildFacts): SiblingBuildFreshness;
+//# sourceMappingURL=siblingBuildFreshness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"siblingBuildFreshness.d.ts","sourceRoot":"","sources":["../../src/core/siblingBuildFreshness.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,WAAW,EAAE,eAAe,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAIF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,iBAAiB,GAAG,qBAAqB,CA2B1F"}

package/dist/core/siblingBuildFreshness.js

@@ -0,0 +1,25 @@
+const excludedSource = /(?:\.test\.ts|\.test-helper\.ts|\.d\.ts)$/u;
+export function checkSiblingBuildFreshness(facts) {
+    if (!facts.hasSourceDirectory) {
+        return { packageName: facts.packageName, linked: false, sourcesScanned: 0, outputsScanned: 0, ok: true };
+    }
+    const sourceFiles = facts.sourceFiles.filter(({ path }) => !excludedSource.test(path));
+    const outputFiles = facts.outputFiles.filter(({ path }) => path.endsWith(".js"));
+    const command = `run "npm run build" in ${facts.packageDirectory}`;
+    if (sourceFiles.length === 0) {
+        return failure(facts.packageName, sourceFiles.length, outputFiles.length, `linked package ${facts.packageName} scanned zero source files; ${command}`);
+    }
+    if (outputFiles.length === 0) {
+        return failure(facts.packageName, sourceFiles.length, outputFiles.length, `linked package ${facts.packageName} has no emitted JavaScript; ${command}`);
+    }
+    const newestSource = sourceFiles.reduce((newest, file) => file.mtimeMs > newest.mtimeMs ? file : newest);
+    const oldestOutput = outputFiles.reduce((oldest, file) => file.mtimeMs < oldest.mtimeMs ? file : oldest);
+    if (newestSource.mtimeMs > oldestOutput.mtimeMs) {
+        return failure(facts.packageName, sourceFiles.length, outputFiles.length, `linked package ${facts.packageName} is stale: newest source ${newestSource.path} (${newestSource.mtimeMs}) `
+            + `is newer than oldest output ${oldestOutput.path} (${oldestOutput.mtimeMs}); ${command}`);
+    }
+    return { packageName: facts.packageName, linked: true, sourcesScanned: sourceFiles.length, outputsScanned: outputFiles.length, ok: true };
+}
+function failure(packageName, sourcesScanned, outputsScanned, message) {
+    return { packageName, linked: true, sourcesScanned, outputsScanned, ok: false, message };
+}

package/dist/core/types.d.ts

@@ -20,11 +20,30 @@ export interface HarnessModelSpec {
     name: string;
     provider: string;
 }
+export interface WakeDeliveryMetadata {
+    eventId: string;
+    sender: string;
+    target: string;
+    contextId: string;
+}
 export interface WakeEvent {
     id: string;
-    kind: "manual" | "message" | "schedule";
+    kind: "manual" | "message" | "schedule" | "dream";
     from?: string;
     text: string;
+    context?: {
+        networkId?: string;
+        roomId?: string;
+        teamId?: string;
+        taskId?: string;
+        roleId?: string;
+        from?: string;
+        pairPeers?: string[];
+        artifactPaths?: string[];
+    };
+    delivery?: WakeDeliveryMetadata;
+    /** Exact transport body retained outside the runtime-enriched model prompt. */
+    transportText?: 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,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,GAAG,OAAO,CAAC;IAClD,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;IACF,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,+EAA+E;IAC/E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;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/exampleCausalId.d.ts

@@ -0,0 +1,3 @@
+/** Namespaces caller-authored example wakes for the shared causal contract. */
+export declare const exampleCausalId: (localId: string) => string;
+//# sourceMappingURL=exampleCausalId.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exampleCausalId.d.ts","sourceRoot":"","sources":["../../src/examples/exampleCausalId.ts"],"names":[],"mappings":"AAEA,+EAA+E;AAC/E,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,MAKjD,CAAC"}

package/dist/examples/exampleCausalId.js

@@ -0,0 +1,8 @@
+const LOCAL_CAUSAL_ID = /^[a-z0-9][a-z0-9._-]{0,255}$/u;
+/** Namespaces caller-authored example wakes for the shared causal contract. */
+export const exampleCausalId = (localId) => {
+    if (!LOCAL_CAUSAL_ID.test(localId)) {
+        throw new Error("Daimon example causal id must be a bounded local id");
+    }
+    return `daimon:${localId}`;
+};

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,281 @@
+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 { exampleCausalId } from "./exampleCausalId.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: exampleCausalId(`${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: exampleCausalId(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":""}