simfile 0.0.1

package/dist/view/engineProvenance.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Engine provenance disclosure (honesty gap fix): a run-replay viewer must
+ * never let a deterministic scripted screenplay be mistaken for live
+ * agents. This module classifies each engine name a run declares — either
+ * per-agent (from `spawnfile/up-receipt.json`'s `engines[]`, when the
+ * run-dir carries one) or the single collapsed `manifest.engine` string —
+ * into one of three per-entry buckets (`scripted` / `real-engine` /
+ * `unknown`), then folds those into one overall `EngineProvenance.mode` the
+ * viewer badges unmissably.
+ *
+ * Classification rule (never guess):
+ * - `fake-*` or exactly `scripted` -> `scripted` (a canned, authored
+ *   screenplay — deterministic, not emergent dialogue).
+ * - A recognized real model engine name (`grok`, `codex`, `agy`, `claude`,
+ *   matched as a whole word/hyphenated-prefix so `claude-sonnet-4.5` or
+ *   `grok-4` still match) -> `real-engine`.
+ * - Anything else, including an entirely absent engine field -> `unknown`.
+ *   `unknown` NEVER collapses to `real-engine` — absence of disclosure is
+ *   never treated as evidence of a real engine.
+ *
+ * Overall `mode` is the single per-entry classification when every entry
+ * agrees, or `"mixed"` when entries disagree (e.g. one agent scripted,
+ * another real — or a real name alongside an undetermined one). `"mixed"`
+ * is itself a disclosure, not a suppressed detail.
+ */
+export type EngineClassification = "scripted" | "real-engine" | "unknown";
+export interface EngineEntry {
+    /** Present when derived from a per-agent up-receipt `engines[]` row; absent for a single collapsed `manifest.engine` string. */
+    agent?: string;
+    engine: string;
+}
+export interface EngineProvenance {
+    mode: EngineClassification | "mixed";
+    engines: EngineEntry[];
+    label: string;
+}
+/** Classifies one engine name string. Exported for direct testing of the rule in isolation from the aggregation below. */
+export declare const classifyEngineName: (engine: string) => EngineClassification;
+/**
+ * Folds a list of engine entries (per-agent or a single collapsed entry)
+ * into the one `EngineProvenance` the viewer badges. An empty list (no
+ * engine field disclosed anywhere) is `"unknown"` — never defaulted to
+ * real or scripted.
+ */
+export declare const computeEngineProvenance: (engines: readonly EngineEntry[]) => EngineProvenance;
+//# sourceMappingURL=engineProvenance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engineProvenance.d.ts","sourceRoot":"","sources":["../../src/view/engineProvenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,MAAM,oBAAoB,GAAG,UAAU,GAAG,aAAa,GAAG,SAAS,CAAC;AAE1E,MAAM,WAAW,WAAW;IAC1B,gIAAgI;IAChI,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC;IACrC,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf;AAaD,0HAA0H;AAC1H,eAAO,MAAM,kBAAkB,GAAI,QAAQ,MAAM,KAAG,oBAKnD,CAAC;AAmBF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,SAAS,WAAW,EAAE,KAAG,gBAezE,CAAC"}

package/dist/view/engineProvenance.js

@@ -0,0 +1,76 @@
+/**
+ * Engine provenance disclosure (honesty gap fix): a run-replay viewer must
+ * never let a deterministic scripted screenplay be mistaken for live
+ * agents. This module classifies each engine name a run declares — either
+ * per-agent (from `spawnfile/up-receipt.json`'s `engines[]`, when the
+ * run-dir carries one) or the single collapsed `manifest.engine` string —
+ * into one of three per-entry buckets (`scripted` / `real-engine` /
+ * `unknown`), then folds those into one overall `EngineProvenance.mode` the
+ * viewer badges unmissably.
+ *
+ * Classification rule (never guess):
+ * - `fake-*` or exactly `scripted` -> `scripted` (a canned, authored
+ *   screenplay — deterministic, not emergent dialogue).
+ * - A recognized real model engine name (`grok`, `codex`, `agy`, `claude`,
+ *   matched as a whole word/hyphenated-prefix so `claude-sonnet-4.5` or
+ *   `grok-4` still match) -> `real-engine`.
+ * - Anything else, including an entirely absent engine field -> `unknown`.
+ *   `unknown` NEVER collapses to `real-engine` — absence of disclosure is
+ *   never treated as evidence of a real engine.
+ *
+ * Overall `mode` is the single per-entry classification when every entry
+ * agrees, or `"mixed"` when entries disagree (e.g. one agent scripted,
+ * another real — or a real name alongside an undetermined one). `"mixed"`
+ * is itself a disclosure, not a suppressed detail.
+ */
+const SCRIPTED_PATTERN = /^fake-/iu;
+const REAL_ENGINE_NAMES = ["grok", "codex", "agy", "claude"];
+/** Matches a real engine name as a whole segment (`grok`, `grok-4`, `claude-sonnet-4.5`) so a substring of an unrelated word never false-matches. */
+const realEngineNameFrom = (engine) => {
+    const lowered = engine.toLowerCase();
+    return REAL_ENGINE_NAMES.find((name) => lowered === name || lowered.startsWith(`${name}-`) || lowered.startsWith(`${name}_`));
+};
+/** Classifies one engine name string. Exported for direct testing of the rule in isolation from the aggregation below. */
+export const classifyEngineName = (engine) => {
+    const lowered = engine.trim().toLowerCase();
+    if (lowered === "scripted" || SCRIPTED_PATTERN.test(lowered))
+        return "scripted";
+    if (realEngineNameFrom(lowered))
+        return "real-engine";
+    return "unknown";
+};
+const SCRIPTED_LABEL = "⚙ SCRIPTED RUN — authored screenplay, not emergent dialogue (deterministic, not live agents)";
+const UNKNOWN_LABEL = "❓ ENGINE UNKNOWN — provenance not disclosed, do not assume real agents";
+const realEngineLabel = (engines) => {
+    const names = [...new Set(engines.map((entry) => entry.engine))];
+    return `🧠 REAL ENGINE · ${names.join(", ")}`;
+};
+const mixedLabel = (engines) => {
+    const parts = engines.map((entry) => {
+        const classification = classifyEngineName(entry.engine);
+        const tag = classification === "scripted" ? "scripted" : classification === "real-engine" ? `real: ${entry.engine}` : "unknown";
+        return entry.agent ? `${entry.agent}: ${tag}` : tag;
+    });
+    return `◐ MIXED ENGINES — ${parts.join(", ")} (not uniformly real or scripted)`;
+};
+/**
+ * Folds a list of engine entries (per-agent or a single collapsed entry)
+ * into the one `EngineProvenance` the viewer badges. An empty list (no
+ * engine field disclosed anywhere) is `"unknown"` — never defaulted to
+ * real or scripted.
+ */
+export const computeEngineProvenance = (engines) => {
+    if (engines.length === 0) {
+        return { mode: "unknown", engines: [], label: UNKNOWN_LABEL };
+    }
+    const classifications = new Set(engines.map((entry) => classifyEngineName(entry.engine)));
+    if (classifications.size === 1) {
+        const [mode] = classifications;
+        if (mode === "scripted")
+            return { mode, engines: [...engines], label: SCRIPTED_LABEL };
+        if (mode === "real-engine")
+            return { mode, engines: [...engines], label: realEngineLabel(engines) };
+        return { mode: "unknown", engines: [...engines], label: UNKNOWN_LABEL };
+    }
+    return { mode: "mixed", engines: [...engines], label: mixedLabel(engines) };
+};

package/dist/view/index.d.ts

@@ -0,0 +1,14 @@
+export interface ViewCommandOptions {
+    port: number;
+    sourcePath: string;
+    statePath?: string;
+    openBrowser: boolean;
+}
+export interface ParsedViewCommand {
+    options?: ViewCommandOptions;
+    error?: string;
+    help?: boolean;
+}
+export declare const parseViewArguments: (argv: readonly string[]) => ParsedViewCommand;
+export declare const runViewCommand: (argv: readonly string[]) => Promise<number>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/view/index.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,eAAO,MAAM,kBAAkB,GAAI,MAAM,SAAS,MAAM,EAAE,KAAG,iBAyE5D,CAAA;AAED,eAAO,MAAM,cAAc,GAAU,MAAM,SAAS,MAAM,EAAE,KAAG,OAAO,CAAC,MAAM,CAiC5E,CAAC"}

package/dist/view/index.js

@@ -0,0 +1,107 @@
+import { spawn } from "node:child_process";
+import { createViewerServer } from "./server.js";
+export const parseViewArguments = (argv) => {
+    const parsed = {
+        port: 4400,
+        sourcePath: ".",
+        openBrowser: true,
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--help" || arg === "-h") {
+            return { help: true };
+        }
+        if (arg === "--port") {
+            const value = argv[index + 1];
+            if (!value) {
+                return { error: "Missing value for --port" };
+            }
+            const port = Number(value);
+            if (!Number.isInteger(port) || port < 1024 || port > 65535) {
+                return { error: "Invalid value for --port" };
+            }
+            parsed.port = port;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--port=")) {
+            const port = Number(arg.slice("--port=".length));
+            if (!Number.isInteger(port) || port < 1024 || port > 65535) {
+                return { error: "Invalid value for --port" };
+            }
+            parsed.port = port;
+            continue;
+        }
+        if (arg === "--no-open") {
+            parsed.openBrowser = false;
+            continue;
+        }
+        if (arg === "--state") {
+            const value = argv[index + 1];
+            if (!value) {
+                return { error: "Missing value for --state" };
+            }
+            parsed.statePath = value;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--state=")) {
+            parsed.statePath = arg.slice("--state=".length);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            return { error: `Unknown flag ${arg}` };
+        }
+        if (parsed.sourcePath !== ".") {
+            return { error: `Unexpected positional argument ${arg}` };
+        }
+        parsed.sourcePath = arg;
+    }
+    return {
+        options: {
+            ...parsed,
+            mode: parsed.statePath ? "live" : "replay",
+        },
+    };
+};
+export const runViewCommand = async (argv) => {
+    const parsed = parseViewArguments(argv);
+    if (parsed.help) {
+        process.stdout.write(viewUsage());
+        return 0;
+    }
+    if (parsed.error || !parsed.options) {
+        if (parsed.error)
+            process.stderr.write(`${parsed.error}\n`);
+        process.stderr.write(viewUsage());
+        return 1;
+    }
+    const handle = await createViewerServer({
+        port: parsed.options.port,
+        sourcePath: parsed.options.sourcePath,
+        statePath: parsed.options.statePath,
+        mode: parsed.options.statePath ? "live" : "replay",
+    });
+    const modeLabel = parsed.options.statePath ? "live" : "replay";
+    process.stdout.write(`Simfile viewer running at ${handle.url} (mode: ${modeLabel})\n`);
+    process.stdout.write(`Press Ctrl+C to stop.\n`);
+    if (parsed.options.openBrowser) {
+        openBrowser(handle.url);
+    }
+    await new Promise(() => { });
+    return 0;
+};
+const openBrowser = (url) => {
+    const command = process.platform === "darwin" ? "open"
+        : process.platform === "win32" ? "start \"\""
+            : "xdg-open";
+    spawn(command, [url], { detached: true, stdio: "ignore", shell: true });
+};
+const viewUsage = () => [
+    "Usage:",
+    "  simfile view --state <path>",
+    "  simfile view <run-record-dir>",
+    "  simfile view --port 4400 --no-open --state .sim/",
+    "  simfile view --help",
+    "",
+].join("\n");

package/dist/view/membranes.d.ts

@@ -0,0 +1,14 @@
+import type { RunTimelineMembrane } from "./runTimelineTypes.js";
+/**
+ * Builds the membranes array. Empty (never throwing) when the report is
+ * absent/unparseable or declares no interior self-teams — the office-sim
+ * golden (no teams, no report in its run-dir) legitimately yields `[]`.
+ */
+export declare const deriveMembranes: (report: unknown) => RunTimelineMembrane[];
+/**
+ * Reads `spawnfile-report.json` from a run-dir and derives its membranes.
+ * Returns `[]` when the file is missing (a non-composed or single-team run
+ * that never copied a report in) — never throws for a run without one.
+ */
+export declare const readRunMembranes: (runDir: string) => Promise<RunTimelineMembrane[]>;
+//# sourceMappingURL=membranes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"membranes.d.ts","sourceRoot":"","sources":["../../src/view/membranes.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAwHjE;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,QAAQ,OAAO,KAAG,mBAAmB,EAwCpE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,mBAAmB,EAAE,CAQpF,CAAC"}

package/dist/view/membranes.js

@@ -0,0 +1,127 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { agentRef, roomRef } from "./runTimelineRefs.js";
+const asRecord = (value) => typeof value === "object" && value !== null ? value : undefined;
+const asString = (value) => (typeof value === "string" ? value : undefined);
+const stripPrefix = (id, prefix) => (id.startsWith(prefix) ? id.slice(prefix.length) : id);
+/** Team-slug set: every `nodes[]` entry with `kind: "team"`, stripped of the `team:` id prefix. */
+const collectTeamSlugs = (report) => {
+    const teams = new Set();
+    const nodes = Array.isArray(report.nodes) ? report.nodes : [];
+    for (const node of nodes) {
+        if (asString(node.kind) === "team") {
+            const id = asString(node.id);
+            if (id)
+                teams.add(stripPrefix(id, "team:"));
+        }
+    }
+    return teams;
+};
+/**
+ * team-slug -> representative `agent:<id>` ref, read from every agent node's
+ * `active_environments.moltnet[network][room].member_slot`: when that slot is
+ * a known team slug OTHER than the agent's own id, this agent is that team's
+ * representative on a parent floor.
+ */
+const collectRepresentatives = (report, teamSlugs) => {
+    const byTeam = new Map();
+    const nodes = Array.isArray(report.nodes) ? report.nodes : [];
+    for (const node of nodes) {
+        if (asString(node.kind) !== "agent")
+            continue;
+        const nodeId = asString(node.id);
+        if (!nodeId)
+            continue;
+        const agentSlug = stripPrefix(nodeId, "agent:");
+        const active = asRecord(node.active_environments);
+        const moltnet = asRecord(active?.moltnet);
+        if (!moltnet)
+            continue;
+        for (const networkBinding of Object.values(moltnet)) {
+            const rooms = asRecord(asRecord(networkBinding)?.rooms);
+            if (!rooms)
+                continue;
+            for (const roomBinding of Object.values(rooms)) {
+                const slot = asString(asRecord(roomBinding)?.member_slot);
+                if (slot && slot !== agentSlug && teamSlugs.has(slot) && !byTeam.has(slot)) {
+                    byTeam.set(slot, agentRef(agentSlug));
+                }
+            }
+        }
+    }
+    return byTeam;
+};
+/** The `server_plans[]` a team owns, matched by the compiler's `id === `${teamSlug}-${networkId}`` convention. */
+const ownedServerPlans = (report, teamSlug) => {
+    const moltnet = asRecord(asRecord(report.container)?.moltnet);
+    const plans = Array.isArray(moltnet?.server_plans)
+        ? moltnet.server_plans
+        : [];
+    return plans.filter((plan) => {
+        const id = asString(plan.id);
+        const networkId = asString(plan.network_id);
+        return Boolean(id && networkId && id === `${teamSlug}-${networkId}`);
+    });
+};
+/**
+ * Builds the membranes array. Empty (never throwing) when the report is
+ * absent/unparseable or declares no interior self-teams — the office-sim
+ * golden (no teams, no report in its run-dir) legitimately yields `[]`.
+ */
+export const deriveMembranes = (report) => {
+    const shape = asRecord(report);
+    if (!shape)
+        return [];
+    const teamSlugs = collectTeamSlugs(shape);
+    const representatives = collectRepresentatives(shape, teamSlugs);
+    const membranes = [];
+    for (const [teamSlug, representative] of representatives) {
+        const plans = ownedServerPlans(shape, teamSlug);
+        if (plans.length === 0)
+            continue;
+        const interiorRooms = [];
+        const members = new Set();
+        for (const plan of plans) {
+            const networkId = asString(plan.network_id);
+            const rooms = Array.isArray(plan.rooms) ? plan.rooms : [];
+            for (const room of rooms) {
+                const roomId = asString(room.id);
+                if (!networkId || !roomId)
+                    continue;
+                interiorRooms.push(roomRef(networkId, roomId));
+                const roomMembers = Array.isArray(room.members) ? room.members : [];
+                for (const member of roomMembers) {
+                    const memberId = asString(member);
+                    if (memberId)
+                        members.add(agentRef(memberId));
+                }
+            }
+        }
+        if (interiorRooms.length === 0)
+            continue;
+        membranes.push({
+            ref: `team:${teamSlug}`,
+            label: teamSlug,
+            representative,
+            interiorRooms: interiorRooms.sort(),
+            members: [...members].sort()
+        });
+    }
+    return membranes.sort((left, right) => left.ref.localeCompare(right.ref));
+};
+/**
+ * Reads `spawnfile-report.json` from a run-dir and derives its membranes.
+ * Returns `[]` when the file is missing (a non-composed or single-team run
+ * that never copied a report in) — never throws for a run without one.
+ */
+export const readRunMembranes = async (runDir) => {
+    const raw = await readFile(path.join(runDir, "spawnfile-report.json"), "utf8").catch(() => null);
+    if (raw === null)
+        return [];
+    try {
+        return deriveMembranes(JSON.parse(raw));
+    }
+    catch {
+        return [];
+    }
+};

package/dist/view/runDetect.d.ts

@@ -0,0 +1,2 @@
+export declare const isObserveRunDir: (dirPath: string) => Promise<boolean>;
+//# sourceMappingURL=runDetect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runDetect.d.ts","sourceRoot":"","sources":["../../src/view/runDetect.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,eAAe,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,OAAO,CAStE,CAAC"}

package/dist/view/runDetect.js

@@ -0,0 +1,47 @@
+import { access, readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+/**
+ * Detects a compose-and-observe run directory (`simfile.run-manifest.v1` + at
+ * least one moltnet transcript) so `simfile view <dir>` can pick the
+ * run-reader replay mode instead of the world/3D replay mode. Deliberately
+ * narrow: it only checks the two artifacts that make the golden fixtures
+ * (`fixtures/observe/office-sim-golden/`, `fixtures/observe/jungian-daimon-org-golden/`)
+ * and any future real run directory renderable, never a full manifest parse —
+ * `runObserve` does the real validation once this returns true. A transcript
+ * may be the single-network flat `raw/moltnet/transcript.json` OR any
+ * multi-network per-network `raw/moltnet/<network_id>/transcript.json`.
+ */
+const hasMoltnetTranscript = async (dirPath) => {
+    const moltnetDir = path.join(dirPath, "raw", "moltnet");
+    try {
+        await access(path.join(moltnetDir, "transcript.json"));
+        return true;
+    }
+    catch {
+        // fall through to the per-network scan
+    }
+    const entries = await readdir(moltnetDir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        try {
+            await access(path.join(moltnetDir, entry.name, "transcript.json"));
+            return true;
+        }
+        catch {
+            // keep scanning
+        }
+    }
+    return false;
+};
+export const isObserveRunDir = async (dirPath) => {
+    if (!(await hasMoltnetTranscript(dirPath)))
+        return false;
+    try {
+        const raw = JSON.parse(await readFile(path.join(dirPath, "manifest.json"), "utf8"));
+        return raw.version === "simfile.run-manifest.v1";
+    }
+    catch {
+        return false;
+    }
+};

package/dist/view/runRawArtifacts.d.ts

@@ -0,0 +1,48 @@
+import type { EngineEntry } from "./engineProvenance.js";
+import type { RawMnemeEvent, RawTranscript, RunTelemetrySample } from "./runViewModelTypes.js";
+export declare const readMnemeEventsByBank: (runDir: string) => Promise<Map<string, RawMnemeEvent[]>>;
+/**
+ * Normalizes both `raw/moltnet/transcript.json` shapes into one internal
+ * message list: the golden fixture's `{seedMessageText, transcript: [...]}`
+ * and a real composed run's export shape `{conversations: [{messages:
+ * [...]}] }` (`moltnet/transcript-export.ts`'s `MoltnetExportedTranscript`).
+ * Every conversation's messages are flattened and re-sorted by
+ * `created_at` so multi-conversation exports still read chronologically;
+ * single-conversation runs (the only shape produced today) are a no-op
+ * re-sort of an already-ordered list.
+ */
+export declare const normalizeRawTranscript: (raw: unknown) => RawTranscript;
+/**
+ * Reads every moltnet transcript in a run-dir and merges them into one
+ * chronologically-sorted message list. A single-network run writes the flat
+ * `raw/moltnet/transcript.json` (the golden/office-sim shape); a multi-network
+ * composed run (the jungian psyche) writes one per network under
+ * `raw/moltnet/<network_id>/transcript.json`. Both are read and unioned so the
+ * timeline's `messagesById` spans every room across every network — the join
+ * an interior-council membrane needs. Message ids are globally-unique UUIDs, so
+ * a flat re-sort of the union is a correct chronological interleave.
+ */
+export declare const readTranscript: (runDir: string) => Promise<RawTranscript>;
+/**
+ * Reads `world/telemetry.json` when present (world-driven runs only —
+ * `office-secret-v0-golden` ships one, `office-sim-golden` does not).
+ * Returns `null` on any missing/malformed file rather than throwing: this
+ * artifact is optional, never a requirement for a run to render
+ * (`runDetect.ts`'s shape check does not require it).
+ */
+export declare const readWorldTelemetry: (runDir: string) => Promise<RunTelemetrySample[] | null>;
+/** `true` when at least one sample carries at least one variable — the gate that decides whether a run has real gauge data to render (`RunViewModel.variableSamples`'s own doc comment: never a fabricated empty gauge). */
+export declare const hasVariableSamples: (samples: readonly RunTelemetrySample[] | null) => boolean;
+/**
+ * Reads `spawnfile/up-receipt.json`'s `engines[]` (per-agent engine
+ * breakdown) when a composed run-dir carries one. Loosely shaped, not
+ * schema-validated — this is an optional, best-effort finer-grained signal
+ * layered on top of the manifest's own single `engine` field, so a
+ * malformed/partial file degrades to `undefined` (the caller falls back to
+ * `manifest.engine`) rather than throwing. No run-dir currently ships this
+ * file, but a composed driver's `spawnfileReceipts.ts` up-receipt schema
+ * already carries `engines` when a real deployment reports mixed per-agent
+ * engines, so this reads it the moment one does.
+ */
+export declare const readUpReceiptEngines: (runDir: string) => Promise<EngineEntry[] | undefined>;
+//# sourceMappingURL=runRawArtifacts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runRawArtifacts.d.ts","sourceRoot":"","sources":["../../src/view/runRawArtifacts.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAwB,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAmBrH,eAAO,MAAM,qBAAqB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,CAYhG,CAAC;AAkBF;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,GAAI,KAAK,OAAO,KAAG,aAWrD,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,aAAa,CAsB1E,CAAC;AASF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,kBAAkB,EAAE,GAAG,IAAI,CAe5F,CAAC;AAEF,4NAA4N;AAC5N,eAAO,MAAM,kBAAkB,GAAI,SAAS,SAAS,kBAAkB,EAAE,GAAG,IAAI,KAAG,OACK,CAAC;AAEzF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,WAAW,EAAE,GAAG,SAAS,CAkB5F,CAAC"}

package/dist/view/runRawArtifacts.js

@@ -0,0 +1,143 @@
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+/**
+ * Shared, dependency-free reads of the raw run-directory artifacts every
+ * run-reader/run-replay data path needs: the moltnet transcript, the
+ * per-bank mneme event logs, and (increment 3) the world telemetry
+ * snapshot. Extracted out of `runViewModel.ts` so `runTimeline.ts`
+ * (`buildRunTimeline`) can read the exact same records without
+ * re-implementing or duplicating file I/O (`AGENTS.md`: small composable
+ * modules, no invented state).
+ */
+const parseJsonlLines = (text) => text
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => JSON.parse(line));
+export const readMnemeEventsByBank = async (runDir) => {
+    const mnemeDir = path.join(runDir, "raw", "mneme");
+    const bankDirs = await readdir(mnemeDir, { withFileTypes: true }).catch(() => []);
+    const byBank = new Map();
+    for (const entry of bankDirs) {
+        if (!entry.isDirectory())
+            continue;
+        const text = await readFile(path.join(mnemeDir, entry.name, "events.jsonl"), "utf8").catch(() => null);
+        if (text === null)
+            continue;
+        byBank.set(entry.name, parseJsonlLines(text));
+    }
+    return byBank;
+};
+const isExportShape = (value) => typeof value === "object" && value !== null && Array.isArray(value.conversations);
+/**
+ * Normalizes both `raw/moltnet/transcript.json` shapes into one internal
+ * message list: the golden fixture's `{seedMessageText, transcript: [...]}`
+ * and a real composed run's export shape `{conversations: [{messages:
+ * [...]}] }` (`moltnet/transcript-export.ts`'s `MoltnetExportedTranscript`).
+ * Every conversation's messages are flattened and re-sorted by
+ * `created_at` so multi-conversation exports still read chronologically;
+ * single-conversation runs (the only shape produced today) are a no-op
+ * re-sort of an already-ordered list.
+ */
+export const normalizeRawTranscript = (raw) => {
+    if (isExportShape(raw)) {
+        const transcript = raw.conversations
+            .flatMap((conversation) => conversation.messages ?? [])
+            .slice()
+            .sort((left, right) => Date.parse(left.created_at) - Date.parse(right.created_at));
+        return { transcript };
+    }
+    const golden = raw;
+    return { seedMessageText: golden.seedMessageText, transcript: golden.transcript ?? [] };
+};
+/**
+ * Reads every moltnet transcript in a run-dir and merges them into one
+ * chronologically-sorted message list. A single-network run writes the flat
+ * `raw/moltnet/transcript.json` (the golden/office-sim shape); a multi-network
+ * composed run (the jungian psyche) writes one per network under
+ * `raw/moltnet/<network_id>/transcript.json`. Both are read and unioned so the
+ * timeline's `messagesById` spans every room across every network — the join
+ * an interior-council membrane needs. Message ids are globally-unique UUIDs, so
+ * a flat re-sort of the union is a correct chronological interleave.
+ */
+export const readTranscript = async (runDir) => {
+    const moltnetDir = path.join(runDir, "raw", "moltnet");
+    const files = [path.join(moltnetDir, "transcript.json")];
+    const entries = await readdir(moltnetDir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (entry.isDirectory())
+            files.push(path.join(moltnetDir, entry.name, "transcript.json"));
+    }
+    let seedMessageText;
+    const merged = [];
+    for (const file of files) {
+        const text = await readFile(file, "utf8").catch(() => null);
+        if (text === null)
+            continue;
+        const normalized = normalizeRawTranscript(JSON.parse(text));
+        if (seedMessageText === undefined && normalized.seedMessageText !== undefined) {
+            seedMessageText = normalized.seedMessageText;
+        }
+        merged.push(...normalized.transcript);
+    }
+    merged.sort((left, right) => Date.parse(left.created_at) - Date.parse(right.created_at));
+    return { seedMessageText, transcript: merged };
+};
+/**
+ * Reads `world/telemetry.json` when present (world-driven runs only —
+ * `office-secret-v0-golden` ships one, `office-sim-golden` does not).
+ * Returns `null` on any missing/malformed file rather than throwing: this
+ * artifact is optional, never a requirement for a run to render
+ * (`runDetect.ts`'s shape check does not require it).
+ */
+export const readWorldTelemetry = async (runDir) => {
+    const raw = await readFile(path.join(runDir, "world", "telemetry.json"), "utf8").catch(() => null);
+    if (raw === null)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.samples))
+            return null;
+        return parsed.samples.map((sample) => ({
+            tick: sample.tick,
+            simTime: sample.sim_time,
+            phase: sample.phase,
+            variables: sample.variables ?? {},
+        }));
+    }
+    catch {
+        return null;
+    }
+};
+/** `true` when at least one sample carries at least one variable — the gate that decides whether a run has real gauge data to render (`RunViewModel.variableSamples`'s own doc comment: never a fabricated empty gauge). */
+export const hasVariableSamples = (samples) => samples !== null && samples.some((sample) => Object.keys(sample.variables).length > 0);
+/**
+ * Reads `spawnfile/up-receipt.json`'s `engines[]` (per-agent engine
+ * breakdown) when a composed run-dir carries one. Loosely shaped, not
+ * schema-validated — this is an optional, best-effort finer-grained signal
+ * layered on top of the manifest's own single `engine` field, so a
+ * malformed/partial file degrades to `undefined` (the caller falls back to
+ * `manifest.engine`) rather than throwing. No run-dir currently ships this
+ * file, but a composed driver's `spawnfileReceipts.ts` up-receipt schema
+ * already carries `engines` when a real deployment reports mixed per-agent
+ * engines, so this reads it the moment one does.
+ */
+export const readUpReceiptEngines = async (runDir) => {
+    const raw = await readFile(path.join(runDir, "spawnfile", "up-receipt.json"), "utf8").catch(() => null);
+    if (raw === null)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.engines))
+            return undefined;
+        const entries = parsed.engines.filter((entry) => typeof entry === "object" &&
+            entry !== null &&
+            typeof entry.engine === "string" &&
+            entry.engine.length > 0 &&
+            (typeof entry.agent === "string" || entry.agent === undefined));
+        return entries.length > 0 ? entries : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};