@pleri/olam-cli 0.1.148 → 0.1.150

package/dist/agent-stream/driver-runner.js

@@ -0,0 +1,347 @@
+/**
+ * driver-runner.ts — Phase B B5 (minimum-demo cut) driver hot-loop.
+ *
+ * Composes the existing primitives into a runnable agent process:
+ *   transport (B1) → operator-pickup filter (C6) → SDK query → adapter (C1) → POST chunks
+ *
+ * Entry point: spawned as a child of B6 supervisor; reads env for
+ * HOST_CP_URL / HOST_CP_BEARER / WORLD_ID / SESSION_ID /
+ * DRIVER_SYSTEM_PROMPT_APPEND (legacy: DRIVER_SYSTEM_PROMPT — falls back to
+ * the new name post-`olam-sdk-latency-tuning` Phase A) /
+ * AGENT_DRIVER_TOOLS_ENABLED (set to "1" to re-enable Bash/Edit/Write/Read/
+ * Glob/Grep/Task for the conversational driver; default off per Phase A).
+ *
+ * Demo-cut simplifications (per minimum-demo decision; full contract
+ * deferred to follow-up Phase B B5-full):
+ *   - lastConsumedSeq is IN-MEMORY only (no chunks_subscriber_state
+ *     server-side table). Restart loses cursor; for demo this means a
+ *     re-spawn replays operator chunks from `seq=0` (the cold-start
+ *     sentinel from `interject` Fallback). Idempotency at the adapter
+ *     level (PK message_id+seq) keeps the substrate clean.
+ *   - No host-cp REST endpoint for cursor write/read.
+ *   - No PID-recycle-safe cursor file naming (cursor is in process memory only).
+ *   - Pure shared-secret auth (the bearer env value); JWT scope-claim
+ *     migration is B9 / post-demo.
+ *
+ * Iteration model:
+ *   - Wait for the next operator chunk via transport (or boot-time
+ *     `dispatch` chunk on first poll).
+ *   - Build the iteration's prompt prefix from accumulated pickups.
+ *   - Invoke SDK query() with the prefix + a small system prompt.
+ *   - Stream SDK output via streamSdkToChunks back to host-cp.
+ *   - Loop until SIGTERM.
+ *
+ * Source: docs/design/olam-plan-chat-agent-runtime.md `interject` +
+ * `subscriber` sections, minimum-demo cut.
+ */
+import { randomUUID } from 'node:crypto';
+import { makeHostCpChunkPoster, streamMultiTurnSdkToChunks, } from './agent-sdk-to-chunks.js';
+import { subscribeToChunks } from './chunks-subscriber-transport.js';
+import { filterOperatorPickups, pickupConsumedKey, pickupsToPromptPrefix, } from './operator-subscription.js';
+/**
+ * Default `append` text for the Claude Code preset system prompt.
+ * Exported so the regression test can assert non-empty + coordinator-shaped
+ * content (Phase A.1 adv-7 follow-up: the snapshot test alone doesn't catch
+ * a "default emptied during refactor" regression).
+ */
+export const DEFAULT_SYSTEM_PROMPT_APPEND = `You are the driver agent inside an olam plan-chat session. The operator may interject mid-iteration; their interjects appear as a prefix to your next prompt. Acknowledge interjects explicitly in your response (e.g. "noted — switching to retry middleware") and continue the work. Keep responses focused and under 200 tokens unless deep analysis is required. You are a conversational coordinator — do not invoke filesystem/code tools unless explicitly asked.`;
+/**
+ * Builds the SDK options object used for every `query()` call. Exported
+ * for snapshot testing (Phase A A2) — the snapshot is the regression
+ * gate that prevents the pre-Phase-A malformation from recurring.
+ *
+ * The `abortController` field is NOT included here; the caller adds it
+ * at the call site so this helper stays deterministic + snapshot-safe.
+ *
+ * Phase A levers applied here:
+ *  - `systemPrompt: { type: 'preset', preset: 'claude_code', append: <hint> }` —
+ *    fixes the pre-Phase-A `{type:'preset', preset:<custom-string>}`
+ *    malformation; the SDK runtime extracts only `append` on the preset
+ *    branch (Pass 2 source-read at sdk.mjs:847641; Pass 3 runtime probe).
+ *  - `allowedTools: []` — empty allowlist filters out ALL tools from the
+ *    Claude Code preset. Allowlist (not denylist — corrects adv-1 from
+ *    Phase A CP3): the SDK's tool surface grows over time; allowlist
+ *    means new tools stay disabled by default until explicitly opted in,
+ *    which preserves the "coordinator-not-coder" seam.
+ *  - `effort: 'low'` + `thinking: { type: 'disabled' }` — driver doesn't
+ *    do deep reasoning; sub-agents inherit their own config.
+ *  - `model: 'claude-sonnet-4-6'` — Pass 4 OQ7 resolution. Driver
+ *    coordinator runs Sonnet, not Opus. (`claude-sonnet-4-6` is the
+ *    SDK's documented model-ID example shape per sdk.d.ts:1472,1626.)
+ *
+ * `permissionMode` is intentionally omitted: with `allowedTools: []` the
+ * permission decision is moot (zero tools to permission). The pre-fix
+ * `permissionMode: 'dontAsk'` was kept as belt-and-suspenders but its
+ * SDK semantic — "deny if not pre-approved" — is exactly what an empty
+ * allowlist already enforces (corrects adv-2).
+ *
+ * Escape hatch: `AGENT_DRIVER_TOOLS_ENABLED=1` removes the allowedTools
+ * field entirely so the SDK falls back to the preset's full tool set.
+ * Documented per plan T2 mitigation. Note the env-var is read from the
+ * driver child process; the supervisor propagates its env, so setting
+ * this on the supervisor enables it FLEET-WIDE (adv-6 — by design).
+ */
+export function buildSdkOptions(input) {
+    const driverToolsEnabled = process.env.AGENT_DRIVER_TOOLS_ENABLED === '1';
+    return {
+        systemPrompt: {
+            type: 'preset',
+            preset: 'claude_code',
+            ...(input.systemPromptAppend ? { append: input.systemPromptAppend } : {}),
+        },
+        // Empty allowlist = strict coordinator (no tools); undefined = full preset tools.
+        ...(driverToolsEnabled ? {} : { allowedTools: [] }),
+        effort: 'low',
+        thinking: { type: 'disabled' },
+        model: 'claude-sonnet-4-6',
+    };
+}
+/**
+ * Factory: takes the raw SDK `query` function, returns the `SdkQueryFn`
+ * that `runDriver` consumes. Extracted from `main()` so the call-site
+ * composition (buildSdkOptions output + abortController forwarding) is
+ * directly testable with a mocked `query` (Phase A.1 adv-5 follow-up).
+ *
+ * Behavior contract:
+ *  - `options` passed to `query` is `buildSdkOptions(...)` output spread
+ *    FIRST, then `abortController` added LAST (cannot be clobbered).
+ *  - `abortController` is a fresh AbortController per call; the input
+ *    `abortSignal` is forwarded via `addEventListener('abort', ...)`.
+ *  - The `prompt` is passed through unchanged.
+ */
+export function createSdkQuery(query) {
+    return ({ prompt, abortSignal, systemPromptAppend }) => {
+        // eslint-disable-next-line no-console
+        console.error(`[driver] sdkQuery fired (prompt: ${typeof prompt === 'string' ? `${prompt.length} chars` : 'AsyncIterable<SdkUserMessage>'})`);
+        // Forward the runDriver-owned abortSignal to a fresh AbortController
+        // (the SDK's Options.abortController expects an AbortController, not
+        // a bare AbortSignal). One per query() call — cheap; no global state.
+        const sdkAbortController = new AbortController();
+        if (abortSignal) {
+            if (abortSignal.aborted)
+                sdkAbortController.abort();
+            else
+                abortSignal.addEventListener('abort', () => sdkAbortController.abort(), {
+                    once: true,
+                });
+        }
+        const options = {
+            ...buildSdkOptions({ systemPromptAppend }),
+            abortController: sdkAbortController,
+        };
+        return query({ prompt, options });
+    };
+}
+/**
+ * Run the driver hot-loop. Returns a handle to stop it cleanly.
+ *
+ * The driver doesn't terminate on its own — it runs until aborted
+ * (SIGTERM via the supervisor → the abortSignal here).
+ */
+export function runDriver(opts) {
+    const { hostCpUrl, bearer, worldId, sessionId, systemPromptAppend = DEFAULT_SYSTEM_PROMPT_APPEND, sdkQuery, abortSignal: externalSignal, subscribeImpl = subscribeToChunks, postChunkImpl = (url, b) => makeHostCpChunkPoster({ sidecarUrl: url, bearer: b }), } = opts;
+    const controller = new AbortController();
+    if (externalSignal) {
+        if (externalSignal.aborted)
+            controller.abort();
+        else
+            externalSignal.addEventListener('abort', () => controller.abort(), { once: true });
+    }
+    const signal = controller.signal;
+    const postChunk = postChunkImpl(hostCpUrl, bearer);
+    // In-memory dedup set (Phase D D6). Replaces the prior `lastConsumedSeq`
+    // monotonic-cursor model which dropped every operator chunk after the
+    // first one in a session (every SPA dispatch has seq=0 with its own
+    // message_id; `seq <= lastConsumedSeq` rejected 0 <= 0). Set keyed on
+    // `${messageId}:${seq}` matches the substrate's PK shape exactly.
+    // Per crash-resume: process restart loses the set; operator chunks are
+    // re-presented; substrate idempotency (PK message_id+seq) keeps the
+    // adapter writes clean.
+    const consumedKeys = new Set();
+    // Pending pickups accumulate from the transport; drained by the
+    // userMessageStream generator each time it wakes.
+    const pendingPickups = [];
+    let iterationWakeup = null;
+    // P2 (plan risk candidate): bound the queue to prevent memory leak in
+    // long-lived iteration (operator pickups accumulate over many-hour
+    // sessions). Above this limit, drop the oldest pickups + log + emit
+    // system error chunk so the operator sees something went wrong.
+    const PENDING_PICKUPS_MAX = 100;
+    const transport = subscribeImpl({
+        baseUrl: hostCpUrl,
+        bearer,
+        worldId,
+        sessionId,
+        abortSignal: signal,
+        onChunk: (chunk) => {
+            const pickups = filterOperatorPickups([chunk], consumedKeys);
+            if (pickups.length === 0)
+                return;
+            pendingPickups.push(...pickups);
+            if (pendingPickups.length > PENDING_PICKUPS_MAX) {
+                const overflow = pendingPickups.length - PENDING_PICKUPS_MAX;
+                pendingPickups.splice(0, overflow);
+                // eslint-disable-next-line no-console
+                console.error(`[driver] pendingPickups overflow: dropped ${overflow} oldest pickups (queue cap=${PENDING_PICKUPS_MAX})`);
+            }
+            for (const p of pickups) {
+                consumedKeys.add(pickupConsumedKey(p));
+            }
+            if (iterationWakeup) {
+                iterationWakeup();
+                iterationWakeup = null;
+            }
+        },
+    });
+    // Convert a batch of pickups into ONE SdkUserMessage (preserves the
+    // pre-refactor batched-prompt behavior: multiple operator chunks
+    // arriving in the same wakeup window combine into one user turn).
+    function batchToUserMessage(batch) {
+        const content = pickupsToPromptPrefix(batch);
+        if (!content)
+            return null;
+        return {
+            type: 'user',
+            message: { role: 'user', content },
+            parent_tool_use_id: null,
+        };
+    }
+    // Iteration loop runs in parallel with the transport. NEW architecture
+    // (Phase B B2): opens ONE long-lived sdkQuery with an AsyncIterable
+    // prompt that pulls from pendingPickups. Each `'result'` boundary in
+    // the SDK's response stream allocates a fresh messageId via the
+    // turn-splitter helper.
+    const iterationLoop = async () => {
+        if (signal.aborted)
+            return;
+        async function* userMessageStream() {
+            while (!signal.aborted) {
+                if (pendingPickups.length === 0) {
+                    await new Promise((resolve) => {
+                        iterationWakeup = resolve;
+                        const abortHandler = () => {
+                            iterationWakeup = null;
+                            resolve();
+                        };
+                        signal.addEventListener('abort', abortHandler, { once: true });
+                    });
+                    if (signal.aborted)
+                        return;
+                    if (pendingPickups.length === 0)
+                        continue;
+                }
+                const batch = pendingPickups.splice(0);
+                const userMessage = batchToUserMessage(batch);
+                if (userMessage !== null)
+                    yield userMessage;
+            }
+        }
+        try {
+            const messages = sdkQuery({
+                prompt: userMessageStream(),
+                abortSignal: signal,
+                systemPromptAppend,
+            });
+            await streamMultiTurnSdkToChunks({
+                messages,
+                worldId,
+                sessionId,
+                allocateMessageId: () => `driver-${randomUUID()}`,
+                postChunk,
+            });
+        }
+        catch (err) {
+            if (signal.aborted)
+                return;
+            // eslint-disable-next-line no-console
+            console.error('[driver] iteration failed:', err);
+            try {
+                await postChunk({
+                    world_id: worldId,
+                    session_id: sessionId,
+                    message_id: `driver-error-${randomUUID()}`,
+                    seq: 0,
+                    role: 'system',
+                    kind: 'result',
+                    chunk: JSON.stringify({ error: 'iteration failed', detail: String(err) }),
+                    created_at: new Date().toISOString(),
+                });
+            }
+            catch {
+                // swallow — postChunk failure on top of iteration failure is unrecoverable
+            }
+        }
+    };
+    const done = Promise.all([transport.done, iterationLoop()]).then(() => undefined);
+    return {
+        stop: async () => {
+            controller.abort();
+            try {
+                await done;
+            }
+            catch {
+                // swallow — caller can inspect done directly if needed
+            }
+        },
+        done,
+    };
+}
+/**
+ * CLI entry point when this module is run directly (via supervisor fork).
+ * Reads env, validates, calls runDriver, installs SIGTERM handler.
+ */
+export async function main() {
+    const hostCpUrl = process.env.HOST_CP_URL;
+    const bearer = process.env.HOST_CP_BEARER;
+    const worldId = process.env.WORLD_ID;
+    const sessionId = process.env.SESSION_ID;
+    if (!hostCpUrl || !bearer || !worldId || !sessionId) {
+        // eslint-disable-next-line no-console
+        console.error('[driver] missing required env: HOST_CP_URL, HOST_CP_BEARER, WORLD_ID, SESSION_ID');
+        process.exit(1);
+    }
+    // Lazy-load SDK so tests don't need the package installed.
+    const { query } = await import('@anthropic-ai/claude-agent-sdk');
+    const controller = new AbortController();
+    process.on('SIGTERM', () => controller.abort());
+    process.on('SIGINT', () => controller.abort());
+    // eslint-disable-next-line no-console
+    console.error(`[driver] starting · world=${worldId} session=${sessionId} ` +
+        `hostCp=${hostCpUrl}`);
+    const handle = runDriver({
+        hostCpUrl,
+        bearer,
+        worldId,
+        sessionId,
+        // Backwards-compat: read both env var names. `DRIVER_SYSTEM_PROMPT_APPEND`
+        // is the new (post-Phase-A) name; `DRIVER_SYSTEM_PROMPT` is honored for
+        // operators with legacy supervisor configs.
+        systemPromptAppend: process.env.DRIVER_SYSTEM_PROMPT_APPEND ?? process.env.DRIVER_SYSTEM_PROMPT,
+        sdkQuery: createSdkQuery(query),
+        abortSignal: controller.signal,
+    });
+    try {
+        await handle.done;
+        // eslint-disable-next-line no-console
+        console.error('[driver] done.resolved — clean exit');
+        process.exit(0);
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.error('[driver] done.rejected — fatal:', err);
+        process.exit(1);
+    }
+}
+// Run main() only when invoked directly (not when imported as a module).
+// The check uses `process.argv[1]` to compare against this module's path.
+// Note: this is a Node-specific pattern; tests bypass it by importing runDriver.
+if (typeof process !== 'undefined' &&
+    process.argv[1] &&
+    (process.argv[1].endsWith('driver-runner.js') || process.argv[1].endsWith('driver-runner.ts'))) {
+    main().catch((err) => {
+        // eslint-disable-next-line no-console
+        console.error('[driver] fatal:', err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=driver-runner.js.map

package/dist/agent-stream/operator-subscription.js

@@ -0,0 +1,179 @@
+/**
+ * operator-subscription.ts — Phase C C6 agent-as-subscriber primitive.
+ *
+ * Driver-agent's hot loop subscribes to operator chunks; each new operator
+ * chunk feeds the agent's next reasoning iteration as steer input. The
+ * substrate IS the orchestration channel — no RPC, no event bus, no
+ * "interject" API on the agent runtime: the agent simply reads chunks
+ * where `actor_type='operator' AND seq > last_consumed_seq`.
+ *
+ * This module ships the PURE-FUNCTION pattern for both the driver
+ * subscriber and other agent kinds (codex, lookouts). The devbox
+ * bootstrap launcher that spawns these processes is C+1 follow-up
+ * scope — the pure pattern is what's load-bearing for the seam.
+ *
+ * Architecture (per pass-7 plan body):
+ *   - Driver in devbox container opens a shape subscription via
+ *     `host.docker.internal:3112/v1/shape` (the host-cp sidecar from
+ *     Phase B B1).
+ *   - On each new operator chunk, the driver's NEXT reasoning iteration
+ *     receives it as a prompt prefix.
+ *   - Codex runs as a SEPARATE process with the same subscription
+ *     pattern, but with a CONTENT FILTER (PR-draft regex).
+ *   - Lookouts (Scout / PM / Brainstorm from PR #443) follow the
+ *     same pattern with persona-specific trigger heuristics; emit
+ *     SIGNALS (to plan_sidebar_signals) instead of chunks.
+ *
+ * Per OQ10 lean (a): driver + codex + lookouts all talk to host-cp's
+ * /v1/shape via `host.docker.internal:3112`. No in-container PGlite
+ * mirror; no LISTEN/NOTIFY direct.
+ *
+ * Source: docs/plans/olam-plan-chat-chunks-substrate/phase-c-tasks.md (C6)
+ */
+/**
+ * Pure: derive the consumed-key for an operator pickup. The key is
+ * `${messageId}:${seq}` — the (PK) shape Postgres uses for chunks.
+ * Callers store these in a Set to dedup the operator stream.
+ */
+export function pickupConsumedKey(p) {
+    return `${p.messageId}:${p.seq}`;
+}
+/**
+ * Pure: filter a chunk stream to operator chunks NOT YET CONSUMED.
+ * Used as the load-bearing primitive by the driver's hot loop —
+ * each iteration call materialises the next batch of operator pickups
+ * to feed into the next reasoning turn.
+ *
+ * `consumedKeys` is tracked by the caller (driver hot loop's local
+ * state). On first call (cold start), pass an empty Set to receive
+ * all historical operator chunks for the session.
+ *
+ * **History note** (Phase D D6 dedup fix): pre-fix this took a
+ * `lastConsumedSeq: number` and filtered with `c.seq <= lastConsumedSeq`.
+ * That broke in production because each SPA-dispatched operator chunk is
+ * a NEW message_id with `seq=0` (the chunks substrate scopes seq per
+ * message_id, not per session). Under that model, the second operator
+ * dispatch with `seq=0` was rejected because `0 <= 0`, silently dropping
+ * every operator chunk after the first one. Switched to message_id+seq
+ * Set dedup which matches the substrate's PK shape exactly.
+ */
+export function filterOperatorPickups(chunks, consumedKeys) {
+    const out = [];
+    for (const c of chunks) {
+        if (c.actor_type !== 'operator')
+            continue;
+        const key = `${c.message_id}:${c.seq}`;
+        if (consumedKeys.has(key))
+            continue;
+        out.push({
+            messageId: c.message_id,
+            seq: c.seq,
+            content: c.chunk,
+            createdAt: c.created_at,
+        });
+    }
+    return out;
+}
+/**
+ * Pure: compose a prompt-prefix string from operator pickups. Each
+ * pickup becomes a `[operator]: ...` line; multiple pickups stack
+ * in seq order. The driver's next-iteration prompt prepends this
+ * prefix so the agent sees the operator's interjects without
+ * needing a custom message-injection hook in the SDK.
+ *
+ * Returns null when there are no pickups (skip the prefix; vanilla
+ * iteration).
+ */
+export function pickupsToPromptPrefix(pickups) {
+    if (pickups.length === 0)
+        return null;
+    const sorted = [...pickups].sort((a, b) => a.seq - b.seq);
+    const lines = sorted.map((p) => `[operator]: ${p.content}`);
+    return lines.join('\n');
+}
+/**
+ * Pure: derive the next-iteration `consumedKeys` Set after processing
+ * a batch of pickups. The driver hot loop calls this after each
+ * iteration to update its local state. Returns a NEW Set (caller
+ * keeps the prior set immutable; cheap on the small operator volumes
+ * a single session produces).
+ */
+export function advanceConsumedKeys(pickups, current) {
+    const next = new Set(current);
+    for (const p of pickups) {
+        next.add(pickupConsumedKey(p));
+    }
+    return next;
+}
+/**
+ * Pure: detect PR-draft patterns in driver chunks for codex pickup
+ * (Phase C C6 codex-runner trigger).
+ *
+ * Codex runs as a parallel process subscribing to driver chunks; on
+ * detecting "PR draft" / "draft PR" / "opening PR" / "PR title"
+ * patterns, codex generates an approval/rejection chunk. This pure
+ * helper isolates the trigger heuristic for unit-test coverage
+ * separate from the codex process's stateful execution loop.
+ */
+export function detectCodexTrigger(chunk) {
+    if (chunk.actor_type !== 'agent')
+        return { matched: false };
+    const text = chunk.chunk;
+    const patterns = [
+        /\bdraft\s+pr\b/i,
+        /\bpr\s+draft\b/i,
+        /\bpr\s+title\b/i,
+        /\bopening\s+pr\b/i,
+        /\bcreate\s+(a\s+)?pull\s+request\b/i,
+    ];
+    for (const re of patterns) {
+        const m = re.exec(text);
+        if (m !== null) {
+            return { matched: true, matchedPattern: m[0] };
+        }
+    }
+    return { matched: false };
+}
+/**
+ * Pure: generate a codex approval/rejection chunk content for a
+ * matched PR-draft trigger. The codex runner uses this to compose
+ * the chunk it writes back via host-cp POST /v1/chunks (with
+ * actor_type='codex').
+ *
+ * The actual reasoning runs through Claude Agent SDK with a codex
+ * system prompt; this helper covers the deterministic boilerplate
+ * (decision + reasoning summary). Real codex output flows through
+ * streamSdkToChunks (Phase C C1's adapter).
+ */
+export function codexApprovalDraft(opts) {
+    const verdict = opts.approved ? 'APPROVED' : 'BLOCKED';
+    return {
+        content: [
+            `[codex] ${verdict}`,
+            `Trigger: chunk ${opts.triggerChunk.message_id}#${opts.triggerChunk.seq}`,
+            `Reason: ${opts.reason}`,
+        ].join('\n'),
+        actorType: 'codex',
+    };
+}
+/**
+ * Pure: minimal v1 trigger heuristic for Scout (lookout persona). Fires
+ * on agent chunks containing "TODO" or "FIXME" or "XXX" markers as a
+ * conservative starting point. Real Scout uses LLM-based judgment;
+ * this v1 heuristic is the deterministic fallback for tests + the
+ * pattern other personas extend.
+ */
+export const scoutTrigger = (chunk) => {
+    if (chunk.actor_type !== 'agent')
+        return { triggered: false };
+    const markers = /\b(TODO|FIXME|XXX|HACK)\b/.exec(chunk.chunk);
+    if (markers === null)
+        return { triggered: false };
+    return {
+        triggered: true,
+        urgency: 'p2',
+        reason: `marker ${markers[0]} surfaced`,
+        content: `Scout noted: ${markers[0]} in chunk ${chunk.message_id}#${chunk.seq}.`,
+    };
+};
+//# sourceMappingURL=operator-subscription.js.map

package/dist/commands/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/commands/create.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgDzC,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAsjBrD"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/commands/create.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmDzC,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA6lBrD"}

package/dist/commands/create.js

@@ -17,6 +17,9 @@ import { printError, printInfo, printHeader, printWarning } from '../output.js';
 import { probeHostCp, gatherProbeFailureDiagnostics, callHostCpProxy, openHostCpUrl } from './host-cp.js';
 import { readMemorySecretOrNull } from '../lib/memory-secret.js';
 import { registerAgentMemoryMcp } from '../lib/world-mcp-register.js';
+import { buildIfStale } from '../lib/build-if-stale.js';
+import { resolveBundleSource, BundleSourceNotFoundError } from '../lib/bundle-source.js';
+import { isDevMode } from '../install-root.js';
 // Phase B1 — mirror of AGENTMEMORY_HOST_INTERNAL_URL in
 // packages/adapters/src/docker/container.ts. Hardcoded here for the
 // post-spawn MCP registration call so the host knows what URL was
@@ -283,6 +286,41 @@ export function registerCreate(program) {
                 }
             }
         }
+        // C2 (olam-world-bundle-freshness): resolve the agent-stream bundle
+        // source. Handles both source-mode (OLAM_DEV=1 + packages/ sibling →
+        // auto-build if stale) and install-mode (CLI's own dist/agent-stream/).
+        let agentStreamDistPath;
+        try {
+            const bundleSource = resolveBundleSource();
+            if (bundleSource.mode === 'source') {
+                // B3 path: auto-build when dist is stale.
+                const bundleRepoRoot = resolveRepoRoot(process.cwd());
+                const buildResult = buildIfStale(bundleRepoRoot);
+                if (!buildResult.ok) {
+                    printError('Agent-stream bundle build failed. Not creating world with a stale bundle.\n' +
+                        'Fix the build error and re-run `olam create`.');
+                    process.exitCode = 1;
+                    return;
+                }
+                if (buildResult.built) {
+                    printInfo('Bundle', buildResult.message);
+                }
+            }
+            // Both modes: pass the resolved path so the docker provider bind-mounts
+            // the correct dist (source-mode: repo dist; install-mode: CLI dist).
+            agentStreamDistPath = bundleSource.path;
+        }
+        catch (err) {
+            if (err instanceof BundleSourceNotFoundError) {
+                // Graceful degradation: warn but do not block world create.
+                // The world will use the image-baked bundle as fallback.
+                printWarning(`agent-stream bundle path unresolved; world will use image-baked bundle.\n` +
+                    `  ${err.message}`);
+            }
+            else {
+                throw err;
+            }
+        }
         const spinner = ora('Creating world...').start();
         try {
             const world = await ctx.worldManager.createWorld({
@@ -293,6 +331,7 @@ export function registerCreate(program) {
                 branchName: opts.branch,
                 planFile: opts.plan,
                 noAuth: !opts.auth,
+                ...(agentStreamDistPath ? { agentStreamDistPath } : {}),
                 // ADV-B3-LOW2: strict-boolean coercion. `?? false` would pass through
                 // truthy non-booleans (e.g. if the flag's shape ever grows to
                 // `--carry-uncommitted [mode]` where commander returns a string).