cognitive-core 0.2.4 → 0.3.1

package/dist/eval/live/skill-injector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-injector.js","sourceRoot":"","sources":["../../../src/eval/live/skill-injector.ts"],"names":[],"mappings":"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"}

package/dist/eval/live/skillflow-embedded-workbook-bundle.d.ts

@@ -0,0 +1,3 @@
+import type { SkillBundle } from '../skill-bundle.js';
+export declare function createEmbeddedWorkbookSkillBundle(): SkillBundle;
+//# sourceMappingURL=skillflow-embedded-workbook-bundle.d.ts.map

package/dist/eval/live/skillflow-embedded-workbook-bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillflow-embedded-workbook-bundle.d.ts","sourceRoot":"","sources":["../../../src/eval/live/skillflow-embedded-workbook-bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,wBAAgB,iCAAiC,IAAI,WAAW,CAkC/D"}

package/dist/eval/live/skillflow-embedded-workbook-bundle.js

@@ -0,0 +1,391 @@
+export function createEmbeddedWorkbookSkillBundle() {
+    return {
+        name: 'office-embedded-workbook-correction',
+        description: 'Repair embedded Excel workbooks inside Office files while preserving the outer document package and workbook formulas.',
+        instructions: [
+            'MANDATORY when an Office file (PPTX/DOCX) has an embedded Excel workbook: drive the edit with the bundled `embedded_workbook_tools.py`. Do NOT hand-edit the zip/XML, openpyxl-rewrite the file yourself, or rebuild the document — those leave stale formula caches and FAIL the verifier.',
+            '',
+            'STEP 1 — always start here. Inspect the structure (embedded workbook, sheets, and which cells are formulas):',
+            '  python resources/embedded_workbook_tools.py inspect --office /root/input.pptx',
+            '',
+            'STEP 2 — pick the path by task shape:',
+            '',
+            '➤ RATE / CROSS-RATE / RECIPROCAL / FX-MATRIX tasks — i.e. a currency or rate matrix, or any cell that should equal 1/(another cell). Use `fix-matrix`. It reads the slide note, locates the matrix, patches the WRITABLE input cell, and recalculates. This is the ONLY reliable path for these; patching a formula cell by hand WILL fail. `fx-cross-rate`-style tasks belong here.',
+            '  python resources/embedded_workbook_tools.py fix-matrix --office /root/input.pptx --out /root/results.pptx',
+            '  # if note auto-detection is uncertain, read the note yourself and pass it:',
+            '  python resources/embedded_workbook_tools.py fix-matrix --office /root/input.pptx --out /root/results.pptx --from EUR --to GBP --rate 0.8645',
+            '',
+            '➤ Plain single-cell value edits — `patch` the WRITABLE input cell (never a formula cell); it recalculates dependents automatically:',
+            '  python resources/embedded_workbook_tools.py patch --office /root/input.pptx --sheet "FX Matrix" --cell D5 --value 1.1567 --out /root/results.pptx',
+            '',
+            'STEP 3 — always verify before you finish (reads the cached value the grader reads):',
+            '  python resources/embedded_workbook_tools.py verify --office /root/results.pptx --sheet "FX Matrix" --cell E4 --expected 0.8645',
+            '',
+            'Why this is mandatory: the grader reads CACHED formula values (openpyxl `data_only=True`). If you edit a value but do not recalculate, a dependent formula like an inverse `=1/D5` keeps its OLD cached number and the task fails. These tools recalculate with LibreOffice and replace only the embedded workbook bytes; keep formulas as formulas and patch the input cell that feeds them.',
+        ].join('\n'),
+        files: [
+            {
+                path: 'resources/embedded_workbook_tools.py',
+                executable: true,
+                content: EMBEDDED_WORKBOOK_TOOLS,
+            },
+        ],
+    };
+}
+const EMBEDDED_WORKBOOK_TOOLS = String.raw `#!/usr/bin/env python3
+"""Repair embedded Excel workbooks inside Office (PPTX/DOCX) files.
+
+Edits go through openpyxl (formula-preserving) and an optional LibreOffice
+recalculation, so dependent formula cells get fresh CACHED values — which is what
+data_only verifiers read. Only the embedded workbook bytes are replaced; the rest
+of the Office package is left byte-for-byte identical.
+"""
+import argparse
+import io
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import zipfile
+import xml.etree.ElementTree as ET
+
+from openpyxl import load_workbook
+
+A_NS = "{http://schemas.openxmlformats.org/drawingml/2006/main}"
+PREFER = ("final", "approved", "live", "current")
+IGNORE = ("archive", "archived", "superseded", "draft", "obsolete")
+NOTE_RE = re.compile(r"([A-Za-z0-9]+)\s+to\s+([A-Za-z0-9]+)\s*=\s*([0-9]+(?:\.[0-9]+)?)", re.IGNORECASE)
+
+
+def is_formula(v):
+    return isinstance(v, str) and v.startswith("=")
+
+
+def normalize(text):
+    return "".join(ch.lower() for ch in str(text) if ch.isalnum())
+
+
+def token_matches(value, token):
+    return value is not None and normalize(token) in normalize(value)
+
+
+def coerce(value):
+    s = str(value)
+    try:
+        f = float(s)
+    except ValueError:
+        return value
+    if f.is_integer() and "." not in s and "e" not in s.lower():
+        return int(f)
+    return f
+
+
+def list_embedded(office):
+    with zipfile.ZipFile(office) as zf:
+        return sorted(
+            n for n in zf.namelist()
+            if n.lower().endswith((".xlsx", ".xlsm")) and "embeddings/" in n.lower()
+        )
+
+
+def resolve_embedded(office, embedded):
+    found = list_embedded(office)
+    if embedded:
+        if embedded in found:
+            return embedded
+        for n in found:
+            if n.endswith("/" + embedded) or os.path.basename(n) == embedded:
+                return n
+        raise SystemExit("embedded workbook not found: %s; available: %s" % (embedded, found))
+    if len(found) == 1:
+        return found[0]
+    if not found:
+        raise SystemExit("no embedded workbook found in %s" % office)
+    raise SystemExit("multiple embedded workbooks; pass --embedded one of: %s" % found)
+
+
+def extract_embedded(office, name):
+    with zipfile.ZipFile(office) as zf:
+        return zf.read(name)
+
+
+def reembed(office, name, data, out):
+    with zipfile.ZipFile(office) as zin, zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as zout:
+        for info in zin.infolist():
+            zout.writestr(info, data if info.filename == name else zin.read(info.filename))
+
+
+def slide_text_chunks(office):
+    chunks = []
+    with zipfile.ZipFile(office) as zf:
+        names = sorted(n for n in zf.namelist() if re.match(r"ppt/slides/slide\d+\.xml$", n))
+        for n in names:
+            root = ET.fromstring(zf.read(n))
+            for node in root.iter(A_NS + "t"):
+                text = (node.text or "").strip()
+                for part in re.split(r"\|\||\n", text):
+                    part = part.strip()
+                    if part:
+                        chunks.append(part)
+    return chunks
+
+
+def setup_libreoffice_macro():
+    macro_dir = os.path.expanduser("~/.config/libreoffice/4/user/basic/Standard")
+    macro_file = os.path.join(macro_dir, "Module1.xba")
+    if os.path.exists(macro_file):
+        with open(macro_file) as f:
+            if "RecalculateAndSave" in f.read():
+                return True
+    try:
+        if not os.path.exists(macro_dir):
+            subprocess.run(["soffice", "--headless", "--terminate_after_init"],
+                           capture_output=True, timeout=60)
+            os.makedirs(macro_dir, exist_ok=True)
+    except FileNotFoundError:
+        return False
+    macro = (
+        '<?xml version="1.0" encoding="UTF-8"?>\n'
+        '<!DOCTYPE script:module PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "module.dtd">\n'
+        '<script:module xmlns:script="http://openoffice.org/2000/script" '
+        'script:name="Module1" script:language="StarBasic">\n'
+        "Sub RecalculateAndSave()\n"
+        "  ThisComponent.calculateAll()\n"
+        "  ThisComponent.store()\n"
+        "  ThisComponent.close(True)\n"
+        "End Sub\n"
+        "</script:module>\n"
+    )
+    try:
+        with open(macro_file, "w") as f:
+            f.write(macro)
+    except OSError:
+        return False
+    return True
+
+
+def recalc_bytes(xlsx_bytes, timeout=90):
+    if not setup_libreoffice_macro():
+        sys.stderr.write("WARNING: LibreOffice unavailable; skipping recalculation (formula caches may be stale)\n")
+        return xlsx_bytes
+    with tempfile.TemporaryDirectory() as d:
+        path = os.path.join(d, "wb.xlsx")
+        with open(path, "wb") as f:
+            f.write(xlsx_bytes)
+        cmd = ["soffice", "--headless", "--norestore",
+               "vnd.sun.star.script:Standard.Module1.RecalculateAndSave?language=Basic&location=application",
+               os.path.abspath(path)]
+        if sys.platform.startswith("linux"):
+            cmd = ["timeout", str(timeout)] + cmd
+        try:
+            r = subprocess.run(cmd, capture_output=True, text=True)
+        except FileNotFoundError:
+            sys.stderr.write("WARNING: soffice not found; skipping recalculation\n")
+            return xlsx_bytes
+        if r.returncode not in (0, 124):
+            sys.stderr.write("WARNING: recalc exited %s: %s\n" % (r.returncode, (r.stderr or "")[:300]))
+        with open(path, "rb") as f:
+            return f.read()
+
+
+def open_wb(xlsx_bytes, data_only=False):
+    return load_workbook(io.BytesIO(xlsx_bytes), data_only=data_only)
+
+
+def locate_matrix(ws, from_token, to_token):
+    for arow in range(1, ws.max_row + 1):
+        for acol in range(1, ws.max_column + 1):
+            rows = {r: ws.cell(row=r, column=acol).value for r in range(arow + 1, ws.max_row + 1)
+                    if ws.cell(row=r, column=acol).value not in (None, "")}
+            cols = {c: ws.cell(row=arow, column=c).value for c in range(acol + 1, ws.max_column + 1)
+                    if ws.cell(row=arow, column=c).value not in (None, "")}
+            if len(rows) < 2 or len(cols) < 2:
+                continue
+            fr = [r for r, v in rows.items() if token_matches(v, from_token)]
+            tr = [r for r, v in rows.items() if token_matches(v, to_token)]
+            fc = [c for c, v in cols.items() if token_matches(v, from_token)]
+            tc = [c for c, v in cols.items() if token_matches(v, to_token)]
+            for from_row in fr:
+                for to_row in tr:
+                    for from_col in fc:
+                        for to_col in tc:
+                            if ws.cell(row=from_row, column=to_col).value is None:
+                                continue
+                            if ws.cell(row=to_row, column=from_col).value is None:
+                                continue
+                            return {"from_row": from_row, "to_row": to_row,
+                                    "from_col": from_col, "to_col": to_col}
+    return None
+
+
+def parse_note(chunks):
+    cands = []
+    for i, chunk in enumerate(chunks):
+        m = NOTE_RE.search(chunk)
+        if not m:
+            continue
+        low = chunk.lower()
+        score = (5 if any(p in low for p in PREFER) else 0) - (5 if any(g in low for g in IGNORE) else 0)
+        cands.append((score, i, m.group(1), m.group(2), float(m.group(3))))
+    if not cands:
+        raise SystemExit("no 'FROM to TO = RATE' correction found in slide text; pass --from/--to/--rate")
+    cands.sort(key=lambda c: (c[0], c[1]))
+    _, _, f, t, r = cands[-1]
+    return f, t, r
+
+
+def cmd_inspect(args):
+    names = list_embedded(args.office)
+    print(json.dumps({"embedded": names}, indent=2))
+    if not names:
+        return
+    if not (args.embedded or len(names) == 1):
+        sys.stderr.write("multiple embedded workbooks; pass --embedded to inspect cells\n")
+        return
+    target = resolve_embedded(args.office, args.embedded)
+    wb = open_wb(extract_embedded(args.office, target))
+    out = {"workbook": target, "sheets": []}
+    for ws in wb.worksheets:
+        if args.sheet and ws.title != args.sheet:
+            continue
+        cells = {}
+        for row in ws.iter_rows():
+            for c in row:
+                if c.value is None:
+                    continue
+                cells[c.coordinate] = ("FORMULA " + c.value) if is_formula(c.value) else c.value
+        out["sheets"].append({"name": ws.title, "dimensions": ws.dimensions, "cells": cells})
+    print(json.dumps(out, indent=2, default=str))
+
+
+def cmd_patch(args):
+    name = resolve_embedded(args.office, args.embedded)
+    wb = open_wb(extract_embedded(args.office, name))
+    ws = wb[args.sheet] if args.sheet else wb.active
+    if is_formula(ws[args.cell].value):
+        sys.stderr.write(
+            "WARNING: %s is a formula (%r). Patch the writable INPUT cell that feeds it instead.\n"
+            % (args.cell, ws[args.cell].value)
+        )
+    ws[args.cell] = coerce(args.value)
+    buf = io.BytesIO()
+    wb.save(buf)
+    data = buf.getvalue() if args.no_recalc else recalc_bytes(buf.getvalue())
+    reembed(args.office, name, data, args.out)
+    print("patched %s!%s!%s = %s (recalc=%s) -> %s" %
+          (name, ws.title, args.cell, args.value, "no" if args.no_recalc else "yes", args.out))
+
+
+def cmd_recalc(args):
+    name = resolve_embedded(args.office, args.embedded)
+    data = recalc_bytes(extract_embedded(args.office, name))
+    reembed(args.office, name, data, args.out)
+    print("recalculated %s -> %s" % (name, args.out))
+
+
+def cmd_fix_matrix(args):
+    if args.rate is not None and args.from_token and args.to_token:
+        from_token, to_token, rate = args.from_token, args.to_token, float(args.rate)
+    else:
+        from_token, to_token, rate = parse_note(slide_text_chunks(args.office))
+    name = resolve_embedded(args.office, args.embedded)
+    wb = open_wb(extract_embedded(args.office, name))
+    sheets = [wb[args.sheet]] if args.sheet else list(wb.worksheets)
+    matrix, ws = None, None
+    for cand in sheets:
+        matrix = locate_matrix(cand, from_token, to_token)
+        if matrix:
+            ws = cand
+            break
+    if matrix is None:
+        raise SystemExit("could not locate a %s/%s reciprocal matrix" % (from_token, to_token))
+    direct = ws.cell(row=matrix["from_row"], column=matrix["to_col"])
+    inverse = ws.cell(row=matrix["to_row"], column=matrix["from_col"])
+    if not is_formula(direct.value):
+        direct.value = rate
+        edited = direct.coordinate
+    elif not is_formula(inverse.value):
+        inverse.value = 1.0 / rate
+        edited = inverse.coordinate
+    else:
+        raise SystemExit("both %s (direct) and %s (inverse) are formulas; no writable input cell" %
+                         (direct.coordinate, inverse.coordinate))
+    buf = io.BytesIO()
+    wb.save(buf)
+    data = recalc_bytes(buf.getvalue())
+    reembed(args.office, name, data, args.out)
+    print("fix-matrix %s->%s=%s: edited writable cell %s on sheet %r -> %s" %
+          (from_token, to_token, rate, edited, ws.title, args.out))
+
+
+def cmd_verify(args):
+    name = resolve_embedded(args.office, args.embedded)
+    wb = open_wb(extract_embedded(args.office, name), data_only=True)
+    ws = wb[args.sheet] if args.sheet else wb.active
+    actual = ws[args.cell].value
+    if args.expected is not None:
+        try:
+            if abs(float(actual) - float(args.expected)) < 1e-4:
+                print("%s=%s (ok)" % (args.cell, actual))
+                return
+        except (TypeError, ValueError):
+            pass
+        if str(actual) != str(args.expected):
+            raise SystemExit("%s: expected %r, got %r" % (args.cell, args.expected, actual))
+    print("%s=%s" % (args.cell, actual))
+
+
+def main(argv):
+    p = argparse.ArgumentParser(description="Repair embedded Excel workbooks inside Office files.")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    ins = sub.add_parser("inspect")
+    ins.add_argument("--office", required=True)
+    ins.add_argument("--embedded")
+    ins.add_argument("--sheet")
+    ins.set_defaults(func=cmd_inspect)
+
+    pa = sub.add_parser("patch")
+    pa.add_argument("--office", required=True)
+    pa.add_argument("--embedded")
+    pa.add_argument("--sheet")
+    pa.add_argument("--cell", required=True)
+    pa.add_argument("--value", required=True)
+    pa.add_argument("--out", required=True)
+    pa.add_argument("--no-recalc", action="store_true")
+    pa.set_defaults(func=cmd_patch)
+
+    rc = sub.add_parser("recalc")
+    rc.add_argument("--office", required=True)
+    rc.add_argument("--embedded")
+    rc.add_argument("--out", required=True)
+    rc.set_defaults(func=cmd_recalc)
+
+    fm = sub.add_parser("fix-matrix")
+    fm.add_argument("--office", required=True)
+    fm.add_argument("--out", required=True)
+    fm.add_argument("--embedded")
+    fm.add_argument("--sheet")
+    fm.add_argument("--from", dest="from_token")
+    fm.add_argument("--to", dest="to_token")
+    fm.add_argument("--rate")
+    fm.set_defaults(func=cmd_fix_matrix)
+
+    ve = sub.add_parser("verify")
+    ve.add_argument("--office", required=True)
+    ve.add_argument("--embedded")
+    ve.add_argument("--sheet")
+    ve.add_argument("--cell", required=True)
+    ve.add_argument("--expected")
+    ve.set_defaults(func=cmd_verify)
+
+    args = p.parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
+`;
+//# sourceMappingURL=skillflow-embedded-workbook-bundle.js.map

package/dist/eval/live/skillflow-embedded-workbook-bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillflow-embedded-workbook-bundle.js","sourceRoot":"","sources":["../../../src/eval/live/skillflow-embedded-workbook-bundle.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,iCAAiC;IAC/C,OAAO;QACL,IAAI,EAAE,qCAAqC;QAC3C,WAAW,EACT,wHAAwH;QAC1H,YAAY,EAAE;YACZ,6RAA6R;YAC7R,EAAE;YACF,8GAA8G;YAC9G,iFAAiF;YACjF,EAAE;YACF,uCAAuC;YACvC,EAAE;YACF,sXAAsX;YACtX,6GAA6G;YAC7G,8EAA8E;YAC9E,+IAA+I;YAC/I,EAAE;YACF,qIAAqI;YACrI,qJAAqJ;YACrJ,EAAE;YACF,qFAAqF;YACrF,kIAAkI;YAClI,EAAE;YACF,+XAA+X;SAChY,CAAC,IAAI,CAAC,IAAI,CAAC;QACZ,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,sCAAsC;gBAC5C,UAAU,EAAE,IAAI;gBAChB,OAAO,EAAE,uBAAuB;aACjC;SACF;KACF,CAAC;AACJ,CAAC;AAED,MAAM,uBAAuB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmWzC,CAAC"}

package/dist/eval/live/skillflow.d.ts

@@ -0,0 +1,154 @@
+import { type Task } from '../../types/index.js';
+import type { EvalTask } from '../types.js';
+import type { ExtendedLiveBenchmark, BenchmarkVerdict } from './live-benchmark.js';
+import type { BenchmarkDelegate } from './live-runner.js';
+import { EnvBridge } from './env-bridge.js';
+import { type Logger } from '../../utils/logger.js';
+/**
+ * SkillFlow — 166 tasks across 5 domains (Finance, Ops, Healthcare, Gov, Data),
+ * ordered by difficulty within 20 task families.
+ *
+ * The most important benchmark for ccore: it directly tests the loop ccore is
+ * built for (solve → learn → inject → solve harder tasks). Each family has
+ * tasks of increasing difficulty, and success on later tasks should benefit from
+ * experience accumulated on earlier ones.
+ *
+ * Interactive (multi-turn): the agent sends shell commands or code inside a
+ * persistent Docker container (built from the task's Dockerfile, launched with
+ * --network none so the agent cannot reach the oracle). After the episode ends
+ * (DONE sentinel or maxSteps), the bridge commits the agent container, runs a
+ * disposable verify container with /tests:ro + /logs mounts, and reads
+ * reward.txt for the pass/fail signal.
+ *
+ * Environment variables:
+ *   SKILLFLOW_BRIDGE — command to start the bridge process
+ *                      (default: python3 <bundled>/bridges/skillflow_bridge.py)
+ *   SKILLFLOW_RUNTIME — docker | e2b (default docker)
+ *   SKILLFLOW_REPO   — path to the cloned SkillFlow repository
+ */
+export interface SkillFlowTaskInfo {
+    id: string;
+    family: string;
+    domain: string;
+    difficulty: number;
+    description?: string;
+}
+export declare class SkillFlowBenchmark implements ExtendedLiveBenchmark {
+    readonly name = "skillflow";
+    readonly interactive = true;
+    readonly preserveOrder = true;
+    readonly playbookMinTrajectories = 3;
+    readonly maxConcurrency = 1;
+    private bridge;
+    private readonly maxSteps;
+    private readonly reinject;
+    private readonly historyWindow;
+    private readonly families?;
+    private readonly runtime?;
+    private readonly embeddedWorkbookBundle;
+    constructor(opts?: {
+        maxSteps?: number;
+        reinject?: boolean;
+        historyWindow?: number;
+        families?: string[];
+        runtime?: string;
+        embeddedWorkbookBundle?: boolean;
+    });
+    setup(): Promise<void>;
+    teardown(): Promise<void>;
+    private getBridge;
+    freshBridge(): Promise<EnvBridge>;
+    loadTasks(opts: {
+        count: number;
+        seed: number;
+    }): Promise<EvalTask[]>;
+    verify(_task: Task, _output: string): BenchmarkVerdict;
+    delegateFactory: (_benchmark: ExtendedLiveBenchmark, opts?: {
+        model?: string;
+        timeoutMs?: number;
+        provider?: string;
+        awsRegion?: string;
+        cliRetries?: number;
+    }) => BenchmarkDelegate;
+}
+/**
+ * Hard wall-clock ceiling for a single SkillFlow episode (see the episode cap at
+ * `maxEpisodeMs` in the delegate). The e2b sandbox must outlive this, plus setup,
+ * verify, and inter-op gaps, or it gets reaped mid-episode → "sandbox was not
+ * found" env_errors.
+ */
+export declare const SKILLFLOW_EPISODE_HARD_CAP_MS: number;
+/** Env var (shared with swarmkit-eval's e2b bridge) for the sandbox idle timeout. */
+export declare const SKILLFLOW_E2B_SANDBOX_TIMEOUT_ENV = "SKILLFLOW_E2B_SANDBOX_TIMEOUT_MS";
+/** Env var controlling how many times a dead-sandbox op is recreated + retried. */
+export declare const SKILLFLOW_E2B_SANDBOX_RETRIES_ENV = "SKILLFLOW_E2B_SANDBOX_RETRIES";
+/**
+ * Idle timeout (ms) passed to e2b sandbox creation via
+ * `SKILLFLOW_E2B_SANDBOX_TIMEOUT_MS`. Defaults generously so the sandbox outlives
+ * the full episode budget: hard episode cap (25min) + a 10min margin covering
+ * setup, snapshot bootstrap, verify, and gaps between bridge ops. The e2b bridge's
+ * own default (20min in swarmkit-eval) is SHORTER than the episode cap, which is
+ * exactly why sandboxes were reaped mid-episode. A user-provided value always wins.
+ */
+export declare function skillFlowSandboxTimeoutMs(): number;
+/**
+ * Number of transparent recreate+retry attempts when a bridge op fails with the
+ * sandbox-not-found/timeout signature. Default 1 (exactly one recreate+retry);
+ * a second failure surfaces the env_error as before. A user-provided value wins.
+ */
+export declare function skillFlowSandboxRetries(): number;
+/**
+ * True iff the error is specifically an e2b "sandbox was not found" / sandbox
+ * timeout — the reaped-sandbox class we can transparently recover from. Matches
+ * conservatively so genuine task failures and other env errors are NOT masked.
+ */
+export declare function isSandboxNotFoundError(err: unknown): boolean;
+/**
+ * Run a bridge op with bounded recovery from a reaped e2b sandbox. On a
+ * sandbox-not-found error, `recreate()` rebuilds a fresh bridge/sandbox (from the
+ * snapshot cache) and the op is retried, up to `retries` times. Any other error —
+ * including genuine task failures and non-sandbox env errors — is re-thrown
+ * immediately, preserving fail-fast semantics.
+ */
+export declare function withSandboxRecovery<T>(op: () => Promise<T>, recreate: () => Promise<void>, opts: {
+    retries: number;
+    label: string;
+    logger?: Logger;
+}): Promise<T>;
+/**
+ * Extra env vars for the spawned bridge process. For the e2b runtime we inject a
+ * generous sandbox idle timeout so the sandbox outlives the whole episode; a
+ * value the caller already set in the environment is preserved (only-if-unset).
+ * The docker bridge needs nothing extra (undefined → inherit process.env).
+ */
+export declare function skillFlowBridgeEnv(runtime?: string): Record<string, string> | undefined;
+export declare function ensureSkillFlowE2BBridgeDependency(runtime?: string, projectRoot?: string): void;
+export declare function createSkillFlowBenchmark(opts?: {
+    maxSteps?: number;
+    reinject?: boolean;
+    historyWindow?: number;
+    families?: string[];
+    runtime?: string;
+    embeddedWorkbookBundle?: boolean;
+}): SkillFlowBenchmark;
+/**
+ * Select explicit families when provided; otherwise select families by seed.
+ * Within each family, tasks always remain difficulty-ordered.
+ */
+export declare function selectSkillFlowTasks(allTasks: SkillFlowTaskInfo[], count: number, seed: number, explicitFamilies?: string[]): SkillFlowTaskInfo[];
+/**
+ * Structured per-step prompt (B2 pattern) for SkillFlow tasks.
+ * Re-surfaces injected knowledge + task context every step.
+ */
+export declare function buildSkillFlowPrompt(p: {
+    knowledge?: string;
+    instruction: string;
+    family: string;
+    difficulty: number;
+    history: Array<{
+        action: string;
+        obs: string;
+    }>;
+    obs: string;
+}): string;
+//# sourceMappingURL=skillflow.d.ts.map

package/dist/eval/live/skillflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillflow.d.ts","sourceRoot":"","sources":["../../../src/eval/live/skillflow.ts"],"names":[],"mappings":"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"}