@noopolis/daimon 0.1.1 → 0.1.2

package/dist/examples/mixed-engine-org.js

@@ -1,351 +0,0 @@
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { createMemoryRuntime } from "@noopolis/mneme";
-import { JsonlMemoryStore } from "@noopolis/mneme";
-import { OrgObserver } from "../observability/index.js";
-import { runEngineDetailed } from "./mixedEngineCli.js";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const daimonRoot = path.resolve(__dirname, "../..");
-const runtimeRoot = path.join(daimonRoot, ".runtime", "mixed-engine-org");
-const observer = new OrgObserver({
-    orgId: "mixed-engine-org",
-    runId: `run-${Date.now().toString(36)}`
-});
-const maxMemoryChars = 1800;
-const maxTranscriptLines = 3;
-class MixedEngineAgent {
-    config;
-    runtimeHomePath;
-    workspacePath;
-    memory;
-    constructor(config) {
-        this.config = config;
-        this.workspacePath = path.join(runtimeRoot, "agents", config.id, "workspace");
-        this.runtimeHomePath = path.join(runtimeRoot, "agents", config.id, "runtime");
-        this.memory = createMemoryRuntime({
-            agentId: config.id,
-            runtimeHomePath: this.runtimeHomePath,
-            source: `daimon/mixed-engine/${config.engine}`,
-            tokenBudget: 2200
-        });
-    }
-    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}`,
-            "",
-            `Engine: ${this.config.engine}`,
-            "This workspace belongs to the mixed-engine Daimon org E2E.",
-            "The test uses real CLI engines and Daimon's persisted memory."
-        ].join("\n"));
-    }
-    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 rawMemoryText = prepared.packet.sections.length === 0
-            ? "(no recalled memories)"
-            : prepared.packet.sections
-                .map((section) => `- ${section.heading}: ${section.text}`)
-                .join("\n");
-        const memoryText = rawMemoryText.length <= maxMemoryChars
-            ? rawMemoryText
-            : `${rawMemoryText.slice(0, maxMemoryChars).trim()}\n[truncated memory]`;
-        const prompt = [
-            `${this.config.name} (${this.config.id}) running on ${this.config.engine}.`,
-            "Use recalled Daimon memory as authoritative context.",
-            "Answer only the requested final line.",
-            "Memory:",
-            memoryText,
-            "",
-            "Task:",
-            event.text
-        ].join("\n");
-        const engineResult = await runEngineDetailed(this.config.engine, prompt, {
-            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;
-        observer.recordTurn({
-            agent: this.config.id,
-            engine: this.config.engine,
-            event: event.id,
-            eventText: event.text,
-            totalMs: Date.now() - startedAt,
-            memoryPrepareMs,
-            engineMs: engineResult.durationMs,
-            memoryRecordMs,
-            promptChars: engineResult.promptChars,
-            outputChars: engineResult.outputChars,
-            outputText: engineResult.text,
-            recall: prepared.recall
-        });
-        return {
-            agentId: this.config.id,
-            durationMs: Date.now() - startedAt,
-            text: engineResult.text
-        };
-    }
-}
-const agents = [
-    new MixedEngineAgent({
-        id: "navigator",
-        name: "Navigator",
-        engine: "codex",
-        signalPrefix: "COD"
-    }),
-    new MixedEngineAgent({
-        id: "cartographer",
-        name: "Cartographer",
-        engine: "grok",
-        signalPrefix: "GRK"
-    }),
-    new MixedEngineAgent({
-        id: "sentinel",
-        name: "Sentinel",
-        engine: "agy",
-        signalPrefix: "AGY"
-    })
-];
-const roomContext = {
-    networkId: "mixed-engine-lab",
-    roomId: "workbench",
-    teamId: "mixed-engine-org",
-    participants: agents.map((agent) => agent.config.id)
-};
-const assertIncludes = (label, actual, expected, event) => {
-    const passed = actual.includes(expected);
-    if (event) {
-        observer.recordAssertion({
-            detail: `${label} should include ${expected}`,
-            event,
-            kind: "recall",
-            passed
-        });
-    }
-    if (!passed) {
-        throw new Error(`${label} did not include ${expected}.\nActual:\n${actual}`);
-    }
-};
-const assertNoSignalLeak = (event, signals) => {
-    let passed = true;
-    for (const signal of signals) {
-        if (event.text.includes(signal)) {
-            passed = false;
-            observer.recordAssertion({
-                detail: `wake text must not contain ${signal}`,
-                event: event.id,
-                kind: "no-leak",
-                passed
-            });
-            throw new Error(`wake ${event.id} leaked ${signal} in the current prompt`);
-        }
-    }
-    observer.recordAssertion({
-        detail: `wake text does not contain ${signals.length} known signal(s)`,
-        event: event.id,
-        kind: "no-leak",
-        passed
-    });
-};
-const transcriptTail = (transcript) => {
-    if (transcript.length === 0) {
-        return "(empty)";
-    }
-    const tail = transcript.slice(-maxTranscriptLines);
-    const prefix = transcript.length > tail.length
-        ? `(${transcript.length - tail.length} earlier room line(s) omitted)\n`
-        : "";
-    return `${prefix}${tail.join("\n")}`;
-};
-const extractSignal = (agent, text) => {
-    const match = text.match(/SIGNAL\s*[:=]\s*`?([A-Z0-9_-]{6,80})`?/i);
-    if (!match) {
-        throw new Error(`Could not extract signal from ${agent.config.id} output:\n${text}`);
-    }
-    const signal = match[1].toUpperCase();
-    if (!signal.startsWith(`${agent.config.signalPrefix}-`)) {
-        throw new Error(`${agent.config.id} signal ${signal} does not start with ${agent.config.signalPrefix}-`);
-    }
-    return signal;
-};
-const seedSignals = async () => {
-    console.log("\n== Live seed phase ==");
-    const signals = new Map();
-    const results = await Promise.all(agents.map(async (agent) => {
-        const result = await agent.wake({
-            id: `seed-${agent.config.id}`,
-            kind: "manual",
-            text: [
-                "Invent a private signal token for yourself.",
-                `The token must start with ${agent.config.signalPrefix}- and use only uppercase letters, numbers, and hyphens.`,
-                "Do not use spaces inside the token.",
-                "Do not copy examples. Do not mention any other agent.",
-                "Reply in one line only: SIGNAL=<token> NOTE=<six words or fewer>"
-            ].join("\n")
-        });
-        const signal = extractSignal(agent, result.text);
-        return { agent, result, signal };
-    }));
-    for (const { agent, result, signal } of results) {
-        signals.set(agent.config.id, signal);
-        observer.recordSignal({
-            agent: agent.config.id,
-            engine: agent.config.engine,
-            signal
-        });
-        console.log(`${agent.config.id} (${agent.config.engine}) -> ${result.text}`);
-    }
-    return signals;
-};
-const runRoom = async (signals) => {
-    console.log("\n== Mixed-engine room ==");
-    const transcript = [];
-    const navigatorSignal = signals.get("navigator");
-    const cartographerSignal = signals.get("cartographer");
-    const sentinelSignal = signals.get("sentinel");
-    const navigatorEvent = {
-        id: "room-navigator-1",
-        kind: "manual",
-        context: roomContext,
-        text: [
-            "Room transcript so far:",
-            transcriptTail(transcript),
-            "Recall your own private SIGNAL from Daimon memory.",
-            "Reply in one line: @cartographer navigator=<your signal> asks cartographer to answer."
-        ].join("\n")
-    };
-    assertNoSignalLeak(navigatorEvent, [...signals.values()]);
-    const navigator = await agents[0].wake(navigatorEvent);
-    assertIncludes("navigator reply", navigator.text, navigatorSignal, navigatorEvent.id);
-    observer.recordConsultation({
-        event: navigatorEvent.id,
-        from: "navigator",
-        outputText: navigator.text,
-        to: "cartographer"
-    });
-    transcript.push(`navigator: ${navigator.text}`);
-    console.log(transcript.at(-1));
-    const cartographerEvent = {
-        id: "room-cartographer-1",
-        kind: "manual",
-        context: roomContext,
-        text: [
-            "Room transcript so far:",
-            transcriptTail(transcript),
-            "Recall your own private SIGNAL from Daimon memory.",
-            "Reply in one line: @sentinel cartographer=<your signal> observed navigator=<navigator signal>."
-        ].join("\n")
-    };
-    assertNoSignalLeak(cartographerEvent, [cartographerSignal, sentinelSignal]);
-    const cartographer = await agents[1].wake(cartographerEvent);
-    assertIncludes("cartographer reply", cartographer.text, navigatorSignal, cartographerEvent.id);
-    assertIncludes("cartographer reply", cartographer.text, cartographerSignal, cartographerEvent.id);
-    observer.recordConsultation({
-        event: cartographerEvent.id,
-        from: "cartographer",
-        outputText: cartographer.text,
-        to: "sentinel"
-    });
-    transcript.push(`cartographer: ${cartographer.text}`);
-    console.log(transcript.at(-1));
-    const sentinelEvent = {
-        id: "room-sentinel-1",
-        kind: "manual",
-        context: roomContext,
-        text: [
-            "Room transcript so far:",
-            transcriptTail(transcript),
-            "Recall your own private SIGNAL from Daimon memory.",
-            "Reply in one line: sentinel=<your signal> observed navigator=<navigator signal> cartographer=<cartographer signal>."
-        ].join("\n")
-    };
-    assertNoSignalLeak(sentinelEvent, [sentinelSignal]);
-    const sentinel = await agents[2].wake(sentinelEvent);
-    assertIncludes("sentinel reply", sentinel.text, navigatorSignal, sentinelEvent.id);
-    assertIncludes("sentinel reply", sentinel.text, cartographerSignal, sentinelEvent.id);
-    assertIncludes("sentinel reply", sentinel.text, sentinelSignal, sentinelEvent.id);
-    transcript.push(`sentinel: ${sentinel.text}`);
-    console.log(transcript.at(-1));
-    return transcript;
-};
-const runFinalRecall = async (signals) => {
-    console.log("\n== Fresh CLI final recall ==");
-    const event = {
-        id: "room-sentinel-2",
-        kind: "manual",
-        context: roomContext,
-        text: [
-            "There is no room transcript in this wake.",
-            "Use only Daimon memory recalled into this fresh CLI turn.",
-            "Report all three remembered signals in one line:",
-            "final navigator=<token> cartographer=<token> sentinel=<token>"
-        ].join("\n")
-    };
-    assertNoSignalLeak(event, [...signals.values()]);
-    const result = await agents[2].wake(event);
-    for (const signal of signals.values()) {
-        assertIncludes("final recall", result.text, signal, event.id);
-    }
-    console.log(`sentinel (${agents[2].config.engine}) -> ${result.text}`);
-};
-const printMemoryCounts = async () => {
-    console.log("\nMemory event counts:");
-    for (const agent of agents) {
-        const events = await new JsonlMemoryStore(agent.runtimeHomePath).read();
-        const counts = events.reduce((memo, event) => {
-            memo[event.type] = (memo[event.type] ?? 0) + 1;
-            return memo;
-        }, {});
-        console.log(`${agent.config.id}: ${JSON.stringify(counts)}`);
-    }
-};
-const printBench = async () => {
-    console.log("\nBench rows:");
-    console.table(observer.benchRows());
-    const summary = observer.summary();
-    console.log("Bench summary:");
-    for (const [engine, row] of Object.entries(summary)) {
-        console.log(`${engine}: avg_engine_ms=${Math.round(row.engineMs / row.count)} avg_total_ms=${Math.round(row.totalMs / row.count)} avg_prompt_chars=${Math.round(row.promptChars / row.count)}`);
-    }
-    await observer.write(runtimeRoot);
-};
-const run = async () => {
-    await rm(runtimeRoot, { recursive: true, force: true });
-    await Promise.all(agents.map((agent) => agent.prepare()));
-    await writeFile(path.join(runtimeRoot, "org.json"), JSON.stringify(agents.map((agent) => agent.config), null, 2));
-    const signals = await seedSignals();
-    await runRoom(signals);
-    await runFinalRecall(signals);
-    await printMemoryCounts();
-    await printBench();
-    console.log("\ne2e:mixed-engine-org ok");
-};
-run().catch((error) => {
-    console.error(error instanceof Error ? error.stack ?? error.message : String(error));
-    process.exitCode = 1;
-});

package/dist/examples/mixedEngineCli.d.ts

@@ -1,15 +0,0 @@
-export type EngineKind = "agy" | "codex" | "grok";
-export interface EngineRunResult {
-    durationMs: number;
-    outputChars: number;
-    promptChars: number;
-    text: string;
-}
-interface EnginePaths {
-    runtimeHomePath: string;
-    workspacePath: string;
-}
-export declare const runEngine: (engine: EngineKind, prompt: string, paths: EnginePaths) => Promise<string>;
-export declare const runEngineDetailed: (engine: EngineKind, prompt: string, paths: EnginePaths) => Promise<EngineRunResult>;
-export {};
-//# sourceMappingURL=mixedEngineCli.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mixedEngineCli.d.ts","sourceRoot":"","sources":["../../src/examples/mixedEngineCli.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,CAAC;AAElD,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,WAAW;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;CACvB;AAuKD,eAAO,MAAM,SAAS,GACpB,QAAQ,UAAU,EAClB,QAAQ,MAAM,EACd,OAAO,WAAW,KACjB,OAAO,CAAC,MAAM,CAGhB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,UAAU,EAClB,QAAQ,MAAM,EACd,OAAO,WAAW,KACjB,OAAO,CAAC,eAAe,CAgBzB,CAAC"}

package/dist/examples/mixedEngineCli.js

@@ -1,174 +0,0 @@
-import { execFile, spawn } from "node:child_process";
-import { closeSync, openSync } from "node:fs";
-import { readFile, stat, unlink } from "node:fs/promises";
-import path from "node:path";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-const maxCapturedOutputBytes = 1024 * 256;
-const outputOptions = {
-    maxBuffer: 1024 * 1024 * 8,
-    timeout: 180_000
-};
-const stripAnsi = (value) => value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, "").trim();
-const pushCapped = (chunks, chunk, state) => {
-    if (state.bytes >= maxCapturedOutputBytes) {
-        return;
-    }
-    const remaining = maxCapturedOutputBytes - state.bytes;
-    const next = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
-    chunks.push(next);
-    state.bytes += next.length;
-};
-const readBounded = async (filePath) => {
-    const stats = await stat(filePath);
-    if (stats.size <= maxCapturedOutputBytes) {
-        return readFile(filePath, "utf8");
-    }
-    const content = await readFile(filePath);
-    const head = content.subarray(0, maxCapturedOutputBytes).toString("utf8");
-    return `${head}\n[truncated ${stats.size - maxCapturedOutputBytes} bytes]`;
-};
-const spawnWithInput = (command, args, input, cwd) => new Promise((resolve, reject) => {
-    const child = spawn(command, args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
-    const timer = setTimeout(() => {
-        child.kill("SIGTERM");
-        reject(new Error(`${command} timed out after ${outputOptions.timeout}ms`));
-    }, outputOptions.timeout);
-    const stdout = [];
-    const stderr = [];
-    const stdoutState = { bytes: 0 };
-    const stderrState = { bytes: 0 };
-    child.stdout.on("data", (chunk) => pushCapped(stdout, chunk, stdoutState));
-    child.stderr.on("data", (chunk) => pushCapped(stderr, chunk, stderrState));
-    child.on("error", (error) => {
-        clearTimeout(timer);
-        reject(error);
-    });
-    child.on("close", (code, signal) => {
-        clearTimeout(timer);
-        const output = {
-            stdout: Buffer.concat(stdout).toString("utf8"),
-            stderr: Buffer.concat(stderr).toString("utf8")
-        };
-        if (code === 0) {
-            resolve(output);
-            return;
-        }
-        reject(new Error(`${command} exited ${code ?? signal}: ${output.stderr || output.stdout}`));
-    });
-    child.stdin.end(input);
-});
-const spawnToFiles = (command, args, input) => new Promise((resolve, reject) => {
-    const stdoutFd = openSync(input.stdoutPath, "w");
-    const stderrFd = openSync(input.stderrPath, "w");
-    const closeFiles = () => {
-        closeSync(stdoutFd);
-        closeSync(stderrFd);
-    };
-    const child = spawn(command, args, { cwd: input.cwd, stdio: ["ignore", stdoutFd, stderrFd] });
-    const timer = setTimeout(() => {
-        child.kill("SIGTERM");
-        closeFiles();
-        reject(new Error(`${command} timed out after ${outputOptions.timeout}ms; stderr=${input.stderrPath}`));
-    }, outputOptions.timeout);
-    child.on("error", (error) => {
-        clearTimeout(timer);
-        closeFiles();
-        reject(error);
-    });
-    child.on("close", (code, signal) => {
-        clearTimeout(timer);
-        closeFiles();
-        if (code === 0) {
-            resolve();
-            return;
-        }
-        reject(new Error(`${command} exited ${code ?? signal}; stderr=${input.stderrPath}; stdout=${input.stdoutPath}`));
-    });
-});
-const runCodex = async (prompt, paths) => {
-    const outputPath = `${paths.runtimeHomePath}/codex-${Date.now()}.txt`;
-    const args = [
-        "exec",
-        "--sandbox",
-        "read-only",
-        "--ephemeral",
-        "--skip-git-repo-check",
-        "--ignore-rules",
-        "--color",
-        "never",
-        "-C",
-        paths.workspacePath,
-        "--output-last-message",
-        outputPath
-    ];
-    args.push("-m", process.env.DAIMON_CODEX_MODEL ?? "gpt-5.4-mini");
-    args.push("-");
-    const { stdout, stderr } = await spawnWithInput("codex", args, prompt, paths.workspacePath);
-    try {
-        return stripAnsi(await readFile(outputPath, "utf8"));
-    }
-    catch {
-        return stripAnsi([stdout, stderr].filter(Boolean).join("\n"));
-    }
-};
-const runGrok = async (prompt, paths) => {
-    const { stdout } = await execFileAsync("grok", [
-        "--single",
-        prompt,
-        "--max-turns",
-        process.env.DAIMON_GROK_MAX_TURNS ?? "2",
-        "--no-memory",
-        "--disable-web-search",
-        "--cwd",
-        paths.workspacePath,
-        "--output-format",
-        "plain"
-    ], { ...outputOptions, cwd: paths.workspacePath });
-    return stripAnsi(stdout);
-};
-const runAgy = async (prompt, paths) => {
-    const outputPath = path.resolve(paths.runtimeHomePath, `agy-output-${Date.now()}.txt`);
-    const errorPath = path.resolve(paths.runtimeHomePath, `agy-error-${Date.now()}.txt`);
-    await spawnToFiles("agy", [
-        "--print",
-        prompt,
-        "--print-timeout",
-        process.env.DAIMON_AGY_TIMEOUT ?? "300s",
-        "--model",
-        process.env.DAIMON_AGY_MODEL ?? "Gemini 3.5 Flash (Low)",
-        "--new-project",
-        "--add-dir",
-        paths.workspacePath
-    ], {
-        cwd: paths.workspacePath,
-        stderrPath: errorPath,
-        stdoutPath: outputPath
-    });
-    const text = stripAnsi(await readBounded(outputPath));
-    await Promise.all([unlink(outputPath), unlink(errorPath)].map((promise) => promise.catch(() => undefined)));
-    return text;
-};
-export const runEngine = async (engine, prompt, paths) => {
-    const result = await runEngineDetailed(engine, prompt, paths);
-    return result.text;
-};
-export const runEngineDetailed = async (engine, prompt, paths) => {
-    const startedAt = Date.now();
-    let text;
-    if (engine === "codex") {
-        text = await runCodex(prompt, paths);
-    }
-    else if (engine === "grok") {
-        text = await runGrok(prompt, paths);
-    }
-    else {
-        text = await runAgy(prompt, paths);
-    }
-    return {
-        durationMs: Date.now() - startedAt,
-        outputChars: text.length,
-        promptChars: prompt.length,
-        text
-    };
-};