cognitive-core 0.2.5 → 0.3.1

package/dist/eval/live/alfworld.js

@@ -0,0 +1,637 @@
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createTask, createTrajectory, createStep, successOutcome, failureOutcome, } from '../../types/index.js';
+import { EnvBridge, resolveBridgeCommand } from './env-bridge.js';
+import { runClaude } from './claude-cli.js';
+import { seededRng } from '../rng.js';
+import { classifyGoal } from '../retrieval/quality.js';
+import { TASK_TYPES } from '../retrieval/corpus.js';
+import { runRefineStep, createMemoryRefineHooks } from './refine.js';
+/**
+ * Build the Curriculum-1 recurrence-ladder ordering given per-type game pools.
+ *
+ * - BLOCK phase  : for each type (sorted), repeat `blockRun` consecutive same-type
+ *                  tasks before moving to the next type; cycles until blockCount filled.
+ * - INTERLEAVE   : round-robin across types (one per type per round) for interleaveCount tasks.
+ * - PROBE        : one distinct unseen game id per type (6 total by default),
+ *                  drawn from ids NOT used in block/interleave.
+ *
+ * No game id appears more than once across the full ladder. Deterministic given seed.
+ *
+ * @param gamesByType  Map from TaskType to seed-shuffled game id pool (deepcopied internally).
+ * @param opts         Phase-size and seed options.
+ * @returns            Ordered list of LadderEntry (length ≤ total, may be less if pool exhausted).
+ */
+export function buildRecurrenceLadder(gamesByType, opts = {}) {
+    const total = opts.total ?? 36;
+    const blockRun = opts.blockRun ?? 3;
+    const numTypes = TASK_TYPES.length; // 6
+    // Derive phase sizes from design-doc 50%/33%/17% split.
+    const rawBlock = Math.floor(total / 2);
+    const blockCount = opts.blockCount ?? Math.floor(rawBlock / blockRun) * blockRun;
+    const interleaveCount = opts.interleaveCount ?? Math.floor(total / 3);
+    // probe = one per type, but bounded by remaining budget
+    const probeCount = Math.min(numTypes, total - blockCount - interleaveCount);
+    // Deep-copy buckets so we don't mutate the caller's maps.
+    const buckets = new Map();
+    for (const t of TASK_TYPES) {
+        buckets.set(t, [...(gamesByType.get(t) ?? [])]);
+    }
+    // Shuffle each bucket with the provided seed so draws are deterministic.
+    const rng = seededRng('recurrence-ladder', opts.seed ?? 1);
+    for (const arr of buckets.values()) {
+        for (let i = arr.length - 1; i > 0; i--) {
+            const j = Math.floor(rng() * (i + 1));
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+        }
+    }
+    const used = new Set();
+    const out = [];
+    // Helper: pop the next unseen id from a type's bucket.
+    function nextId(type) {
+        const arr = buckets.get(type);
+        while (arr.length > 0) {
+            const id = arr.pop();
+            if (!used.has(id))
+                return id;
+        }
+        return undefined;
+    }
+    // --- BLOCK phase ---
+    const types = [...TASK_TYPES].sort(); // stable ordering
+    let typeIdx = 0;
+    while (out.length < blockCount) {
+        const type = types[typeIdx % types.length];
+        let added = 0;
+        while (added < blockRun && out.length < blockCount) {
+            const id = nextId(type);
+            if (id === undefined)
+                break;
+            used.add(id);
+            out.push({ gameId: id, phase: 'block', taskType: type });
+            added++;
+        }
+        typeIdx++;
+        // Stop if all types exhausted
+        if (typeIdx > 0 && typeIdx % types.length === 0) {
+            // Check if any type still has ids
+            const anyLeft = types.some((t) => (buckets.get(t)?.length ?? 0) > 0);
+            if (!anyLeft)
+                break;
+        }
+    }
+    // --- INTERLEAVE phase ---
+    let interleaved = 0;
+    let rounds = 0;
+    // Shuffle type order for interleave with a separate rng draw
+    const interleaveTypes = [...types];
+    for (let i = interleaveTypes.length - 1; i > 0; i--) {
+        const j = Math.floor(rng() * (i + 1));
+        [interleaveTypes[i], interleaveTypes[j]] = [interleaveTypes[j], interleaveTypes[i]];
+    }
+    while (interleaved < interleaveCount) {
+        let progressed = false;
+        for (const type of interleaveTypes) {
+            if (interleaved >= interleaveCount)
+                break;
+            const id = nextId(type);
+            if (id !== undefined) {
+                used.add(id);
+                out.push({ gameId: id, phase: 'interleave', taskType: type });
+                interleaved++;
+                progressed = true;
+            }
+        }
+        rounds++;
+        if (!progressed || rounds > 1000)
+            break;
+    }
+    // --- PROBE phase ---
+    // One distinct UNSEEN id per type. Probe ids must not be in `used`.
+    for (const type of types) {
+        if (out.filter((e) => e.phase === 'probe').length >= probeCount)
+            break;
+        const id = nextId(type);
+        if (id !== undefined) {
+            used.add(id);
+            out.push({ gameId: id, phase: 'probe', taskType: type });
+        }
+    }
+    return out;
+}
+/**
+ * ALFWorld — text-based embodied household tasks. The canonical learning-curve
+ * benchmark used by Reflexion / ExpeL / Evo-Memory, so results are directly
+ * comparable to that literature. **Interactive** (multi-turn): the agent issues
+ * one text action per step and gets an observation back; the environment
+ * provides a binary success reward (no LLM judge).
+ *
+ * ALFWorld is a Python package, so this adapter talks to a small Python bridge
+ * (`bridges/alfworld_bridge.py`) over JSONL. It is **opt-in**: you must
+ * `pip install alfworld && alfworld-download` and point ALFWORLD_BRIDGE at the
+ * script (or have `python3` + the script on the default path). See EVALUATION.md
+ * §"ALFWorld setup". If the bridge can't start, loadTasks throws a clear error
+ * rather than pretending to run.
+ */
+export class AlfworldBenchmark {
+    name = 'alfworld';
+    interactive = true;
+    // The TextWorld python bridge leaks multiprocessing semaphores and dies when
+    // run concurrently (4-wide crashed most cold episodes into env_error). Force
+    // sequential episodes for this benchmark regardless of --concurrency.
+    maxConcurrency = 1;
+    bridge = null;
+    maxSteps;
+    reinject;
+    stratified;
+    refine;
+    /** 'recurrence-ladder' enables Curriculum-1 ordering; undefined = default. */
+    curriculum;
+    /**
+     * When set, loadTasks returns exactly these game indices (in order) instead
+     * of the first-N or stratified selection. Used by the oracle smoke harness to
+     * guarantee the learning arm runs the exact games the oracle playbooks solve.
+     */
+    gameIndices;
+    /** Cache of peeked goals by gameId so a second arm doesn't re-reset (each
+     * reset is a TextWorld env init — halving them adds resource-leak margin). */
+    goalCache = new Map();
+    constructor(opts = {}) {
+        this.maxSteps = opts.maxSteps ?? 30;
+        this.reinject = opts.reinject ?? true;
+        this.stratified = opts.stratified ?? false;
+        this.refine = opts.refine ?? false;
+        this.curriculum = opts.curriculum;
+        this.gameIndices = opts.gameIndices ?? null;
+    }
+    /** Lazily start the bridge; surfaces a setup-friendly error on failure. */
+    async getBridge() {
+        if (this.bridge)
+            return this.bridge;
+        const here = dirname(fileURLToPath(import.meta.url));
+        const script = join(here, 'bridges', 'alfworld_bridge.py');
+        const { command, args } = resolveBridgeCommand(script);
+        const bridge = new EnvBridge(command, args);
+        try {
+            await bridge.start();
+        }
+        catch (err) {
+            throw new Error(`ALFWorld bridge failed to start (${err.message}).\n` +
+                `The ALFWorld live arm needs the Python env:\n` +
+                `  pip install alfworld && alfworld-download\n` +
+                `Then either ensure 'python3 ${script}' runs, or set ALFWORLD_BRIDGE\n` +
+                `to your bridge command. See EVALUATION.md "ALFWorld setup".`);
+        }
+        this.bridge = bridge;
+        return bridge;
+    }
+    /**
+     * Close the current bridge and start a fresh one. Used per-episode by the
+     * delegate: a long-lived bridge accumulates TextWorld resources across many
+     * init_env calls and dies silently mid-run (which then hangs/exits node since
+     * the in-flight request never resolves). Bounding each bridge process to a
+     * single episode sidesteps the accumulation entirely.
+     */
+    async freshBridge() {
+        await this.bridge?.close();
+        this.bridge = null;
+        return this.getBridge();
+    }
+    peekCount = 0;
+    /**
+     * Peek a game's goal (cached). Goal-aware retrieval keys on this. Restarts the
+     * bridge every 25 uncached resets so peeking a large pool (stratified) doesn't
+     * hit the TextWorld resource leak.
+     */
+    async peekGoal(gameId) {
+        if (this.goalCache.has(gameId))
+            return this.goalCache.get(gameId);
+        if (this.peekCount > 0 && this.peekCount % 25 === 0)
+            await this.freshBridge();
+        const bridge = await this.getBridge();
+        const obs = await bridge.reset(gameId);
+        this.peekCount++;
+        this.goalCache.set(gameId, parseGoal(obs.obs));
+        return this.goalCache.get(gameId);
+    }
+    async loadTasks(opts) {
+        const bridge = await this.getBridge();
+        const { tasks } = await bridge.listTasks();
+        // --games override: select exactly these game indices (oracle smoke harness).
+        // gameIndices are positions in the full task list, not game IDs.
+        if (this.gameIndices !== null) {
+            const selected = this.gameIndices.map((idx) => {
+                if (idx < 0 || idx >= tasks.length) {
+                    throw new Error(`--games index ${idx} is out of range (total games: ${tasks.length})`);
+                }
+                return tasks[idx];
+            });
+            return this.buildEvalTasks(selected);
+        }
+        if (this.curriculum === 'recurrence-ladder') {
+            // Curriculum-1: classify the pool, build the recurrence-ladder ordering,
+            // and tag each EvalTask with its phase + type.
+            const ladder = await this.recurrenceLadderSelect(tasks, opts.count, opts.seed);
+            return this.buildEvalTasksFromLadder(ladder);
+        }
+        if (this.stratified) {
+            // First-N games are skewed by task type (the OOD split is grouped), so
+            // optionally sample evenly across the 6 types for a representative subset.
+            const selected = await this.stratifiedSelect(tasks, opts.count, opts.seed);
+            return this.buildEvalTasks(selected);
+        }
+        return this.buildEvalTasks(tasks.slice(0, opts.count));
+    }
+    /** Build EvalTask[] from a plain ordered game-id list (no phase tagging). */
+    async buildEvalTasks(selected) {
+        const result = [];
+        for (let index = 0; index < selected.length; index++) {
+            const gameId = selected[index];
+            const goal = await this.peekGoal(gameId);
+            const task = createTask({
+                id: `alfworld-${index}`,
+                domain: 'embodied',
+                description: goal ?? `ALFWorld household task (game ${gameId})`,
+                metadata: { skillTag: 'alfworld', gameId, goal, evalIndex: index },
+            });
+            result.push({ task, skillTag: 'alfworld', index, coldProb: 0, warmProb: 0 });
+        }
+        return result;
+    }
+    /** Build EvalTask[] from ladder entries, tagging phase + taskType in metadata. */
+    async buildEvalTasksFromLadder(ladder) {
+        const result = [];
+        for (let index = 0; index < ladder.length; index++) {
+            const { gameId, phase, taskType } = ladder[index];
+            const goal = await this.peekGoal(gameId);
+            const task = createTask({
+                id: `alfworld-${index}`,
+                domain: 'embodied',
+                description: goal ?? `ALFWorld household task (game ${gameId})`,
+                metadata: {
+                    skillTag: 'alfworld',
+                    gameId,
+                    goal,
+                    evalIndex: index,
+                    curriculumPhase: phase,
+                    taskType,
+                },
+            });
+            result.push({ task, skillTag: 'alfworld', index, coldProb: 0, warmProb: 0 });
+        }
+        return result;
+    }
+    /**
+     * Classify a pool of game ids into per-type buckets by peeking each goal.
+     * Stops early once every type has `perType` ids to avoid peeking all 134.
+     */
+    async classifyGamePool(tasks, perType) {
+        const buckets = new Map();
+        const cap = Math.min(tasks.length, 134);
+        for (let i = 0; i < cap; i++) {
+            const type = classifyGoal((await this.peekGoal(tasks[i])) ?? '');
+            const arr = buckets.get(type) ?? buckets.set(type, []).get(type);
+            arr.push(tasks[i]);
+            if (buckets.size >= 6 && [...buckets.values()].every((a) => a.length >= perType))
+                break;
+        }
+        return buckets;
+    }
+    /**
+     * Select `count` games balanced across the 6 task types. Peeks a pool of
+     * games, classifies each by goal, deterministically shuffles each type bucket
+     * by seed, then round-robins across types. Falls back gracefully if a type is
+     * underrepresented in the pool.
+     */
+    async stratifiedSelect(tasks, count, seed) {
+        // OOD games are grouped by type, so peek incrementally and stop early once
+        // every type has enough — avoids peeking all 134 when types appear sooner.
+        const perType = Math.ceil(count / 6) + 1;
+        const buckets = await this.classifyGamePool(tasks, perType);
+        const rng = seededRng('alfworld-stratify', seed);
+        for (const arr of buckets.values()) {
+            for (let i = arr.length - 1; i > 0; i--) {
+                const j = Math.floor(rng() * (i + 1));
+                [arr[i], arr[j]] = [arr[j], arr[i]];
+            }
+        }
+        const types = [...buckets.keys()].sort();
+        const out = [];
+        while (out.length < count) {
+            let progressed = false;
+            for (const t of types) {
+                const arr = buckets.get(t);
+                if (arr.length) {
+                    out.push(arr.pop());
+                    progressed = true;
+                    if (out.length >= count)
+                        break;
+                }
+            }
+            if (!progressed)
+                break; // pool exhausted
+        }
+        return out;
+    }
+    /**
+     * Build a recurrence-ladder selection: classify the pool, then delegate to
+     * `buildRecurrenceLadder` for the block→interleave→probe ordering.
+     */
+    async recurrenceLadderSelect(tasks, count, seed) {
+        // Need enough ids per type to cover all three phases. A generous perType
+        // budget ensures the probe phase can always find a held-out id.
+        const perType = Math.ceil(count / 6) + 4;
+        const buckets = await this.classifyGamePool(tasks, perType);
+        return buildRecurrenceLadder(buckets, { total: count, seed });
+    }
+    /** Interactive scoring happens in the delegate loop; verify is a no-op. */
+    verify() {
+        return { correct: false };
+    }
+    /** Factory for the multi-turn delegate bound to this benchmark's bridge.
+     * Uses a FRESH bridge process per episode for resource robustness. */
+    delegateFactory = (_benchmark, opts) => {
+        return new AlfworldDelegate(() => this.freshBridge(), this.maxSteps, {
+            model: opts?.model,
+            timeoutMs: opts?.timeoutMs,
+            provider: opts?.provider,
+            awsRegion: opts?.awsRegion,
+            reinject: this.reinject,
+            // F4: refine enabled if either the benchmark constructor flag OR the
+            // LiveRunConfig.refine experiment flag is set. Both compose.
+            refine: this.refine || (opts?.refine ?? false),
+        });
+    };
+    async close() {
+        await this.bridge?.close();
+        this.bridge = null;
+    }
+}
+export function createAlfworldBenchmark(opts) {
+    return new AlfworldBenchmark(opts);
+}
+/**
+ * Directory of bundled ALFWorld recipe playbooks (B1 seeding). Resolved relative
+ * to this module so it works from both src (tests) and dist (CLI).
+ */
+export function alfworldSeedDir() {
+    return join(dirname(fileURLToPath(import.meta.url)), '../../../playbooks/alfworld');
+}
+/**
+ * Multi-turn delegate that drives one ALFWorld episode per task. Maintains the
+ * agent's conversation across steps via `claude --resume`, feeding each new
+ * observation back, until the environment reports done (or maxSteps).
+ */
+export class AlfworldDelegate {
+    getBridge;
+    maxSteps;
+    opts;
+    currentTask = null;
+    reinject;
+    refine;
+    historyWindow;
+    memory = null;
+    constructor(getBridge, maxSteps, opts = {}) {
+        this.getBridge = getBridge;
+        this.maxSteps = maxSteps;
+        this.opts = opts;
+        // B2: re-inject the retrieved recipes + curated recent history into EVERY
+        // step's prompt (ReMem-style), rather than only turn 1. Default on.
+        this.reinject = opts.reinject ?? true;
+        // B3: in-episode think-act-refine loop (prune misleading items). Default off.
+        this.refine = opts.refine ?? false;
+        this.historyWindow = opts.historyWindow ?? 10;
+        // Per-episode wall-clock budget. Without it a cold agent on a hard game
+        // wanders to maxSteps with slow/unbounded per-step CLI calls (×env_error
+        // retry), burning hours on one task. Default per-step timeout (or 90s) ×
+        // maxSteps, capped at 20 min — enough headroom for a real solve, hard stop
+        // on a runaway. Exceeding it ends the episode as a task failure (the agent
+        // simply didn't finish), NOT an env_error.
+        this.maxEpisodeMs =
+            opts.maxEpisodeMs ?? Math.min(20 * 60_000, (opts.timeoutMs ?? 90_000) * maxSteps);
+    }
+    maxEpisodeMs;
+    setCurrentTask(task) {
+        this.currentTask = task;
+    }
+    setMemory(memory) {
+        this.memory = memory;
+    }
+    async execute(prompt, options) {
+        const task = this.currentTask;
+        const gameId = String(task?.metadata?.gameId ?? '');
+        const goal = String(task?.metadata?.goal ?? prompt);
+        const knowledge = options.systemContext; // injected recipes + playbooks (Atlas)
+        const bridge = await this.getBridge();
+        const start = await bridge.reset(gameId);
+        const steps = [createStep({ action: 'reset', observation: start.obs })];
+        const history = [];
+        let sessionId;
+        let reward = 0;
+        let done = false;
+        let transcript = start.obs;
+        let obs = start.obs;
+        let admissible = start.admissible;
+        // B3: when refine is active, set up the curated working set (from the
+        // structured injected knowledge) + persistence hooks once per episode.
+        const refineActive = this.refine && !!this.memory && !!options.injectedKnowledge;
+        const trajId = crypto.randomUUID();
+        let working = refineActive ? toRefineItems(options.injectedKnowledge) : [];
+        const hooks = refineActive ? createMemoryRefineHooks(this.memory, trajId) : undefined;
+        const episodeStart = Date.now();
+        for (let i = 0; i < this.maxSteps && !done; i++) {
+            if (Date.now() - episodeStart > this.maxEpisodeMs) {
+                // Episode wall-clock budget exhausted — abandon as a task failure.
+                break;
+            }
+            let action;
+            try {
+                if (refineActive) {
+                    // Inner THINK/PRUNE/ACT loop; prunes curate `working` and persist.
+                    const step = await runRefineStep({
+                        working,
+                        buildPrompt: (w, trace) => buildRefinePrompt({
+                            working: w,
+                            trace,
+                            goal,
+                            history: history.slice(-this.historyWindow),
+                            obs,
+                            admissible,
+                        }),
+                        callAgent: (p) => runClaude(p, {
+                            model: this.opts.model,
+                            timeoutMs: this.opts.timeoutMs,
+                            provider: this.opts.provider,
+                            awsRegion: this.opts.awsRegion,
+                            bedrock: this.opts.bedrock,
+                        }).then((r) => r.text),
+                        hooks,
+                        maxInner: 3,
+                    });
+                    working = step.working;
+                    action = step.command;
+                }
+                else if (this.reinject) {
+                    // Structured prompt, full context every step (no --resume): the recipe
+                    // stays in front of the agent instead of decaying into buried history.
+                    const res = await runClaude(buildStructuredPrompt({
+                        knowledge,
+                        goal,
+                        history: history.slice(-this.historyWindow),
+                        obs,
+                        admissible,
+                    }), {
+                        model: this.opts.model,
+                        timeoutMs: this.opts.timeoutMs,
+                        provider: this.opts.provider,
+                        awsRegion: this.opts.awsRegion,
+                        bedrock: this.opts.bedrock,
+                    });
+                    action = firstActionLine(res.text);
+                }
+                else {
+                    // Ablation/legacy path: knowledge on turn 1 only, observation-only after,
+                    // relying on `claude --resume` to carry context.
+                    const stepPrompt = i === 0
+                        ? [knowledge, goal].filter(Boolean).join('\n\n') +
+                            `\n\nYou are in a text world. Respond with EXACTLY ONE admissible action.\n` +
+                            observationBlock(obs, admissible)
+                        : observationBlock(obs, admissible);
+                    const res = await runClaude(stepPrompt, {
+                        model: this.opts.model,
+                        timeoutMs: this.opts.timeoutMs,
+                        resumeSessionId: sessionId,
+                        bedrock: this.opts.bedrock,
+                        awsRegion: this.opts.awsRegion,
+                    });
+                    sessionId = res.sessionId ?? sessionId;
+                    action = firstActionLine(res.text);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (/timed? out|timeout/i.test(msg)) {
+                    // A per-step CLI timeout is the agent being slow, not infra dying.
+                    // End the episode as a failure instead of letting it bubble up to a
+                    // task-level env_error + whole-task retry — that amplifier is what
+                    // turned stuck episodes into multi-hour reruns. Genuine infra errors
+                    // (dead bridge, spawn failure) still propagate.
+                    break;
+                }
+                throw err;
+            }
+            const stepObs = await bridge.step(action);
+            reward = stepObs.reward ?? reward;
+            done = stepObs.done ?? false;
+            obs = stepObs.obs;
+            admissible = stepObs.admissible;
+            history.push({ action, obs });
+            steps.push(createStep({ action, observation: obs }));
+            transcript += `\n> ${action}\n${obs}`;
+        }
+        const success = reward >= 1;
+        const trajectory = createTrajectory({
+            task: task ?? createTask({ domain: 'embodied', description: gameId }),
+            steps,
+            outcome: success
+                ? successOutcome(transcript)
+                : failureOutcome(`ALFWorld episode ended without success (reward=${reward})`),
+            agentId: 'alfworld-delegate',
+        });
+        return { success, output: transcript, trajectory };
+    }
+}
+/** Map Atlas's structured retrieval result into prunable refine items. */
+function toRefineItems(knowledge) {
+    const items = [];
+    for (const { playbook } of knowledge.playbooks) {
+        items.push({ id: playbook.id, kind: 'playbook', label: playbook.name });
+    }
+    for (const { experience } of knowledge.experiences) {
+        items.push({
+            id: experience.id,
+            kind: 'experience',
+            label: experience.taskInput.slice(0, 120),
+        });
+    }
+    return items;
+}
+/**
+ * Per-iteration prompt for the B3 refine loop. Renders the curated working set
+ * as a numbered list (so PRUNE ids map to it) + goal/history/observation, and
+ * asks for exactly one of THINK / PRUNE / ACT.
+ */
+export function buildRefinePrompt(p) {
+    const sections = ['You are an agent in a text-world household environment (ALFWorld).'];
+    if (p.working.length) {
+        const list = p.working.map((it, i) => `${i + 1}. [${it.kind}] ${it.label}`).join('\n');
+        sections.push(`## Retrieved guidance (you may prune misleading items)\n${list}`);
+    }
+    sections.push(`## Your task\n${p.goal}`);
+    if (p.history.length) {
+        sections.push(`## Recent history (most recent last)\n` +
+            p.history.map((h) => `> ${h.action}\n${h.obs}`).join('\n'));
+    }
+    if (p.trace.length)
+        sections.push(`## Your reasoning so far\n${p.trace.join('\n')}`);
+    sections.push(`## Current observation\n${p.obs}` +
+        (p.admissible && p.admissible.length
+            ? `\nAdmissible actions: ${p.admissible.join(' | ')}`
+            : ''));
+    sections.push('Respond with EXACTLY ONE of:\n' +
+        '  Think: <reasoning>            (to reason before acting)\n' +
+        "  Prune: <ids>                  (drop misleading guidance, e.g. '1' or '2-3')\n" +
+        '  Action: <one admissible action>');
+    return sections.join('\n\n');
+}
+/**
+ * Extract the task goal from an ALFWorld reset observation, which ends with
+ * "Your task is to: <goal>". Returns undefined if not found.
+ */
+export function parseGoal(obs) {
+    const m = obs.match(/your task is to:\s*(.+?)\s*$/is);
+    if (!m)
+        return undefined;
+    // Take the first line of the goal, trimmed of trailing punctuation noise.
+    return m[1].split('\n')[0].trim() || undefined;
+}
+/**
+ * ReMem-style structured per-step prompt (B2). Re-surfaces the retrieved
+ * recipes/playbooks + a curated recent-history window every step so the agent
+ * keeps the recipe in view rather than relying on it being buried in turn 1.
+ */
+export function buildStructuredPrompt(p) {
+    const sections = [
+        'You are an agent in a text-world household environment (ALFWorld). ' +
+            'Respond with EXACTLY ONE admissible action and nothing else.',
+    ];
+    if (p.knowledge)
+        sections.push(`## Relevant recipes and past experience\n${p.knowledge}`);
+    sections.push(`## Your task\n${p.goal}`);
+    if (p.history.length) {
+        const lines = p.history.map((h) => `> ${h.action}\n${h.obs}`).join('\n');
+        sections.push(`## Recent history (most recent last)\n${lines}`);
+    }
+    sections.push(`## Current observation\n${p.obs}` +
+        (p.admissible && p.admissible.length
+            ? `\nAdmissible actions: ${p.admissible.join(' | ')}`
+            : '') +
+        `\n\nYour action:`);
+    return sections.join('\n\n');
+}
+/** Format an observation + admissible-actions block for the next agent turn. */
+function observationBlock(obs, admissible) {
+    return (`Observation: ${obs}\n` +
+        (admissible && admissible.length ? `Admissible actions: ${admissible.join(' | ')}\n` : '') +
+        `Your action:`);
+}
+/** ALFWorld expects a single action string; take the first non-empty line. */
+function firstActionLine(text) {
+    const line = text
+        .split('\n')
+        .map((l) => l.trim())
+        .find((l) => l.length > 0);
+    // Strip a leading "Action:"/"> " prefix if the model added one.
+    return (line ?? 'look').replace(/^(action:|>\s*)/i, '').trim();
+}
+//# sourceMappingURL=alfworld.js.map