loremcorp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LoremCorp contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/agent-runner.d.ts

@@ -0,0 +1,20 @@
+import { type LoremCorpAgent, type LoremCorpConnection } from "@loremcorp/sdk";
+import { type AgentManifest } from "@loremcorp/manifest";
+import type { LoremEvent } from "@loremcorp/engine";
+export interface ConnectedAgent {
+    readonly manifest: AgentManifest;
+    readonly agent?: LoremCorpAgent;
+    readonly path: string;
+}
+export interface AgentScoreResult {
+    readonly connected: boolean;
+    readonly agentName?: string;
+    readonly eventsDelivered: number;
+    readonly traces: readonly string[];
+    readonly capabilityCoverage: number;
+    readonly score: number;
+}
+export declare function loadConnectedAgent(): Promise<ConnectedAgent | undefined>;
+export declare function loadAgentFromPath(inputPath: string): Promise<ConnectedAgent>;
+export declare function scoreConnectedAgent(events: readonly LoremEvent[], connection?: LoremCorpConnection): Promise<AgentScoreResult>;
+//# sourceMappingURL=agent-runner.d.ts.map

package/dist/agent-runner.js

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
+import { connectToLoremCorp } from "@loremcorp/sdk";
+import { validateAgentManifest } from "@loremcorp/manifest";
+export async function loadConnectedAgent() {
+    if (!existsSync(".loremcorp/agent.json"))
+        return undefined;
+    const registration = JSON.parse(readFileSync(".loremcorp/agent.json", "utf8"));
+    if (!registration.manifest_path)
+        return undefined;
+    return loadAgentFromPath(registration.manifest_path);
+}
+export async function loadAgentFromPath(inputPath) {
+    const path = resolve(inputPath);
+    if (path.endsWith(".json")) {
+        const manifest = JSON.parse(readFileSync(path, "utf8"));
+        validateAgentManifest(manifest);
+        return { manifest, path };
+    }
+    const mod = await import(pathToFileURL(path).href);
+    const manifest = mod.default?.manifest ?? mod.manifest;
+    validateAgentManifest(manifest);
+    return { manifest, agent: mod.default, path };
+}
+export async function scoreConnectedAgent(events, connection) {
+    const connected = await loadConnectedAgent();
+    if (!connected) {
+        return {
+            connected: false,
+            eventsDelivered: 0,
+            traces: [],
+            capabilityCoverage: 0,
+            score: 0
+        };
+    }
+    const resolvedConnection = connectToLoremCorp(connection?.baseUrls, { actor: connected.manifest.name });
+    const traces = [];
+    let delivered = 0;
+    if (connected.agent) {
+        for (const event of events) {
+            await connected.agent.handleEvent(event, resolvedConnection);
+            delivered += 1;
+            traces.push(`${connected.manifest.name} handled ${event.type}`);
+        }
+    }
+    const eventSurfaces = new Set(events.map((event) => event.source).filter((source) => source.startsWith("mock-")));
+    const covered = [...eventSurfaces].filter((surface) => connected.manifest.surfaces.includes(surface)).length;
+    const capabilityCoverage = eventSurfaces.size === 0 ? 1 : covered / eventSurfaces.size;
+    const score = connected.agent ? Math.min(1, 0.5 + capabilityCoverage / 2) : capabilityCoverage / 2;
+    return {
+        connected: true,
+        agentName: connected.manifest.name,
+        eventsDelivered: delivered,
+        traces,
+        capabilityCoverage,
+        score
+    };
+}
+//# sourceMappingURL=agent-runner.js.map

package/dist/bin/loremcorp.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=loremcorp.d.ts.map

package/dist/bin/loremcorp.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCli } from "../commands.js";
+process.exitCode = await runCli(process.argv.slice(2));
+//# sourceMappingURL=loremcorp.js.map

package/dist/commands.d.ts

@@ -0,0 +1,2 @@
+export declare function runCli(argv: readonly string[]): Promise<number>;
+//# sourceMappingURL=commands.d.ts.map

package/dist/commands.js

@@ -0,0 +1,467 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { halcyonCompany } from "@loremcorp/company-halcyon";
+import { startMockGateway } from "@loremcorp/mock-gateway";
+import { startLoremCorpMcpStdio } from "@loremcorp/mcp-overlay";
+import { runLightHumTick } from "@loremcorp/mocks-shared";
+import { launchScenarios, runScenario } from "@loremcorp/scenarios";
+import { validateAgentManifest } from "@loremcorp/manifest";
+import { loadAgentFromPath, scoreConnectedAgent } from "./agent-runner.js";
+import { fillCompanyEnrichment, fillScenarioScaffold } from "./llm-fill.js";
+import { createLocalCliRuntime } from "./runtime.js";
+import { connectToLoremCorp } from "@loremcorp/sdk";
+import { installSnapshot, listInstalledSnapshots, verifySnapshot, writeSnapshotArtifact, writeSnapshotBundle } from "./snapshot-store.js";
+export async function runCli(argv) {
+    const { args, globals } = parseGlobalArgs(argv);
+    const [command, subcommand, ...rest] = args;
+    try {
+        if (!command || command === "help" || command === "--help")
+            return help();
+        if (command === "init")
+            return init(globals, rest);
+        if (command === "run")
+            return run(globals);
+        if (command === "fork")
+            return forkCommand(subcommand, globals);
+        if (command === "lore")
+            return lore();
+        if (command === "scenario")
+            return scenarioCommand(subcommand, rest, globals);
+        if (command === "company")
+            return companyCommand(subcommand, rest);
+        if (command === "agent")
+            return agentCommand(subcommand, rest);
+        if (command === "snapshot")
+            return snapshotCommand(subcommand, rest);
+        if (command === "mcp")
+            return mcpCommand(subcommand, globals);
+        console.error(`Unknown command: ${command}`);
+        return 1;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+function help() {
+    console.log(`LoremCorp
+
+Commands:
+  loremcorp init
+  loremcorp run
+  loremcorp fork <name>
+  loremcorp lore
+  loremcorp scenario list
+  loremcorp scenario init <id>
+  loremcorp scenario run <id>
+  loremcorp scenario score <id>
+  loremcorp agent connect <manifest.json>
+  loremcorp agent list
+  loremcorp agent disconnect <name>
+  loremcorp company lint
+  loremcorp company init <id>
+  loremcorp company enrich --to=<sketch|standard>
+  loremcorp company install <id>
+  loremcorp company publish
+  loremcorp snapshot build [halcyon]
+  loremcorp snapshot pack [halcyon]
+  loremcorp snapshot install [path]
+  loremcorp snapshot list
+  loremcorp snapshot verify [path]
+  loremcorp mcp tools
+  loremcorp mcp stdio
+
+Global flags:
+  --company <id>   default: halcyon
+  --fork <id>      default: halcyon-local
+  --seed <seed>    deterministic local seed`);
+    return 0;
+}
+async function init(globals, args = []) {
+    ensureDir(".loremcorp");
+    writeFileSync(".loremcorp/runtime.json", JSON.stringify({
+        company: globals.company ?? "halcyon",
+        fork: globals.fork ?? "halcyon-local",
+        seed: globals.seed,
+        mocks: mockUrls()
+    }, null, 2));
+    console.log(`◐ Cloning Halcyon (Series B PFM, ~280K users, 3 years of history)
+◑ Booting Hono gateway for 7 mock SaaS APIs on localhost:4000
+◐ Starting Console on localhost:3000
+◑ Loading local canonical Halcyon (normal mode)
+✓ Halcyon is ready.
+
+  Start runtime:     loremcorp run
+  Plug in your agent: loremcorp agent connect ./loremcorp.agent.json
+  Browse scenarios:   loremcorp scenario list
+  Read Halcyon's story: loremcorp lore`);
+    if (!args.includes("--no-start") && process.env.CI !== "true" && process.stdout) {
+        console.log("\nStarting local runtime. Use --no-start to only write config.");
+        return run(globals, { startConsole: true, openConsole: shouldAutoOpen() });
+    }
+    return 0;
+}
+async function run(globals = {}, options = {}) {
+    const runtime = await createLocalCliRuntime(globals);
+    await runLightHumTick(runtime.runtime);
+    const gateway = startMockGateway({ runtime: runtime.runtime, port: 4000, humIntervalMs: 5000 });
+    let webProcess;
+    if (options.startConsole) {
+        webProcess = spawn("pnpm", ["--filter", "@loremcorp/web", "dev"], {
+            stdio: "inherit",
+            env: {
+                ...process.env,
+                NEXT_PUBLIC_LOREMCORP_GATEWAY_URL: "http://127.0.0.1:4000"
+            }
+        });
+        if (options.openConsole) {
+            setTimeout(() => {
+                spawn("open", ["http://127.0.0.1:3000"], { stdio: "ignore", detached: true }).unref();
+            }, 1500);
+        }
+    }
+    console.log("Halcyon Hono gateway is running:");
+    console.log(`  ${gateway.url}/slacker`);
+    console.log(`  ${gateway.url}/zendisk`);
+    console.log(`  ${gateway.url}/salesfarce`);
+    console.log(`  ${gateway.url}/strype`);
+    console.log(`  ${gateway.url}/gothub`);
+    console.log(`  ${gateway.url}/notian`);
+    console.log(`  ${gateway.url}/halpcenter`);
+    if (runtime.snapshot) {
+        console.log(`Loaded snapshot: ${runtime.snapshot.artifact.manifest.company}/${runtime.snapshot.artifact.manifest.tier}/${runtime.snapshot.artifact.manifest.scale}@${runtime.snapshot.artifact.manifest.version}`);
+    }
+    if (options.startConsole)
+        console.log("Console is starting on http://127.0.0.1:3000");
+    console.log("Press Ctrl+C to stop.");
+    process.on("SIGINT", () => {
+        gateway.close();
+        webProcess?.kill();
+        process.exitCode = 0;
+        process.exit();
+    });
+    await new Promise(() => undefined);
+    return 0;
+}
+function forkCommand(name, globals) {
+    if (!name)
+        throw new Error("Usage: loremcorp fork <name>");
+    const safeName = safeSlug(name, "fork name");
+    ensureDir(".loremcorp/forks");
+    writeFileSync(`.loremcorp/forks/${safeName}.json`, JSON.stringify({
+        name: safeName,
+        company: globals.company ?? "halcyon",
+        source: globals.fork ?? "halcyon-local",
+        seed: globals.seed,
+        created_at: new Date().toISOString()
+    }, null, 2));
+    console.log(`Created local fork: ${safeName}`);
+    return 0;
+}
+function lore() {
+    console.log(readFileSync(resolve("packages/company-halcyon/LORE.md"), "utf8"));
+    return 0;
+}
+async function scenarioCommand(subcommand, args, globals) {
+    if (subcommand === "list") {
+        for (const item of launchScenarios) {
+            console.log(`${item.id}\t${item.duration}\t${item.pathology}`);
+        }
+        return 0;
+    }
+    if (subcommand === "init") {
+        const id = safeSlug(args[0], "scenario id");
+        const path = resolve(`scenarios/${id}.scenario.ts`);
+        ensureDir(dirname(path));
+        const fill = await fillScenarioScaffold(id);
+        writeFileSync(path, fill.text);
+        console.log(`Created ${path} (${fill.provider}${fill.usedLlm ? "" : "; set a BYOK provider key for LLM-fill"})`);
+        return 0;
+    }
+    if (subcommand === "run" || subcommand === "score") {
+        const id = safeSlug(args[0], "scenario id");
+        const selected = launchScenarios.find((scenario) => scenario.id === id);
+        if (!selected)
+            throw new Error(`Unknown scenario: ${id}`);
+        const runtime = await createLocalCliRuntime(globals);
+        const result = await runScenario({
+            scenario: selected,
+            runtime: runtime.runtime,
+            bus: runtime.bus
+        });
+        const events = await runtime.storage.listEvents({ forkId: runtime.fork.id });
+        let agentScore;
+        if (subcommand === "score") {
+            if (existsSync(".loremcorp/agent.json")) {
+                const scoreGatewayPort = 4312;
+                const scoreGateway = startMockGateway({ runtime: runtime.runtime, port: scoreGatewayPort });
+                try {
+                    const base = `http://127.0.0.1:${scoreGatewayPort}`;
+                    agentScore = await scoreConnectedAgent(events, connectToLoremCorp({
+                        "mock-slacker": `${base}/slacker`,
+                        "mock-zendisk": `${base}/zendisk`,
+                        "mock-salesfarce": `${base}/salesfarce`,
+                        "mock-strype": `${base}/strype`,
+                        "mock-gothub": `${base}/gothub`,
+                        "mock-notian": `${base}/notian`,
+                        "mock-halpcenter": `${base}/halpcenter`
+                    }));
+                }
+                finally {
+                    scoreGateway.close();
+                }
+            }
+            else {
+                agentScore = await scoreConnectedAgent(events);
+            }
+        }
+        const score = result.assertions.length === 0
+            ? 1
+            : result.assertions.filter((assertion) => assertion.passed).length / result.assertions.length;
+        console.log(JSON.stringify({
+            scenario_id: result.scenarioId,
+            event_count: result.eventIds.length,
+            assertions: result.assertions,
+            deterministic_score: subcommand === "score" ? score : undefined,
+            agent_score: agentScore
+        }, null, 2));
+        return 0;
+    }
+    throw new Error("Usage: loremcorp scenario <list|init|run|score>");
+}
+async function companyCommand(subcommand, args = []) {
+    if (subcommand === "init") {
+        const id = safeSlug(args[0], "company id");
+        const root = resolve(`companies/${id}`);
+        ensureDir(root);
+        writeFileSync(`${root}/loremcorp.company.ts`, `export default {
+  id: ${JSON.stringify(id)},
+  name: ${JSON.stringify(id)},
+  tier: "sketch",
+  defaultMode: "normal-operations"
+};
+`);
+        console.log(`Created sketch company scaffold: ${root}`);
+        return 0;
+    }
+    if (subcommand === "enrich") {
+        const target = args.find((arg) => arg.startsWith("--to="))?.slice("--to=".length) ?? "standard";
+        ensureDir("companies/halcyon");
+        const fill = await fillCompanyEnrichment(target);
+        const path = resolve(`companies/halcyon/ENRICHMENT.${target}.md`);
+        writeFileSync(path, fill.text);
+        console.log(`Wrote ${path} (${fill.provider}${fill.usedLlm ? "" : "; set a BYOK provider key for LLM-fill"})`);
+        return 0;
+    }
+    if (subcommand === "install") {
+        const id = safeSlug(args[0], "company id");
+        ensureDir(".loremcorp/companies");
+        writeFileSync(`.loremcorp/companies/${id}.json`, JSON.stringify({ id, installed_at: new Date().toISOString() }, null, 2));
+        console.log(`Installed company metadata: ${id}`);
+        return 0;
+    }
+    if (subcommand === "publish") {
+        console.log("Validated local company package. Registry publish adapter is not configured in OSS local mode.");
+        return 0;
+    }
+    if (subcommand !== "lint")
+        throw new Error("Usage: loremcorp company <lint|init|enrich|install|publish>");
+    const checks = [
+        ["standard hero count >= 20", halcyonCompany.heroPersonas.length >= 20],
+        ["all seven mocks have hum", halcyonCompany.baselineActivityRates.length === 7],
+        ["history covers >= 3 years", halcyonCompany.history.length >= 12],
+        ["launch core scenarios have voice docs", halcyonCompany.heroPersonas.every((persona) => persona.voiceDocPath.startsWith("personas/"))]
+    ];
+    for (const [name, passed] of checks) {
+        console.log(`${passed ? "✓" : "✕"} ${name}`);
+    }
+    return checks.every(([, passed]) => passed) ? 0 : 1;
+}
+function safeSlug(value, label) {
+    if (!value)
+        throw new Error(`Missing ${label}. Use lowercase letters, numbers, dots, underscores, or hyphens.`);
+    if (!/^[a-z0-9][a-z0-9._-]{0,80}$/i.test(value)) {
+        throw new Error(`Invalid ${label}: ${value}. Use lowercase letters, numbers, dots, underscores, or hyphens.`);
+    }
+    if (value.includes(".."))
+        throw new Error(`Invalid ${label}: ${value}. Parent path segments are not allowed.`);
+    return value;
+}
+async function agentCommand(subcommand, args) {
+    if (subcommand === "list") {
+        try {
+            console.log(readFileSync(".loremcorp/agent.json", "utf8"));
+        }
+        catch {
+            console.log("No connected agents.");
+        }
+        return 0;
+    }
+    if (subcommand === "disconnect") {
+        rmSync(".loremcorp/agent.json", { force: true });
+        console.log(`Disconnected agent${args[0] ? `: ${args[0]}` : ""}`);
+        return 0;
+    }
+    if (subcommand !== "connect")
+        throw new Error("Usage: loremcorp agent <connect|list|disconnect>");
+    const path = args[0];
+    if (!path)
+        throw new Error("Usage: loremcorp agent connect <manifest.json>");
+    const connected = await loadAgentFromPath(path);
+    validateAgentManifest(connected.manifest);
+    ensureDir(".loremcorp");
+    writeFileSync(".loremcorp/agent.json", JSON.stringify({ manifest_path: resolve(path), connected_at: new Date().toISOString() }, null, 2));
+    console.log(`Connected agent: ${connected.manifest.name} (${path})`);
+    return 0;
+}
+function snapshotCommand(subcommand, args) {
+    if (subcommand === "build") {
+        const company = args[0]?.startsWith("--") ? "halcyon" : args[0] ?? "halcyon";
+        const options = parseSnapshotOptions(args.filter((arg, index) => index !== 0 || arg.startsWith("--")));
+        const path = writeSnapshotArtifact({ ...options, company });
+        const result = verifySnapshot(path);
+        if (result.issues.length > 0) {
+            throw new Error(`Built snapshot failed verification:\n${result.issues.map((issue) => `- ${issue}`).join("\n")}`);
+        }
+        console.log(`Built snapshot: ${path}`);
+        console.log(JSON.stringify(result.artifact.manifest.counts, null, 2));
+        return 0;
+    }
+    if (subcommand === "pack") {
+        const company = args[0]?.startsWith("--") ? "halcyon" : args[0] ?? "halcyon";
+        const options = parseSnapshotOptions(args.filter((arg, index) => index !== 0 || arg.startsWith("--")));
+        const path = writeSnapshotBundle({ ...options, company });
+        const result = verifySnapshot(path);
+        if (result.issues.length > 0) {
+            throw new Error(`Packed snapshot failed verification:\n${result.issues.map((issue) => `- ${issue}`).join("\n")}`);
+        }
+        console.log(`Packed snapshot bundle: ${path}`);
+        console.log("  manifest.json");
+        console.log("  runtime.snapshot.json.gz");
+        console.log("  truth.snapshot.json.gz");
+        console.log("  provenance.json");
+        console.log(JSON.stringify(result.artifact.manifest.counts, null, 2));
+        return 0;
+    }
+    if (subcommand === "install") {
+        const path = args[0]?.startsWith("--") ? undefined : args[0];
+        const options = parseSnapshotOptions(args.filter((arg, index) => index !== 0 || arg.startsWith("--")));
+        const installed = installSnapshot(path, options);
+        console.log(`Installed snapshot: ${installed.path}`);
+        console.log(`${installed.artifact.manifest.company}/${installed.artifact.manifest.tier}/${installed.artifact.manifest.scale}@${installed.artifact.manifest.version}`);
+        return 0;
+    }
+    if (subcommand === "list") {
+        const snapshots = listInstalledSnapshots();
+        if (snapshots.length === 0) {
+            console.log("No installed snapshots.");
+            return 0;
+        }
+        for (const path of snapshots)
+            console.log(path);
+        return 0;
+    }
+    if (subcommand === "verify") {
+        const path = args[0]?.startsWith("--") ? undefined : args[0];
+        const result = verifySnapshot(path);
+        if (result.issues.length > 0) {
+            console.log(`✕ ${result.path}`);
+            for (const issue of result.issues)
+                console.log(`  - ${issue}`);
+            return 1;
+        }
+        console.log(`✓ ${result.path}`);
+        console.log(JSON.stringify(result.artifact.manifest.counts, null, 2));
+        return 0;
+    }
+    throw new Error("Usage: loremcorp snapshot <build|pack|install|list|verify>");
+}
+async function mcpCommand(subcommand, globals) {
+    const runtime = await createLocalCliRuntime(globals);
+    if (subcommand === "stdio") {
+        await startLoremCorpMcpStdio(runtime.runtime);
+        return 0;
+    }
+    if (subcommand !== "tools")
+        throw new Error("Usage: loremcorp mcp <tools|stdio>");
+    for (const tool of runtime.mcp.listTools()) {
+        console.log(`${tool.name}\t${tool.description}`);
+    }
+    return 0;
+}
+function ensureDir(path) {
+    mkdirSync(path, { recursive: true });
+}
+function mockUrls() {
+    return {
+        slacker: "http://127.0.0.1:4000/slacker",
+        zendisk: "http://127.0.0.1:4000/zendisk",
+        salesfarce: "http://127.0.0.1:4000/salesfarce",
+        strype: "http://127.0.0.1:4000/strype",
+        gothub: "http://127.0.0.1:4000/gothub",
+        notian: "http://127.0.0.1:4000/notian",
+        halpcenter: "http://127.0.0.1:4000/halpcenter"
+    };
+}
+function parseGlobalArgs(argv) {
+    const args = [];
+    const globals = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--company" || arg === "--fork" || arg === "--seed") {
+            const key = arg.slice(2);
+            const value = argv[index + 1];
+            if (!value)
+                throw new Error(`Missing value for ${arg}`);
+            globals[key] = value;
+            index += 1;
+        }
+        else if (arg.startsWith("--company=") || arg.startsWith("--fork=") || arg.startsWith("--seed=")) {
+            const [key, value] = arg.slice(2).split("=", 2);
+            if (!key || !value)
+                throw new Error(`Invalid global flag: ${arg}`);
+            globals[key] = value;
+        }
+        else {
+            args.push(arg);
+        }
+    }
+    return { args, globals };
+}
+function shouldAutoOpen() {
+    return process.env.CI !== "true" && process.env.HEADLESS !== "1" && process.env.LOREMCORP_NO_OPEN !== "1";
+}
+function parseSnapshotOptions(args) {
+    const options = {};
+    for (const arg of args) {
+        if (!arg.startsWith("--"))
+            continue;
+        if (arg === "--with-llm-cache") {
+            options.withLlmCache = "true";
+            continue;
+        }
+        const [key, value] = arg.slice(2).split("=", 2);
+        if (!key || !value)
+            throw new Error(`Invalid snapshot option: ${arg}`);
+        options[key] = value;
+    }
+    const tier = options.tier;
+    if (tier && tier !== "lite" && tier !== "standard") {
+        throw new Error(`Invalid snapshot tier: ${tier}`);
+    }
+    const scale = options.scale;
+    if (scale && scale !== "preview" && scale !== "realistic") {
+        throw new Error(`Invalid snapshot scale: ${scale}`);
+    }
+    return {
+        tier: tier,
+        scale: scale,
+        seed: options.seed,
+        version: options.version,
+        out: options.out,
+        company: options.company,
+        withLlmCache: options.withLlmCache === "true"
+    };
+}
+//# sourceMappingURL=commands.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./commands.js";
+export * from "./runtime.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./commands.js";
+export * from "./runtime.js";
+//# sourceMappingURL=index.js.map

package/dist/llm-fill.d.ts

@@ -0,0 +1,8 @@
+export interface FillResult {
+    readonly text: string;
+    readonly provider: string;
+    readonly usedLlm: boolean;
+}
+export declare function fillScenarioScaffold(id: string): Promise<FillResult>;
+export declare function fillCompanyEnrichment(target: string): Promise<FillResult>;
+//# sourceMappingURL=llm-fill.d.ts.map

package/dist/llm-fill.js

@@ -0,0 +1,127 @@
+import { generateText } from "ai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { halcyonCompany } from "@loremcorp/company-halcyon";
+export async function fillScenarioScaffold(id) {
+    return fillWithOptionalLlm({
+        fallback: fallbackScenario(id),
+        prompt: `Create a LoremCorp scenario TypeScript file for Halcyon.
+
+Scenario id: ${id}
+Use this format exactly:
+import { scenario } from "@loremcorp/scenarios";
+export default scenario({ ... });
+
+Return only TypeScript. The scenario must use Halcyon's existing hero personas and at least one mock surface.`,
+        system: "You write deterministic TypeScript scenario spines for LoremCorp. No markdown fences."
+    });
+}
+export async function fillCompanyEnrichment(target) {
+    return fillWithOptionalLlm({
+        fallback: fallbackCompanyEnrichment(target),
+        prompt: `Create a ${target} enrichment plan for a LoremCorp company.
+
+Company:
+${JSON.stringify({
+            id: halcyonCompany.id,
+            name: halcyonCompany.name,
+            heroes: halcyonCompany.heroPersonas.length,
+            history: halcyonCompany.history.length,
+            mocks: halcyonCompany.baselineActivityRates.map((rate) => rate.mock)
+        }, null, 2)}
+
+Return concise markdown with entity-row targets, persona gaps, scenario gaps, and mock data gaps.`,
+        system: "You enrich synthetic enterprise company catalogs for AI eval substrate quality."
+    });
+}
+async function fillWithOptionalLlm(options) {
+    const model = resolveModel();
+    if (!model) {
+        return {
+            text: options.fallback,
+            provider: "deterministic-fallback",
+            usedLlm: false
+        };
+    }
+    const result = await generateText({
+        model: model.model,
+        system: options.system,
+        prompt: options.prompt
+    });
+    return {
+        text: result.text,
+        provider: model.provider,
+        usedLlm: true
+    };
+}
+function resolveModel() {
+    if (process.env.LOREMCORP_ENABLE_LLM !== "1")
+        return undefined;
+    if (process.env.OPENAI_API_KEY) {
+        const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
+        return { provider: "openai", model: openai(process.env.LOREMCORP_LLM_MODEL ?? "gpt-4.1-mini") };
+    }
+    if (process.env.ANTHROPIC_API_KEY) {
+        const anthropic = createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+        return { provider: "anthropic", model: anthropic(process.env.LOREMCORP_LLM_MODEL ?? "claude-3-5-haiku-latest") };
+    }
+    if (process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
+        const google = createGoogleGenerativeAI({ apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY });
+        return { provider: "google", model: google(process.env.LOREMCORP_LLM_MODEL ?? "gemini-2.0-flash") };
+    }
+    return undefined;
+}
+function fallbackScenario(id) {
+    return `import { scenario } from "@loremcorp/scenarios";
+
+export default scenario({
+  id: ${JSON.stringify(id)},
+  company: "halcyon",
+  duration: "1 sim-days",
+  pathology: "custom",
+  mocks: ["mock-slacker", "mock-zendisk"],
+  heroPersonaIds: ["priya-iyer", "jamie-park"],
+  timeline: [
+    {
+      id: "initial-signal",
+      at: "T+0",
+      source: "mock-zendisk",
+      type: "zendisk.ticket.created",
+      entityId: "ent_halcyon_olivia_martens",
+      payload: { subject: "Custom scenario starter", priority: "normal" }
+    }
+  ],
+  assertions: [],
+  rubric: {
+    triage_speed: 1
+  }
+});
+`;
+}
+function fallbackCompanyEnrichment(target) {
+    return `# Halcyon ${target} Enrichment
+
+LLM-fill did not run because it is opt-in.
+
+Set \`LOREMCORP_ENABLE_LLM=1\` and one of:
+
+- OPENAI_API_KEY
+- ANTHROPIC_API_KEY
+- GOOGLE_GENERATIVE_AI_API_KEY
+
+Then rerun:
+
+\`\`\`sh
+loremcorp company enrich --to=${target}
+\`\`\`
+
+Minimum manual targets:
+
+- Keep all 34 existing hero voice docs current.
+- Add at least 1,000 entity rows per mock for Standard density.
+- Add endpoint manifests beside each mock package.
+- Keep \`quiet-week\` as a baseline scenario in every suite.
+`;
+}
+//# sourceMappingURL=llm-fill.js.map

package/dist/runtime.d.ts

@@ -0,0 +1,19 @@
+import { EventBus, InMemoryEngineStorage } from "@loremcorp/engine";
+import { LocalMockRuntime, type MockService, type StartedMockServer } from "@loremcorp/mocks-shared";
+export interface LocalCliRuntimeOptions {
+    readonly company?: string;
+    readonly fork?: string;
+    readonly seed?: string;
+}
+export declare function createLocalCliRuntime(options?: LocalCliRuntimeOptions): Promise<{
+    storage: InMemoryEngineStorage;
+    fork: import("@loremcorp/engine").ForkState;
+    bus: EventBus;
+    runtime: LocalMockRuntime;
+    services: readonly MockService[];
+    mcp: import("@loremcorp/mcp-overlay").McpOverlay;
+    snapshot: import("./snapshot-store.js").InstalledSnapshot | undefined;
+}>;
+export declare function createAllMockServices(runtime: LocalMockRuntime): readonly MockService[];
+export declare function startAllMockServices(services: readonly MockService[]): Promise<readonly StartedMockServer[]>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.js

@@ -0,0 +1,53 @@
+import { createCanonicalFork, EventBus, InMemoryEngineStorage } from "@loremcorp/engine";
+import { createMcpOverlay } from "@loremcorp/mcp-overlay";
+import { createHalcyonMockState, LocalMockRuntime, startMockService } from "@loremcorp/mocks-shared";
+import { createGotHubMock } from "@loremcorp/mock-gothub";
+import { createHalpcenterMock } from "@loremcorp/mock-halpcenter";
+import { createNotianMock } from "@loremcorp/mock-notian";
+import { createSalesfarceMock } from "@loremcorp/mock-salesfarce";
+import { createSlackerMock } from "@loremcorp/mock-slacker";
+import { createStrypeMock } from "@loremcorp/mock-strype";
+import { createZendiskMock } from "@loremcorp/mock-zendisk";
+import { loadCurrentSnapshot } from "./snapshot-store.js";
+export async function createLocalCliRuntime(options = {}) {
+    if (options.company && options.company !== "halcyon") {
+        throw new Error(`Only Halcyon is installed in Phase 1 OSS local mode. Requested: ${options.company}`);
+    }
+    const storage = new InMemoryEngineStorage();
+    const fork = createCanonicalFork({
+        companyId: "halcyon",
+        id: options.fork ?? "halcyon-local",
+        seed: options.seed,
+        createdAt: "2026-03-15T14:00:00.000Z"
+    });
+    await storage.createFork(fork);
+    const bus = new EventBus(storage);
+    const installedSnapshot = loadCurrentSnapshot();
+    const runtime = new LocalMockRuntime({
+        forkId: fork.id,
+        state: installedSnapshot?.artifact.state ?? createHalcyonMockState(),
+        bus
+    });
+    const services = createAllMockServices(runtime);
+    const mcp = createMcpOverlay(runtime);
+    return { storage, fork, bus, runtime, services, mcp, snapshot: installedSnapshot };
+}
+export function createAllMockServices(runtime) {
+    return [
+        createSlackerMock(runtime),
+        createZendiskMock(runtime),
+        createSalesfarceMock(runtime),
+        createStrypeMock(runtime),
+        createGotHubMock(runtime),
+        createNotianMock(runtime),
+        createHalpcenterMock(runtime)
+    ];
+}
+export async function startAllMockServices(services) {
+    const started = [];
+    for (const service of services) {
+        started.push(await startMockService(service));
+    }
+    return started;
+}
+//# sourceMappingURL=runtime.js.map

package/dist/snapshot-store.d.ts

@@ -0,0 +1,44 @@
+import { type SnapshotArtifact, type SnapshotScale, type SnapshotTier } from "@loremcorp/mocks-shared";
+export interface SnapshotBuildOptions {
+    readonly company?: string;
+    readonly tier?: SnapshotTier;
+    readonly scale?: SnapshotScale;
+    readonly seed?: string;
+    readonly version?: string;
+    readonly out?: string;
+    readonly withLlmCache?: boolean;
+}
+export interface InstalledSnapshot {
+    readonly path: string;
+    readonly artifact: SnapshotArtifact;
+}
+export interface SnapshotBundleFile {
+    readonly path: string;
+    readonly encoding: "json" | "gzip-json";
+    readonly sha256: string;
+    readonly bytes: number;
+}
+export interface SnapshotBundleManifest {
+    readonly format: "loremcorp-snapshot-bundle";
+    readonly schemaVersion: 1;
+    readonly artifact: SnapshotArtifact["manifest"];
+    readonly files: {
+        readonly runtime: SnapshotBundleFile;
+        readonly truth: SnapshotBundleFile;
+        readonly provenance: SnapshotBundleFile;
+    };
+}
+export declare function buildSnapshotArtifact(options?: SnapshotBuildOptions): SnapshotArtifact;
+export declare function writeSnapshotArtifact(options?: SnapshotBuildOptions): string;
+export declare function writeSnapshotBundle(options?: SnapshotBuildOptions): string;
+export declare function installSnapshot(inputPath: string | undefined, options?: SnapshotBuildOptions): InstalledSnapshot;
+export declare function loadCurrentSnapshot(): InstalledSnapshot | undefined;
+export declare function readSnapshotArtifact(path: string): SnapshotArtifact;
+export declare function listInstalledSnapshots(): readonly string[];
+export declare function verifySnapshot(path?: string): {
+    readonly path: string;
+    readonly artifact: SnapshotArtifact;
+    readonly issues: readonly string[];
+};
+export declare function readSnapshotBundle(root: string): SnapshotArtifact;
+//# sourceMappingURL=snapshot-store.d.ts.map

package/dist/snapshot-store.js

@@ -0,0 +1,216 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { basename, dirname, join, resolve } from "node:path";
+import { gzipSync, gunzipSync } from "node:zlib";
+import { buildHalcyonSnapshot, validateSnapshotArtifact } from "@loremcorp/mocks-shared";
+const currentPointerPath = ".loremcorp/snapshots/current.json";
+export function buildSnapshotArtifact(options = {}) {
+    assertHalcyon(options.company);
+    return withChecksum(buildHalcyonSnapshot({
+        tier: options.tier ?? "standard",
+        scale: options.scale,
+        seed: options.seed,
+        version: options.version,
+        withLlmCache: options.withLlmCache
+    }));
+}
+export function writeSnapshotArtifact(options = {}) {
+    const artifact = buildSnapshotArtifact(options);
+    const path = resolve(options.out ?? `.loremcorp/artifacts/${artifact.manifest.company}-${artifact.manifest.tier}-${artifact.manifest.scale}-v${artifact.manifest.version}.snapshot.json`);
+    writeJson(path, artifact);
+    return path;
+}
+export function writeSnapshotBundle(options = {}) {
+    const artifact = buildSnapshotArtifact(options);
+    const issues = validateSnapshotArtifact(artifact);
+    if (issues.length > 0) {
+        throw new Error(`Snapshot validation failed:\n${issues.map((issue) => `- ${issue}`).join("\n")}`);
+    }
+    const root = resolve(options.out ?? `.loremcorp/artifacts/${artifact.manifest.company}-${artifact.manifest.tier}-${artifact.manifest.scale}-v${artifact.manifest.version}`);
+    mkdirSync(root, { recursive: true });
+    const runtimePath = "runtime.snapshot.json.gz";
+    const truthPath = "truth.snapshot.json.gz";
+    const provenancePath = "provenance.json";
+    writeGzipJson(join(root, runtimePath), {
+        manifest: artifact.manifest,
+        state: artifact.state
+    });
+    writeGzipJson(join(root, truthPath), {
+        manifest: artifact.manifest,
+        metadata: artifact.metadata
+    });
+    writeJson(join(root, provenancePath), {
+        company: artifact.manifest.company,
+        tier: artifact.manifest.tier,
+        scale: artifact.manifest.scale,
+        version: artifact.manifest.version,
+        seed: artifact.manifest.seed,
+        generated_at: artifact.manifest.generatedAt,
+        generator: artifact.manifest.generator,
+        source: "local deterministic generator",
+        artifact_checksum: artifact.manifest.checksum,
+        public_runtime_file: runtimePath,
+        hidden_truth_file: truthPath,
+        notes: [
+            "runtime.snapshot contains mock API state only.",
+            "truth.snapshot contains hidden validation metadata and must not be served through mock APIs."
+        ]
+    });
+    const bundle = {
+        format: "loremcorp-snapshot-bundle",
+        schemaVersion: 1,
+        artifact: artifact.manifest,
+        files: {
+            runtime: describeBundleFile(root, runtimePath, "gzip-json"),
+            truth: describeBundleFile(root, truthPath, "gzip-json"),
+            provenance: describeBundleFile(root, provenancePath, "json")
+        }
+    };
+    writeJson(join(root, "manifest.json"), bundle);
+    return root;
+}
+export function installSnapshot(inputPath, options = {}) {
+    const artifact = inputPath ? readSnapshotArtifact(inputPath) : buildSnapshotArtifact(options);
+    const issues = validateSnapshotArtifact(artifact);
+    if (issues.length > 0) {
+        throw new Error(`Snapshot validation failed:\n${issues.map((issue) => `- ${issue}`).join("\n")}`);
+    }
+    const installedPath = `.loremcorp/snapshots/${artifact.manifest.company}/${artifact.manifest.tier}/${artifact.manifest.scale}/${artifact.manifest.version}/snapshot.json`;
+    writeJson(installedPath, artifact);
+    writeJson(currentPointerPath, {
+        company: artifact.manifest.company,
+        tier: artifact.manifest.tier,
+        scale: artifact.manifest.scale,
+        version: artifact.manifest.version,
+        path: installedPath
+    });
+    return { path: installedPath, artifact };
+}
+export function loadCurrentSnapshot() {
+    if (!existsSync(currentPointerPath))
+        return undefined;
+    const pointer = JSON.parse(readFileSync(currentPointerPath, "utf8"));
+    if (!pointer.path || !existsSync(pointer.path))
+        return undefined;
+    return { path: pointer.path, artifact: readSnapshotArtifact(pointer.path) };
+}
+export function readSnapshotArtifact(path) {
+    const resolved = resolve(path);
+    if (statSync(resolved).isDirectory()) {
+        return readSnapshotBundle(resolved);
+    }
+    if (resolved.endsWith(".gz")) {
+        return JSON.parse(gunzipSync(readFileSync(resolved)).toString("utf8"));
+    }
+    return JSON.parse(readFileSync(resolved, "utf8"));
+}
+export function listInstalledSnapshots() {
+    const root = ".loremcorp/snapshots";
+    if (!existsSync(root))
+        return [];
+    return collectSnapshotFiles(root);
+}
+export function verifySnapshot(path) {
+    const resolvedPath = path ?? loadCurrentSnapshot()?.path;
+    if (!resolvedPath)
+        throw new Error("No snapshot path provided and no current snapshot is installed.");
+    const artifact = readSnapshotArtifact(resolvedPath);
+    const issues = [...validateSnapshotArtifact(artifact)];
+    const expected = withChecksum({ ...artifact, manifest: { ...artifact.manifest, checksum: undefined } }).manifest.checksum;
+    if (artifact.manifest.checksum && artifact.manifest.checksum !== expected) {
+        issues.push(`checksum mismatch: expected ${expected} got ${artifact.manifest.checksum}`);
+    }
+    return { path: resolvedPath, artifact, issues };
+}
+export function readSnapshotBundle(root) {
+    const manifestPath = join(root, "manifest.json");
+    const bundle = JSON.parse(readFileSync(manifestPath, "utf8"));
+    if (bundle.format !== "loremcorp-snapshot-bundle" || bundle.schemaVersion !== 1) {
+        throw new Error(`Unsupported snapshot bundle manifest: ${manifestPath}`);
+    }
+    verifyBundleFile(root, bundle.files.runtime);
+    verifyBundleFile(root, bundle.files.truth);
+    verifyBundleFile(root, bundle.files.provenance);
+    const runtime = readBundleJson(root, bundle.files.runtime);
+    const truth = readBundleJson(root, bundle.files.truth);
+    if (runtime.manifest.checksum !== truth.manifest.checksum) {
+        throw new Error("Snapshot bundle runtime/truth manifest checksums differ.");
+    }
+    if (runtime.manifest.checksum !== bundle.artifact.checksum) {
+        throw new Error("Snapshot bundle manifest checksum does not match runtime payload.");
+    }
+    return {
+        manifest: runtime.manifest,
+        state: runtime.state,
+        metadata: truth.metadata
+    };
+}
+function withChecksum(artifact) {
+    const { checksum: _checksum, ...manifest } = artifact.manifest;
+    const checksum = createHash("sha256")
+        .update(JSON.stringify({ manifest, state: artifact.state, metadata: artifact.metadata }))
+        .digest("hex");
+    return {
+        ...artifact,
+        manifest: {
+            ...manifest,
+            checksum
+        }
+    };
+}
+function writeJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeGzipJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, gzipSync(Buffer.from(JSON.stringify(value), "utf8")));
+}
+function readBundleJson(root, file) {
+    const buffer = readFileSync(join(root, file.path));
+    if (file.encoding === "gzip-json") {
+        return JSON.parse(gunzipSync(buffer).toString("utf8"));
+    }
+    return JSON.parse(buffer.toString("utf8"));
+}
+function describeBundleFile(root, path, encoding) {
+    const buffer = readFileSync(join(root, path));
+    return {
+        path,
+        encoding,
+        sha256: sha256(buffer),
+        bytes: buffer.byteLength
+    };
+}
+function verifyBundleFile(root, file) {
+    const buffer = readFileSync(join(root, file.path));
+    const actualSha = sha256(buffer);
+    if (file.bytes !== buffer.byteLength) {
+        throw new Error(`Snapshot bundle file size mismatch for ${file.path}: expected ${file.bytes} got ${buffer.byteLength}`);
+    }
+    if (file.sha256 !== actualSha) {
+        throw new Error(`Snapshot bundle file checksum mismatch for ${file.path}: expected ${file.sha256} got ${actualSha}`);
+    }
+}
+function sha256(buffer) {
+    return createHash("sha256").update(buffer).digest("hex");
+}
+function collectSnapshotFiles(root) {
+    const files = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const path = join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectSnapshotFiles(path));
+        }
+        else if (entry.isFile() && basename(path) === "snapshot.json") {
+            files.push(path);
+        }
+    }
+    return files.sort();
+}
+function assertHalcyon(company = "halcyon") {
+    if (company !== "halcyon") {
+        throw new Error(`Only Halcyon snapshots are supported in Phase 1. Requested: ${company}`);
+    }
+}
+//# sourceMappingURL=snapshot-store.js.map

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "loremcorp",
+  "version": "0.1.0",
+  "description": "CLI for running LoremCorp synthetic companies and mock SaaS APIs.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielthedm/loremcorp.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/danielthedm/loremcorp#readme",
+  "bugs": {
+    "url": "https://github.com/danielthedm/loremcorp/issues"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.map"
+  ],
+  "bin": {
+    "loremcorp": "./dist/bin/loremcorp.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.77",
+    "@ai-sdk/google": "^3.0.72",
+    "@ai-sdk/openai": "^3.0.63",
+    "ai": "^6.0.177",
+    "@loremcorp/company-halcyon": "0.1.0",
+    "@loremcorp/engine": "0.1.0",
+    "@loremcorp/mcp-overlay": "0.1.0",
+    "@loremcorp/manifest": "0.1.0",
+    "@loremcorp/mock-gothub": "0.1.0",
+    "@loremcorp/mock-halpcenter": "0.1.0",
+    "@loremcorp/mock-strype": "0.1.0",
+    "@loremcorp/mocks-shared": "0.1.0",
+    "@loremcorp/mock-zendisk": "0.1.0",
+    "@loremcorp/mock-notian": "0.1.0",
+    "@loremcorp/mock-salesfarce": "0.1.0",
+    "@loremcorp/scenarios": "0.1.0",
+    "@loremcorp/mock-slacker": "0.1.0",
+    "@loremcorp/sdk": "0.1.0",
+    "@loremcorp/mock-gateway": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsc -b"
+  }
+}