bareloop 0.5.0 → 0.6.0

package/types/extract.d.ts

@@ -1,25 +0,0 @@
-/**
- * Distill/update a lineage's rules from one green run's ledger facts.
- * @param {object} opts
- * @param {object} opts.config the config that went green
- * @param {object} opts.provider a bareagent provider — SHELL-owned, sealed
- * @param {string[]|null} opts.priorRules the lineage's current rules, if any
- * @param {string[]} [opts.revisionDiff] changed config paths, when the run recovered mid-run
- * @returns {Promise<{rules: string[]|null, valid: boolean, reds: Array<object>, costUsd: number|null, raw: string}>}
- *   costUsd is null when the spend could not be priced — the explicit-unknown
- *   signal (F6: unpriced is never free); callers must not coerce it to 0
- */
-export function extractRules({ config, provider, priorRules, revisionDiff }: {
-    config: object;
-    provider: object;
-    priorRules: string[] | null;
-    revisionDiff?: string[] | undefined;
-}): Promise<{
-    rules: string[] | null;
-    valid: boolean;
-    reds: Array<object>;
-    costUsd: number | null;
-    raw: string;
-}>;
-export const MAX_RULES: 5;
-export const MAX_RULE_CHARS: 200;

package/types/interpret.d.ts

@@ -1,201 +0,0 @@
-/**
- * The retrieval pair (F19). `shell_read` cannot seek — it starts at byte zero — so a
- * pointer at a symbol was inert and the worker paged whole files to reach one function.
- * `ctx_recall` hands back a POINTER (no body: a search index returns pointers, and bodies
- * on every hit rebuild the bloat — measured, a 5-hit recall dumps ~15k tokens unbidden);
- * `ctx_get` trades that pointer for ONE chunk. A chunk starts at its doc-comment, so the
- * body arrives WITH the docstring that says what it was supposed to do.
- * @param {any} lc the run's LiteCtx (rooted at workdir)
- * @param {string} workdir
- * @param {(type: string, data: object) => void} emit the spine — a retrieval verb whose
- *   RESULT is invisible cannot be judged: a `ctx_get` that silently reds (stale pointer,
- *   bad range) looks exactly like one that worked, and the worker's fallback to a
- *   whole-file read looks like a free choice instead of a forced one.
- */
-export function createCtxTools(lc: any, workdir: string, emit: (type: string, data: object) => void): ({
-    name: string;
-    description: string;
-    parameters: {
-        type: string;
-        properties: {
-            query: {
-                type: string;
-                description: string;
-            };
-            n: {
-                type: string;
-                description: string;
-            };
-            path?: undefined;
-            startLine?: undefined;
-            endLine?: undefined;
-        };
-        required: string[];
-    };
-    execute: ({ query, n }: {
-        query: string;
-        n?: number;
-    }) => Promise<any>;
-} | {
-    name: string;
-    description: string;
-    parameters: {
-        type: string;
-        properties: {
-            path: {
-                type: string;
-                description: string;
-            };
-            startLine: {
-                type: string;
-                description: string;
-            };
-            endLine: {
-                type: string;
-                description: string;
-            };
-            query?: undefined;
-            n?: undefined;
-        };
-        required: string[];
-    };
-    execute: ({ path: p, startLine, endLine }: {
-        path: string;
-        startLine: number;
-        endLine: number;
-    }) => Promise<any>;
-})[];
-/**
- * Execute a workflow config against one task under the dumb shell.
- *
- * @param {object|string} configRaw schema v1 config (object or raw JSON text)
- * @param {object} opts
- * @param {string} opts.task implement instruction shown to the worker
- * @param {string} [opts.target] absolute path the artifact is written to —
- *        required in text mode; unused in tool mode (the worker writes through
- *        the gated tools, wherever the fence allows)
- * @param {string[]} opts.close argv whose exit code is truth (shell-owned)
- * @param {number} [opts.closeExpect] the exit code the SIGNED spec calls success
- * @param {{pattern: string, min: number}} [opts.closeJudged] the signed spec's
- *   judgment-rendered signal — proof the close actually judged something before
- *   its exit code is believed in EITHER direction (PRD v1.11; the drafted config
- *   cannot express it, and must not: it is the arbiter's own honesty check)
- * @param {string} [opts.closeGapKeep] the signed spec's kept-failures pattern (F28):
- *   close-output lines matching it survive the gap bound, so a large suite's
- *   `not ok` names reach the worker instead of being elided into "N fail" — also
- *   arbiter territory, inexpressible in the drafted config
- * @param {string} opts.workdir run directory (litectx root, gate audit, scope base)
- * @param {number} opts.capRuns shell iteration budget; the config may tighten via loop.maxIterations, never exceed
- * @param {(type: string, data?: object) => object} opts.emit spine emitter
- * @param {object} opts.provider a bareagent provider — SHELL-owned binding (adaptlearn F8: an unsealed binding is a gate bypass)
- * @param {number} [opts.shellCapUsd=2] the shell's USD cap; a config budgetUsd above it REDS at validation (bounds — no silent clamping)
- * @param {number} [opts.closeTimeoutMs] close wall-clock cap, threaded to the shell
- *        (shell/operator territory — the workflow config cannot express it)
- * @param {string[]} [opts.jobWriteScope] the job spec's outer write fence (operator law,
- *        job-v1) — enforced HERE, the one choke point where a config becomes a Gate:
- *        every workflow scope must fit inside it (scope-escape config-red otherwise),
- *        on entry validation and on every revision candidate alike
- * @param {(o: {config: object, gaps: string[], policy: any, onLlmResult: any}) => Promise<{candidate: object|null, parseError?: string|null, costUsd?: number}>} [opts.revisor]
- *        optional mid-run revision seam. Fires ONCE per run after STALL_REDS consecutive
- *        close reds. The interpreter — never the revisor — owns acceptance: the candidate
- *        must validate, and gate/escalation/loop.maxIterations must be unchanged
- *        (arbiter-touch / cap-touch revision-reds otherwise; the run continues on the old
- *        config). Revisor spend rides the run's own gate handlers — same budget axis as
- *        the worker.
- * @param {string} [opts.closeState] the close's CURRENT output on the tree as it stands
- *        (the shell's pre-token close check, F13) — shown to the first attempt only, and
- *        never framed as an attempt: the worker cannot run the close itself (`run` is a
- *        locked verb), so without this it is asked to fix a failure it cannot see
- * @param {'text'|'tools'} [opts.mode] middle mode (2b): 'text' (default) writes the ONE
- *        target from the response artifact; 'tools' gives the worker Gate-governed file
- *        tools — SPEC-side territory (the step declares it; the config cannot express it)
- * @param {boolean} [opts.layerRoot=false] Layer R (the within-run ratchet, src/root.js):
- *        shell-assembled fixation detection over the run's own books, injecting an
- *        escalating summary→verbatim note when consecutive attempts rewrite the same
- *        files without moving the reds. Inert when the worker is not stuck (RSI §3.3).
- *        Defaults OFF (decided 2026-07-21): fixation is extinct on every current job
- *        (F41), so ON is unproven — the field read defers to Layer 2. `true` is the
- *        ON/experimental arm; never a worker-visible knob
- * @param {string[]} [opts.tools] the spec's tool grant (subset of read|grep|write,
- *        job-v1 validated); defaults to the full menu in tool mode
- * @returns {Promise<'green'|'escalated'|'config-red'>}
- */
-export function interpret(configRaw: object | string, { task, target, close, workdir, capRuns, emit, provider, shellCapUsd, jobWriteScope, revisor, closeTimeoutMs, mode, tools, closeState, closeExpect, closeJudged, closeGapKeep, layerRoot }: {
-    task: string;
-    target?: string | undefined;
-    close: string[];
-    closeExpect?: number | undefined;
-    closeJudged?: {
-        pattern: string;
-        min: number;
-    } | undefined;
-    closeGapKeep?: string | undefined;
-    workdir: string;
-    capRuns: number;
-    emit: (type: string, data?: object) => object;
-    provider: object;
-    shellCapUsd?: number | undefined;
-    closeTimeoutMs?: number | undefined;
-    jobWriteScope?: string[] | undefined;
-    revisor?: ((o: {
-        config: object;
-        gaps: string[];
-        policy: any;
-        onLlmResult: any;
-    }) => Promise<{
-        candidate: object | null;
-        parseError?: string | null;
-        costUsd?: number;
-    }>) | undefined;
-    closeState?: string | undefined;
-    mode?: "text" | "tools" | undefined;
-    layerRoot?: boolean | undefined;
-    tools?: string[] | undefined;
-}): Promise<"green" | "escalated" | "config-red">;
-/** @typedef {Error & {category?: string, lib?: string}} CategorizedError the failure map's carrier: ralph relays by `category`, and by `lib` when the thrower knows which library owns the failure (the ledger prefers it over prose) */
-export const STALL_REDS: 2;
-export const PERSONA_TOOLS: string;
-export const RETRIEVAL_STRATEGY: string;
-export const EDIT_STRATEGY: string;
-export const TOOL_BY_VERB: Readonly<{
-    read: "shell_read";
-    grep: "shell_grep";
-    write: "shell_write";
-    edit: "shell_edit";
-    recall: "ctx_recall";
-    get: "ctx_get";
-}>;
-export const CTX_TOOLS: readonly string[];
-export function toolAction(name: string, args: any, workdir?: string): {
-    type: string;
-    path: string;
-    args: {
-        bytes: number;
-        tool?: undefined;
-    };
-} | {
-    type: string;
-    path: string;
-    args: {
-        tool: string;
-        bytes?: undefined;
-    };
-} | {
-    type: string;
-    args: any;
-    path?: undefined;
-};
-/**
- * the failure map's carrier: ralph relays by `category`, and by `lib` when the thrower knows which library owns the failure (the ledger prefers it over prose)
- */
-export type CategorizedError = Error & {
-    category?: string;
-    lib?: string;
-};
-/**
- * litectx recall hit — body present only with `{body: true}`
- */
-export type RecallHit = {
-    body?: string | null;
-    text?: string | null;
-};