simfile 0.0.1

package/dist/view/runTimelineTypes.d.ts

@@ -0,0 +1,99 @@
+import type { RunWorldTrace } from "./runWorldTrace.js";
+/**
+ * `RunTimeline` — the single merged, dense, causally-repaired event
+ * timeline `simfile view <run-dir>`'s run-replay mode scrubs (`docs/VIEW_DESIGN.md`
+ * rule 7: time is one axis everywhere). Built once per run by
+ * `buildRunTimeline` (`runTimeline.ts`) from every `causal.jsonl` stream
+ * (`../observe/causalStreams.ts`'s `collectCausalStreams`) plus every mneme
+ * bank's `events.jsonl` bank log. `t` is the scrub key: a dense integer
+ * `0..N-1` assigned after sorting and causal repair, never `recorded_at`
+ * directly (real clocks are not guaranteed monotonic across systems).
+ */
+/**
+ * `agent:<id>` | `room:<network>:<room>` | `bank:<bank>` | `variable:<id>`
+ * (increment 4's variable storyline). `object:` remains reserved — no data
+ * to back it yet.
+ */
+export type ElementRef = string;
+/**
+ * `clock` (`clock.sync`) and `marker` (`marker.seen`) are increment 3's
+ * world-authority additions (`buildWorldRecord` in `runTimeline.ts`);
+ * `wake` is shared between `daimon`'s `control.wake.accepted` (already
+ * existed) and the world's `wake.recommended` — both name "an agent was
+ * recommended/accepted a wake," so one view class serves both authorities
+ * rather than forking it per-authority.
+ */
+export type TimelineViewClass = "message" | "wake" | "clock" | "marker" | "turn.input" | "turn.output" | "memory.claimed" | "memory.observed" | "memory.recalled" | "other";
+export interface TimelineEvent {
+    /** Dense scrub key, 0..N-1, assigned after sort + causal repair. */
+    t: number;
+    /** The real record id: a `causal.jsonl` `event_id` or a mneme bank log row's `id`. */
+    eventId: string;
+    /** The `raw/<authority>/...` directory this record was read from (`moltnet` | `daimon` | `mneme`). */
+    authority: string;
+    streamId: string;
+    seq: number;
+    type: string;
+    viewClass: TimelineViewClass;
+    /** The record's own timestamp — a display annotation; `t` is the scrub axis. */
+    recordedAt: string;
+    actor?: string;
+    /** Every element whose storyline includes this event. */
+    subjects: ElementRef[];
+    /** This record's own causal predecessor ids, verbatim (never invented). */
+    causes: string[];
+    /** Joined from the transcript or a mneme bank log by id — never invented. */
+    text?: string;
+    /**
+     * Increment 3 dedup join: on a `moltnet` `message.accepted` record, the
+     * `simfile_event_id` breadcrumb read from the transcript message's own
+     * `parts[].data` (`src/moltnet/world-participant.ts`'s
+     * `metadataFromEvent`) — the real `world.message`/`world.dm`/
+     * `wake.recommended` event this message echoes, when this message
+     * originated from a world action. Undefined for a message with no such
+     * breadcrumb (a genuine agent-authored message). The chat pane uses this
+     * to badge the echo "world" and to suppress its `world`-authority twin.
+     */
+    worldEventId?: string;
+    payload: unknown;
+}
+export type RunTimelineElementKind = "agent" | "room" | "bank" | "team" | "variable";
+export interface RunTimelineElement {
+    ref: ElementRef;
+    kind: RunTimelineElementKind;
+    label: string;
+}
+/**
+ * An interior self-team (the "descend into a mind" structure): a team that
+ * owns its own Moltnet network (`interiorRooms`) and is represented on a
+ * parent floor by one of its members (`representative`). Derived from the
+ * run's `spawnfile-report.json` by `membranes.ts`'s `deriveMembranes`.
+ */
+export interface RunTimelineMembrane {
+    /** `team:<id>`. */
+    ref: string;
+    label: string;
+    /** `agent:<id>` of the team's parent-floor representative (its lead/external face). */
+    representative: string;
+    /** `room:<network>:<room>` refs for the team's own interior council room(s). */
+    interiorRooms: string[];
+    /** `agent:<id>` refs for every member of the interior room(s). */
+    members: string[];
+    /**
+     * A `viewer.trace.v1` world trace scoped to exactly this membrane's
+     * `interiorRooms` — the "descend into a mind" mini map (`runWorldTrace.ts`'s
+     * `buildMembraneInteriorWorlds`, populated by `server.ts` once the full
+     * `RunTimeline` exists; `deriveMembranes`/`buildRunTimeline` never set this
+     * field themselves, since it needs the completed timeline). Undefined only
+     * before that population step runs.
+     */
+    interiorWorld?: RunWorldTrace;
+}
+export interface RunTimeline {
+    version: "simfile.run-timeline.v1";
+    runId: string;
+    events: TimelineEvent[];
+    elements: RunTimelineElement[];
+    membranes?: RunTimelineMembrane[];
+}
+//# sourceMappingURL=runTimelineTypes.d.ts.map

package/dist/view/runTimelineTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runTimelineTypes.d.ts","sourceRoot":"","sources":["../../src/view/runTimelineTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD;;;;;;;;;GASG;AAEH;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GACzB,SAAS,GACT,MAAM,GACN,OAAO,GACP,QAAQ,GACR,YAAY,GACZ,aAAa,GACb,gBAAgB,GAChB,iBAAiB,GACjB,iBAAiB,GACjB,OAAO,CAAC;AAEZ,MAAM,WAAW,aAAa;IAC5B,oEAAoE;IACpE,CAAC,EAAE,MAAM,CAAC;IACV,sFAAsF;IACtF,OAAO,EAAE,MAAM,CAAC;IAChB,sGAAsG;IACtG,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,iBAAiB,CAAC;IAC7B,gFAAgF;IAChF,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,6EAA6E;IAC7E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC;AAErF,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,UAAU,CAAC;IAChB,IAAI,EAAE,sBAAsB,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,mBAAmB;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,uFAAuF;IACvF,cAAc,EAAE,MAAM,CAAC;IACvB,gFAAgF;IAChF,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,kEAAkE;IAClE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,yBAAyB,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,QAAQ,EAAE,kBAAkB,EAAE,CAAC;IAC/B,SAAS,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACnC"}

package/dist/view/runTimelineTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/view/runViewModel.d.ts

@@ -0,0 +1,21 @@
+import type { RunViewModel } from "./runViewModelTypes.js";
+/**
+ * Loads a sealed compose-and-observe run directory and builds the single
+ * `RunViewModel`: reconciles the causal streams via the existing
+ * `runObserve` (Slice B pipeline, never re-implemented here), reads the raw
+ * moltnet transcript for message text, and reads each mneme bank's
+ * `events.jsonl` for the per-agent memory portals. Pure orchestration —
+ * every field this returns traces back to one of those three
+ * already-audited sources (`observe/AGENTS.md`, `docs/VIEW_DESIGN.md` rule 2:
+ * observer tier only, no invented state). `server.ts`'s `/api/run-meta`
+ * serves this model's `verdict`/`provenance` fields to the React shell
+ * (`web/src/viewer/RunMetaPanels.tsx`); `thread`/`minds` are computed too
+ * but no longer served whole — the shell gets chat/minds content from
+ * `/api/timeline` instead. Increment 3 additionally passes through
+ * `runObserve`'s own `seed_spread`/`spread_summary` (never recomputed) and,
+ * only when the run has a non-empty `world/telemetry.json` variable
+ * sample set, that sample set too — also served via `/api/run-meta` for
+ * the spread readout and the (seam-only) variable gauge.
+ */
+export declare const buildRunViewModel: (runDir: string) => Promise<RunViewModel>;
+//# sourceMappingURL=runViewModel.d.ts.map

package/dist/view/runViewModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runViewModel.d.ts","sourceRoot":"","sources":["../../src/view/runViewModel.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAO3D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,YAAY,CA2C5E,CAAC"}

package/dist/view/runViewModel.js

@@ -0,0 +1,66 @@
+import { runObserve } from "../observe/index.js";
+import { computeEngineProvenance } from "./engineProvenance.js";
+import { computeMinds, computeProvenance, computeThread, computeVerdict } from "./runViewModelCompute.js";
+import { hasVariableSamples, readMnemeEventsByBank, readTranscript, readUpReceiptEngines, readWorldTelemetry } from "./runRawArtifacts.js";
+const stringField = (world, key) => {
+    const value = world[key];
+    return typeof value === "string" ? value : undefined;
+};
+/**
+ * Loads a sealed compose-and-observe run directory and builds the single
+ * `RunViewModel`: reconciles the causal streams via the existing
+ * `runObserve` (Slice B pipeline, never re-implemented here), reads the raw
+ * moltnet transcript for message text, and reads each mneme bank's
+ * `events.jsonl` for the per-agent memory portals. Pure orchestration —
+ * every field this returns traces back to one of those three
+ * already-audited sources (`observe/AGENTS.md`, `docs/VIEW_DESIGN.md` rule 2:
+ * observer tier only, no invented state). `server.ts`'s `/api/run-meta`
+ * serves this model's `verdict`/`provenance` fields to the React shell
+ * (`web/src/viewer/RunMetaPanels.tsx`); `thread`/`minds` are computed too
+ * but no longer served whole — the shell gets chat/minds content from
+ * `/api/timeline` instead. Increment 3 additionally passes through
+ * `runObserve`'s own `seed_spread`/`spread_summary` (never recomputed) and,
+ * only when the run has a non-empty `world/telemetry.json` variable
+ * sample set, that sample set too — also served via `/api/run-meta` for
+ * the spread readout and the (seam-only) variable gauge.
+ */
+export const buildRunViewModel = async (runDir) => {
+    const observed = await runObserve(runDir);
+    const transcript = await readTranscript(runDir);
+    const mnemeEventsByBank = await readMnemeEventsByBank(runDir);
+    const telemetrySamples = await readWorldTelemetry(runDir);
+    const upReceiptEngines = await readUpReceiptEngines(runDir);
+    const allEvents = observed.streams.flatMap((stream) => stream.events);
+    const world = observed.manifest.world;
+    const members = world?.members;
+    // Prefer the up-receipt's per-agent engines[] (finer-grained, catches a
+    // mixed run) when the run-dir has one; otherwise fall back to the
+    // manifest's own single collapsed `engine` string, folded to one entry.
+    // No engine anywhere at all -> an empty list, which `computeEngineProvenance`
+    // reports as `"unknown"` rather than defaulting to real.
+    const engineEntries = upReceiptEngines ?? (observed.manifest.engine ? [{ engine: observed.manifest.engine }] : []);
+    return {
+        version: "simfile.run-view-model.v1",
+        runId: observed.manifest.run_id,
+        createdAt: observed.manifest.created_at,
+        engine: observed.manifest.engine,
+        engineProvenance: computeEngineProvenance(engineEntries),
+        world: world
+            ? {
+                networkId: stringField(world, "network_id"),
+                roomId: stringField(world, "room_id"),
+                members: Array.isArray(members)
+                    ? members.filter((member) => typeof member === "string")
+                    : undefined
+            }
+            : undefined,
+        participants: observed.report.participants,
+        verdict: computeVerdict(observed.report, observed.artifactIntegrity),
+        thread: computeThread(transcript, allEvents, mnemeEventsByBank),
+        minds: computeMinds(mnemeEventsByBank),
+        provenance: computeProvenance(observed.manifest, observed.report, observed.artifactIntegrity),
+        seedSpread: observed.report.seed_spread,
+        spreadSummary: observed.report.spread_summary,
+        variableSamples: hasVariableSamples(telemetrySamples) ? telemetrySamples : undefined
+    };
+};

package/dist/view/runViewModelCompute.d.ts

@@ -0,0 +1,24 @@
+import type { ArtifactIntegrityCheck } from "../observe/artifacts.js";
+import type { SimfileRunManifest } from "../observe/manifest.js";
+import type { SimfileObserveReport } from "../observe/report.js";
+import type { RawMnemeEvent, RawTranscript, RunMindPortal, RunMindRow, RunThreadMessage, RunVerdict, RunViewModel } from "./runViewModelTypes.js";
+import type { CausalEvent } from "@noopolis/stele";
+/**
+ * Merges every mneme bank's `events.jsonl` rows (in file-encounter order,
+ * banks iterated in map insertion order) and groups them by
+ * `principal.agentId`. Shared by `computeMinds` (aggregate portal view) and
+ * `computeThread` (per-turn memory-write grouping) so both read the exact
+ * same ordered record set.
+ */
+export declare const mindRowsByAgent: (mnemeEventsByBank: ReadonlyMap<string, readonly RawMnemeEvent[]>) => Map<string, RunMindRow[]>;
+export declare const computeMinds: (mnemeEventsByBank: ReadonlyMap<string, readonly RawMnemeEvent[]>) => RunMindPortal[];
+/**
+ * Builds the conversation timeline: the seed message (transcript[0], no
+ * trace) followed by every reply, each carrying the causal trace
+ * `message -> wake -> turn -> reply` when the reconciled daimon stream for
+ * that reply's author resolves one (real ids only — docs/VIEW_DESIGN.md rule 3).
+ */
+export declare const computeThread: (transcript: RawTranscript, events: readonly CausalEvent[], mnemeEventsByBank: ReadonlyMap<string, readonly RawMnemeEvent[]>) => RunThreadMessage[];
+export declare const computeVerdict: (report: SimfileObserveReport, artifactIntegrity: readonly ArtifactIntegrityCheck[]) => RunVerdict;
+export declare const computeProvenance: (manifest: SimfileRunManifest, report: SimfileObserveReport, artifactIntegrity: readonly ArtifactIntegrityCheck[]) => RunViewModel["provenance"];
+//# sourceMappingURL=runViewModelCompute.d.ts.map

package/dist/view/runViewModelCompute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runViewModelCompute.d.ts","sourceRoot":"","sources":["../../src/view/runViewModelCompute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EAEb,aAAa,EACb,UAAU,EAGV,gBAAgB,EAEhB,UAAU,EACV,YAAY,EACb,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAkBnD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAC1B,mBAAmB,WAAW,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC,KAC/D,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAY1B,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,mBAAmB,WAAW,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC,KAC/D,aAAa,EAGqD,CAAC;AA8EtE;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GACxB,YAAY,aAAa,EACzB,QAAQ,SAAS,WAAW,EAAE,EAC9B,mBAAmB,WAAW,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC,KAC/D,gBAAgB,EAmDlB,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,QAAQ,oBAAoB,EAC5B,mBAAmB,SAAS,sBAAsB,EAAE,KACnD,UAeF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,UAAU,kBAAkB,EAC5B,QAAQ,oBAAoB,EAC5B,mBAAmB,SAAS,sBAAsB,EAAE,KACnD,YAAY,CAAC,YAAY,CAkB3B,CAAC"}

package/dist/view/runViewModelCompute.js

@@ -0,0 +1,157 @@
+const MIND_STRATA = {
+    "memory.claimed": "claimed",
+    "memory.observed": "observed",
+    "memory.recalled": "recalled"
+};
+const agentIdFromFqid = (fqid) => fqid.split("/").pop();
+const extractMentions = (message) => (message.mentions ?? [])
+    .map(agentIdFromFqid)
+    .filter((id) => typeof id === "string" && id.length > 0);
+const messageText = (message) => message.parts.find((part) => part.kind === "text")?.text ?? "";
+/**
+ * Merges every mneme bank's `events.jsonl` rows (in file-encounter order,
+ * banks iterated in map insertion order) and groups them by
+ * `principal.agentId`. Shared by `computeMinds` (aggregate portal view) and
+ * `computeThread` (per-turn memory-write grouping) so both read the exact
+ * same ordered record set.
+ */
+export const mindRowsByAgent = (mnemeEventsByBank) => {
+    const byAgent = new Map();
+    for (const events of mnemeEventsByBank.values()) {
+        for (const event of events) {
+            const stratum = MIND_STRATA[event.type];
+            if (!stratum)
+                continue;
+            const rows = byAgent.get(event.principal.agentId) ?? [];
+            rows.push({ stratum, text: event.content.text, sourceId: event.id });
+            byAgent.set(event.principal.agentId, rows);
+        }
+    }
+    return byAgent;
+};
+export const computeMinds = (mnemeEventsByBank) => [...mindRowsByAgent(mnemeEventsByBank)]
+    .map(([agentId, rows]) => ({ agentId, eventCount: rows.length, rows }))
+    .sort((left, right) => left.agentId.localeCompare(right.agentId));
+/**
+ * Splits one agent's ordered mind rows into per-turn groups: each
+ * `"claimed"` row (mneme's "took the wake request in" record — always the
+ * first write of a turn) opens a new group; every row until the next
+ * `"claimed"` belongs to that same turn. Purely structural — no content
+ * matching — so it generalizes to any run, not just the golden fixture.
+ */
+const groupMindRowsByTurn = (rows) => {
+    const groups = [];
+    for (const row of rows) {
+        if (row.stratum === "claimed" || groups.length === 0) {
+            groups.push([row]);
+        }
+        else {
+            groups[groups.length - 1].push(row);
+        }
+    }
+    return groups;
+};
+const daimonEventsForAgent = (events, agentId) => events.filter((event) => event.emitter.system === "daimon" && event.emitter.stream_id === `agent:${agentId}`);
+const findTurnInput = (agentEvents, triggerEventId) => agentEvents.find((event) => event.type === "turn.input.submitted" &&
+    Array.isArray(event.payload.input_message_ids) &&
+    event.payload.input_message_ids.includes(triggerEventId));
+const findTurnOutput = (agentEvents, turnInputEventId) => agentEvents.find((event) => event.type === "turn.output.completed" && event.cause_event_ids.includes(turnInputEventId));
+const findWake = (agentEvents, triggerEventId) => agentEvents.find((event) => event.type === "control.wake.accepted" && event.cause_event_ids.includes(triggerEventId));
+const buildTrace = (agentEvents, triggerEventId, memoryWrites) => {
+    const turnInput = findTurnInput(agentEvents, triggerEventId);
+    if (!turnInput)
+        return undefined;
+    const turnOutput = findTurnOutput(agentEvents, turnInput.event_id);
+    const wake = findWake(agentEvents, triggerEventId);
+    return {
+        inEventId: triggerEventId,
+        wakeEventId: wake?.event_id,
+        turnInputEventId: turnInput.event_id,
+        turnOutputEventId: turnOutput?.event_id,
+        turnInputCauses: turnInput.cause_event_ids,
+        recalledMemoryEventIds: turnInput.cause_event_ids.filter((causeId) => causeId.startsWith("mneme:")),
+        memoryWrites: [...memoryWrites]
+    };
+};
+/**
+ * Builds the conversation timeline: the seed message (transcript[0], no
+ * trace) followed by every reply, each carrying the causal trace
+ * `message -> wake -> turn -> reply` when the reconciled daimon stream for
+ * that reply's author resolves one (real ids only — docs/VIEW_DESIGN.md rule 3).
+ */
+export const computeThread = (transcript, events, mnemeEventsByBank) => {
+    const rowsByAgent = mindRowsByAgent(mnemeEventsByBank);
+    const turnGroupsByAgent = new Map([...rowsByAgent].map(([agentId, rows]) => [agentId, groupMindRowsByTurn(rows)]));
+    const turnOrdinalByAgent = new Map();
+    let turnCounter = 0;
+    return transcript.transcript.map((message, index) => {
+        const isSeed = index === 0;
+        const agentId = message.from.type === "agent" ? message.from.id : null;
+        const previous = transcript.transcript[index - 1];
+        // "woken by @<agentId>" names the @mention in the PRIOR message that
+        // caused this agent's wake (the same mention `control.wake.accepted`
+        // resolves against) — not that message's author. The seed (index 0) is
+        // always the special case: even though it also @mentions the first
+        // responder, it is the conversation's opening move, not a reply-trigger.
+        const role = isSeed
+            ? `${message.from.type} · seed`
+            : index === 1
+                ? "woken by seed"
+                : agentId && previous && extractMentions(previous).includes(agentId)
+                    ? `woken by @${agentId}`
+                    : "woken by message";
+        const base = {
+            messageId: message.id,
+            agentId,
+            fromName: message.from.name,
+            turn: null,
+            role,
+            createdAt: message.created_at,
+            text: messageText(message),
+            mentions: extractMentions(message)
+        };
+        if (isSeed || !agentId || !previous) {
+            return base;
+        }
+        turnCounter += 1;
+        const ordinal = (turnOrdinalByAgent.get(agentId) ?? 0) + 1;
+        turnOrdinalByAgent.set(agentId, ordinal);
+        const memoryWrites = turnGroupsByAgent.get(agentId)?.[ordinal - 1] ?? [];
+        const triggerEventId = `moltnet:${previous.id}`;
+        const trace = buildTrace(daimonEventsForAgent(events, agentId), triggerEventId, memoryWrites);
+        return { ...base, turn: turnCounter, trace };
+    });
+};
+export const computeVerdict = (report, artifactIntegrity) => {
+    const artifactsVerified = artifactIntegrity.filter((check) => check.ok).length;
+    return {
+        healthy: report.failures.length === 0
+            && report.chains.incomplete.length === 0
+            && artifactsVerified === artifactIntegrity.length,
+        turnCount: report.agent_turns.count,
+        chainsComplete: report.chains.complete,
+        chainsIncomplete: report.chains.incomplete.length,
+        memoryEvents: report.memory.reduce((sum, bank) => sum + bank.events, 0),
+        memoryRecalls: report.memory.reduce((sum, bank) => sum + bank.recalls, 0),
+        artifactsVerified,
+        artifactsTotal: artifactIntegrity.length,
+        failures: report.failures.length
+    };
+};
+export const computeProvenance = (manifest, report, artifactIntegrity) => {
+    const okByPath = new Map(artifactIntegrity.map((check) => [check.path, check.ok]));
+    const artifacts = manifest.artifacts.map((artifact) => ({
+        path: artifact.path,
+        sha256: artifact.sha256,
+        ok: okByPath.get(artifact.path) ?? false
+    }));
+    const entries = [
+        { key: "participants", value: report.participants.join(", ") || "—" },
+        { key: "turn sequence", value: report.agent_turns.sequence.join(" → ") || "—" },
+        { key: "chains complete", value: String(report.chains.complete) },
+        { key: "chains incomplete", value: String(report.chains.incomplete.length) },
+        { key: "failures", value: String(report.failures.length) },
+        { key: "contract", value: report.version }
+    ];
+    return { artifacts, entries };
+};

package/dist/view/runViewModelTypes.d.ts

@@ -0,0 +1,177 @@
+import type { CausalEvent } from "@noopolis/stele";
+import type { EngineProvenance } from "./engineProvenance.js";
+import type { SeedSpreadEntry, SpreadSummary } from "../observe/report.js";
+/**
+ * `RunViewModel` — the data-driven model the run-reader page renders
+ * (`docs/VIEW_DESIGN.md` rule 3: every rendered element traces to a record id).
+ * Built once per `simfile view <run-dir>` invocation by
+ * `buildRunViewModel` (`runViewModel.ts`) from a sealed compose-and-observe
+ * run directory: the reconciled `simfile.observe.v1` report, the raw
+ * moltnet transcript, and the raw per-bank mneme event logs. Nothing here
+ * is invented; fields that cannot be derived from a real record are simply
+ * omitted (`trace`, `recallEventIds` on non-agent messages).
+ */
+export interface RunVerdict {
+    healthy: boolean;
+    turnCount: number;
+    chainsComplete: number;
+    chainsIncomplete: number;
+    memoryEvents: number;
+    memoryRecalls: number;
+    artifactsVerified: number;
+    artifactsTotal: number;
+    failures: number;
+}
+/** One hop the causal trace names, each a real `event_id` from a causal stream. */
+export interface RunThreadTrace {
+    /** The moltnet message event_id that triggered this turn. */
+    inEventId: string;
+    /** `daimon` `control.wake.accepted` event_id for this turn, when reconciled. */
+    wakeEventId?: string;
+    turnInputEventId: string;
+    turnOutputEventId?: string;
+    /** `turn.input.submitted`'s own `cause_event_ids`, verbatim. */
+    turnInputCauses: string[];
+    /** The subset of `turnInputCauses` prefixed `mneme:` — memories that fed this turn. */
+    recalledMemoryEventIds: string[];
+    /** This turn's mneme bank writes (claimed/observed/recalled), in file order. */
+    memoryWrites: RunMindRow[];
+}
+export interface RunThreadMessage {
+    messageId: string;
+    /** `null` for a human/operator message — it has no daimon turn. */
+    agentId: string | null;
+    fromName: string;
+    /** 1-based ordinal among agent-authored messages; `null` for the seed. */
+    turn: number | null;
+    role: string;
+    createdAt: string;
+    text: string;
+    /** Agent ids `@mentioned` in this message's text. */
+    mentions: string[];
+    trace?: RunThreadTrace;
+}
+export type RunMindStratum = "claimed" | "observed" | "recalled";
+export interface RunMindRow {
+    stratum: RunMindStratum;
+    text: string;
+    sourceId: string;
+}
+export interface RunMindPortal {
+    agentId: string;
+    eventCount: number;
+    rows: RunMindRow[];
+}
+export interface RunProvenanceArtifact {
+    path: string;
+    sha256: string;
+    ok: boolean;
+}
+export interface RunProvenanceEntry {
+    key: string;
+    value: string;
+}
+export interface RunViewModel {
+    version: "simfile.run-view-model.v1";
+    runId: string;
+    createdAt: string;
+    engine?: string;
+    /**
+     * The honesty-critical disclosure (docs/VIEW_DESIGN.md / the run-replay badge):
+     * whether this run's dialogue came from a deterministic scripted
+     * screenplay or a real engine, derived by `engineProvenance.ts` from
+     * `spawnfile/up-receipt.json`'s per-agent `engines[]` when present, else
+     * this same `engine` field collapsed to one entry. Never absent — an
+     * engine-less manifest still yields `{mode: "unknown", ...}` rather than
+     * omitting the field, so the viewer always has something to badge.
+     */
+    engineProvenance: EngineProvenance;
+    world?: {
+        networkId?: string;
+        roomId?: string;
+        members?: string[];
+    };
+    participants: string[];
+    verdict: RunVerdict;
+    thread: RunThreadMessage[];
+    minds: RunMindPortal[];
+    provenance: {
+        artifacts: RunProvenanceArtifact[];
+        entries: RunProvenanceEntry[];
+    };
+    /**
+     * Increment 3: `runObserve`'s already-computed `seed_spread`/
+     * `spread_summary` (`../observe/seedSpread.ts`), passed through verbatim
+     * — never recomputed here. Both are DEFINED-BUT-OPTIONAL
+     * (`../observe/report.ts`): a run with no `manifest.seed_declaration`
+     * (e.g. `office-sim-golden`) simply omits them, and the viewer renders no
+     * spread UI at all rather than fake reach/latency numbers.
+     */
+    seedSpread?: SeedSpreadEntry[];
+    spreadSummary?: SpreadSummary;
+    /**
+     * Increment 3: `world/telemetry.json`'s per-tick variable samples, when
+     * the run has any (`readWorldTelemetry` in `runRawArtifacts.ts`).
+     * Omitted — never a fabricated empty gauge — when the run has no
+     * telemetry file, or every sample's `variables` map is empty (e.g.
+     * `office-secret-v0-golden`, which drives no variable).
+     */
+    variableSamples?: RunTelemetrySample[];
+}
+/** One `world/telemetry.json` sample row (`simfile.telemetry.v1`, `src/runtime/run-record.ts`'s `TelemetryArtifact`). */
+export interface RunTelemetrySample {
+    tick: number;
+    simTime: number;
+    phase?: string;
+    variables: Record<string, number>;
+}
+/** The raw `raw/moltnet/transcript.json` shape this package writes and reads. */
+export interface RawTranscriptMessage {
+    id: string;
+    from: {
+        type: string;
+        id: string;
+        name: string;
+    };
+    /**
+     * `data` is the `simfile_event_id`/`simfile_event_kind`/`simfile_rule_id`
+     * breadcrumb `src/moltnet/world-participant.ts`'s `metadataFromEvent`
+     * attaches to a message that originated from a world action
+     * (`world.message`/`world.dm`/`wake.recommended`) — absent on a genuine
+     * agent-authored message.
+     */
+    parts: {
+        kind: string;
+        text?: string;
+        data?: Record<string, unknown>;
+    }[];
+    mentions?: string[];
+    created_at: string;
+}
+export interface RawTranscript {
+    seedMessageText?: string;
+    transcript: RawTranscriptMessage[];
+}
+/** One line of a mneme bank's `events.jsonl` (the human-readable memory log). */
+export interface RawMnemeEvent {
+    id: string;
+    type: string;
+    createdAt: string;
+    principal: {
+        agentId: string;
+    };
+    content: {
+        kind: string;
+        text: string;
+    };
+    /** This bank log's own causal predecessors (distinct id space from `causal.jsonl`'s `event_id`s). */
+    parentEventIds?: string[];
+    /** Per-principal sequence number within this bank's `events.jsonl`. */
+    seq?: number;
+}
+export interface RunViewModelSource {
+    events: readonly CausalEvent[];
+    mnemeEventsByBank: ReadonlyMap<string, readonly RawMnemeEvent[]>;
+    transcript: RawTranscript;
+}
+//# sourceMappingURL=runViewModelTypes.d.ts.map

package/dist/view/runViewModelTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runViewModelTypes.d.ts","sourceRoot":"","sources":["../../src/view/runViewModelTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE3E;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,mFAAmF;AACnF,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,uFAAuF;IACvF,sBAAsB,EAAE,MAAM,EAAE,CAAC;IACjC,gFAAgF;IAChF,YAAY,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAED,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;AAEjE,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,cAAc,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,UAAU,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,OAAO,CAAC;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,2BAA2B,CAAC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;OAQG;IACH,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,KAAK,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACpE,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,UAAU,EAAE;QACV,SAAS,EAAE,qBAAqB,EAAE,CAAC;QACnC,OAAO,EAAE,kBAAkB,EAAE,CAAC;KAC/B,CAAC;IACF;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;IAC/B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,kBAAkB,EAAE,CAAC;CACxC;AAED,yHAAyH;AACzH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED,iFAAiF;AACjF,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACjD;;;;;;OAMG;IACH,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EAAE,CAAC;IACzE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,oBAAoB,EAAE,CAAC;CACpC;AAED,iFAAiF;AACjF,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/B,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,qGAAqG;IACrG,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,uEAAuE;IACvE,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IAC/B,iBAAiB,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC,CAAC;IACjE,UAAU,EAAE,aAAa,CAAC;CAC3B"}

package/dist/view/runViewModelTypes.js

@@ -0,0 +1 @@
+export {};