@noopolis/daimon 0.1.0 → 0.1.1

package/dist/examples/pi-memory-org.js

@@ -0,0 +1,230 @@
+import { access, mkdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { JsonlMemoryStore } from "@noopolis/mneme";
+import { seedPiOpenAICodexAuthFromCodex } from "../pi/auth.js";
+import { PiHarnessAdapter } from "../pi/piHarness.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const daimonRoot = path.resolve(__dirname, "../..");
+const runtimeRoot = path.join(daimonRoot, ".runtime", "pi-memory-org");
+const piAuthPath = path.join(runtimeRoot, "auth", "auth.json");
+const codexAuthPath = path.join(process.env.HOME ?? "", ".codex", "auth.json");
+const demoAgents = [
+    { id: "atlas", name: "Atlas", marker: "ATLAS_BLUE_17" },
+    { id: "oracle", name: "Oracle", marker: "ORACLE_GOLD_23" },
+    { id: "keeper", name: "Keeper", marker: "KEEPER_GREEN_31" }
+];
+const roomContext = {
+    networkId: "memory-lab",
+    roomId: "council",
+    teamId: "memory-e2e",
+    participants: demoAgents.map((agent) => agent.id)
+};
+const assertIncludes = (label, content, expected) => {
+    if (!content.includes(expected)) {
+        throw new Error(`${label} did not include ${expected}.\nActual:\n${content}`);
+    }
+};
+const assertCurrentPromptDoesNotLeakMarkers = (event) => {
+    for (const agent of demoAgents) {
+        if (event.text.includes(agent.marker)) {
+            throw new Error(`wake ${event.id} leaked marker ${agent.marker} in current prompt`);
+        }
+    }
+};
+const agentRuntimeHome = (agentId) => path.join(runtimeRoot, "agents", agentId, "runtime");
+const prepareWorkspace = async (agentId) => {
+    const workspacePath = path.join(runtimeRoot, "agents", agentId, "workspace");
+    const runtimeHomePath = agentRuntimeHome(agentId);
+    await mkdir(workspacePath, { recursive: true });
+    await mkdir(runtimeHomePath, { recursive: true });
+    await writeFile(path.join(workspacePath, "AGENTS.md"), [
+        `# ${agentId}`,
+        "",
+        "This workspace is part of the Daimon Pi memory-org E2E.",
+        "The test intentionally disables file tools and verifies persisted Daimon memory."
+    ].join("\n"));
+    return { workspacePath, runtimeHomePath };
+};
+const setupRuntime = async () => {
+    await access(codexAuthPath);
+    await rm(runtimeRoot, { recursive: true, force: true });
+    await mkdir(path.dirname(piAuthPath), { recursive: true });
+    await seedPiOpenAICodexAuthFromCodex({ codexAuthPath, piAuthPath });
+};
+const resetPiSessionHistory = async (agentId) => {
+    await rm(path.join(agentRuntimeHome(agentId), "sessions"), { recursive: true, force: true });
+};
+const startAgent = async (adapter, agent) => {
+    const paths = await prepareWorkspace(agent.id);
+    return adapter.startAgent({
+        id: agent.id,
+        name: agent.name,
+        instructions: [
+            "You are participating in a live Daimon memory E2E.",
+            "Use the Memory context injected above the wake event as authoritative recalled memory.",
+            "When asked to recall marker tokens, copy exact marker tokens from memory.",
+            "Keep every response to one concise line unless the wake explicitly asks otherwise."
+        ].join(" "),
+        tools: [],
+        ...paths
+    });
+};
+const startAllAgents = async (adapter) => {
+    const handles = new Map();
+    for (const agent of demoAgents) {
+        handles.set(agent.id, await startAgent(adapter, agent));
+    }
+    return handles;
+};
+const stopAll = async (handles) => {
+    await Promise.all([...handles.values()].map((handle) => handle.stop()));
+};
+const wake = async (handle, event, options = {}) => {
+    if (options.assertNoMarkerLeak) {
+        assertCurrentPromptDoesNotLeakMarkers(event);
+    }
+    const result = await handle.wake(event);
+    console.log(`[${event.id}] ${result.agentId}: ${result.text}`);
+    return result;
+};
+const seedPrivateMemories = async (handles) => {
+    console.log("\n== Private seed phase ==");
+    for (const agent of demoAgents) {
+        const result = await handles.get(agent.id)?.wake({
+            id: `seed-${agent.id}`,
+            kind: "manual",
+            text: [
+                "Private memory seed.",
+                `Remember this exact marker token for later recall: ${agent.marker}`,
+                "Do not write files. Reply with exactly: stored"
+            ].join("\n")
+        });
+        console.log(`[seed-${agent.id}] ${agent.id}: ${result?.text ?? ""}`);
+    }
+};
+const runRoomConversation = async (handles) => {
+    console.log("\n== Room recall phase ==");
+    const transcript = [];
+    const atlas = await wake(handles.get("atlas"), {
+        id: "room-atlas-1",
+        kind: "manual",
+        context: roomContext,
+        text: [
+            "Moltnet room simulation. Visible room transcript so far:",
+            transcript.join("\n") || "(empty)",
+            "Recall your private marker token from Daimon memory.",
+            "Reply in one line: @oracle atlas recalls <exact token>",
+            "Do not invent markers for other agents."
+        ].join("\n")
+    }, { assertNoMarkerLeak: true });
+    assertIncludes("atlas room reply", atlas.text, "ATLAS_BLUE_17");
+    transcript.push(`atlas: ${atlas.text}`);
+    const oracle = await wake(handles.get("oracle"), {
+        id: "room-oracle-1",
+        kind: "manual",
+        context: roomContext,
+        text: [
+            "Moltnet room simulation. Visible room transcript so far:",
+            transcript.join("\n"),
+            "Recall your private marker token from Daimon memory and acknowledge Atlas from the transcript.",
+            "Reply in one line: @keeper oracle recalls <exact token>; observed atlas=<atlas token>"
+        ].join("\n")
+    });
+    assertIncludes("oracle room reply", oracle.text, "ORACLE_GOLD_23");
+    assertIncludes("oracle room reply", oracle.text, "ATLAS_BLUE_17");
+    transcript.push(`oracle: ${oracle.text}`);
+    const keeper = await wake(handles.get("keeper"), {
+        id: "room-keeper-1",
+        kind: "manual",
+        context: roomContext,
+        text: [
+            "Moltnet room simulation. Visible room transcript so far:",
+            transcript.join("\n"),
+            "Recall your private marker token from Daimon memory and acknowledge Atlas and Oracle from the transcript.",
+            "Reply in one line: keeper recalls <exact token>; observed atlas=<atlas token> oracle=<oracle token>"
+        ].join("\n")
+    });
+    assertIncludes("keeper room reply", keeper.text, "KEEPER_GREEN_31");
+    assertIncludes("keeper room reply", keeper.text, "ATLAS_BLUE_17");
+    assertIncludes("keeper room reply", keeper.text, "ORACLE_GOLD_23");
+    transcript.push(`keeper: ${keeper.text}`);
+    console.log("\nRoom transcript:");
+    for (const line of transcript) {
+        console.log(line);
+    }
+    return transcript;
+};
+const verifyFreshSessionRecall = async (adapter, previousKeeper) => {
+    console.log("\n== Fresh session recall phase ==");
+    await previousKeeper.stop();
+    await resetPiSessionHistory("keeper");
+    const keeper = await startAgent(adapter, demoAgents.find((agent) => agent.id === "keeper"));
+    try {
+        const event = {
+            id: "room-keeper-2",
+            kind: "manual",
+            context: roomContext,
+            text: [
+                "Fresh session check. You do not get the room transcript in this wake.",
+                "Use only Daimon memory recalled into this turn.",
+                "Report the marker tokens for atlas, oracle, and keeper from your previous memory-lab room turn.",
+                "Reply in one line: final atlas=<token> oracle=<token> keeper=<token>"
+            ].join("\n")
+        };
+        const result = await wake(keeper, event, { assertNoMarkerLeak: true });
+        assertIncludes("fresh keeper recall", result.text, "ATLAS_BLUE_17");
+        assertIncludes("fresh keeper recall", result.text, "ORACLE_GOLD_23");
+        assertIncludes("fresh keeper recall", result.text, "KEEPER_GREEN_31");
+    }
+    finally {
+        await keeper.stop();
+    }
+};
+const printMemoryCounts = async () => {
+    console.log("\nMemory event counts:");
+    for (const agent of demoAgents) {
+        const events = await new JsonlMemoryStore(agentRuntimeHome(agent.id)).read();
+        const counts = events.reduce((memo, event) => {
+            memo[event.type] = (memo[event.type] ?? 0) + 1;
+            return memo;
+        }, {});
+        console.log(`${agent.id}: ${JSON.stringify(counts)}`);
+    }
+};
+const run = async () => {
+    await setupRuntime();
+    const adapter = new PiHarnessAdapter({
+        authPath: piAuthPath,
+        model: {
+            provider: "openai-codex",
+            name: process.env.HARNESS_PI_MODEL ?? "gpt-5.4-mini"
+        },
+        memory: {
+            tokenBudget: 1800
+        }
+    });
+    const seedHandles = await startAllAgents(adapter);
+    await seedPrivateMemories(seedHandles);
+    await stopAll(seedHandles);
+    await Promise.all(demoAgents.map((agent) => resetPiSessionHistory(agent.id)));
+    const roomHandles = await startAllAgents(adapter);
+    try {
+        await runRoomConversation(roomHandles);
+        await verifyFreshSessionRecall(adapter, roomHandles.get("keeper"));
+        await roomHandles.get("atlas")?.stop();
+        await roomHandles.get("oracle")?.stop();
+        await printMemoryCounts();
+        console.log("\ne2e:pi-memory-org ok");
+    }
+    finally {
+        await Promise.all([
+            roomHandles.get("atlas")?.stop(),
+            roomHandles.get("oracle")?.stop()
+        ]);
+    }
+};
+run().catch((error) => {
+    console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/index.d.ts

@@ -1,5 +1,3 @@
 export * from "./core/types.js";
-export * from "./pi/auth.js";
-export * from "./pi/modelConfig.js";
-export * from "./pi/piHarness.js";
+export * from "./observability/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC"}

package/dist/index.js

@@ -1,4 +1,2 @@
 export * from "./core/types.js";
-export * from "./pi/auth.js";
-export * from "./pi/modelConfig.js";
-export * from "./pi/piHarness.js";
+export * from "./observability/index.js";

package/dist/observability/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./orgObserver.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/observability/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/observability/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/observability/index.js

@@ -0,0 +1 @@
+export * from "./orgObserver.js";

package/dist/observability/orgObserver.d.ts

@@ -0,0 +1,98 @@
+import type { MemoryRecallAudit } from "@noopolis/mneme";
+export interface WakeBenchRow {
+    agent: string;
+    engine: string;
+    event: string;
+    totalMs: number;
+    memoryPrepareMs: number;
+    engineMs: number;
+    memoryRecordMs: number;
+    promptChars: number;
+    outputChars: number;
+    recallCandidates: number;
+    recallSelected: number;
+}
+export interface TurnObservation extends WakeBenchRow {
+    mentions: string[];
+    outputText: string;
+    recall: Array<{
+        decision: string;
+        eventId: string;
+        representation: string;
+        scope: string;
+    }>;
+    signalsMentioned: string[];
+    signalsInWakeText: string[];
+}
+export interface SignalObservation {
+    agent: string;
+    engine: string;
+    signal: string;
+}
+export interface ConsultationObservation {
+    event: string;
+    from: string;
+    observed: boolean;
+    outputText: string;
+    to: string;
+}
+export interface BehaviorAssertion {
+    detail: string;
+    event: string;
+    kind: "consultation" | "no-leak" | "recall";
+    passed: boolean;
+}
+export interface OrgObserverOptions {
+    orgId: string;
+    runId: string;
+}
+export declare const mentionsFrom: (text: string) => string[];
+export declare class OrgObserver {
+    readonly options: OrgObserverOptions;
+    readonly assertions: BehaviorAssertion[];
+    readonly consultations: ConsultationObservation[];
+    readonly signals: SignalObservation[];
+    readonly turns: TurnObservation[];
+    constructor(options: OrgObserverOptions);
+    knownSignals(): string[];
+    recordAssertion(assertion: BehaviorAssertion): void;
+    recordSignal(input: SignalObservation): void;
+    recordTurn(input: {
+        agent: string;
+        engine: string;
+        engineMs: number;
+        event: string;
+        eventText: string;
+        memoryPrepareMs: number;
+        memoryRecordMs: number;
+        outputChars: number;
+        outputText: string;
+        promptChars: number;
+        recall: MemoryRecallAudit;
+        totalMs: number;
+    }): void;
+    recordConsultation(input: {
+        event: string;
+        from: string;
+        outputText: string;
+        to: string;
+    }): ConsultationObservation;
+    benchRows(): WakeBenchRow[];
+    summary(): Record<string, {
+        count: number;
+        engineMs: number;
+        promptChars: number;
+        totalMs: number;
+    }>;
+    behaviorSummary(): {
+        assertionPassRate: number;
+        consultationObservedRate: number;
+        signalsGenerated: number;
+        totalRecallSelected: number;
+        totalTurns: number;
+    };
+    tracePayload(): object;
+    write(runtimeRoot: string): Promise<void>;
+    toMarkdown(): string;
+}
+//# sourceMappingURL=orgObserver.d.ts.map

package/dist/observability/orgObserver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orgObserver.d.ts","sourceRoot":"","sources":["../../src/observability/orgObserver.ts"],"names":[],"mappings":"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"}

package/dist/observability/orgObserver.js

@@ -0,0 +1,181 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+const maxExcerptChars = 280;
+const excerpt = (text) => text.length <= maxExcerptChars ? text : `${text.slice(0, maxExcerptChars).trim()}...`;
+export const mentionsFrom = (text) => [...new Set([...text.matchAll(/@([a-z0-9-]+)/gi)].map((match) => match[1].toLowerCase()))];
+export class OrgObserver {
+    options;
+    assertions = [];
+    consultations = [];
+    signals = [];
+    turns = [];
+    constructor(options) {
+        this.options = options;
+    }
+    knownSignals() {
+        return this.signals.map((signal) => signal.signal);
+    }
+    recordAssertion(assertion) {
+        this.assertions.push(assertion);
+    }
+    recordSignal(input) {
+        this.signals.push(input);
+    }
+    recordTurn(input) {
+        this.turns.push({
+            agent: input.agent,
+            engine: input.engine,
+            event: input.event,
+            totalMs: input.totalMs,
+            memoryPrepareMs: input.memoryPrepareMs,
+            engineMs: input.engineMs,
+            memoryRecordMs: input.memoryRecordMs,
+            promptChars: input.promptChars,
+            outputChars: input.outputChars,
+            recallCandidates: input.recall.totalCandidates,
+            recallSelected: input.recall.selectedEventIds.length,
+            mentions: mentionsFrom(input.outputText),
+            outputText: input.outputText,
+            recall: (input.recall.selected ?? []).map((selected) => ({
+                decision: selected.decision,
+                eventId: selected.eventId,
+                representation: excerpt(selected.representation),
+                scope: selected.scope
+            })),
+            signalsMentioned: this.knownSignals().filter((signal) => input.outputText.includes(signal)),
+            signalsInWakeText: this.knownSignals().filter((signal) => input.eventText.includes(signal))
+        });
+    }
+    recordConsultation(input) {
+        const observed = mentionsFrom(input.outputText).includes(input.to);
+        const edge = { ...input, observed };
+        this.consultations.push(edge);
+        this.recordAssertion({
+            detail: `${input.from} should mention @${input.to}`,
+            event: input.event,
+            kind: "consultation",
+            passed: observed
+        });
+        return edge;
+    }
+    benchRows() {
+        return this.turns.map((turn) => ({
+            agent: turn.agent,
+            engine: turn.engine,
+            event: turn.event,
+            totalMs: turn.totalMs,
+            memoryPrepareMs: turn.memoryPrepareMs,
+            engineMs: turn.engineMs,
+            memoryRecordMs: turn.memoryRecordMs,
+            promptChars: turn.promptChars,
+            outputChars: turn.outputChars,
+            recallCandidates: turn.recallCandidates,
+            recallSelected: turn.recallSelected
+        }));
+    }
+    summary() {
+        return this.turns.reduce((memo, turn) => {
+            const value = memo[turn.engine] ?? { count: 0, engineMs: 0, promptChars: 0, totalMs: 0 };
+            value.count += 1;
+            value.engineMs += turn.engineMs;
+            value.promptChars += turn.promptChars;
+            value.totalMs += turn.totalMs;
+            memo[turn.engine] = value;
+            return memo;
+        }, {});
+    }
+    behaviorSummary() {
+        const passedAssertions = this.assertions.filter((assertion) => assertion.passed).length;
+        const observedConsultations = this.consultations.filter((edge) => edge.observed).length;
+        const rate = (part, total) => total === 0 ? 1 : part / total;
+        return {
+            assertionPassRate: rate(passedAssertions, this.assertions.length),
+            consultationObservedRate: rate(observedConsultations, this.consultations.length),
+            signalsGenerated: this.signals.length,
+            totalRecallSelected: this.turns.reduce((total, turn) => total + turn.recallSelected, 0),
+            totalTurns: this.turns.length
+        };
+    }
+    tracePayload() {
+        return {
+            assertions: this.assertions,
+            behavior: this.behaviorSummary(),
+            consultations: this.consultations,
+            org_id: this.options.orgId,
+            run_id: this.options.runId,
+            schema: "daimon.org.telemetry/v1",
+            signals: this.signals,
+            summary: this.summary(),
+            turns: this.turns
+        };
+    }
+    async write(runtimeRoot) {
+        const telemetryDir = path.join(runtimeRoot, "telemetry");
+        await mkdir(telemetryDir, { recursive: true });
+        const summaryRecord = {
+            assertions: this.assertions,
+            behavior: this.behaviorSummary(),
+            kind: "org.turn_summary",
+            org_id: this.options.orgId,
+            run_id: this.options.runId,
+            schema: "daimon.org.telemetry/v1",
+            summary: this.summary()
+        };
+        const turnRecords = this.turns.map((turn) => ({
+            kind: "org.turn",
+            org_id: this.options.orgId,
+            run_id: this.options.runId,
+            schema: "daimon.org.telemetry/v1",
+            turn
+        }));
+        const ndjson = [...turnRecords, summaryRecord]
+            .map((record) => JSON.stringify(record))
+            .join("\n");
+        await writeFile(path.join(runtimeRoot, "trace.json"), `${JSON.stringify(this.tracePayload(), null, 2)}\n`);
+        await writeFile(path.join(runtimeRoot, "trace.md"), this.toMarkdown());
+        await writeFile(path.join(runtimeRoot, "bench.json"), `${JSON.stringify({ rows: this.benchRows(), summary: this.summary() }, null, 2)}\n`);
+        await writeFile(path.join(telemetryDir, "events.ndjson"), `${ndjson}\n`);
+        await writeFile(path.join(telemetryDir, "summary.json"), `${JSON.stringify(summaryRecord, null, 2)}\n`);
+    }
+    toMarkdown() {
+        const lines = [
+            "# Mixed Engine Org Trace",
+            "",
+            `- org: ${this.options.orgId}`,
+            `- run: ${this.options.runId}`,
+            "",
+            "## Behavior",
+            "",
+            `- assertion_pass_rate: ${this.behaviorSummary().assertionPassRate}`,
+            `- consultation_observed_rate: ${this.behaviorSummary().consultationObservedRate}`,
+            `- total_recall_selected: ${this.behaviorSummary().totalRecallSelected}`,
+            "",
+            "## Signals",
+            "",
+            "| Agent | Engine | Signal |",
+            "| --- | --- | --- |",
+            ...this.signals.map((signal) => `| ${signal.agent} | ${signal.engine} | ${signal.signal} |`),
+            "",
+            "## Consultations",
+            "",
+            "| Event | Edge | Observed |",
+            "| --- | --- | --- |",
+            ...this.consultations.map((edge) => `| ${edge.event} | ${edge.from} -> ${edge.to} | ${edge.observed ? "yes" : "no"} |`),
+            "",
+            "## Turns",
+            ""
+        ];
+        for (const turn of this.turns) {
+            lines.push(`### ${turn.event}`, "", `- agent: ${turn.agent}`, `- engine: ${turn.engine}`, `- total_ms: ${turn.totalMs}`, `- engine_ms: ${turn.engineMs}`, `- memory_prepare_ms: ${turn.memoryPrepareMs}`, `- memory_record_ms: ${turn.memoryRecordMs}`, `- prompt_chars: ${turn.promptChars}`, `- recall: ${turn.recallSelected}/${turn.recallCandidates}`, `- mentions: ${turn.mentions.join(", ") || "(none)"}`, `- signals_mentioned: ${turn.signalsMentioned.join(", ") || "(none)"}`, "", "Output:", "", `> ${turn.outputText}`, "");
+            if (turn.recall.length > 0) {
+                lines.push("Recalled memory:", "");
+                for (const recall of turn.recall) {
+                    lines.push(`- ${recall.eventId} [${recall.decision}] ${recall.representation}`);
+                }
+                lines.push("");
+            }
+        }
+        lines.push("## Assertions", "", "| Event | Kind | Passed | Detail |", "| --- | --- | --- | --- |", ...this.assertions.map((assertion) => `| ${assertion.event} | ${assertion.kind} | ${assertion.passed ? "yes" : "no"} | ${assertion.detail} |`), "");
+        return lines.join("\n");
+    }
+}

package/dist/pi/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./auth.js";
+export * from "./modelConfig.js";
+export * from "./piHarness.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/pi/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pi/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC"}

package/dist/pi/index.js

@@ -0,0 +1,3 @@
+export * from "./auth.js";
+export * from "./modelConfig.js";
+export * from "./piHarness.js";

package/dist/pi/memoryTools.d.ts

@@ -0,0 +1,15 @@
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { MemoryRuntime, MemoryToolExecutionContext } from "@noopolis/mneme";
+export interface PiMemoryToolContextRef {
+    current?: MemoryToolExecutionContext;
+}
+interface PiMemoryToolInput {
+    agentId: string;
+    memory: MemoryRuntime;
+    contextRef: PiMemoryToolContextRef;
+}
+type PiMemoryTool = ToolDefinition<any, unknown>;
+export declare const createPiMemoryTools: (input: PiMemoryToolInput) => PiMemoryTool[];
+export declare const piMemoryToolNames: (tools: PiMemoryTool[]) => string[];
+export {};
+//# sourceMappingURL=memoryTools.d.ts.map

package/dist/pi/memoryTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryTools.d.ts","sourceRoot":"","sources":["../../src/pi/memoryTools.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAGlF,OAAO,KAAK,EAAE,aAAa,EAAE,0BAA0B,EAAoB,MAAM,iBAAiB,CAAC;AAEnG,MAAM,WAAW,sBAAsB;IACrC,OAAO,CAAC,EAAE,0BAA0B,CAAC;CACtC;AAED,UAAU,iBAAiB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,aAAa,CAAC;IACtB,UAAU,EAAE,sBAAsB,CAAC;CACpC;AAED,KAAK,YAAY,GAAG,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AA4DjD,eAAO,MAAM,mBAAmB,GAAI,OAAO,iBAAiB,KAAG,YAAY,EAiBxE,CAAC;AAEJ,eAAO,MAAM,iBAAiB,GAAI,OAAO,YAAY,EAAE,KAAG,MAAM,EAChC,CAAC"}

package/dist/pi/memoryTools.js

@@ -0,0 +1,70 @@
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { createMemoryToolDescriptors } from "@noopolis/mneme";
+const fallbackContext = (agentId) => ({
+    wakeId: "manual",
+    threadId: "manual",
+    principal: { agentId, scope: "global" },
+    conversationScope: "global",
+    audienceKey: agentId,
+    transport: "in_process"
+});
+const textContent = (result) => ({
+    content: [{ type: "text", text: JSON.stringify(result) }],
+    details: result
+});
+const contentSchema = Type.Object({
+    kind: Type.String({ description: "Memory content kind: text, claim, decision, artifact, or relationship." })
+}, { additionalProperties: true });
+const schemaFor = (name) => {
+    if (name === "memory_search") {
+        return Type.Object({
+            scope: Type.String({ description: "Scope alias or canonical scope id. Use current, global, or all when appropriate." }),
+            query: Type.String({ description: "Search query." }),
+            limit: Type.Optional(Type.Number({ description: "Maximum result count." }))
+        });
+    }
+    if (name === "memory_locate") {
+        return Type.Object({
+            query: Type.String({ description: "What to locate in memory." }),
+            limit: Type.Optional(Type.Number({ description: "Maximum candidate count." })),
+            active_scope: Type.Optional(Type.String({ description: "Optional active scope hint." }))
+        });
+    }
+    if (name === "memory_register") {
+        return Type.Object({
+            scope: Type.String({ description: "Scope alias or canonical scope id where the memory belongs." }),
+            kind: Type.String({ description: "Memory content kind." }),
+            content: contentSchema,
+            visibility: Type.String({ description: "private, pair, team, room, global, public, or sealed." }),
+            sensitivity: Type.String({ description: "normal, sensitive, or secret." }),
+            evidence_event_ids: Type.Array(Type.String(), { description: "Event ids that justify the memory." }),
+            source_type: Type.String({ description: "Source label for the registered memory." }),
+            confidence: Type.Optional(Type.Number({ description: "Confidence from 0 to 1." }))
+        });
+    }
+    if (name === "memory_summarize") {
+        return Type.Object({
+            scope: Type.String({ description: "Scope alias or canonical scope id to summarize." }),
+            horizon: Type.Optional(Type.Number({ description: "Approximate number of recent memories to include." }))
+        });
+    }
+    return Type.Object({
+        scope: Type.String({ description: "Scope alias or canonical scope id for the tombstone." }),
+        event_ids: Type.Array(Type.String(), { description: "Memory event ids to tombstone." }),
+        reason: Type.Optional(Type.String({ description: "Why these memories should be forgotten." }))
+    });
+};
+export const createPiMemoryTools = (input) => createMemoryToolDescriptors(input.memory.kernel).map((descriptor) => defineTool({
+    name: descriptor.modelName,
+    label: descriptor.label,
+    description: descriptor.description,
+    promptSnippet: descriptor.promptSnippet,
+    promptGuidelines: descriptor.promptGuidelines,
+    parameters: schemaFor(descriptor.modelName),
+    async execute(_toolCallId, params) {
+        const result = await descriptor.invoke(params, input.contextRef.current ?? fallbackContext(input.agentId));
+        return textContent(result);
+    }
+}));
+export const piMemoryToolNames = (tools) => tools.map((tool) => tool.name);