simfile 0.0.1

package/dist/view/runTimeline.d.ts

@@ -0,0 +1,24 @@
+import type { ElementRef, RunTimeline } from "./runTimelineTypes.js";
+/**
+ * One room the run declares (`manifest.world`): a `room:<network>:<room>`
+ * ref, its network + bare room id, and its member agent ids. Exported so
+ * `server.ts` can tell an OUTER (parent-floor) room from an interior one —
+ * a membrane's `interiorRooms` are also entries of this same list — when it
+ * builds the outer map's `/api/world` trace (`runWorldTrace.ts`'s
+ * `buildRunWorldTrace` `rooms` param).
+ */
+export interface WorldRoom {
+    ref: ElementRef;
+    networkId: string;
+    roomId: string;
+    members: string[];
+}
+/**
+ * Reads and parses `manifest.json`'s `world` field into its declared rooms —
+ * the same parse `buildRunTimeline` does internally, exported so `server.ts`
+ * can tell an outer (parent-floor) room from an interior one when it builds
+ * the outer map's `/api/world` trace, without re-deriving the whole timeline.
+ */
+export declare const readWorldRooms: (runDir: string) => Promise<WorldRoom[]>;
+export declare const buildRunTimeline: (runDir: string) => Promise<RunTimeline>;
+//# sourceMappingURL=runTimeline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runTimeline.d.ts","sourceRoot":"","sources":["../../src/view/runTimeline.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAA0D,MAAM,uBAAuB,CAAC;AAgE7H;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,UAAU,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAkFD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,SAAS,EAAE,CAGxE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,WAAW,CA6D1E,CAAC"}

package/dist/view/runTimeline.js

@@ -0,0 +1,204 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { collectCausalStreams } from "../observe/causalStreams.js";
+import { parseRunManifest } from "../observe/manifest.js";
+import { readMnemeEventsByBank, readTranscript } from "./runRawArtifacts.js";
+import { agentIdFromStreamId, agentRef, bankFromRelativePath, bankRef, roomRef, stringField } from "./runTimelineRefs.js";
+import { readRunMembranes } from "./membranes.js";
+import { buildBankLogRecord, buildCausalRecord, roomForMoltnetMessage } from "./runTimelineRecords.js";
+/**
+ * `buildRunTimeline` merges every causal record in a sealed run directory
+ * into one deterministic, scrubbable `RunTimeline` (see `runTimelineTypes.ts`
+ * for the shape and `docs/VIEW_DESIGN.md` rule 7). This is the only file that
+ * assigns the scrub key `t`; everything downstream (the world-trace adapter,
+ * the web store, the chat/minds/portal views) treats `t` as ground truth.
+ *
+ * The per-authority record-building logic itself lives in
+ * `runTimelineRecords.ts` (split out to keep this file, the orchestrator,
+ * under 400 lines — `AGENTS.md`); this file owns merge order (`sortRecords`),
+ * causal repair, dense `t` assignment, and element enumeration.
+ */
+const sortRecords = (records) => [...records].sort((left, right) => {
+    const timeDiff = Date.parse(left.recordedAt) - Date.parse(right.recordedAt);
+    if (timeDiff !== 0)
+        return timeDiff;
+    if (left.authority !== right.authority)
+        return left.authority.localeCompare(right.authority);
+    if (left.streamId !== right.streamId)
+        return left.streamId.localeCompare(right.streamId);
+    if (left.seq !== right.seq)
+        return left.seq - right.seq;
+    return left.eventId.localeCompare(right.eventId);
+});
+/**
+ * Stable causal-repair pass: an event may not precede any of its own
+ * `causeIds`. Repeatedly finds the first record whose latest-known cause
+ * sits after it and re-splices it immediately after that cause, restarting
+ * the scan after each move (small run sizes at this increment's scale make
+ * the O(n^2) worst case negligible; correctness first).
+ */
+const causalRepair = (records) => {
+    const order = [...records];
+    const maxPasses = order.length + 5;
+    for (let pass = 0; pass < maxPasses; pass += 1) {
+        const indexOf = new Map(order.map((record, index) => [record.eventId, index]));
+        let moved = false;
+        for (let index = 0; index < order.length; index += 1) {
+            const record = order[index];
+            let latestCauseIndex = -1;
+            for (const causeId of record.causeIds) {
+                const causeIndex = indexOf.get(causeId);
+                if (causeIndex !== undefined)
+                    latestCauseIndex = Math.max(latestCauseIndex, causeIndex);
+            }
+            if (latestCauseIndex > index) {
+                order.splice(index, 1);
+                order.splice(latestCauseIndex, 0, record);
+                moved = true;
+                break;
+            }
+        }
+        if (!moved)
+            break;
+    }
+    return order;
+};
+const buildElements = (params) => {
+    const elements = new Map();
+    for (const room of params.rooms) {
+        elements.set(room.ref, { ref: room.ref, kind: "room", label: room.roomId });
+        for (const member of room.members) {
+            const ref = agentRef(member);
+            if (!elements.has(ref))
+                elements.set(ref, { ref, kind: "agent", label: member });
+        }
+    }
+    for (const membrane of params.membranes) {
+        if (!elements.has(membrane.ref))
+            elements.set(membrane.ref, { ref: membrane.ref, kind: "team", label: membrane.label });
+    }
+    for (const stream of params.streams) {
+        if (stream.authority !== "daimon")
+            continue;
+        for (const event of stream.events) {
+            const agentId = agentIdFromStreamId(event.emitter.stream_id);
+            if (!agentId)
+                continue;
+            const ref = agentRef(agentId);
+            if (!elements.has(ref))
+                elements.set(ref, { ref, kind: "agent", label: agentId });
+        }
+    }
+    for (const bankName of params.mnemeByBank.keys()) {
+        const ref = bankRef(bankName);
+        if (!elements.has(ref))
+            elements.set(ref, { ref, kind: "bank", label: bankName });
+    }
+    // Increment 4: a variable element per distinct `variable:<id>` subject
+    // that actually appears somewhere in this run's own world-authority
+    // records (`buildWorldRecord`'s `variable:<id>` subjects, joined from a
+    // `rule.fired`/`world.message`/`world.act` event's own `payload.variables`
+    // or `payload.target`) — derived purely from what this run's own records
+    // name, never from a separate schema/telemetry read.
+    for (const record of params.records) {
+        for (const subject of record.subjects) {
+            if (!subject.startsWith("variable:") || elements.has(subject))
+                continue;
+            elements.set(subject, { ref: subject, kind: "variable", label: subject.slice("variable:".length) });
+        }
+    }
+    return [...elements.values()];
+};
+const stringMembers = (value) => Array.isArray(value) ? value.filter((member) => typeof member === "string") : [];
+/**
+ * Parses `manifest.world` into the run's rooms, supporting both shapes: a
+ * single-network run's flat `{network_id, room_id, members}` (office-sim
+ * golden) and a multi-network composed run's `{rooms: [{network_id, room_id,
+ * members}, ...]}` (the jungian psyche, one entry per network's room).
+ */
+const parseWorldRooms = (worldRecord) => {
+    const toRoom = (record) => {
+        const networkId = stringField(record, "network_id");
+        const roomId = stringField(record, "room_id");
+        if (!networkId || !roomId)
+            return undefined;
+        return { ref: roomRef(networkId, roomId), networkId, roomId, members: stringMembers(record?.members) };
+    };
+    const roomsRaw = worldRecord?.rooms;
+    if (Array.isArray(roomsRaw)) {
+        return roomsRaw
+            .map((entry) => toRoom(typeof entry === "object" && entry !== null ? entry : undefined))
+            .filter((room) => room !== undefined);
+    }
+    const single = toRoom(worldRecord);
+    return single ? [single] : [];
+};
+/**
+ * Reads and parses `manifest.json`'s `world` field into its declared rooms —
+ * the same parse `buildRunTimeline` does internally, exported so `server.ts`
+ * can tell an outer (parent-floor) room from an interior one when it builds
+ * the outer map's `/api/world` trace, without re-deriving the whole timeline.
+ */
+export const readWorldRooms = async (runDir) => {
+    const manifest = parseRunManifest(JSON.parse(await readFile(path.join(runDir, "manifest.json"), "utf8")));
+    return parseWorldRooms(manifest.world);
+};
+export const buildRunTimeline = async (runDir) => {
+    const manifest = parseRunManifest(JSON.parse(await readFile(path.join(runDir, "manifest.json"), "utf8")));
+    const worldRecord = manifest.world;
+    const rooms = parseWorldRooms(worldRecord);
+    const room = rooms[0]?.ref;
+    const [streams, mnemeByBank, transcript, membranes] = await Promise.all([
+        collectCausalStreams(runDir),
+        readMnemeEventsByBank(runDir),
+        readTranscript(runDir),
+        readRunMembranes(runDir),
+    ]);
+    const messagesById = new Map(transcript.transcript.map((message) => [message.id, message]));
+    const roomsByMessageEventId = new Map();
+    for (const stream of streams) {
+        if (stream.authority !== "moltnet")
+            continue;
+        for (const event of stream.events) {
+            const messageRoom = roomForMoltnetMessage(event);
+            if (messageRoom)
+                roomsByMessageEventId.set(event.event_id, messageRoom);
+        }
+    }
+    const memoryContentById = new Map();
+    for (const bankEvents of mnemeByBank.values()) {
+        for (const event of bankEvents)
+            memoryContentById.set(event.id, event.content.text);
+    }
+    const ctx = { room, messagesById, roomsByMessageEventId, memoryContentById };
+    const records = [];
+    for (const stream of streams) {
+        const bank = bankFromRelativePath(stream.relativePath);
+        for (const event of stream.events) {
+            records.push(buildCausalRecord(event, stream.authority, bank, ctx));
+        }
+    }
+    for (const [bankName, bankEvents] of mnemeByBank) {
+        for (const event of bankEvents)
+            records.push(buildBankLogRecord(event, bankName));
+    }
+    const repaired = causalRepair(sortRecords(records));
+    const events = repaired.map((record, index) => ({
+        t: index,
+        eventId: record.eventId,
+        authority: record.authority,
+        streamId: record.streamId,
+        seq: record.seq,
+        type: record.type,
+        viewClass: record.viewClass,
+        recordedAt: record.recordedAt,
+        actor: record.actor,
+        subjects: record.subjects,
+        causes: record.causeIds,
+        text: record.text,
+        worldEventId: record.worldEventId,
+        payload: record.payload,
+    }));
+    const elements = buildElements({ rooms, membranes, streams, mnemeByBank, records });
+    return { version: "simfile.run-timeline.v1", runId: manifest.run_id, events, elements, membranes };
+};

package/dist/view/runTimelineRecords.d.ts

@@ -0,0 +1,42 @@
+import type { CausalEvent } from "@noopolis/stele";
+import type { RawMnemeEvent, RawTranscriptMessage } from "./runViewModelTypes.js";
+import type { ElementRef, TimelineViewClass } from "./runTimelineTypes.js";
+/**
+ * Per-authority (`moltnet`/`daimon`/`mneme`/`world`/mneme-bank-log) raw
+ * record builders, split out of `runTimeline.ts` (`AGENTS.md`: split before
+ * 400 lines) so the orchestrator (`buildRunTimeline`: merge, sort, causal
+ * repair, dense `t` assignment) stays the file that's easy to read
+ * end-to-end. `buildCausalRecord` is the one dispatcher every
+ * `raw/<authority>/causal.jsonl` record goes through; `buildBankLogRecord`
+ * is the parallel path for a mneme bank's `events.jsonl` rows.
+ */
+/** Internal pre-`t` record: everything a `TimelineEvent` needs except its dense scrub index. */
+export interface RawRecord {
+    eventId: string;
+    authority: string;
+    streamId: string;
+    seq: number;
+    type: string;
+    viewClass: TimelineViewClass;
+    recordedAt: string;
+    causeIds: string[];
+    actor?: string;
+    subjects: ElementRef[];
+    text?: string;
+    /** See `TimelineEvent.worldEventId`'s doc comment (`runTimelineTypes.ts`). */
+    worldEventId?: string;
+    payload: unknown;
+}
+export interface JoinContext {
+    room?: ElementRef;
+    messagesById: ReadonlyMap<string, RawTranscriptMessage>;
+    roomsByMessageEventId: ReadonlyMap<string, ElementRef>;
+    memoryContentById: ReadonlyMap<string, string>;
+}
+/** Resolves the room a moltnet `message.accepted` event targeted — `buildRunTimeline` uses this directly (not just `buildMoltnetRecord`) to build `roomsByMessageEventId`, the daimon-attribution join surface. */
+export declare const roomForMoltnetMessage: (event: CausalEvent) => ElementRef | undefined;
+/** The one dispatcher every `raw/<authority>/causal.jsonl` record goes through. */
+export declare const buildCausalRecord: (event: CausalEvent, authority: string, bank: string | undefined, ctx: JoinContext) => RawRecord;
+/** The parallel path for a mneme bank's `events.jsonl` rows (the human-readable memory log, distinct from that bank's `causal.jsonl`). */
+export declare const buildBankLogRecord: (event: RawMnemeEvent, bankName: string) => RawRecord;
+//# sourceMappingURL=runTimelineRecords.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runTimelineRecords.d.ts","sourceRoot":"","sources":["../../src/view/runTimelineRecords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG3E;;;;;;;;GAQG;AAEH,gGAAgG;AAChG,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,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,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8EAA8E;IAC9E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IACxD,qBAAqB,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACvD,iBAAiB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChD;AA8BD,mNAAmN;AACnN,eAAO,MAAM,qBAAqB,GAAI,OAAO,WAAW,KAAG,UAAU,GAAG,SAQvE,CAAC;AAuLF,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,GAC5B,OAAO,WAAW,EAClB,WAAW,MAAM,EACjB,MAAM,MAAM,GAAG,SAAS,EACxB,KAAK,WAAW,KACf,SAkBF,CAAC;AAEF,0IAA0I;AAC1I,eAAO,MAAM,kBAAkB,GAAI,OAAO,aAAa,EAAE,UAAU,MAAM,KAAG,SAgB3E,CAAC"}

package/dist/view/runTimelineRecords.js

@@ -0,0 +1,244 @@
+import { agentIdFromStreamId, agentRef, bankRef, isDefined, messageText, networkIdFromStreamId, roomRef, stringField, variableRef } from "./runTimelineRefs.js";
+const viewClassForCausalType = (type) => {
+    switch (type) {
+        case "message.accepted": return "message";
+        case "control.wake.accepted": return "wake";
+        case "turn.input.submitted": return "turn.input";
+        case "turn.output.completed": return "turn.output";
+        case "memory.recalled": return "memory.recalled";
+        // World-authority additions (increment 3, `buildWorldRecord` below):
+        // `world.message` is a message like any other room chat line;
+        // `wake.recommended` shares the daimon `control.wake.accepted` class
+        // (both mean "a wake was recommended/accepted for an agent").
+        case "clock.sync": return "clock";
+        case "marker.seen": return "marker";
+        case "world.message": return "message";
+        case "wake.recommended": return "wake";
+        default: return "other";
+    }
+};
+const viewClassForBankLogType = (type) => {
+    switch (type) {
+        case "memory.claimed": return "memory.claimed";
+        case "memory.observed": return "memory.observed";
+        case "memory.recalled": return "memory.recalled";
+        default: return "other";
+    }
+};
+/** Resolves the room a moltnet `message.accepted` event targeted — `buildRunTimeline` uses this directly (not just `buildMoltnetRecord`) to build `roomsByMessageEventId`, the daimon-attribution join surface. */
+export const roomForMoltnetMessage = (event) => {
+    if (event.type !== "message.accepted")
+        return undefined;
+    const networkId = networkIdFromStreamId(event.emitter.stream_id);
+    const target = event.payload?.target;
+    if (!networkId || typeof target !== "object" || target === null)
+        return undefined;
+    const targetRecord = target;
+    const roomId = stringField(targetRecord, "room_id");
+    return targetRecord.kind === "room" && roomId ? roomRef(networkId, roomId) : undefined;
+};
+/**
+ * The `simfile_event_id` breadcrumb `src/moltnet/world-participant.ts`'s
+ * `metadataFromEvent` attaches to a message's first text part's `data` when
+ * that message originated from a world action — the real join surface for
+ * "this moltnet message echoes that world-authority event" (increment 3
+ * dedup rule). Undefined for a genuine agent-authored message, which has no
+ * such breadcrumb.
+ */
+const worldEventIdFromMessage = (message) => {
+    const breadcrumb = message.parts.find((part) => part.kind === "text")?.data?.simfile_event_id;
+    return typeof breadcrumb === "string" ? breadcrumb : undefined;
+};
+const buildMoltnetRecord = (event, base, ctx) => {
+    // A message.accepted names its OWN room from its network stream_id +
+    // target.room_id (`roomForMoltnetMessage`), never the run's single primary
+    // room — the fix that keeps an inner-council message under
+    // `room:<inner_net>:<room>` in a multi-network run instead of collapsing
+    // every network's messages onto the floor room. Falls back to `ctx.room`
+    // only when the event carries no resolvable target (never, for a
+    // message.accepted).
+    const messageRoom = roomForMoltnetMessage(event) ?? ctx.room;
+    if (event.type !== "message.accepted") {
+        return { ...base, subjects: [ctx.room].filter(isDefined) };
+    }
+    const messageId = stringField(event.payload, "message_id");
+    const message = messageId ? ctx.messagesById.get(messageId) : undefined;
+    const authorId = message?.from.id;
+    return {
+        ...base,
+        actor: authorId,
+        subjects: [messageRoom, authorId ? agentRef(authorId) : undefined].filter(isDefined),
+        text: message ? messageText(message) : undefined,
+        worldEventId: message ? worldEventIdFromMessage(message) : undefined,
+    };
+};
+const buildDaimonRecord = (event, base, ctx) => {
+    const agentId = agentIdFromStreamId(event.emitter.stream_id);
+    const turnId = stringField(event.payload, "turn_id");
+    const causingMessageEventIds = [
+        turnId?.startsWith("moltnet:") ? turnId : undefined,
+        ...event.cause_event_ids,
+    ].filter(isDefined);
+    const causingRoom = causingMessageEventIds
+        .map((eventId) => ctx.roomsByMessageEventId.get(eventId))
+        .find(isDefined);
+    const subjects = [agentId ? agentRef(agentId) : undefined, causingRoom].filter(isDefined);
+    let text;
+    if (event.type === "turn.input.submitted") {
+        const causingMessageId = turnId?.startsWith("moltnet:") ? turnId.slice("moltnet:".length) : undefined;
+        const causingMessage = causingMessageId ? ctx.messagesById.get(causingMessageId) : undefined;
+        text = causingMessage ? messageText(causingMessage) : undefined;
+    }
+    return { ...base, actor: agentId, subjects, text };
+};
+const buildMnemeCausalRecord = (event, bank, base, ctx) => {
+    const agentId = event.principal_id.startsWith("agent:") ? event.principal_id.slice("agent:".length) : undefined;
+    const subjects = [bank ? bankRef(bank) : undefined, agentId ? agentRef(agentId) : undefined].filter(isDefined);
+    let text;
+    if (event.type === "memory.recalled") {
+        const memoryId = stringField(event.payload, "memory_id");
+        text = memoryId ? ctx.memoryContentById.get(memoryId) : undefined;
+    }
+    return { ...base, actor: agentId, subjects, text };
+};
+const roomTargetPattern = /^room:[^:]+:[^:]+$/u;
+const agentTargetPattern = /^agent:[^:]+$/u;
+/**
+ * The world clock's own anchor — increment 3's `clock.sync` subject. A
+ * `clock.sync` event names the tick axis itself, not any one room or agent,
+ * so it gets a dedicated ref rather than an empty `subjects` array (which
+ * would make it invisible to any future "world clock" storyline portal).
+ */
+const globalClockRef = "clock:global";
+/**
+ * The world stream's own `payload.target` is already an `ElementRef`-shaped
+ * string (`room:<network>:<room>` or `agent:<id>`, per
+ * `src/runtime/rule-actions.ts`'s `action.to` — a Simfile rule's `to:`
+ * field, e.g. `room:office_lab:office-room` or `agent:eleanor`) for every
+ * world event kind this run emits. Returned verbatim when it matches one of
+ * those two shapes; `undefined` otherwise (e.g. `clock.sync`'s `"global"`,
+ * which has no per-room/per-agent subject of its own).
+ */
+const worldTargetRef = (payload) => {
+    const target = stringField(payload, "target");
+    if (!target)
+        return undefined;
+    return roomTargetPattern.test(target) || agentTargetPattern.test(target) ? target : undefined;
+};
+/**
+ * Increment 4's variable storyline join: the `variables: string[]` payload
+ * field `src/runtime/step-tick.ts`'s `runRule` (and `rule-actions.ts`'s
+ * `emitRuleActionEvents`) stamps onto a `rule.fired` event and every
+ * world-effect event it emits, whenever that rule's own `when:` condition
+ * references at least one variable (`conditionVariableIds`). Read straight
+ * off the event's own payload — never invented — and turned into
+ * `variable:<id>` subjects so the variable's storyline
+ * (`eventsForElement(timeline, "variable:<id>")`) includes the rule firing
+ * and the message/dm/wake it caused. Absent on a `clock.sync` (every tick,
+ * not this rule's own event) and on any rule with no variable condition.
+ */
+const variableRefsFromPayload = (payload) => {
+    const raw = payload?.variables;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((id) => typeof id === "string").map(variableRef);
+};
+/**
+ * World-authority records (`raw/world/causal.jsonl`, increment 3): the
+ * mechanical clock/marker/message/wake stream a world-driven run emits
+ * alongside the agents' own moltnet/daimon/mneme streams.
+ * - `clock.sync` anchors the tick axis itself (`globalClockRef`), never a
+ *   room — it is the run's own heartbeat, not a room event.
+ * - `marker.seen` is attributed to the room plus the real agent who
+ *   authored the moltnet message that tripped it, joined by
+ *   `source_event_id` (a bare transcript message `id`, never `moltnet:`-
+ *   prefixed — confirmed against this run's own fixture) against
+ *   `ctx.messagesById`, never invented from the marker's own `alias`.
+ * - `world.message`/`world.dm` are attributed to the room/agent the action
+ *   targeted, with `text` joined from the event's own `content` field (the
+ *   same text moltnet re-delivers as the echo message this dedups against).
+ * - `world.act` is attributed directly to the fed variable it wrote
+ *   (`payload.target` IS the variable id for this event type, unlike every
+ *   other world event kind where `target` is a room/agent ref).
+ * - `wake.recommended` and any other world event type (`rule.fired`, ...)
+ *   fall back to the event's own `target` ref, or the run's single room
+ *   when `target` doesn't resolve to one.
+ * - Every branch additionally folds in `variable:<id>` subjects from the
+ *   event's own `payload.variables` (`variableRefsFromPayload`) when
+ *   present — increment 4's variable storyline join.
+ */
+const buildWorldRecord = (event, base, ctx) => {
+    const payload = event.payload;
+    const targetRef = worldTargetRef(payload);
+    const variableSubjects = variableRefsFromPayload(payload);
+    const withVariableSubjects = (record) => variableSubjects.length === 0 ? record : { ...record, subjects: [...new Set([...record.subjects, ...variableSubjects])] };
+    if (event.type === "clock.sync") {
+        return withVariableSubjects({ ...base, subjects: [globalClockRef] });
+    }
+    if (event.type === "marker.seen") {
+        const sourceEventId = stringField(payload, "source_event_id");
+        const sourceMessage = sourceEventId ? ctx.messagesById.get(sourceEventId) : undefined;
+        const authorId = sourceMessage?.from.id;
+        return withVariableSubjects({
+            ...base,
+            actor: authorId,
+            subjects: [ctx.room ?? targetRef, authorId ? agentRef(authorId) : undefined].filter(isDefined),
+        });
+    }
+    if (event.type === "world.message" || event.type === "world.dm") {
+        return withVariableSubjects({
+            ...base,
+            subjects: [ctx.room ?? targetRef].filter(isDefined),
+            text: stringField(payload, "content"),
+        });
+    }
+    if (event.type === "world.act") {
+        const fedVariableId = stringField(payload, "target");
+        return withVariableSubjects({
+            ...base,
+            subjects: [fedVariableId ? variableRef(fedVariableId) : (targetRef ?? ctx.room)].filter(isDefined),
+        });
+    }
+    return withVariableSubjects({ ...base, subjects: [targetRef ?? ctx.room].filter(isDefined) });
+};
+/** The one dispatcher every `raw/<authority>/causal.jsonl` record goes through. */
+export const buildCausalRecord = (event, authority, bank, ctx) => {
+    const base = {
+        eventId: event.event_id,
+        authority,
+        streamId: event.emitter.stream_id,
+        seq: event.emitter.seq,
+        type: event.type,
+        viewClass: viewClassForCausalType(event.type),
+        recordedAt: event.recorded_at,
+        causeIds: event.cause_event_ids,
+        payload: event.payload,
+    };
+    if (authority === "moltnet")
+        return buildMoltnetRecord(event, base, ctx);
+    if (authority === "daimon")
+        return buildDaimonRecord(event, base, ctx);
+    if (authority === "mneme")
+        return buildMnemeCausalRecord(event, bank, base, ctx);
+    if (authority === "world")
+        return buildWorldRecord(event, base, ctx);
+    return { ...base, subjects: [] };
+};
+/** The parallel path for a mneme bank's `events.jsonl` rows (the human-readable memory log, distinct from that bank's `causal.jsonl`). */
+export const buildBankLogRecord = (event, bankName) => {
+    const agentId = event.principal.agentId;
+    return {
+        eventId: event.id,
+        authority: "mneme",
+        streamId: bankRef(bankName),
+        seq: event.seq ?? 0,
+        type: event.type,
+        viewClass: viewClassForBankLogType(event.type),
+        recordedAt: event.createdAt,
+        causeIds: event.parentEventIds ?? [],
+        actor: agentId,
+        subjects: [bankRef(bankName), agentRef(agentId)],
+        text: event.content.text,
+        payload: event.content,
+    };
+};

package/dist/view/runTimelineRefs.d.ts

@@ -0,0 +1,27 @@
+import type { RawTranscriptMessage } from "./runViewModelTypes.js";
+import type { ElementRef } from "./runTimelineTypes.js";
+/**
+ * The small, generic `ElementRef`/string helpers `runTimeline.ts` (the
+ * orchestrator) and `runTimelineRecords.ts` (the per-authority record
+ * builders) both need — split out so neither file has to import the other
+ * just for a one-line ref constructor (`AGENTS.md`: small composable
+ * modules, split before 400 lines).
+ */
+export declare const agentRef: (id: string) => ElementRef;
+export declare const roomRef: (network: string, room: string) => ElementRef;
+export declare const bankRef: (bank: string) => ElementRef;
+export declare const variableRef: (id: string) => ElementRef;
+/** Inverse of `roomRef`: splits a `room:<network>:<room>` ref back into its parts. `undefined` for anything else. */
+export declare const parseRoomRef: (ref: ElementRef) => {
+    networkId: string;
+    roomId: string;
+} | undefined;
+/** Strips a ref's `<kind>:` prefix, e.g. `agent:luna-shadow` -> `luna-shadow`. Refs with no `:` pass through unchanged. */
+export declare const stripRefPrefix: (ref: ElementRef) => string;
+export declare const isDefined: <T>(value: T | undefined) => value is T;
+export declare const stringField: (record: Record<string, unknown> | undefined, key: string) => string | undefined;
+export declare const messageText: (message: RawTranscriptMessage) => string;
+export declare const agentIdFromStreamId: (streamId: string) => string | undefined;
+export declare const networkIdFromStreamId: (streamId: string) => string | undefined;
+export declare const bankFromRelativePath: (relativePath: string) => string | undefined;
+//# sourceMappingURL=runTimelineRefs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runTimelineRefs.d.ts","sourceRoot":"","sources":["../../src/view/runTimelineRefs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;;;;GAMG;AAEH,eAAO,MAAM,QAAQ,GAAI,IAAI,MAAM,KAAG,UAA2B,CAAC;AAClE,eAAO,MAAM,OAAO,GAAI,SAAS,MAAM,EAAE,MAAM,MAAM,KAAG,UAAuC,CAAC;AAChG,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,KAAG,UAA4B,CAAC;AACpE,eAAO,MAAM,WAAW,GAAI,IAAI,MAAM,KAAG,UAA8B,CAAC;AAExE,qHAAqH;AACrH,eAAO,MAAM,YAAY,GAAI,KAAK,UAAU,KAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAGtF,CAAC;AAEF,2HAA2H;AAC3H,eAAO,MAAM,cAAc,GAAI,KAAK,UAAU,KAAG,MAAqE,CAAC;AAEvH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAG,OAAO,CAAC,GAAG,SAAS,KAAG,KAAK,IAAI,CAAwB,CAAC;AAEvF,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAAE,KAAK,MAAM,KAAG,MAAM,GAAG,SAG/F,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,SAAS,oBAAoB,KAAG,MACI,CAAC;AAEjE,eAAO,MAAM,mBAAmB,GAAI,UAAU,MAAM,KAAG,MAAM,GAAG,SAAiD,CAAC;AAElH,eAAO,MAAM,qBAAqB,GAAI,UAAU,MAAM,KAAG,MAAM,GAAG,SAAmD,CAAC;AAEtH,eAAO,MAAM,oBAAoB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SAGpE,CAAC"}

package/dist/view/runTimelineRefs.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+/**
+ * The small, generic `ElementRef`/string helpers `runTimeline.ts` (the
+ * orchestrator) and `runTimelineRecords.ts` (the per-authority record
+ * builders) both need — split out so neither file has to import the other
+ * just for a one-line ref constructor (`AGENTS.md`: small composable
+ * modules, split before 400 lines).
+ */
+export const agentRef = (id) => `agent:${id}`;
+export const roomRef = (network, room) => `room:${network}:${room}`;
+export const bankRef = (bank) => `bank:${bank}`;
+export const variableRef = (id) => `variable:${id}`;
+/** Inverse of `roomRef`: splits a `room:<network>:<room>` ref back into its parts. `undefined` for anything else. */
+export const parseRoomRef = (ref) => {
+    const match = ref.match(/^room:([^:]+):(.+)$/u);
+    return match ? { networkId: match[1], roomId: match[2] } : undefined;
+};
+/** Strips a ref's `<kind>:` prefix, e.g. `agent:luna-shadow` -> `luna-shadow`. Refs with no `:` pass through unchanged. */
+export const stripRefPrefix = (ref) => (ref.includes(":") ? ref.slice(ref.indexOf(":") + 1) : ref);
+export const isDefined = (value) => value !== undefined;
+export const stringField = (record, key) => {
+    const value = record?.[key];
+    return typeof value === "string" ? value : undefined;
+};
+export const messageText = (message) => message.parts.find((part) => part.kind === "text")?.text ?? "";
+export const agentIdFromStreamId = (streamId) => streamId.match(/^agent:(.+)$/u)?.[1];
+export const networkIdFromStreamId = (streamId) => streamId.match(/^network:(.+)$/u)?.[1];
+export const bankFromRelativePath = (relativePath) => {
+    const segments = relativePath.split(path.sep);
+    return segments[0] === "raw" && segments[1] === "mneme" ? segments[2] : undefined;
+};