simfile 0.0.1

package/dist/sims/worldDrivenOfficeSimDriver.js

@@ -0,0 +1,182 @@
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { exportMoltnetTranscript, roomTranscriptTargetFromScope } from "../moltnet/transcript-export.js";
+import { parseSimfileSource } from "../schema/parse.js";
+import { parseClockSpec } from "../runtime/clock.js";
+import { compileRuntime } from "../runtime/trace-compile.js";
+import { clampAndRound } from "../runtime/numeric.js";
+import { composeRunManifest, sha256HexOfBuffer } from "./composeRunManifest.js";
+import { DEFAULT_QUIET_GRACE_MS, resolveTargetTurns } from "./exchangeWait.js";
+import { allMembersConnected, getMoltnetRoom, listMoltnetAgents, moltnetHealthy } from "./moltnetRoomClient.js";
+import { defaultSleep, pollUntilReady } from "./poll.js";
+import { runSpawnfileArtifactsExport, runSpawnfileDown, runSpawnfileUp } from "./spawnfileCli.js";
+import { createWorldLedgerWriter } from "./worldLedgerWriter.js";
+import { assertWorldRuleContentClean, buildSeedDeclarationFromMemoryDoc } from "./worldSeedLint.js";
+import { runLiveTickLoop } from "./worldTickLoop.js";
+const DEFAULT_NETWORK_ID = "office_lab";
+const DEFAULT_ROOM_ID = "office-room";
+const DEFAULT_AGENT_IDS = ["eleanor", "sam"];
+const DEFAULT_SEED_AGENT_ID = "eleanor";
+const DEFAULT_TOKEN_SET = ["Rosa Delgado"];
+const DEFAULT_TIMEOUT_MS = 240_000;
+const DEFAULT_POLL_INTERVAL_MS = 2_000;
+const DEFAULT_MAX_TICKS = 200;
+const collapseEngineDisclosure = (engines) => {
+    const distinct = [...new Set((engines ?? []).map((entry) => entry.engine))].sort();
+    return distinct.length === 0 ? "unknown" : distinct.join("+");
+};
+const waitForMoltnetReady = async (baseUrl, roomId, agentIds, pollOptions) => {
+    await pollUntilReady("moltnet health", pollOptions, async () => ((await moltnetHealthy(baseUrl)) ? true : null));
+    await pollUntilReady(`moltnet room ${roomId} membership`, pollOptions, async () => {
+        const room = await getMoltnetRoom(baseUrl, roomId);
+        const expected = [...agentIds].sort();
+        const actual = [...room.members].sort();
+        return expected.length === actual.length && expected.every((id, index) => actual[index] === id) ? room : null;
+    });
+    await pollUntilReady(`moltnet bridge attachments for ${roomId}`, pollOptions, async () => {
+        const agents = await listMoltnetAgents(baseUrl);
+        return allMembersConnected(agents, roomId, agentIds) ? agents : null;
+    });
+};
+const relativeArtifactPath = (runDir, absolutePath) => path.relative(runDir, absolutePath).split(path.sep).join("/");
+const hashedArtifact = async (runDir, absolutePath) => ({
+    path: relativeArtifactPath(runDir, absolutePath),
+    sha256: sha256HexOfBuffer(await readFile(absolutePath))
+});
+const writeTranscriptArtifact = async (runDir, transcript) => {
+    const absolutePath = path.join(runDir, "raw", "moltnet", "transcript.json");
+    await writeFile(absolutePath, `${JSON.stringify(transcript, null, 2)}\n`, "utf8");
+    return hashedArtifact(runDir, absolutePath);
+};
+export const runWorldDrivenOfficeSim = async (options) => {
+    const cliContext = { spawnfileBin: options.spawnfileBin };
+    const networkId = options.networkId ?? DEFAULT_NETWORK_ID;
+    const roomId = options.roomId ?? DEFAULT_ROOM_ID;
+    const agentIds = options.agentIds ?? DEFAULT_AGENT_IDS;
+    const seedAgentId = options.seedAgentId ?? DEFAULT_SEED_AGENT_ID;
+    const tokenSet = options.tokenSet ?? DEFAULT_TOKEN_SET;
+    const memoryDocPath = options.memoryDocPath ?? path.join(options.orgPath, "agents", seedAgentId, "MEMORY.md");
+    const targetTurns = resolveTargetTurns(options.targetTurns);
+    const quietGraceMs = options.quietGraceMs ?? DEFAULT_QUIET_GRACE_MS;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const pollOptions = {
+        intervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+        sleep: defaultSleep,
+        timeoutMs
+    };
+    const maxTicks = options.maxTicks ?? DEFAULT_MAX_TICKS;
+    const now = options.now ?? (() => new Date());
+    const worldSource = await readFile(options.worldPath, "utf8");
+    const { simfile } = parseSimfileSource(worldSource, { path: options.worldPath });
+    assertWorldRuleContentClean(simfile, tokenSet);
+    const upReceipt = await runSpawnfileUp(cliContext, {
+        orgPath: options.orgPath,
+        containerName: options.containerName,
+        deploymentName: options.deploymentName,
+        compiledOutputDirectory: options.compiledOutputDirectory
+    });
+    if (!upReceipt.run_id) {
+        throw new Error("spawnfile up-receipt had no run_id; cannot assemble a run directory");
+    }
+    const baseUrl = upReceipt.readiness.moltnet_base_url;
+    if (!baseUrl) {
+        throw new Error("spawnfile up-receipt had no moltnet_base_url; is human_ingress enabled on the network?");
+    }
+    const runId = upReceipt.run_id;
+    const runDir = path.join(options.runsRootDirectory, runId);
+    const createdAt = now().toISOString();
+    let loopResult;
+    try {
+        await waitForMoltnetReady(baseUrl, roomId, agentIds, pollOptions);
+        const clock = parseClockSpec(simfile.clock);
+        const runtime = compileRuntime(simfile);
+        const precision = 6;
+        const state = {};
+        for (const [id, value] of Object.entries(runtime.initialState)) {
+            const range = runtime.ranges.get(id);
+            if (!range) {
+                throw new Error(`variable ${id} missing range`);
+            }
+            state[id] = clampAndRound(value, range, precision);
+        }
+        const ledgerWriter = await createWorldLedgerWriter(runDir, runId);
+        loopResult = await runLiveTickLoop({
+            baseUrl,
+            networkId,
+            roomId,
+            roomScope: `room:${networkId}:${roomId}`,
+            agentIds,
+            clock,
+            runtime,
+            simfile,
+            state,
+            precision,
+            runId,
+            seed: simfile.clock.seed,
+            ledgerWriter,
+            pollOptions,
+            targetTurns,
+            quietGraceMs,
+            timeoutMs,
+            maxTicks
+        });
+        const exportResult = await runSpawnfileArtifactsExport(cliContext, {
+            orgPath: options.orgPath,
+            deploymentName: options.deploymentName,
+            compiledOutputDirectory: options.compiledOutputDirectory,
+            destinationDirectory: runDir
+        });
+        const transcript = await exportMoltnetTranscript({
+            baseUrl,
+            targets: [roomTranscriptTargetFromScope(`room:${networkId}:${roomId}`)]
+        });
+        const transcriptArtifact = await writeTranscriptArtifact(runDir, transcript);
+        await runSpawnfileDown(cliContext, {
+            orgPath: options.orgPath,
+            deploymentName: options.deploymentName,
+            compiledOutputDirectory: options.compiledOutputDirectory,
+            removeVolumes: options.removeVolumesOnDown ?? true
+        });
+        const worldLedgerWriter = ledgerWriter;
+        const worldArtifacts = await Promise.all([
+            hashedArtifact(runDir, worldLedgerWriter.causalJsonlPath),
+            hashedArtifact(runDir, worldLedgerWriter.telemetryJsonPath),
+            hashedArtifact(runDir, worldLedgerWriter.ingestedMessagesPath)
+        ]);
+        const seedDeclaration = await buildSeedDeclarationFromMemoryDoc({
+            memoryDocPath,
+            tokenSet,
+            seedAgent: seedAgentId,
+            seedEpoch: createdAt
+        });
+        const world = { network_id: networkId, room_id: roomId, members: [...agentIds].sort() };
+        const manifest = composeRunManifest({
+            runId,
+            createdAt,
+            fingerprint: upReceipt.fingerprint,
+            engine: collapseEngineDisclosure(upReceipt.engines),
+            world,
+            exportedArtifacts: exportResult.index.files,
+            extraArtifacts: [transcriptArtifact, ...worldArtifacts],
+            seedDeclaration
+        });
+        await writeFile(path.join(runDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+    }
+    catch (error) {
+        await runSpawnfileDown(cliContext, {
+            orgPath: options.orgPath,
+            deploymentName: options.deploymentName,
+            compiledOutputDirectory: options.compiledOutputDirectory,
+            removeVolumes: options.removeVolumesOnDown ?? true
+        }).catch(() => undefined);
+        throw error;
+    }
+    return {
+        runDir,
+        runId,
+        endedReason: loopResult.endedReason,
+        ticksRun: loopResult.ticksRun,
+        markerFired: loopResult.markerFired,
+        agentTurnCount: loopResult.agentTurnCount
+    };
+};

package/dist/sims/worldLedgerWriter.d.ts

@@ -0,0 +1,32 @@
+import type { RuntimeTraceEvent, RuntimeVariableSample } from "../runtime/types.js";
+export interface WorldLedgerTickInput {
+    tick: number;
+    tickEvents: readonly RuntimeTraceEvent[];
+    sample: RuntimeVariableSample;
+    /** Every Moltnet room message id folded into this tick — the determinism
+     * contract: without recording exactly which messages a tick ingested,
+     * "the world replays byte-identically" would be unfalsifiable. */
+    ingestedMessageIds: readonly string[];
+}
+export interface WorldLedgerWriter {
+    causalJsonlPath: string;
+    telemetryJsonPath: string;
+    ingestedMessagesPath: string;
+    appendTick: (input: WorldLedgerTickInput) => Promise<void>;
+}
+/**
+ * Live-loop counterpart of `run-record.ts`'s batch artifact writer, scoped
+ * to just the world authority's own stream: appends every tick's minted
+ * events to `raw/world/causal.jsonl` in the `noopolis.causal-event.v1` wire
+ * shape (via `causal-fixture.ts`'s `toCausalFixtureRecord` — the same
+ * mapping B92's conformance harness already validates), grows
+ * `world/telemetry.json` with each tick's variable sample, and appends the
+ * tick's ingested-message-id list to `world/ingested-messages.jsonl`. All
+ * three are real appends (one `appendFile`/rewrite per tick call, not a
+ * single write at the end) so the live loop's own on-disk ledger reflects
+ * ticks as they happen, matching what the composed driver is meant to be
+ * doing here: driving the run, not just producing a side artifact after
+ * the fact.
+ */
+export declare const createWorldLedgerWriter: (runDir: string, runId: string) => Promise<WorldLedgerWriter>;
+//# sourceMappingURL=worldLedgerWriter.d.ts.map

package/dist/sims/worldLedgerWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldLedgerWriter.d.ts","sourceRoot":"","sources":["../../src/sims/worldLedgerWriter.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEpF,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACzC,MAAM,EAAE,qBAAqB,CAAC;IAC9B;;sEAEkE;IAClE,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,iBAAiB;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,UAAU,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5D;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,GAAU,QAAQ,MAAM,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,iBAAiB,CAoCtG,CAAC"}

package/dist/sims/worldLedgerWriter.js

@@ -0,0 +1,39 @@
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { buildCausalFixtureRecords } from "../runtime/causal-fixture.js";
+/**
+ * Live-loop counterpart of `run-record.ts`'s batch artifact writer, scoped
+ * to just the world authority's own stream: appends every tick's minted
+ * events to `raw/world/causal.jsonl` in the `noopolis.causal-event.v1` wire
+ * shape (via `causal-fixture.ts`'s `toCausalFixtureRecord` — the same
+ * mapping B92's conformance harness already validates), grows
+ * `world/telemetry.json` with each tick's variable sample, and appends the
+ * tick's ingested-message-id list to `world/ingested-messages.jsonl`. All
+ * three are real appends (one `appendFile`/rewrite per tick call, not a
+ * single write at the end) so the live loop's own on-disk ledger reflects
+ * ticks as they happen, matching what the composed driver is meant to be
+ * doing here: driving the run, not just producing a side artifact after
+ * the fact.
+ */
+export const createWorldLedgerWriter = async (runDir, runId) => {
+    const worldRawDir = path.join(runDir, "raw", "world");
+    const worldDir = path.join(runDir, "world");
+    await mkdir(worldRawDir, { recursive: true });
+    await mkdir(worldDir, { recursive: true });
+    const causalJsonlPath = path.join(worldRawDir, "causal.jsonl");
+    const telemetryJsonPath = path.join(worldDir, "telemetry.json");
+    const ingestedMessagesPath = path.join(worldDir, "ingested-messages.jsonl");
+    await writeFile(causalJsonlPath, "", "utf8");
+    await writeFile(ingestedMessagesPath, "", "utf8");
+    const samples = [];
+    const appendTick = async (input) => {
+        if (input.tickEvents.length > 0) {
+            const lines = buildCausalFixtureRecords(input.tickEvents).map((record) => JSON.stringify(record));
+            await appendFile(causalJsonlPath, `${lines.join("\n")}\n`, "utf8");
+        }
+        samples.push(input.sample);
+        await writeFile(telemetryJsonPath, `${JSON.stringify({ run_id: runId, samples, version: "simfile.telemetry.v1" }, null, 2)}\n`, "utf8");
+        await appendFile(ingestedMessagesPath, `${JSON.stringify({ tick: input.tick, message_ids: [...input.ingestedMessageIds] })}\n`, "utf8");
+    };
+    return { causalJsonlPath, telemetryJsonPath, ingestedMessagesPath, appendTick };
+};

package/dist/sims/worldSeedLint.d.ts

@@ -0,0 +1,42 @@
+import type { SeedDeclaration } from "../observe/manifest.js";
+import type { Simfile } from "../schema/model.js";
+/**
+ * Every `moltnet:message`/`moltnet:dm` action content string across every
+ * world rule (the kickoff included) — the full surface the token lint below
+ * checks. Kept as its own export so a test can assert the lint actually
+ * looked at every rule, not just the one named `kickoff`.
+ */
+export declare const worldRuleMessageContents: (simfile: Simfile) => {
+    ruleId: string;
+    content: string;
+}[];
+/**
+ * Lints every world rule's message content against the memetics
+ * `token_set` at run start. A hit here means the WORLD ITSELF would speak a
+ * seed token — if that ever happened, any later `marker.seen` on that token
+ * would be meaningless (the world can't measure spread of a fact it just
+ * announced itself). Returns violation strings; an empty array means the
+ * world is clean. Case-insensitive, same as the marker matcher
+ * (`../ledger/markers.ts`'s `containsAlias`).
+ */
+export declare const lintWorldRuleContentAgainstTokenSet: (simfile: Simfile, tokenSet: readonly string[]) => string[];
+/** Throws with every violation listed if the world would leak a seed token. */
+export declare const assertWorldRuleContentClean: (simfile: Simfile, tokenSet: readonly string[]) => void;
+export interface BuildSeedDeclarationOptions {
+    /** Absolute path to the seed agent's doc-seeded memory file. */
+    memoryDocPath: string;
+    tokenSet: readonly string[];
+    seedAgent: string;
+    seedEpoch: string;
+}
+/**
+ * Builds the `seed_declaration` manifest field (Decision-13) from the
+ * agent's own `workspace.docs.memory` file rather than hand-typing the
+ * secret line's hash twice: locates the one line containing every
+ * `token_set` entry, hashes that exact (trimmed) line, and stamps
+ * `matcher_policy: "exact"` / `entry_channel: "doc-seeded"`. Ground truth
+ * for the seed lives in this manifest field, never inferred from the
+ * substrate — see `../observe/manifest.ts`'s `SeedDeclaration` doc comment.
+ */
+export declare const buildSeedDeclarationFromMemoryDoc: (options: BuildSeedDeclarationOptions) => Promise<SeedDeclaration>;
+//# sourceMappingURL=worldSeedLint.d.ts.map

package/dist/sims/worldSeedLint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldSeedLint.d.ts","sourceRoot":"","sources":["../../src/sims/worldSeedLint.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAIlD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,OAAO,KAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAU9F,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,mCAAmC,GAC9C,SAAS,OAAO,EAChB,UAAU,SAAS,MAAM,EAAE,KAC1B,MAAM,EAWR,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,2BAA2B,GAAI,SAAS,OAAO,EAAE,UAAU,SAAS,MAAM,EAAE,KAAG,IAK3F,CAAC;AAEF,MAAM,WAAW,2BAA2B;IAC1C,gEAAgE;IAChE,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,iCAAiC,GAC5C,SAAS,2BAA2B,KACnC,OAAO,CAAC,eAAe,CAkBzB,CAAC"}

package/dist/sims/worldSeedLint.js

@@ -0,0 +1,73 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+const sha256Hex = (value) => createHash("sha256").update(value, "utf8").digest("hex");
+/**
+ * Every `moltnet:message`/`moltnet:dm` action content string across every
+ * world rule (the kickoff included) — the full surface the token lint below
+ * checks. Kept as its own export so a test can assert the lint actually
+ * looked at every rule, not just the one named `kickoff`.
+ */
+export const worldRuleMessageContents = (simfile) => {
+    const contents = [];
+    for (const [ruleId, rule] of Object.entries(simfile.rules)) {
+        for (const action of rule.do) {
+            if (action.action === "moltnet:message" || action.action === "moltnet:dm") {
+                contents.push({ ruleId, content: action.content });
+            }
+        }
+    }
+    return contents;
+};
+/**
+ * Lints every world rule's message content against the memetics
+ * `token_set` at run start. A hit here means the WORLD ITSELF would speak a
+ * seed token — if that ever happened, any later `marker.seen` on that token
+ * would be meaningless (the world can't measure spread of a fact it just
+ * announced itself). Returns violation strings; an empty array means the
+ * world is clean. Case-insensitive, same as the marker matcher
+ * (`../ledger/markers.ts`'s `containsAlias`).
+ */
+export const lintWorldRuleContentAgainstTokenSet = (simfile, tokenSet) => {
+    const violations = [];
+    for (const { ruleId, content } of worldRuleMessageContents(simfile)) {
+        const lowerContent = content.toLowerCase();
+        for (const token of tokenSet) {
+            if (lowerContent.includes(token.toLowerCase())) {
+                violations.push(`rule "${ruleId}" message content contains seed token "${token}": ${content}`);
+            }
+        }
+    }
+    return violations;
+};
+/** Throws with every violation listed if the world would leak a seed token. */
+export const assertWorldRuleContentClean = (simfile, tokenSet) => {
+    const violations = lintWorldRuleContentAgainstTokenSet(simfile, tokenSet);
+    if (violations.length > 0) {
+        throw new Error(`world rule content lint failed — the world would emit a seed token itself:\n${violations.join("\n")}`);
+    }
+};
+/**
+ * Builds the `seed_declaration` manifest field (Decision-13) from the
+ * agent's own `workspace.docs.memory` file rather than hand-typing the
+ * secret line's hash twice: locates the one line containing every
+ * `token_set` entry, hashes that exact (trimmed) line, and stamps
+ * `matcher_policy: "exact"` / `entry_channel: "doc-seeded"`. Ground truth
+ * for the seed lives in this manifest field, never inferred from the
+ * substrate — see `../observe/manifest.ts`'s `SeedDeclaration` doc comment.
+ */
+export const buildSeedDeclarationFromMemoryDoc = async (options) => {
+    const text = await readFile(options.memoryDocPath, "utf8");
+    const lines = text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+    const seedLine = lines.find((line) => options.tokenSet.every((token) => line.includes(token)));
+    if (!seedLine) {
+        throw new Error(`no line in ${options.memoryDocPath} contains every token_set entry (${options.tokenSet.join(", ")})`);
+    }
+    return {
+        content_hash: sha256Hex(seedLine),
+        token_set: [...options.tokenSet],
+        matcher_policy: "exact",
+        seed_agent: options.seedAgent,
+        seed_epoch: options.seedEpoch,
+        entry_channel: "doc-seeded"
+    };
+};

package/dist/sims/worldTickIngest.d.ts

@@ -0,0 +1,27 @@
+import type { LedgerEvent } from "../ledger/markers.js";
+import type { MoltnetRoomMessage } from "./moltnetRoomClient.js";
+/**
+ * Lowers one Moltnet room message to the `LedgerEvent` shape `scanMarkers`
+ * (`../ledger/markers.ts`) expects, so the live world-driven loop can scan
+ * real agent utterances for marker tokens exactly like the batch
+ * `runSimfileTrace` scans its own minted events. `kind` here
+ * ("moltnet.message") is a display-only label for this ingestion path — it
+ * is never merged into `SimfileEventKind`'s own kind space and never minted
+ * as a world-ledger event itself; only the `marker.seen` event a hit
+ * produces gets written to `raw/world/causal.jsonl`.
+ */
+export declare const moltnetMessageToLedgerEvent: (message: MoltnetRoomMessage, roomScope: string, simTime: number) => LedgerEvent;
+export interface IngestNewRoomMessagesResult {
+    newMessages: MoltnetRoomMessage[];
+    ingestedIds: string[];
+}
+/**
+ * Fetches the room's current message list and returns only the messages not
+ * already present in `cursor` (mutated in place: registering an id here is
+ * the ingestion cursor for the whole live loop — a message is folded into
+ * exactly one tick, never re-scanned on a later poll). This is the ONLY read
+ * the live loop performs against Moltnet each tick; delivery of world-minted
+ * events is a separate write path (`../moltnet/world-participant.ts`).
+ */
+export declare const ingestNewRoomMessages: (baseUrl: string, roomId: string, cursor: Set<string>, listMessages: (baseUrl: string, roomId: string, limit: number) => Promise<MoltnetRoomMessage[]>) => Promise<IngestNewRoomMessagesResult>;
+//# sourceMappingURL=worldTickIngest.d.ts.map

package/dist/sims/worldTickIngest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldTickIngest.d.ts","sourceRoot":"","sources":["../../src/sims/worldTickIngest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,GACtC,SAAS,kBAAkB,EAC3B,WAAW,MAAM,EACjB,SAAS,MAAM,KACd,WAQD,CAAC;AAEH,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,kBAAkB,EAAE,CAAC;IAClC,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAChC,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,QAAQ,GAAG,CAAC,MAAM,CAAC,EACnB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,kBAAkB,EAAE,CAAC,KAC9F,OAAO,CAAC,2BAA2B,CAOrC,CAAC"}

package/dist/sims/worldTickIngest.js

@@ -0,0 +1,35 @@
+/**
+ * Lowers one Moltnet room message to the `LedgerEvent` shape `scanMarkers`
+ * (`../ledger/markers.ts`) expects, so the live world-driven loop can scan
+ * real agent utterances for marker tokens exactly like the batch
+ * `runSimfileTrace` scans its own minted events. `kind` here
+ * ("moltnet.message") is a display-only label for this ingestion path — it
+ * is never merged into `SimfileEventKind`'s own kind space and never minted
+ * as a world-ledger event itself; only the `marker.seen` event a hit
+ * produces gets written to `raw/world/causal.jsonl`.
+ */
+export const moltnetMessageToLedgerEvent = (message, roomScope, simTime) => ({
+    event_id: message.id,
+    kind: "moltnet.message",
+    sim_time: simTime,
+    actor: message.from.id,
+    target: roomScope,
+    scope: roomScope,
+    payload: { content: (message.parts ?? []).map((part) => part.text ?? "").join(" ") }
+});
+/**
+ * Fetches the room's current message list and returns only the messages not
+ * already present in `cursor` (mutated in place: registering an id here is
+ * the ingestion cursor for the whole live loop — a message is folded into
+ * exactly one tick, never re-scanned on a later poll). This is the ONLY read
+ * the live loop performs against Moltnet each tick; delivery of world-minted
+ * events is a separate write path (`../moltnet/world-participant.ts`).
+ */
+export const ingestNewRoomMessages = async (baseUrl, roomId, cursor, listMessages) => {
+    const messages = await listMessages(baseUrl, roomId, 200);
+    const newMessages = messages.filter((message) => !cursor.has(message.id));
+    for (const message of newMessages) {
+        cursor.add(message.id);
+    }
+    return { newMessages, ingestedIds: newMessages.map((message) => message.id) };
+};

package/dist/sims/worldTickLoop.d.ts

@@ -0,0 +1,64 @@
+import type { Simfile } from "../schema/model.js";
+import { type ClockRuntime } from "../runtime/clock.js";
+import type { CompiledTraceRuntime } from "../runtime/trace-compile.js";
+import { type ExchangeEndReason } from "./exchangeWait.js";
+import type { WorldLedgerWriter } from "./worldLedgerWriter.js";
+export interface LiveTickLoopContext {
+    baseUrl: string;
+    networkId: string;
+    roomId: string;
+    roomScope: string;
+    agentIds: readonly string[];
+    clock: ClockRuntime;
+    runtime: CompiledTraceRuntime;
+    simfile: Simfile;
+    state: Record<string, number>;
+    precision: number;
+    runId: string;
+    seed: string;
+    ledgerWriter: WorldLedgerWriter;
+    pollOptions: {
+        intervalMs: number;
+        sleep: (ms: number) => Promise<void>;
+        timeoutMs: number;
+    };
+    targetTurns: number;
+    quietGraceMs: number;
+    timeoutMs: number;
+    maxTicks: number;
+}
+export interface LiveTickLoopResult {
+    endedReason: ExchangeEndReason;
+    ticksRun: number;
+    markerFired: boolean;
+    agentTurnCount: number;
+}
+/**
+ * The live loop itself (memetics increment (a)): one iteration per
+ * wall-clock `clock.tick`. Ingest -> step -> scan -> deliver -> append, then
+ * decide stop/continue with the same pure `evaluateExchangeCompletion`
+ * decision the batch composed driver uses for its own exchange wait — never
+ * a coax/resend, per this package's derail-guard rule
+ * (`composedOfficeSimDriver.ts`'s own doc comment; unchanged here).
+ *
+ * - Ingest: `ingestNewRoomMessages` GETs the room and returns only messages
+ *   not yet folded into a tick (the cursor IS the determinism contract).
+ * - Step: `stepSimfileTick` advances the world exactly one tick (clock
+ *   resolve -> world-acts -> generators -> derived -> rules).
+ * - Scan: `scanMarkers` runs LIVE over this tick's own newly ingested
+ *   messages (never the whole transcript, never the world's own minted
+ *   events) so a `marker.seen` hit is always evidence of a REAL agent
+ *   utterance. Its `cause_event_ids` is this tick's own `clock.sync` only —
+ *   the moltnet message id is carried as `source_event_id` in payload, a
+ *   display/measurement join, never a synthesized causal link — so stele
+ *   reconciliation over the world stream stays complete.
+ * - Deliver: any rule-emitted `world.message`/`world.dm`/`wake.recommended`
+ *   from this tick goes out through the existing moltnet world-participant
+ *   bridge, unchanged.
+ * - Append: the tick's events (plus any minted `marker.seen`), its variable
+ *   sample, and the list of ingested message ids all land in
+ *   `raw/world/causal.jsonl` / `world/telemetry.json` /
+ *   `world/ingested-messages.jsonl` via `ledgerWriter`.
+ */
+export declare const runLiveTickLoop: (ctx: LiveTickLoopContext) => Promise<LiveTickLoopResult>;
+//# sourceMappingURL=worldTickLoop.d.ts.map

package/dist/sims/worldTickLoop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldTickLoop.d.ts","sourceRoot":"","sources":["../../src/sims/worldTickLoop.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAKxE,OAAO,EAA8B,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,oBAAoB,CAAC;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,iBAAiB,CAAC;IAChC,WAAW,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7F,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,iBAAiB,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,eAAe,GAAU,KAAK,mBAAmB,KAAG,OAAO,CAAC,kBAAkB,CAiH1F,CAAC"}

package/dist/sims/worldTickLoop.js

@@ -0,0 +1,122 @@
+import { isWorldMessageEvent, sendWorldEventToMoltnet } from "../moltnet/world-participant.js";
+import { scanMarkers } from "../ledger/markers.js";
+import { resolveClockState } from "../runtime/clock.js";
+import { ingestWorldActs } from "../runtime/world-act.js";
+import { createTraceEvent, stepSimfileTick } from "../runtime/step-tick.js";
+import { evaluateExchangeCompletion } from "./exchangeWait.js";
+import { listMoltnetRoomMessages } from "./moltnetRoomClient.js";
+import { ingestNewRoomMessages, moltnetMessageToLedgerEvent } from "./worldTickIngest.js";
+/**
+ * The live loop itself (memetics increment (a)): one iteration per
+ * wall-clock `clock.tick`. Ingest -> step -> scan -> deliver -> append, then
+ * decide stop/continue with the same pure `evaluateExchangeCompletion`
+ * decision the batch composed driver uses for its own exchange wait — never
+ * a coax/resend, per this package's derail-guard rule
+ * (`composedOfficeSimDriver.ts`'s own doc comment; unchanged here).
+ *
+ * - Ingest: `ingestNewRoomMessages` GETs the room and returns only messages
+ *   not yet folded into a tick (the cursor IS the determinism contract).
+ * - Step: `stepSimfileTick` advances the world exactly one tick (clock
+ *   resolve -> world-acts -> generators -> derived -> rules).
+ * - Scan: `scanMarkers` runs LIVE over this tick's own newly ingested
+ *   messages (never the whole transcript, never the world's own minted
+ *   events) so a `marker.seen` hit is always evidence of a REAL agent
+ *   utterance. Its `cause_event_ids` is this tick's own `clock.sync` only —
+ *   the moltnet message id is carried as `source_event_id` in payload, a
+ *   display/measurement join, never a synthesized causal link — so stele
+ *   reconciliation over the world stream stays complete.
+ * - Deliver: any rule-emitted `world.message`/`world.dm`/`wake.recommended`
+ *   from this tick goes out through the existing moltnet world-participant
+ *   bridge, unchanged.
+ * - Append: the tick's events (plus any minted `marker.seen`), its variable
+ *   sample, and the list of ingested message ids all land in
+ *   `raw/world/causal.jsonl` / `world/telemetry.json` /
+ *   `world/ingested-messages.jsonl` via `ledgerWriter`.
+ */
+export const runLiveTickLoop = async (ctx) => {
+    const worldActIngestion = ingestWorldActs([], {
+        ticks: ctx.maxTicks,
+        ranges: ctx.runtime.ranges,
+        variableFedBy: ctx.runtime.variableFedBy
+    });
+    const cursor = new Set();
+    const agentTurns = [];
+    let seq = 1;
+    let markerFired = false;
+    const startedAt = Date.now();
+    let lastAgentMessageAt = startedAt;
+    for (let tick = 0; tick < ctx.maxTicks; tick += 1) {
+        const { simTime } = resolveClockState(ctx.clock, tick);
+        const { newMessages, ingestedIds } = await ingestNewRoomMessages(ctx.baseUrl, ctx.roomId, cursor, listMoltnetRoomMessages);
+        const step = stepSimfileTick(tick, {
+            runId: ctx.runId,
+            seed: ctx.seed,
+            precision: ctx.precision,
+            clock: ctx.clock,
+            runtime: ctx.runtime,
+            state: ctx.state,
+            seq,
+            worldActsForTick: worldActIngestion.queueByTick.get(tick),
+            worldActResultsByActId: worldActIngestion.resultsByActId
+        });
+        seq = step.nextSeq;
+        const clockSyncEventId = step.events[0]?.event_id;
+        if (!clockSyncEventId) {
+            throw new Error(`tick ${tick} produced no clock.sync event`);
+        }
+        const ledgerCandidates = newMessages.map((message) => moltnetMessageToLedgerEvent(message, ctx.roomScope, simTime));
+        const hits = scanMarkers(ledgerCandidates, ctx.simfile.markers);
+        const markerEvents = [];
+        for (const [markerId, markerHits] of Object.entries(hits)) {
+            for (const hit of markerHits) {
+                markerFired = true;
+                markerEvents.push(createTraceEvent(ctx.runId, seq, "marker.seen", simTime, markerId, hit.scope, hit.scope, {
+                    alias: hit.alias,
+                    marker: markerId,
+                    // Display/measurement join to the Moltnet message that carried
+                    // the token — NOT a synthesized causal link. The real
+                    // `cause_event_ids` below is this tick's own `clock.sync` only,
+                    // so stele reconciliation over the world stream stays complete.
+                    source_event_id: hit.eventId,
+                    source_event_kind: hit.eventKind
+                }, [clockSyncEventId]));
+                seq += 1;
+            }
+        }
+        for (const event of step.events) {
+            if (isWorldMessageEvent(event)) {
+                await sendWorldEventToMoltnet(event, { baseUrl: ctx.baseUrl, networkId: ctx.networkId });
+            }
+        }
+        await ctx.ledgerWriter.appendTick({
+            tick,
+            tickEvents: [...step.events, ...markerEvents],
+            sample: step.sample,
+            ingestedMessageIds: ingestedIds
+        });
+        for (const message of newMessages) {
+            if (ctx.agentIds.includes(message.from.id)) {
+                agentTurns.push({ id: message.from.id });
+                lastAgentMessageAt = Date.now();
+            }
+        }
+        const evaluation = evaluateExchangeCompletion({
+            agentTurnCount: agentTurns.length,
+            elapsedSinceLastAgentMessageMs: Date.now() - lastAgentMessageAt,
+            elapsedSinceStartMs: Date.now() - startedAt,
+            quietGraceMs: ctx.quietGraceMs,
+            targetTurns: ctx.targetTurns,
+            timeoutMs: ctx.timeoutMs
+        });
+        if (evaluation.done) {
+            return {
+                endedReason: evaluation.reason,
+                ticksRun: tick + 1,
+                markerFired,
+                agentTurnCount: agentTurns.length
+            };
+        }
+        await ctx.pollOptions.sleep(ctx.pollOptions.intervalMs);
+    }
+    throw new Error(`world tick fuse tripped at ${ctx.maxTicks} ticks without the exchange concluding`);
+};