@ouro.bot/cli 0.1.0-alpha.955 → 0.1.0-alpha.957

package/dist/gateway/server.js

@@ -0,0 +1,429 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GATEWAY_MAX_REQUEST_BYTES = exports.GATEWAY_DEFAULT_COOLDOWN_MS = exports.GATEWAY_DEFAULT_UPSTREAM = exports.GATEWAY_DEFAULT_PORT = exports.GATEWAY_DEFAULT_HOST = void 0;
+exports.isCreditExhaustedBody = isCreditExhaustedBody;
+exports.creditGatewayOptionsFromCli = creditGatewayOptionsFromCli;
+exports.startCreditGateway = startCreditGateway;
+exports.waitForShutdownSignal = waitForShutdownSignal;
+exports.runCreditGatewayCommand = runCreditGatewayCommand;
+const http = __importStar(require("node:http"));
+const https = __importStar(require("node:https"));
+const path = __importStar(require("node:path"));
+const zlib = __importStar(require("node:zlib"));
+const node_crypto_1 = require("node:crypto");
+const node_stream_1 = require("node:stream");
+const runtime_1 = require("../nerves/runtime");
+const keys_1 = require("./keys");
+exports.GATEWAY_DEFAULT_HOST = "127.0.0.1";
+exports.GATEWAY_DEFAULT_PORT = 8787;
+exports.GATEWAY_DEFAULT_UPSTREAM = "https://api.anthropic.com";
+exports.GATEWAY_DEFAULT_COOLDOWN_MS = 60 * 60 * 1000;
+exports.GATEWAY_MAX_REQUEST_BYTES = 32 * 1024 * 1024;
+const CREDIT_LOW_PHRASE = "credit balance is too low";
+const CREDIT_CHECK_STATUSES = new Set([400, 402, 403]);
+const HOP_BY_HOP_HEADERS = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "proxy-connection",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+]);
+class RequestTooLargeError extends Error {
+}
+function anthropicError(type, message) {
+    return JSON.stringify({ type: "error", error: { type, message } });
+}
+/* v8 ignore start -- defensive: Node and the HTTP stack always throw Error instances @preserve */
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/* v8 ignore stop */
+function digest(value) {
+    return (0, node_crypto_1.createHash)("sha256").update(value).digest();
+}
+/** Compares digests so the comparison takes the same time whatever the presented key's length. */
+function matchesMasterKey(presented, masterDigest) {
+    if (!presented)
+        return false;
+    return (0, node_crypto_1.timingSafeEqual)(digest(presented), masterDigest);
+}
+function presentedKey(req) {
+    const apiKey = req.headers["x-api-key"];
+    if (typeof apiKey === "string" && apiKey.trim())
+        return apiKey.trim();
+    const bearer = /^Bearer\s+(.+)$/i.exec(req.headers.authorization ?? "");
+    return bearer ? bearer[1].trim() : undefined;
+}
+function readRequestBody(req, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > maxBytes) {
+                reject(new RequestTooLargeError());
+                req.pause();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => resolve(Buffer.concat(chunks)));
+        req.on("error", reject);
+    });
+}
+function readAll(stream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on("data", (chunk) => chunks.push(chunk));
+        stream.on("end", () => resolve(Buffer.concat(chunks)));
+        stream.on("error", reject);
+    });
+}
+function forwardedRequestHeaders(req, upstreamKey, bodyLength) {
+    const headers = {};
+    for (const [name, value] of Object.entries(req.headers)) {
+        if (HOP_BY_HOP_HEADERS.has(name) || name === "host" || name === "content-length" || name === "x-api-key" || name === "authorization")
+            continue;
+        headers[name] = value;
+    }
+    headers["x-api-key"] = upstreamKey;
+    if (bodyLength > 0)
+        headers["content-length"] = String(bodyLength);
+    return headers;
+}
+function responseHeaders(headers) {
+    const result = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (HOP_BY_HOP_HEADERS.has(name))
+            continue;
+        result[name] = value;
+    }
+    return result;
+}
+/** Decodes a compressed body for inspection only; the client still gets the original bytes. */
+function decodeForInspection(body, encoding) {
+    try {
+        const normalized = (encoding ?? "").trim().toLowerCase();
+        if (normalized === "gzip" || normalized === "x-gzip")
+            return zlib.gunzipSync(body).toString("utf8");
+        if (normalized === "deflate")
+            return zlib.inflateSync(body).toString("utf8");
+        if (normalized === "br")
+            return zlib.brotliDecompressSync(body).toString("utf8");
+        return body.toString("utf8");
+    }
+    catch {
+        return body.toString("utf8");
+    }
+}
+function isCreditExhaustedBody(body, encoding) {
+    return decodeForInspection(body, encoding).toLowerCase().includes(CREDIT_LOW_PHRASE);
+}
+function upstreamUrl(base, requestUrl) {
+    const prefix = base.pathname.replace(/\/+$/, "");
+    return new URL(`${prefix}${requestUrl}`, base.origin);
+}
+function sendUpstream(target, method, headers, body) {
+    return new Promise((resolve, reject) => {
+        const transport = target.protocol === "https:" ? https : http;
+        const request = transport.request(target, { method, headers }, (response) => resolve({ response, request }));
+        request.on("error", reject);
+        request.end(body.length > 0 ? body : undefined);
+    });
+}
+function writeBuffered(res, buffered) {
+    res.writeHead(buffered.status, { ...buffered.headers, "content-length": String(buffered.body.length) });
+    res.end(buffered.body);
+}
+function writeJsonError(res, status, type, message) {
+    const body = Buffer.from(anthropicError(type, message));
+    writeBuffered(res, { status, headers: { "content-type": "application/json" }, body });
+}
+/** Maps `ouro gateway serve` flags to gateway options. */
+function creditGatewayOptionsFromCli(command) {
+    return {
+        keysDir: command.keysDir,
+        ...(command.statePath ? { statePath: command.statePath } : {}),
+        ...(command.host ? { host: command.host } : {}),
+        ...(command.port !== undefined ? { port: command.port } : {}),
+        ...(command.upstream ? { upstream: command.upstream } : {}),
+        ...(command.cooldownMinutes !== undefined ? { cooldownMs: command.cooldownMinutes * 60 * 1000 } : {}),
+    };
+}
+/* v8 ignore start -- the default log writes to the real stderr; tests inject log @preserve */
+function defaultLog(line) {
+    process.stderr.write(`${line}\n`);
+}
+/* v8 ignore stop */
+/**
+ * Starts the credit gateway: a byte-passthrough proxy to the Anthropic API that accepts one master key
+ * and spends the upstream keys in a fixed order, moving to the next key only when the current one
+ * reports that its credit balance is too low.
+ */
+async function startCreditGateway(options) {
+    const keys = (0, keys_1.loadGatewayKeys)(options.keysDir);
+    const statePath = options.statePath ?? path.join(options.keysDir, "gateway-state.json");
+    const state = (0, keys_1.loadGatewayState)(statePath);
+    const host = options.host ?? exports.GATEWAY_DEFAULT_HOST;
+    const upstreamBase = new URL(options.upstream ?? exports.GATEWAY_DEFAULT_UPSTREAM);
+    const cooldownMs = options.cooldownMs ?? exports.GATEWAY_DEFAULT_COOLDOWN_MS;
+    const maxRequestBytes = options.maxRequestBytes ?? exports.GATEWAY_MAX_REQUEST_BYTES;
+    const now = options.now ?? Date.now;
+    const log = options.log ?? defaultLog;
+    const masterDigest = digest(keys.masterKey);
+    function persist() {
+        try {
+            (0, keys_1.saveGatewayState)(statePath, state);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "gateway",
+                event: "gateway.state_save_error",
+                message: "credit gateway could not save its state",
+                meta: { statePath, error: errorMessage(error) },
+            });
+        }
+    }
+    /** Returns the skip-until time for a label, or undefined when the key is usable. Expired entries are dropped. */
+    function skipUntil(label) {
+        const until = state.exhausted[label];
+        if (!until)
+            return undefined;
+        if (Date.parse(until) > now())
+            return until;
+        delete state.exhausted[label];
+        persist();
+        return undefined;
+    }
+    function markExhausted(entry) {
+        state.exhausted[entry.label] = new Date(now() + cooldownMs).toISOString();
+        persist();
+        log(`gateway: ${entry.label} out of credits; moving on`);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "gateway",
+            event: "gateway.key_exhausted",
+            message: "credit gateway key is out of credits",
+            meta: { label: entry.label, skipUntil: state.exhausted[entry.label] },
+        });
+    }
+    function logRequest(label, method, pathname, status, startedAt) {
+        const ms = now() - startedAt;
+        log(`gateway: ${label} ${method} ${pathname} ${status} ${ms}ms`);
+        (0, runtime_1.emitNervesEvent)({
+            component: "gateway",
+            event: "gateway.request",
+            message: "credit gateway request",
+            meta: { label, method, path: pathname, status, ms },
+        });
+    }
+    async function handle(req, res) {
+        const startedAt = now();
+        /* v8 ignore start -- Node always supplies url and method for accepted HTTP requests @preserve */
+        const requestUrl = req.url ?? "/";
+        const method = req.method ?? "GET";
+        /* v8 ignore stop */
+        const pathname = new URL(requestUrl, "http://gateway.local").pathname;
+        if (method === "GET" && pathname === "/health") {
+            const body = JSON.stringify({
+                ok: true,
+                keys: keys.upstream.map((entry) => {
+                    const until = skipUntil(entry.label);
+                    return until ? { label: entry.label, available: false, skipUntil: until } : { label: entry.label, available: true };
+                }),
+            });
+            writeBuffered(res, { status: 200, headers: { "content-type": "application/json" }, body: Buffer.from(body) });
+            logRequest("-", method, pathname, 200, startedAt);
+            return;
+        }
+        if (!matchesMasterKey(presentedKey(req), masterDigest)) {
+            writeJsonError(res, 401, "authentication_error", "invalid x-api-key");
+            logRequest("-", method, pathname, 401, startedAt);
+            return;
+        }
+        const target = upstreamUrl(upstreamBase, requestUrl);
+        if (target.origin !== upstreamBase.origin) {
+            writeJsonError(res, 400, "invalid_request_error", "invalid request path");
+            logRequest("-", method, pathname, 400, startedAt);
+            return;
+        }
+        let body;
+        try {
+            body = await readRequestBody(req, maxRequestBytes);
+        }
+        catch (error) {
+            /* v8 ignore start -- the client went away while sending its body; there is no one to answer @preserve */
+            if (!(error instanceof RequestTooLargeError)) {
+                res.destroy();
+                return;
+            }
+            /* v8 ignore stop */
+            res.setHeader("connection", "close");
+            writeJsonError(res, 413, "request_too_large", `request body exceeds ${maxRequestBytes} bytes`);
+            logRequest("-", method, pathname, 413, startedAt);
+            return;
+        }
+        let lastCredit;
+        let lastCreditLabel = "-";
+        for (const entry of keys.upstream) {
+            if (skipUntil(entry.label))
+                continue;
+            let upstream;
+            try {
+                upstream = await sendUpstream(target, method, forwardedRequestHeaders(req, entry.key, body.length), body);
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "gateway",
+                    event: "gateway.upstream_error",
+                    message: "credit gateway could not reach the upstream API",
+                    meta: { label: entry.label, error: errorMessage(error) },
+                });
+                writeJsonError(res, 502, "api_error", "credit gateway could not reach the upstream API");
+                logRequest(entry.label, method, pathname, 502, startedAt);
+                return;
+            }
+            /* v8 ignore next -- Node always sets statusCode on an upstream response @preserve */
+            const status = upstream.response.statusCode ?? 502;
+            if (CREDIT_CHECK_STATUSES.has(status)) {
+                const buffered = {
+                    status,
+                    headers: responseHeaders(upstream.response.headers),
+                    body: await readAll(upstream.response),
+                };
+                if (isCreditExhaustedBody(buffered.body, upstream.response.headers["content-encoding"])) {
+                    markExhausted(entry);
+                    lastCredit = buffered;
+                    lastCreditLabel = entry.label;
+                    continue;
+                }
+                writeBuffered(res, buffered);
+                logRequest(entry.label, method, pathname, status, startedAt);
+                return;
+            }
+            res.writeHead(status, responseHeaders(upstream.response.headers));
+            res.flushHeaders();
+            (0, node_stream_1.pipeline)(upstream.response, res, (error) => {
+                if (error)
+                    upstream.request.destroy();
+                logRequest(entry.label, method, pathname, status, startedAt);
+            });
+            return;
+        }
+        if (lastCredit) {
+            writeBuffered(res, { ...lastCredit, status: 400 });
+        }
+        else {
+            writeJsonError(res, 400, "invalid_request_error", "Your credit balance is too low on every gateway key");
+        }
+        logRequest(lastCreditLabel, method, pathname, 400, startedAt);
+    }
+    const server = http.createServer((req, res) => {
+        handle(req, res).catch((error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "gateway",
+                event: "gateway.request_error",
+                message: "credit gateway request failed",
+                meta: { error: errorMessage(error) },
+            });
+            /* v8 ignore next 4 -- failures after the headers went out are reported by the stream pipeline instead @preserve */
+            if (res.headersSent) {
+                res.destroy();
+                return;
+            }
+            writeJsonError(res, 502, "api_error", "credit gateway request failed");
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        /* v8 ignore next -- tests always bind port 0; the default is for production @preserve */
+        const port = options.port ?? exports.GATEWAY_DEFAULT_PORT;
+        server.listen(port, host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    const url = `http://${host}:${address.port}`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "gateway",
+        event: "gateway.server_started",
+        message: "credit gateway started",
+        meta: { url, upstream: upstreamBase.origin, labels: keys.upstream.map((entry) => entry.label), statePath },
+    });
+    return {
+        server,
+        url,
+        port: address.port,
+        close: () => new Promise((resolve) => {
+            server.closeAllConnections();
+            server.close(() => {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "gateway",
+                    event: "gateway.server_stopped",
+                    message: "credit gateway stopped",
+                    meta: { url },
+                });
+                resolve();
+            });
+        }),
+    };
+}
+/* v8 ignore start -- waits for real process signals; tests inject waitForStop @preserve */
+function waitForShutdownSignal() {
+    return new Promise((resolve) => {
+        process.once("SIGINT", () => resolve());
+        process.once("SIGTERM", () => resolve());
+    });
+}
+/* v8 ignore stop */
+/** Runs `ouro gateway serve` in the foreground until `waitForStop` resolves. */
+async function runCreditGatewayCommand(command, deps) {
+    const handle = await startCreditGateway(creditGatewayOptionsFromCli(command));
+    const message = `credit gateway listening on ${handle.url}\nhealth: ${handle.url}/health`;
+    deps.writeStdout(message);
+    /* v8 ignore next -- production waits for SIGINT/SIGTERM; tests inject waitForStop @preserve */
+    await (deps.waitForStop ?? waitForShutdownSignal)();
+    await handle.close();
+    return message;
+}

package/dist/heart/auth/auth-flow.js

@@ -361,6 +361,16 @@ async function collectRuntimeAuthCredentials(input, deps) {
         }
         return credentials;
     }
+    if (input.provider === "anthropic" && input.apiKey) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.auth_anthropic_api_key",
+            message: "storing anthropic API key for runtime auth",
+            meta: { agentName: input.agentName, hasBaseUrl: !!input.baseUrl },
+        });
+        writeAuthProgress(input, "using the supplied anthropic API key...");
+        return { apiKey: input.apiKey.trim(), ...(input.baseUrl ? { baseUrl: input.baseUrl } : {}) };
+    }
     if (input.provider === "anthropic") {
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
@@ -414,12 +424,16 @@ async function collectRuntimeAuthCredentials(input, deps) {
     }
     return creds;
 }
+/** True when the record holds `required` or one of the provider's alternative field sets in full. */
+function hasRequiredProviderCredentials(provider, record) {
+    const requirements = identity_1.PROVIDER_CREDENTIALS[provider];
+    return [requirements.required, ...(requirements.alternativeRequired ?? [])].some((fields) => fields.every((key) => !!record[key]));
+}
 async function resolveHatchCredentials(input) {
     const credentials = { ...(input.credentials ?? {}) };
     // If all required fields are already provided, return as-is
     const cred = credentials;
-    const missing = identity_1.PROVIDER_CREDENTIALS[input.provider].required.some((key) => !cred[key]);
-    if (!missing)
+    if (hasRequiredProviderCredentials(input.provider, cred))
         return credentials;
     // Try the full auth flow (wraps collectRuntimeAuthCredentials + writes secrets)
     if (input.runAuthFlow) {
@@ -431,7 +445,7 @@ async function resolveHatchCredentials(input) {
         });
         Object.assign(credentials, result.credentials);
         /* v8 ignore next 3 -- branch: auth flow always fills all required fields in production @preserve */
-        if (!identity_1.PROVIDER_CREDENTIALS[input.provider].required.some((key) => !credentials[key])) {
+        if (hasRequiredProviderCredentials(input.provider, credentials)) {
             return credentials;
         }
     }

package/dist/heart/config.js

@@ -235,7 +235,11 @@ function getMinimaxConfig() {
 }
 function getAnthropicConfig() {
     const raw = readProviderConfig("anthropic");
-    return { setupToken: typeof raw.setupToken === "string" ? raw.setupToken : "" };
+    return {
+        setupToken: typeof raw.setupToken === "string" ? raw.setupToken : "",
+        ...(typeof raw.apiKey === "string" && raw.apiKey ? { apiKey: raw.apiKey } : {}),
+        ...(typeof raw.baseUrl === "string" && raw.baseUrl ? { baseUrl: raw.baseUrl } : {}),
+    };
 }
 function getOpenAICodexConfig() {
     const raw = readProviderConfig("openai-codex");

package/dist/heart/core.js

@@ -285,6 +285,7 @@ exports.STEP_BUDGET_EXTENSION = 4;
 /** Hard ceiling on the per-turn provider-call budget, however much progress is made. */
 exports.MAX_PROVIDER_ITERATIONS_CEILING = 24;
 const STEP_BUDGET_REPORT_INSTRUCTION = "the step budget for this turn is used up. do not call any more work tools; none of the tool calls in your last message were executed. call settle now with a short progress report: what is done (with evidence from tool results above), what is still in flight, and what you will do next. say you can continue where you left off when the conversation resumes.";
+const STEP_BUDGET_REST_INSTRUCTION = "the step budget for this turn is used up. do not call any more work tools; none of the tool calls in your last message were executed. call rest now with a short note: what is done, what is still open, and what to pick up next time.";
 function continuationCallbacks(callbacks, text) {
     const noop = () => undefined;
     return {
@@ -1208,6 +1209,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let stepBudget = exports.MAX_PROVIDER_ITERATIONS;
     let lastIterationMadeProgress = false;
     let stepReportIteration = null;
+    // The one tool a turn may call after its step budget is used up: settle for conversations, rest for private turns.
+    let stepReportTool = "settle";
+    // A pre-dispatch contract check may reject the same call twice in a turn; after that it is advisory, so a check no call can satisfy never traps the turn.
+    const requiredDispatchRejectionCounts = new Map();
     const budgetExhausted = () => {
         if (providerIterations < stepBudget)
             return false;
@@ -1444,7 +1449,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 .filter((name) => candidateToolNames.has(name)));
             const forcingHistoricalEffect = forcedHistoricalToolNames.size > 0;
             const activeTools = stepReportIteration !== null
-                ? candidateActiveTools.filter((tool) => tool.function.name === "settle")
+                ? candidateActiveTools.filter((tool) => tool.function.name === stepReportTool)
                 : forcingHistoricalEffect
                     ? candidateActiveTools.filter((tool) => forcedHistoricalToolNames.has(tool.function.name))
                     : candidateActiveTools;
@@ -1605,8 +1610,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 nextAttemptControls = [];
                 providerIterations += 1;
                 if (stepReportIteration !== null) {
-                    // The progress-report call is the last one: it must settle, or the turn errors.
-                    const settledReport = result.toolCalls.length === 1 && result.toolCalls[0].name === "settle";
+                    // The progress-report call is the last one: it must settle (or rest), or the turn errors.
+                    const settledReport = result.toolCalls.length === 1 && result.toolCalls[0].name === stepReportTool;
                     if (providerIterations > stepReportIteration || (result.toolCalls.length > 0 && !settledReport)) {
                         throw new Error(`provider iteration limit exhausted at response ${providerIterations} before the progress report settled`);
                     }
@@ -1676,20 +1681,22 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 if (thinkingItems.length > 0) {
                     msg._thinking_blocks = thinkingItems;
                 }
-                const settlingNow = result.toolCalls.length === 1 && result.toolCalls[0].name === "settle";
+                const settlingNow = result.toolCalls.length === 1 && (result.toolCalls[0].name === "settle" || result.toolCalls[0].name === "rest");
                 if (stepReportIteration === null && result.toolCalls.length > 0 && !settlingNow && budgetExhausted()) {
-                    if (!candidateToolNames.has("settle")) {
+                    const wrapUpTool = candidateToolNames.has("settle") ? "settle" : candidateToolNames.has("rest") ? "rest" : null;
+                    if (!wrapUpTool) {
                         throw new Error(`provider iteration limit exhausted at response ${stepBudget} before tool execution`);
                     }
-                    // Do not error into the reply: give the model one settle-only call to report progress.
+                    // Do not error into the reply: give the model one settle-only (or rest-only) call to report progress.
                     streamCallbackBuffer?.discard();
                     stepReportIteration = providerIterations + 1;
+                    stepReportTool = wrapUpTool;
                     rejectAttempt(msg, [
                         ...result.toolCalls.map((tc) => ({ role: "tool", tool_call_id: tc.id, content: "not executed: the step budget for this turn is used up." })),
-                        { role: "user", content: STEP_BUDGET_REPORT_INSTRUCTION },
+                        { role: "user", content: wrapUpTool === "settle" ? STEP_BUDGET_REPORT_INSTRUCTION : STEP_BUDGET_REST_INSTRUCTION },
                     ]);
                     callbacks.onClearText?.();
-                    (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.step_budget_exhausted", message: "step budget used up; requesting a settle-only progress report", meta: { stepBudget, providerIterations } });
+                    (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.step_budget_exhausted", message: `step budget used up; requesting a ${wrapUpTool}-only progress report`, meta: { stepBudget, providerIterations } });
                     continue;
                 }
                 if (result.toolCalls.length > 0)
@@ -2166,14 +2173,16 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         const restArgs = validatedCallArguments.get(result.toolCalls[0]);
                         callbacks.onToolStart("rest", restArgs);
                         // Attention queue gate: reject rest if items remain
+                        // A budget wrap-up rest is final: held work and fresh messages wait for the next turn.
+                        const wrappingUp = stepReportIteration !== null;
                         const attentionQueue = augmentedToolContext?.delegatedOrigins;
-                        if (attentionQueue && attentionQueue.length > 0) {
+                        if (!wrappingUp && attentionQueue && attentionQueue.length > 0) {
                             callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs, toolSelection), false);
                             const gateMessage = "current held-work frame still has unsurfaced items — return each listed item with surface(delegationId=...) before you rest. Older transcript claims are historical; only the current held-work frame is the gate.";
                             rejectToolBatch(msg, [gateMessage]);
                             continue;
                         }
-                        if (hasFreshPendingWork(options) && !freshWorkGateFired) {
+                        if (!wrappingUp && hasFreshPendingWork(options) && !freshWorkGateFired) {
                             freshWorkGateFired = true;
                             callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs, toolSelection), false);
                             const gateMessage = "fresh work arrived for me this turn — inspect the pending messages above and take the next concrete action before you rest.";
@@ -2206,8 +2215,20 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     for (const entry of validCalls) {
                         const requiredArgs = entry.validated.arguments;
                         const rejection = options?.requiredToolCalls?.validateToolCallBeforeDispatch?.(entry.call.name, requiredArgs);
-                        if (rejection)
-                            requiredDispatchRejections.set(entry.call.id, { name: entry.call.name, args: requiredArgs, message: rejection });
+                        if (!rejection)
+                            continue;
+                        const rejectionKey = `${entry.call.name}\0${rejection}`;
+                        const priorRejections = requiredDispatchRejectionCounts.get(rejectionKey) ?? 0;
+                        if (priorRejections >= 2) {
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn", component: "engine", event: "engine.required_tool_dispatch_advisory",
+                                message: "required tool dependency rejected twice this turn; letting the call through",
+                                meta: { toolName: entry.call.name },
+                            });
+                            continue;
+                        }
+                        requiredDispatchRejectionCounts.set(rejectionKey, priorRejections + 1);
+                        requiredDispatchRejections.set(entry.call.id, { name: entry.call.name, args: requiredArgs, message: rejection });
                     }
                     if (requiredDispatchRejections.size > 0) {
                         streamCallbackBuffer?.discard();

package/dist/heart/daemon/cli-exec.js

@@ -5648,8 +5648,24 @@ async function executeProviderRefresh(command, deps) {
     deps.writeStdout(message);
     return message;
 }
+/** Reads an API key from a file (or /dev/stdin) so it never appears in argv. */
+function readApiKeyFile(filePath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        /* v8 ignore next -- fs.readFileSync only throws Error objects @preserve */
+        throw new Error(`could not read --api-key-file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const key = raw.trim();
+    if (!key)
+        throw new Error(`--api-key-file ${filePath} is empty.`);
+    return key;
+}
 async function executeAuthRun(command, deps) {
     const provider = command.provider ?? (0, auth_flow_1.readAgentConfigForAgent)(command.agent, deps.bundlesRoot).config.humanFacing.provider;
+    const apiKey = command.apiKeyFile ? readApiKeyFile(command.apiKeyFile) : undefined;
     /* v8 ignore next -- tests always inject runAuthFlow; default is for production @preserve */
     const authRunner = deps.runAuthFlow ?? (await Promise.resolve().then(() => __importStar(require("../auth/auth-flow")))).runRuntimeAuthFlow;
     const progress = createHumanCommandProgress(deps, "auth");
@@ -5662,6 +5678,8 @@ async function executeAuthRun(command, deps) {
             promptInput: deps.promptInput,
             promptSecret: deps.promptSecret,
             onProgress: (message) => progress.updateDetail(message),
+            ...(apiKey ? { apiKey } : {}),
+            ...(command.baseUrl ? { baseUrl: command.baseUrl } : {}),
         });
     }
     catch (error) {
@@ -8231,6 +8249,13 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     if (command.kind === "a2a.card" || command.kind === "a2a.onboard" || command.kind === "a2a.serve" || command.kind === "a2a.escalation" || command.kind === "a2a.delegatedCommands") {
         return executeA2ACommand(command, deps);
     }
+    if (command.kind === "gateway.serve") {
+        const { runCreditGatewayCommand } = await Promise.resolve().then(() => __importStar(require("../../gateway/server")));
+        return runCreditGatewayCommand(command, {
+            writeStdout: deps.writeStdout,
+            ...(deps.waitForShutdownSignal ? { waitForStop: deps.waitForShutdownSignal } : {}),
+        });
+    }
     // ── provider commands (local, no daemon socket needed) ──
     if (command.kind === "provider.use") {
         return executeProviderUse(command, deps);