@noopolis/daimon 0.1.0 → 0.1.2

package/dist/observability/controlCausal.d.ts

@@ -0,0 +1,117 @@
+import { type CausalEvent } from "./causalEvents.js";
+/**
+ * Control-wake causal emitters for root's two wake-acceptance surfaces
+ * (`src/runtime/pi/appControlSource.ts`, root repo, out of scope here):
+ * the operator-only control endpoint and the Moltnet loopback delivery
+ * endpoint (`/agents/:slug/wake`). Both stamp `control.wake.accepted` —
+ * enforcement point #3 in `specs/CAUSAL.md` §"Enforcement points" — but with
+ * different `principal_id` authorities, per the B62 fix (Option B): the
+ * operator endpoint stamps `operator:<name>` (`emitControlWakeAccepted`),
+ * the delivery endpoint stamps the fixed `system:moltnet` authority
+ * (`emitDeliveryWakeAccepted`), never a caller-supplied `from`/agent field.
+ * `control.wake.denied` (`emitControlWakeDenied`) stays operator-only: the
+ * delivery endpoint has no bearer-token deny path to stamp. Root's generated
+ * app calls these directly; this file has no knowledge of HTTP, tokens, or
+ * the request shape, only the causal envelope contract.
+ */
+export declare const CONTROL_WAKE_ACCEPTED_TYPE: "control.wake.accepted";
+export declare const CONTROL_WAKE_DENIED_TYPE: "control.wake.denied";
+/** Payload for `control.wake.accepted`. */
+export interface ControlWakeAcceptedPayload extends Record<string, unknown> {
+    target_agent_id: string;
+    wake_kind: string;
+}
+/** Payload for `control.wake.denied`. */
+export interface ControlWakeDeniedPayload extends Record<string, unknown> {
+    reason: string;
+    target_agent_id: string;
+}
+/**
+ * Payload for a Moltnet-delivered `control.wake.accepted` (same event type
+ * as the operator path — it is still an accepted wake; `principal_id` is
+ * what distinguishes authority). Adds `delivered_by` so downstream readers
+ * can tell a delivery-stamped event from an operator-stamped one without
+ * inspecting `principal_id`.
+ */
+export interface DeliveryWakeAcceptedPayload extends ControlWakeAcceptedPayload {
+    delivered_by: "moltnet";
+}
+/**
+ * Principal grammar per `specs/CAUSAL.md` §3 (`^(agent|operator|system):.+`):
+ * an authenticated operator identity, e.g. `operator:control`. Callers must
+ * pass the identity behind the verified bearer token, never a value read
+ * from the request body or model output.
+ */
+export declare const operatorPrincipalId: (operatorName: string) => string;
+/**
+ * Fixed principal for wakes accepted through the Moltnet loopback delivery
+ * endpoint (`/agents/:slug/wake`): the delivering authority itself, never an
+ * identity derived from a caller-supplied `from`/agent field on the request.
+ */
+export declare const DELIVERY_PRINCIPAL_ID: "system:moltnet";
+/** Deterministic, non-model-derived event id for a control wake acceptance. */
+export declare const controlWakeAcceptedEventId: (requestId: string) => string;
+/** Deterministic, non-model-derived event id for a control wake denial. */
+export declare const controlWakeDeniedEventId: (requestId: string) => string;
+/**
+ * Deterministic, non-model-derived event id for a Moltnet-delivered wake
+ * acceptance. Distinct from `controlWakeAcceptedEventId` (own `.delivery.`
+ * segment) so the two paths never collide even if a future caller reused a
+ * `requestId` across both endpoints for the same target.
+ */
+export declare const deliveryWakeAcceptedEventId: (requestId: string) => string;
+export interface EmitControlWakeAcceptedInput {
+    causeEventIds?: string[];
+    operatorName: string;
+    requestId: string;
+    runId?: string;
+    runtimeHomePath: string;
+    targetAgentId: string;
+    wakeKind: string;
+}
+/**
+ * Stamps `control.wake.accepted` once root's operator-control endpoint has
+ * verified the bearer token and is about to wake `targetAgentId`.
+ * `principal_id` is always `operator:<operatorName>` (the authenticated
+ * operator behind the verified token), never derived from the request body.
+ * `run_id` defaults to `resolveRunId()` like every other daimon emitter.
+ */
+export declare const emitControlWakeAccepted: (input: EmitControlWakeAcceptedInput) => Promise<CausalEvent<ControlWakeAcceptedPayload>>;
+export interface EmitDeliveryWakeAcceptedInput {
+    causeEventIds?: string[];
+    requestId: string;
+    runId?: string;
+    runtimeHomePath: string;
+    targetAgentId: string;
+    wakeKind: string;
+}
+/**
+ * Stamps `control.wake.accepted` once root's Moltnet loopback delivery
+ * endpoint (`/agents/:slug/wake`) is about to wake `targetAgentId` on behalf
+ * of an inter-agent message. `principal_id` is always the fixed
+ * `DELIVERY_PRINCIPAL_ID` (`system:moltnet`) — the delivering authority —
+ * never derived from a caller-supplied `from`/agent field, and never
+ * `operator:<name>` (that principal is reserved for the operator-only
+ * control endpoint; see `emitControlWakeAccepted`). `run_id` defaults to
+ * `resolveRunId()` like every other daimon emitter.
+ */
+export declare const emitDeliveryWakeAccepted: (input: EmitDeliveryWakeAcceptedInput) => Promise<CausalEvent<DeliveryWakeAcceptedPayload>>;
+export interface EmitControlWakeDeniedInput {
+    causeEventIds?: string[];
+    operatorName: string;
+    reason: string;
+    requestId: string;
+    runId?: string;
+    runtimeHomePath: string;
+    targetAgentId: string;
+}
+/**
+ * Stamps `control.wake.denied` when root's operator-control endpoint rejects
+ * a wake request over a missing or invalid bearer token. Deny paths must
+ * never drop silently (see `specs/CAUSAL.md` enforcement point #3 / T5):
+ * every 401 the endpoint returns should carry exactly one of these. As with
+ * `emitControlWakeAccepted`, `principal_id` is always the authenticated
+ * operator identity, never a value read from the request.
+ */
+export declare const emitControlWakeDenied: (input: EmitControlWakeDeniedInput) => Promise<CausalEvent<ControlWakeDeniedPayload>>;
+//# sourceMappingURL=controlCausal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"controlCausal.d.ts","sourceRoot":"","sources":["../../src/observability/controlCausal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEpF;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,0BAA0B,EAAG,uBAAgC,CAAC;AAC3E,eAAO,MAAM,wBAAwB,EAAG,qBAA8B,CAAC;AAEvE,2CAA2C;AAC3C,MAAM,WAAW,0BAA2B,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACzE,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,yCAAyC;AACzC,MAAM,WAAW,wBAAyB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACvE,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,2BAA4B,SAAQ,0BAA0B;IAC7E,YAAY,EAAE,SAAS,CAAC;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,cAAc,MAAM,KAAG,MAAoC,CAAC;AAEhG;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAG,gBAAyB,CAAC;AAE/D,+EAA+E;AAC/E,eAAO,MAAM,0BAA0B,GAAI,WAAW,MAAM,KAAG,MAClB,CAAC;AAE9C,2EAA2E;AAC3E,eAAO,MAAM,wBAAwB,GAAI,WAAW,MAAM,KAAG,MAAmD,CAAC;AAEjH;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,GAAI,WAAW,MAAM,KAAG,MAClB,CAAC;AAE/C,MAAM,WAAW,4BAA4B;IAC3C,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,4BAA4B,KAClC,OAAO,CAAC,WAAW,CAAC,0BAA0B,CAAC,CAa9C,CAAC;AAEL,MAAM,WAAW,6BAA6B;IAC5C,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GACnC,OAAO,6BAA6B,KACnC,OAAO,CAAC,WAAW,CAAC,2BAA2B,CAAC,CAc/C,CAAC;AAEL,MAAM,WAAW,0BAA0B;IACzC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,0BAA0B,KAChC,OAAO,CAAC,WAAW,CAAC,wBAAwB,CAAC,CAa5C,CAAC"}

package/dist/observability/controlCausal.js

@@ -0,0 +1,107 @@
+import { emitCausalEvent, resolveRunId } from "./causalEvents.js";
+/**
+ * Control-wake causal emitters for root's two wake-acceptance surfaces
+ * (`src/runtime/pi/appControlSource.ts`, root repo, out of scope here):
+ * the operator-only control endpoint and the Moltnet loopback delivery
+ * endpoint (`/agents/:slug/wake`). Both stamp `control.wake.accepted` —
+ * enforcement point #3 in `specs/CAUSAL.md` §"Enforcement points" — but with
+ * different `principal_id` authorities, per the B62 fix (Option B): the
+ * operator endpoint stamps `operator:<name>` (`emitControlWakeAccepted`),
+ * the delivery endpoint stamps the fixed `system:moltnet` authority
+ * (`emitDeliveryWakeAccepted`), never a caller-supplied `from`/agent field.
+ * `control.wake.denied` (`emitControlWakeDenied`) stays operator-only: the
+ * delivery endpoint has no bearer-token deny path to stamp. Root's generated
+ * app calls these directly; this file has no knowledge of HTTP, tokens, or
+ * the request shape, only the causal envelope contract.
+ */
+export const CONTROL_WAKE_ACCEPTED_TYPE = "control.wake.accepted";
+export const CONTROL_WAKE_DENIED_TYPE = "control.wake.denied";
+/**
+ * Principal grammar per `specs/CAUSAL.md` §3 (`^(agent|operator|system):.+`):
+ * an authenticated operator identity, e.g. `operator:control`. Callers must
+ * pass the identity behind the verified bearer token, never a value read
+ * from the request body or model output.
+ */
+export const operatorPrincipalId = (operatorName) => `operator:${operatorName}`;
+/**
+ * Fixed principal for wakes accepted through the Moltnet loopback delivery
+ * endpoint (`/agents/:slug/wake`): the delivering authority itself, never an
+ * identity derived from a caller-supplied `from`/agent field on the request.
+ */
+export const DELIVERY_PRINCIPAL_ID = "system:moltnet";
+/** Deterministic, non-model-derived event id for a control wake acceptance. */
+export const controlWakeAcceptedEventId = (requestId) => `daimon:${requestId}:control.wake.accepted`;
+/** Deterministic, non-model-derived event id for a control wake denial. */
+export const controlWakeDeniedEventId = (requestId) => `daimon:${requestId}:control.wake.denied`;
+/**
+ * Deterministic, non-model-derived event id for a Moltnet-delivered wake
+ * acceptance. Distinct from `controlWakeAcceptedEventId` (own `.delivery.`
+ * segment) so the two paths never collide even if a future caller reused a
+ * `requestId` across both endpoints for the same target.
+ */
+export const deliveryWakeAcceptedEventId = (requestId) => `daimon:${requestId}:delivery.wake.accepted`;
+/**
+ * Stamps `control.wake.accepted` once root's operator-control endpoint has
+ * verified the bearer token and is about to wake `targetAgentId`.
+ * `principal_id` is always `operator:<operatorName>` (the authenticated
+ * operator behind the verified token), never derived from the request body.
+ * `run_id` defaults to `resolveRunId()` like every other daimon emitter.
+ */
+export const emitControlWakeAccepted = (input) => emitCausalEvent({
+    agentId: input.targetAgentId,
+    causeEventIds: input.causeEventIds ?? [],
+    eventId: controlWakeAcceptedEventId(input.requestId),
+    payload: {
+        target_agent_id: input.targetAgentId,
+        wake_kind: input.wakeKind
+    },
+    principalId: operatorPrincipalId(input.operatorName),
+    runId: input.runId ?? resolveRunId(),
+    runtimeHomePath: input.runtimeHomePath,
+    type: CONTROL_WAKE_ACCEPTED_TYPE
+});
+/**
+ * Stamps `control.wake.accepted` once root's Moltnet loopback delivery
+ * endpoint (`/agents/:slug/wake`) is about to wake `targetAgentId` on behalf
+ * of an inter-agent message. `principal_id` is always the fixed
+ * `DELIVERY_PRINCIPAL_ID` (`system:moltnet`) — the delivering authority —
+ * never derived from a caller-supplied `from`/agent field, and never
+ * `operator:<name>` (that principal is reserved for the operator-only
+ * control endpoint; see `emitControlWakeAccepted`). `run_id` defaults to
+ * `resolveRunId()` like every other daimon emitter.
+ */
+export const emitDeliveryWakeAccepted = (input) => emitCausalEvent({
+    agentId: input.targetAgentId,
+    causeEventIds: input.causeEventIds ?? [],
+    eventId: deliveryWakeAcceptedEventId(input.requestId),
+    payload: {
+        delivered_by: "moltnet",
+        target_agent_id: input.targetAgentId,
+        wake_kind: input.wakeKind
+    },
+    principalId: DELIVERY_PRINCIPAL_ID,
+    runId: input.runId ?? resolveRunId(),
+    runtimeHomePath: input.runtimeHomePath,
+    type: CONTROL_WAKE_ACCEPTED_TYPE
+});
+/**
+ * Stamps `control.wake.denied` when root's operator-control endpoint rejects
+ * a wake request over a missing or invalid bearer token. Deny paths must
+ * never drop silently (see `specs/CAUSAL.md` enforcement point #3 / T5):
+ * every 401 the endpoint returns should carry exactly one of these. As with
+ * `emitControlWakeAccepted`, `principal_id` is always the authenticated
+ * operator identity, never a value read from the request.
+ */
+export const emitControlWakeDenied = (input) => emitCausalEvent({
+    agentId: input.targetAgentId,
+    causeEventIds: input.causeEventIds ?? [],
+    eventId: controlWakeDeniedEventId(input.requestId),
+    payload: {
+        reason: input.reason,
+        target_agent_id: input.targetAgentId
+    },
+    principalId: operatorPrincipalId(input.operatorName),
+    runId: input.runId ?? resolveRunId(),
+    runtimeHomePath: input.runtimeHomePath,
+    type: CONTROL_WAKE_DENIED_TYPE
+});

package/dist/observability/emitCausalFixture.d.ts

@@ -0,0 +1,25 @@
+import { type CausalEvent } from "./causalEvents.js";
+export interface CausalFixtureResult {
+    events: [CausalEvent, CausalEvent];
+    jsonlPath: string;
+}
+export interface RunCausalFixtureOptions {
+    /** Overrides the scratch runtime home; defaults to a fixed `.runtime/` path keyed on `spoof`. */
+    runtimeHomePath?: string;
+    /**
+     * Adversarial mode: the fixture's "wake text" (standing in for untrusted
+     * model/request input) embeds a forged identity claim, but the emitted
+     * `principal_id` on both events must remain the authenticated
+     * `agent:<agentId>` regardless — never the claimed identity. Mirrors the
+     * spoof invariant already covered live in `piHarnessCausal.test.ts`
+     * ("model output cannot set principal_id...").
+     */
+    spoof?: boolean;
+}
+/**
+ * Runs the fixture and returns the two stamped events plus the jsonl path,
+ * without touching `process.stdout`/`process.exitCode` — the CLI entry
+ * point below wraps this for `npm run emit-causal-fixture`.
+ */
+export declare const runCausalFixture: (options?: RunCausalFixtureOptions) => Promise<CausalFixtureResult>;
+//# sourceMappingURL=emitCausalFixture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emitCausalFixture.d.ts","sourceRoot":"","sources":["../../src/observability/emitCausalFixture.ts"],"names":[],"mappings":"AAIA,OAAO,EAA4E,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AA0B/H,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,uBAAuB;IACtC,iGAAiG;IACjG,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAID;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAU,UAAS,uBAA4B,KAAG,OAAO,CAAC,mBAAmB,CA0DzG,CAAC"}

package/dist/observability/emitCausalFixture.js

@@ -0,0 +1,98 @@
+import { mkdir, rm } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { emitTurnInputSubmitted, emitTurnOutputCompleted, resolveRunId, sha256Hex } from "./causalEvents.js";
+/**
+ * Standalone fixture emitter, run via `npm run emit-causal-fixture`
+ * (or `npm run emit-causal-fixture:spoof` for the adversarial mode below).
+ *
+ * Stamps one synthetic `turn.input.submitted` -> `turn.output.completed`
+ * chain into a scratch runtime home under `.runtime/causal-fixture[-spoof]/`,
+ * using the same `causalEvents.ts` functions `turnCausal.ts` uses for real
+ * turns. This is a fixture, not a live engine run: no Pi session, no mneme
+ * recall.
+ *
+ * `principal_id` here is stamped as `agent:<agentId>` directly (rather than
+ * importing `turnCausal.ts`'s `agentPrincipalId` helper) because this file
+ * lives under `src/observability/`, which stays engine-neutral and must not
+ * import `src/pi/` implementation details (see this folder's `AGENTS.md`).
+ * The value is the same grammar (`specs/CAUSAL.md` §3) either way.
+ *
+ * Exact invocation contract for a future cross-repo conformance harness
+ * (B92/B62, out of scope here) is not defined yet, so this script picks the
+ * simplest reasonable convention: write the fixture under a fixed relative
+ * path and print its absolute location as the last line of stdout.
+ */
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const daimonRoot = path.resolve(__dirname, "../..");
+const SPOOFED_AGENT_ID = "attacker-agent";
+/**
+ * Runs the fixture and returns the two stamped events plus the jsonl path,
+ * without touching `process.stdout`/`process.exitCode` — the CLI entry
+ * point below wraps this for `npm run emit-causal-fixture`.
+ */
+export const runCausalFixture = async (options = {}) => {
+    const spoof = options.spoof ?? false;
+    const runtimeHomePath = options.runtimeHomePath ?? path.join(daimonRoot, ".runtime", spoof ? "causal-fixture-spoof" : "causal-fixture");
+    await rm(runtimeHomePath, { recursive: true, force: true });
+    await mkdir(runtimeHomePath, { recursive: true });
+    const agentId = "fixture-agent";
+    const principalId = `agent:${agentId}`;
+    const turnId = "fixture-turn-1";
+    const runId = resolveRunId();
+    const inputText = spoof
+        ? `Fixture wake text for the causal conformance harness. ` +
+            `SPOOF CLAIM (must be ignored): ${JSON.stringify({ from: SPOOFED_AGENT_ID, principal_id: `agent:${SPOOFED_AGENT_ID}` })}`
+        : "Fixture wake text for the causal conformance harness.";
+    const promptText = "Fixture prompt text.";
+    const outputText = spoof
+        ? `Fixture reply text. SPOOF CLAIM (must be ignored): ${JSON.stringify({ principal_id: `agent:${SPOOFED_AGENT_ID}` })}`
+        : "Fixture reply text.";
+    const inputSubmitted = await emitTurnInputSubmitted({
+        agentId,
+        causeEventIds: [turnId],
+        inputContentSha256: sha256Hex(inputText),
+        inputMessageIds: [turnId],
+        principalId,
+        promptSha256: sha256Hex(promptText),
+        runId,
+        runtimeHomePath,
+        turnId
+    });
+    const outputCompleted = await emitTurnOutputCompleted({
+        agentId,
+        causeEventIds: [inputSubmitted.event_id],
+        outputSha256: sha256Hex(outputText),
+        principalId,
+        runId,
+        runtimeHomePath,
+        turnId
+    });
+    // The whole point of spoof mode: the forged claim above must never reach
+    // the stamped envelope. Fail loudly here rather than let a future refactor
+    // silently regress this invariant.
+    for (const event of [inputSubmitted, outputCompleted]) {
+        if (event.principal_id !== principalId) {
+            throw new Error(`causal fixture invariant violated: principal_id was "${event.principal_id}", expected "${principalId}"`);
+        }
+    }
+    return {
+        events: [inputSubmitted, outputCompleted],
+        jsonlPath: path.join(runtimeHomePath, "telemetry", "causal.jsonl")
+    };
+};
+const isMainModule = () => {
+    const invoked = process.argv[1] ? path.resolve(process.argv[1]) : undefined;
+    return invoked !== undefined && invoked === path.resolve(fileURLToPath(import.meta.url));
+};
+if (isMainModule()) {
+    const spoof = process.argv.includes("--spoof");
+    runCausalFixture({ spoof })
+        .then((result) => {
+        console.log(result.jsonlPath);
+    })
+        .catch((error) => {
+        console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+        process.exitCode = 1;
+    });
+}

package/dist/observability/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./causalEvents.js";
+export * from "./controlCausal.js";
+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,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC"}

package/dist/observability/index.js

@@ -0,0 +1,3 @@
+export * from "./causalEvents.js";
+export * from "./controlCausal.js";
+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");
+    }
+}