@sema-agent/core 5.7.0 → 5.9.0

package/dist/stores/file/index.js

@@ -9,6 +9,7 @@ import { FileToolResultStore } from "./tool-result-store.js";
 import { FileSessionPolicyStore } from "./session-policy-store.js";
 import { FileFileSnapshotStore } from "./file-snapshot-store.js";
 import { FileWorkflowJournalStore } from "./workflow-journal-store.js";
+import { FileUsageWindowStore } from "./usage-window-store.js";
 export { FileCheckpointStore } from "./checkpoint-store.js";
 export { FileMemoryStore } from "./memory-store.js";
 export { FileSessionRepo } from "./session-store.js";
@@ -16,6 +17,7 @@ export { FileToolResultStore } from "./tool-result-store.js";
 export { FileSessionPolicyStore } from "./session-policy-store.js";
 export { FileFileSnapshotStore } from "./file-snapshot-store.js";
 export { FileWorkflowJournalStore, MAX_JOURNAL_RESULT_BYTES, oversizeJournalResult } from "./workflow-journal-store.js";
+export { FileUsageWindowStore } from "./usage-window-store.js";
 export { resolveDataRoot, sanitizeScope, sanitizePathComponent, createFileConsolidationLock } from "./fs-atomic.js";
 export { atomicWriteFile, writeThenLink, ensureDir, readJsonlRecords, AppendLog } from "./fs-atomic.js";
 export class FileStorageBackend {
@@ -27,6 +29,7 @@ export class FileStorageBackend {
     sessionPolicyStore;
     fileSnapshotStore;
     workflowJournalStore;
+    usageWindowStore;
     consolidationLock;
     lock;
     fileCheckpoints;
@@ -53,6 +56,7 @@ export class FileStorageBackend {
             this.fileSnapshotStore = new FileFileSnapshotStore(this.root, opts.snapshotBounds, corruptRead);
             this.fileWorkflowJournal = new FileWorkflowJournalStore(this.root);
             this.workflowJournalStore = this.fileWorkflowJournal;
+            this.usageWindowStore = new FileUsageWindowStore(this.root);
             this.consolidationLock = createFileConsolidationLock(join(this.root, "consolidation-locks"));
         }
         catch (err) {

package/dist/stores/file/usage-window-store.d.ts

@@ -0,0 +1,9 @@
+import { type UsageWindow, type UsageWindowReading, type UsageWindowStore } from "../../core/usage-window-store.js";
+export declare class FileUsageWindowStore implements UsageWindowStore {
+    private readonly dir;
+    constructor(root: string);
+    private pathFor;
+    private loadRecord;
+    charge(key: string, tokens: number, at: number, windows: readonly UsageWindow[]): Promise<void>;
+    read(key: string, windows: readonly UsageWindow[], now: number): Promise<readonly UsageWindowReading[]>;
+}

package/dist/stores/file/usage-window-store.js

@@ -0,0 +1,86 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { chargeUsageRecord, readUsageRecord, EMPTY_USAGE_WINDOW_RECORD, } from "../../core/usage-window-store.js";
+import { atomicWriteFile, ensureDir, sanitizeScope } from "./fs-atomic.js";
+export class FileUsageWindowStore {
+    dir;
+    constructor(root) {
+        this.dir = join(root, "usage-windows");
+        ensureDir(this.dir);
+    }
+    pathFor(key) {
+        return join(this.dir, `${sanitizeScope(key)}.json`);
+    }
+    loadRecord(key) {
+        const path = this.pathFor(key);
+        let raw;
+        try {
+            raw = readFileSync(path, "utf8");
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return EMPTY_USAGE_WINDOW_RECORD;
+            throw err;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw corrupt(path, "unparseable JSON (torn/zero-byte write?)");
+        }
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            throw corrupt(path, "not a JSON object");
+        const rec = parsed;
+        const slots = validateSlots(rec.slots, path);
+        const buckets = validateBuckets(rec.buckets, path);
+        return { slots, buckets };
+    }
+    async charge(key, tokens, at, windows) {
+        const next = chargeUsageRecord(this.loadRecord(key), tokens, at, windows);
+        atomicWriteFile(join(this.dir, "tmp"), this.pathFor(key), JSON.stringify(next));
+    }
+    async read(key, windows, now) {
+        return readUsageRecord(this.loadRecord(key), windows, now);
+    }
+}
+function corrupt(path, reason) {
+    const e = new Error(`usage-window ledger at ${path} is unreadable (${reason}). Refused rather than treated as empty: an unreadable ceiling would grant the key an unlimited, silent allowance.`);
+    e.code = "usage_window.store_corrupt";
+    return e;
+}
+function validateSlots(value, path) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw corrupt(path, "`slots` is not an array");
+    return value.map((s) => {
+        if (s === null || typeof s !== "object")
+            throw corrupt(path, "`slots` entry is not an object");
+        const { at, tokens } = s;
+        if (typeof at !== "number" || !Number.isFinite(at) || typeof tokens !== "number" || !Number.isFinite(tokens)) {
+            throw corrupt(path, "`slots` entry has a non-numeric `at`/`tokens`");
+        }
+        return { at, tokens };
+    });
+}
+function validateBuckets(value, path) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw corrupt(path, "`buckets` is not an array");
+    return value.map((b) => {
+        if (b === null || typeof b !== "object")
+            throw corrupt(path, "`buckets` entry is not an object");
+        const { windowMs, openedAt, tokens } = b;
+        if (typeof windowMs !== "number" ||
+            !Number.isFinite(windowMs) ||
+            typeof openedAt !== "number" ||
+            !Number.isFinite(openedAt) ||
+            typeof tokens !== "number" ||
+            !Number.isFinite(tokens)) {
+            throw corrupt(path, "`buckets` entry has a non-numeric `windowMs`/`openedAt`/`tokens`");
+        }
+        return { windowMs, openedAt, tokens };
+    });
+}

package/dist/tools/fs/fs-bash.d.ts

@@ -5,14 +5,6 @@ import { type BashReadonlyRootBoundary } from "./bash-readonly-classifier.js";
 export declare function bashReversibilityProbe(allow?: readonly string[], boundary?: BashReadonlyRootBoundary | (() => BashReadonlyRootBoundary | undefined)): (args: unknown) => {
     reversible: boolean;
 };
-export interface ExecClampOption {
-    deadlineMs: () => number | undefined;
-    onClamp?: (requestedSec: number, clampedSec: number) => void;
-    registerKillHandle?: (toolCallId: string, handle: {
-        pid: number;
-        kill: () => void;
-    }) => () => void;
-}
 export declare function bashExitOneInterpretation(command: string): string | undefined;
 export declare function canAutoBackground(command: string, depth?: number): boolean;
 export declare function createBashTool(env: ExecutionEnv, rootCanonical: string, coAuthor?: string | false, cwdRef?: CwdRef, taskOpts?: {
@@ -24,14 +16,13 @@ export declare function createBashTool(env: ExecutionEnv, rootCanonical: string,
         priority?: "now" | "next" | "later";
     }) => void;
     detachHub?: import("../../core/tool-detach.js").ToolDetachHub;
-    execClamp?: ExecClampOption;
     autoBackgroundOnTimeout?: boolean;
     oneShot?: boolean;
     additionalRoots?: readonly string[];
     bashDefaultTimeoutMs?: number;
     bashMaxTimeoutMs?: number;
 }): AgentTool;
-export declare function createBashReadonlyTool(env: ExecutionEnv, rootCanonical: string, allow: ReadonlySet<string>, execClamp?: ExecClampOption, opts?: {
+export declare function createBashReadonlyTool(env: ExecutionEnv, rootCanonical: string, allow: ReadonlySet<string>, opts?: {
     bashDefaultTimeoutMs?: number;
     bashMaxTimeoutMs?: number;
     additionalRoots?: readonly string[];

package/dist/tools/fs/fs-bash.js

@@ -231,61 +231,27 @@ function msTimeoutToRequestedSec(timeoutMs) {
         return undefined;
     return Math.max(1, Math.round(timeoutMs / 1000));
 }
-async function runShell(env, cwd, toolName, command, timeoutSec, caps, signal, cwdRef, detach, execClamp, toolCallId, readOnly, containmentRoots) {
+async function runShell(env, cwd, toolName, command, timeoutSec, caps, signal, cwdRef, detach, readOnly, containmentRoots) {
     const requestedSec = Math.max(1, Math.floor(timeoutSec ?? caps.defaultSec));
     let timeout = Math.min(caps.maxSec, requestedSec);
     const cappedByMaxTimeout = requestedSec > caps.maxSec;
-    let clampedByDeadline = false;
-    let deadlineExhausted = false;
-    if (execClamp) {
-        const deadline = execClamp.deadlineMs();
-        if (deadline !== undefined) {
-            const rawRemainSec = Math.floor((deadline - Date.now()) / 1000);
-            const maxSec = Math.max(1, rawRemainSec);
-            if (maxSec < timeout) {
-                execClamp.onClamp?.(requestedSec, maxSec);
-                timeout = maxSec;
-                clampedByDeadline = true;
-                deadlineExhausted = rawRemainSec < 1;
-            }
-        }
-    }
     const effectiveCwd = cwdRef ? cwdRef.current : cwd;
     const toRun = cwdRef
         ? `${command}\n__cc_rc=$?; printf '%s%s%s' '${CWD_SENTINEL}' "$(pwd)" '${CWD_SENTINEL}' 1>&2; exit $__cc_rc`
         : command;
     const execEnv = cwdRef ? { env: { PWD: effectiveCwd } } : undefined;
-    let deregisterKill;
-    const registerKillHandle = execClamp?.registerKillHandle;
-    let res;
-    try {
-        res = await env.exec(toRun, {
-            cwd: effectiveCwd,
-            timeout,
-            abortSignal: signal,
-            ...execEnv,
-            ...(detach
-                ? {
-                    detachSignal: detach.signal,
-                    onDetachAdopted: () => {
-                        deregisterKill?.();
-                        deregisterKill = undefined;
-                    },
-                    autoBackgroundOnTimeout: detach.autoBackgroundEligible === true && !clampedByDeadline,
-                }
-                : {}),
-            ...(registerKillHandle !== undefined && toolCallId !== undefined
-                ? {
-                    onSpawn: (handle) => {
-                        deregisterKill = registerKillHandle(toolCallId, handle);
-                    },
-                }
-                : {}),
-        });
-    }
-    finally {
-        deregisterKill?.();
-    }
+    const res = await env.exec(toRun, {
+        cwd: effectiveCwd,
+        timeout,
+        abortSignal: signal,
+        ...execEnv,
+        ...(detach
+            ? {
+                detachSignal: detach.signal,
+                autoBackgroundOnTimeout: detach.autoBackgroundEligible === true,
+            }
+            : {}),
+    });
     if (!res.ok) {
         if (res.error.code === "spawn_error" || res.error.code === "shell_unavailable") {
             const diagnosis = await diagnoseDeadCwd(env, toolName, effectiveCwd, cwd, cwdRef);
@@ -321,13 +287,9 @@ async function runShell(env, cwd, toolName, command, timeoutSec, caps, signal, c
             const pStdout = clipShellOutput(rawStdout);
             const pStderr = clipShellOutput(rawStderr);
             const headline = res.error.code === "timeout"
-                ? clampedByDeadline
-                    ? deadlineExhausted
-                        ? `Command was cut off after ${timeout}s — NOT its requested ${requestedSec}s timeout: the task's wall-clock deadline has already been reached, so the command only got a ${timeout}s grace window. The process was killed; output produced before the cutoff is shown below. Do NOT retry this foreground command — there is no time left. Use run_in_background (exempt from this clamp) if the work must continue, or write out your results now.`
-                        : `Command was cut off after ${timeout}s — NOT its requested ${requestedSec}s timeout: the task is near its wall-clock deadline, so the foreground time budget was clamped to the ${timeout}s remaining. The process was killed; output produced before the cutoff is shown below. Do NOT retry this foreground command — the next attempt gets even less time. Use run_in_background (exempt from this clamp) if the work must continue, or write out your results now.`
-                    : cappedByMaxTimeout
-                        ? `Command timed out after ${timeout}s — requested ${requestedSec}s, capped at ${caps.maxSec}s (engine ceiling: requests above ${caps.maxSec}s are reduced to it). The process was killed; output produced before the cutoff is shown below. Re-running with a larger timeout gets the same ${caps.maxSec}s ceiling — use run_in_background for work that needs longer, a narrower command, or resume from the partial progress below.`
-                        : `Command timed out after ${timeout}s (timeout limit: ${timeout}s). The process was killed; output produced before the cutoff is shown below. Re-running the same command will likely time out again — consider run_in_background for long commands, a narrower command, or resuming from the partial progress below.`
+                ? cappedByMaxTimeout
+                    ? `Command timed out after ${timeout}s — requested ${requestedSec}s, capped at ${caps.maxSec}s (engine ceiling: requests above ${caps.maxSec}s are reduced to it). The process was killed; output produced before the cutoff is shown below. Re-running with a larger timeout gets the same ${caps.maxSec}s ceiling — use run_in_background for work that needs longer, a narrower command, or resume from the partial progress below.`
+                    : `Command timed out after ${timeout}s (timeout limit: ${timeout}s). The process was killed; output produced before the cutoff is shown below. Re-running the same command will likely time out again — consider run_in_background for long commands, a narrower command, or resuming from the partial progress below.`
                 : res.error.code === "aborted"
                     ? `Command was interrupted (aborted) before completion. Output produced before the interrupt is shown below.`
                     : `Command started but its completion could not be observed — a host-side output-stream callback failed mid-run and the process was terminated (${res.error.message}). Output captured before the cut is shown below; its effects up to that point may have landed. Verify before assuming it needs a full re-run.`;
@@ -350,9 +312,7 @@ async function runShell(env, cwd, toolName, command, timeoutSec, caps, signal, c
                         ? {
                             timedOut: true,
                             timeoutSec: timeout,
-                            ...(clampedByDeadline || cappedByMaxTimeout ? { requestedTimeoutSec: requestedSec } : {}),
-                            ...(clampedByDeadline ? { clampedByDeadline: true } : {}),
-                            ...(cappedByMaxTimeout ? { cappedToMaxTimeoutSec: caps.maxSec } : {}),
+                            ...(cappedByMaxTimeout ? { requestedTimeoutSec: requestedSec, cappedToMaxTimeoutSec: caps.maxSec } : {}),
                         }
                         : res.error.code === "aborted"
                             ? { aborted: true }
@@ -696,7 +656,7 @@ export function createBashTool(env, rootCanonical, coAuthor = false, cwdRef = {
                 : undefined;
             let res;
             try {
-                res = await runShell(env, rootCanonical, "Bash", command, msTimeoutToRequestedSec(timeout), timeoutCapsSecView, ctx.signal, cwdRef, detachChain, taskOpts.execClamp, ctx.toolCallId, false, [rootCanonical, ...(taskOpts.additionalRoots ?? [])]);
+                res = await runShell(env, rootCanonical, "Bash", command, msTimeoutToRequestedSec(timeout), timeoutCapsSecView, ctx.signal, cwdRef, detachChain, false, [rootCanonical, ...(taskOpts.additionalRoots ?? [])]);
             }
             finally {
                 taskOpts.detachHub?.gc(ctx.toolCallId);
@@ -941,7 +901,7 @@ function createCanonicalReadBoundary(env, readRoots) {
         },
     };
 }
-export function createBashReadonlyTool(env, rootCanonical, allow, execClamp, opts) {
+export function createBashReadonlyTool(env, rootCanonical, allow, opts) {
     const timeoutCaps = resolveBashTimeoutCaps(opts);
     const timeoutCapsSecView = bashTimeoutCapsSec(timeoutCaps);
     const sample = [...allow].slice(0, 6).join(", ");
@@ -996,7 +956,7 @@ export function createBashReadonlyTool(env, rootCanonical, allow, execClamp, opt
                 return errorResult(`Error (Bash): a path this command reads resolves through a symlink to ${quoted}, outside the allowed directories for this session: ${readRoots.join(", ")} — not auto-allowed. ` +
                     "bash_readonly is confined to the workspace roots; it has no approval path, so the call is refused rather than escalated.", { code: "readonly_out_of_root", paths: resolved.escaping });
             }
-            return await runShell(env, rootCanonical, "Bash", command, msTimeoutToRequestedSec(timeout), timeoutCapsSecView, ctx.signal, undefined, undefined, execClamp, ctx.toolCallId, true);
+            return await runShell(env, rootCanonical, "Bash", command, msTimeoutToRequestedSec(timeout), timeoutCapsSecView, ctx.signal, undefined, undefined, true);
         },
     });
 }

package/dist/tools/fs/index.d.ts

@@ -11,7 +11,6 @@ export * from "./fs-search-tools.js";
 export * from "./bash-readonly-classifier.js";
 export * from "./fs-bash.js";
 import { type CwdRef, type ReadImageDownsamplerOption } from "./fs-shared.js";
-import { type ExecClampOption } from "./fs-bash.js";
 export interface HandsToolkitOptions {
     additionalRoots?: readonly string[];
     includeShell?: boolean;
@@ -28,7 +27,6 @@ export interface HandsToolkitOptions {
         priority?: "now" | "next" | "later";
     }) => void;
     detachHub?: import("../../core/tool-detach.js").ToolDetachHub;
-    execClamp?: ExecClampOption;
     bashDefaultTimeoutMs?: number;
     bashMaxTimeoutMs?: number;
     oneShot?: boolean;

package/dist/tools/fs/index.js

@@ -35,7 +35,7 @@ export function createHandsToolkit(env, readFileState, rootCanonical, opts = {})
     tools.push(createGrepTool(env, rootCanonical, additionalRoots), createGlobTool(env, rootCanonical, additionalRoots), createRepoMapTool(env, rootCanonical, additionalRoots));
     if (includeShell) {
         tools.push(readOnly
-            ? createBashReadonlyTool(env, rootCanonical, new Set(bashReadonlyAllow ?? BASH_READONLY_DEFAULT_ALLOW), opts.execClamp, {
+            ? createBashReadonlyTool(env, rootCanonical, new Set(bashReadonlyAllow ?? BASH_READONLY_DEFAULT_ALLOW), {
                 ...(opts.bashDefaultTimeoutMs !== undefined ? { bashDefaultTimeoutMs: opts.bashDefaultTimeoutMs } : {}),
                 ...(opts.bashMaxTimeoutMs !== undefined ? { bashMaxTimeoutMs: opts.bashMaxTimeoutMs } : {}),
                 ...(additionalRoots !== undefined ? { additionalRoots } : {}),
@@ -47,7 +47,6 @@ export function createHandsToolkit(env, readFileState, rootCanonical, opts = {})
                 ...(opts.sessionId !== undefined ? { sessionId: opts.sessionId } : {}),
                 onTaskNotification: opts.taskNotification,
                 detachHub: opts.detachHub,
-                execClamp: opts.execClamp,
                 ...(opts.autoBackgroundOnTimeout !== undefined ? { autoBackgroundOnTimeout: opts.autoBackgroundOnTimeout } : {}),
                 ...(opts.oneShot !== undefined ? { oneShot: opts.oneShot } : {}),
                 ...(additionalRoots !== undefined ? { additionalRoots } : {}),

package/dist/tools/web.js

@@ -3,11 +3,28 @@ import { defineTool, errorResult } from "../core/tools.js";
 import { delimitUntrusted, inlineUntrusted } from "../core/untrusted-text.js";
 import { redactSecrets } from "../core/untrusted-egress.js";
 import { isPrivateHost } from "../core/runner/image.js";
+import { binaryMagicFormat } from "./fs/safety.js";
+import { pdfMagicMatches } from "./fs/pdf.js";
 const MAX_REDIRECTS = 10;
 const MAX_URL_LENGTH = 2048;
 const WEBFETCH_ACCEPT = "text/markdown, text/html, */*";
 const DEFAULT_WEBFETCH_USER_AGENT = "Sema-User (@sema-agent/core WebFetch)";
 const DEFAULT_MAX_BYTES = 2 * 1024 * 1024;
+function resolveWebMaxBytes(value) {
+    if (value === undefined)
+        return DEFAULT_MAX_BYTES;
+    if (value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY) {
+        const e = new Error(`WebFetch maxBytes cannot be ${value === Number.POSITIVE_INFINITY ? "Infinity" : "-Infinity"} — the byte cap cannot be turned off, only widened; pass a large finite value instead (got ${String(value)})`);
+        e.code = "config.web_max_bytes_invalid";
+        throw e;
+    }
+    if (!Number.isFinite(value) || value <= 0) {
+        const e = new Error(`WebFetch maxBytes must be a positive finite number of bytes (got ${String(value)})`);
+        e.code = "config.web_max_bytes_invalid";
+        throw e;
+    }
+    return value;
+}
 const DEFAULT_FETCH_TIMEOUT_MS = 30_000;
 const ERROR_BODY_EXCERPT_CHARS = 2048;
 const ERROR_BODY_CONVERT_MAX_CHARS = 64 * 1024;
@@ -126,25 +143,9 @@ function isBinaryContentType(contentType) {
     return true;
 }
 function sniffBinarySignature(b) {
-    const at = (i) => b[i] ?? -1;
-    const ascii = (str, off = 0) => [...str].every((ch, i) => at(off + i) === ch.charCodeAt(0));
-    if (ascii("%PDF"))
+    if (pdfMagicMatches(b))
         return "PDF";
-    if (at(0) === 0x89 && ascii("PNG", 1))
-        return "PNG";
-    if (at(0) === 0xff && at(1) === 0xd8 && at(2) === 0xff)
-        return "JPEG";
-    if (ascii("GIF8"))
-        return "GIF";
-    if (at(0) === 0x1f && at(1) === 0x8b)
-        return "gzip";
-    if (ascii("PK") && ((at(2) === 3 && at(3) === 4) || (at(2) === 5 && at(3) === 6)))
-        return "zip";
-    if (at(0) === 0x7f && ascii("ELF", 1))
-        return "ELF binary";
-    if (at(0) === 0x00 && ascii("asm", 1))
-        return "WebAssembly";
-    return undefined;
+    return binaryMagicFormat(b);
 }
 function isPermittedRedirectHop(from, to) {
     const upgrade = from.protocol === "http:" && to.protocol === "https:";
@@ -209,7 +210,7 @@ async function fetchAllowlisted(doFetch, start, allowHosts, userAgent, signal, o
     return { ok: false, error: "too many redirects" };
 }
 export function webFetchToolSpec(config = {}) {
-    const maxBytes = config.maxBytes ?? DEFAULT_MAX_BYTES;
+    const maxBytes = resolveWebMaxBytes(config.maxBytes);
     const doFetch = config.fetchImpl ?? globalThis.fetch;
     const canSummarize = config.summarize !== undefined;
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "5.7.0",
+  "version": "5.9.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",
@@ -20,9 +20,6 @@
   ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "bin": {
-    "sema-tb": "dist/bin/sema-tb.js"
-  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -64,7 +61,9 @@
     "gate:message-branching": "node scripts/verify-no-message-branching.mjs",
     "gate:failloud": "node scripts/verify-failloud.mjs",
     "gate:domain-lexicon": "node scripts/verify-domain-lexicon.mjs",
-    "gate:single-mint": "node scripts/verify-single-mint.mjs"
+    "gate:single-mint": "node scripts/verify-single-mint.mjs",
+    "gate:nuia": "node scripts/verify-nuia-baseline.mjs",
+    "gate:field-liveness": "node scripts/verify-field-liveness.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",

package/dist/bin/sema-tb.d.ts

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-import { type Model } from "../index.js";
-interface Args {
-    model: string;
-    objectiveFile: string | undefined;
-    jsonl: string | undefined;
-}
-export type ParsedArgs = {
-    args: Args;
-} | {
-    help: true;
-} | {
-    usageError: string;
-};
-export declare function parseArgs(argv: string[], env?: Record<string, string | undefined>): ParsedArgs;
-export type InstructionResolution = {
-    instruction: string;
-} | {
-    error: string;
-};
-export declare function resolveInstruction(args: Pick<Args, "objectiveFile">, readInput: (source: string | 0) => string): InstructionResolution;
-type TbCost = Model["cost"];
-export type TbCostResolution = {
-    cost: TbCost;
-    source: "tb-cost-env" | "model-family" | "provider-default" | "disabled";
-    warning?: string;
-} | {
-    error: string;
-};
-export declare function resolveTbCost(modelId: string, provider: string, baseUrlOverridden: boolean, tbCostEnv: string | undefined): TbCostResolution;
-export {};