@2kw/ai 6.3.0-dev.96 → 6.3.0

package/README.md

@@ -112,7 +112,7 @@ kubectl-style contexts switch between organizations and environments:
 | `providers` | Manage BYOK AI providers |
 | `analytics` | Usage analytics: spend, quality, providers, errors |
 | `billing` | Check subscription tier and usage limits |
-| `agents` | Run agents and decide approvals; apply, export and scaffold agent.yaml; manage versions, labels, approvals and tool catalogs |
+| `agents` | Run agents and answer paused runs (approvals and relayed tool calls); apply, export and scaffold agent.yaml; manage versions, labels, approvals and tool catalogs |
 | `skills` | Import and export SKILL.md bundles; manage skill versions and labels |
 | `plugins` | Install plugin repositories, sync them, and inspect their reports |
 | `conversations` | Create and manage conversations and their items |

package/dist/agent-config/schema.js

@@ -21,6 +21,10 @@ const oneOfLowercase = (...values) => ({ type: "string", enum: values });
 export const NON_AUTHORABLE_TOOL_TYPES = {
     "backbone.tool_search": "the planner adds it automatically",
     "backbone.skill_read": "it is added at run time when skills are pinned",
+    // #944: SkillsetPinner injects it for eligible callers and strips any stored copy (#779).
+    "backbone.skills_apply": "it is added at run time for callers allowed to author skills",
+    // #1241: injected while the conversation's outputs are held; an authored copy is dropped.
+    "backbone.deliver": "it is added at run time while sandbox outputs are held",
     web_search: "it has no executor and is skipped",
 };
 const BUILTIN_TYPES = [

package/dist/commands/agent-run.js

@@ -6,7 +6,7 @@ import { BackboneApiError, CliUsageError } from "../lib/errors.js";
 import { withSpinner } from "../lib/output.js";
 import { resolveAgent, splitAgentRef, suggestAgents } from "../lib/agent-lookup.js";
 import { buildRunEnvelope, EXIT_CODES, MODE_OPTION_HELP, modeItem, parseModeOption, printRunText, stripControl, } from "../lib/agent-run.js";
-import { continueWithDecisions, decisionsFromAnswers, fetchPendingApprovals, planDecisions, } from "../lib/agent-decide.js";
+import { continueWithDecisions, decisionsFromAnswers, fetchPendingApprovals, parseToolAnswers, planContinuation, } from "../lib/agent-decide.js";
 import { PromptAbortedError, promptApprovals, readlineAsk } from "../lib/approval-prompt.js";
 import { withModelOverride } from "../lib/agent-models.js";
 import { readStdinInput } from "./ai.js";
@@ -171,9 +171,11 @@ export function makeAgentRunCommand() {
         });
     });
 }
+/** Repeatable `--output` / `--fail`: a variadic `<v...>` would swallow the arguments that follow it. */
+const collect = (value, previous = []) => [...previous, value];
 export function makeAgentDecideCommand() {
     return new Command("decide")
-        .description("Decide every pending approval of a paused run and continue it")
+        .description("Answer a paused run: decide every pending approval and answer every relayed tool call in one call, then continue it")
         .argument("<agent>", "Agent name or id, optionally with @label and #model (use the same @label and #model the run used)")
         .requiredOption("--response <responseId>", "The paused response id (responseId in the run envelope)")
         .option("--approve <ids...>", "Approval ids to approve")
@@ -182,11 +184,15 @@ export function makeAgentDecideCommand() {
         .option("--reject-all", "Reject every pending approval of the response")
         .option("--reason <text>", "Reason recorded on each decision (the model sees it on rejects)")
         .option("--remember", "Also approve later calls of the same tool in this conversation")
+        .option("--output <callId=value>", "Answer a relayed tool call: <callId>=<text>, <callId>=@<file> or <callId>=@- for stdin; within one hour of the pause (repeatable)", collect)
+        .option("--fail <callId=message>", "Answer a relayed tool call as failed: <callId>=<message> (same @file / @- forms; repeatable)", collect)
         .option("--mode <mode>", MODE_OPTION_HELP)
         .option("--raw", "Print the untouched API response")
         .action(async (agentRef, opts, command) => {
         await runAction(command, async () => {
             const mode = parseModeOption(opts.mode);
+            // Syntax, duplicates and file reads are checked before any request (#671 D4).
+            const toolAnswers = parseToolAnswers(opts.output, opts.fail);
             const client = getClient(command);
             const { name, label, model } = splitAgentRef(agentRef);
             // Dropped silently, an empty override would continue the run on the default model.
@@ -194,15 +200,15 @@ export function makeAgentDecideCommand() {
                 throw new CliUsageError(`Empty #model in '${agentRef}': use the model the run used, or drop the '#'.`);
             const agent = await resolveAgent(client, name);
             const pending = await fetchPendingApprovals(client, String(agent.id), opts.response);
-            const decisions = planDecisions(pending, {
+            const decisions = planContinuation(pending, {
                 approve: opts.approve,
                 reject: opts.reject,
                 approveAll: opts.approveAll,
                 rejectAll: opts.rejectAll,
                 reason: opts.reason,
                 remember: opts.remember,
-            }, opts.response);
-            const result = await withSpinner("Continuing...", () => continueWithDecisions(client, String(agent.id), opts.response, decisions, label, model, mode));
+            }, toolAnswers, opts.response);
+            const result = await withSpinner("Continuing...", () => continueWithDecisions(client, String(agent.id), opts.response, decisions, label, model, mode, toolAnswers));
             await finishRun(command, client, { name, label, model, mode }, result, { raw: !!opts.raw, interactive: false });
         });
     });

package/dist/commands/ai.js

@@ -125,13 +125,7 @@ export function makeAiCommand() {
             if (opts.conversation)
                 body.conversation = opts.conversation;
             const client = getClient(command);
-            const { data } = await withSpinner("Generating response...", () => 
-            // The wire `input` field also accepts a bare string (shorthand for
-            // a single user message; see ResponseItemInputDeserializer), which
-            // the generated type does not model — hence the cast, same as the
-            // untyped convert.ts source-conversion calls.
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            client.POST("/v1/responses", { body }));
+            const { data } = await withSpinner("Generating response...", () => client.POST("/v1/responses", { body }));
             printResponseResult(data, command, opts.agent);
         });
     });

package/dist/commands/billing.js

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { getClient, runAction } from "../lib/client.js";
 import { isJsonOutput } from "../lib/config.js";
+import { CliUsageError } from "../lib/errors.js";
 import { formatDetail, formatList } from "../lib/output.js";
 import chalk from "chalk";
 export function makeBillingCommand() {
@@ -133,6 +134,107 @@ export function makeBillingCommand() {
             }
         });
     });
+    cmd.addCommand(makeOverageCommand());
+    cmd.addCommand(makeTopUpsCommand());
+    return cmd;
+}
+/** Whole euros from cents, e.g. 1234 → "€12.34". Amounts are net of VAT (#973 D-O). */
+function euros(cents) {
+    return `€${((cents ?? 0) / 100).toFixed(2)}`;
+}
+function parseWhole(value, name, min, max) {
+    const n = /^\d+$/.test(value) ? Number(value) : NaN;
+    if (!Number.isInteger(n) || n < min || n > max) {
+        throw new CliUsageError(`${name} must be a whole number between ${min} and ${max}, not '${value}'`);
+    }
+    return n;
+}
+/** `bb billing overage get|set` — the opt-in overage cap (#973, plan D-O). Reads need a member login. */
+function makeOverageCommand() {
+    const cmd = new Command("overage").description("Show or set the opt-in overage cap (euros, net of VAT)");
+    cmd
+        .command("get")
+        .description("Show the overage setting and this period's overage (needs `bb auth login`)")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/billing/overage");
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            console.log(`Overage:   ${data?.enabled ? chalk.green("on") : chalk.dim("off")}`);
+            console.log(`Cap:       €${data?.capEuros ?? 0} (max €${data?.maxCapEuros ?? 0})`);
+            console.log(`Available: ${data?.available ? chalk.green("yes") : chalk.yellow(`no (${data?.unavailableReason ?? "unknown"})`)}`);
+            console.log(`Spent:     ${euros(data?.spentCents)}`);
+            console.log(`Reserved:  ${euros(data?.reservedCents)}`);
+            if (data?.periodStart || data?.periodEnd) {
+                console.log(chalk.dim(`Period: ${data?.periodStart?.slice(0, 10) ?? "?"} → ${data?.periodEnd?.slice(0, 10) ?? "?"}`));
+            }
+        });
+    });
+    cmd
+        .command("set")
+        .description("Turn overage on with a cap, or off (admin)")
+        .option("--cap <euros>", "Monthly cap in whole euros, 1-100; turns overage on")
+        .option("--off", "Turn overage off, keeping the stored cap")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            if (opts.off === Boolean(opts.cap)) {
+                throw new CliUsageError("Pass exactly one of --cap <euros> or --off");
+            }
+            // --off sends no cap: the backend keeps the stored one, and no read is needed (the read
+            // refuses API keys, the write admits an admin's).
+            const body = opts.off
+                ? { enabled: false }
+                : { enabled: true, capEuros: parseWhole(String(opts.cap), "cap", 1, 100) };
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/billing/overage", { body });
+            formatDetail(data, command);
+        });
+    });
+    return cmd;
+}
+/** `bb billing top-ups list|buy` — prepaid credit packs (#973, plan D-E). Never opens a browser. */
+function makeTopUpsCommand() {
+    const cmd = new Command("top-ups").description("List or buy prepaid credit (packs of 1,000 credits at €15)");
+    cmd
+        .command("list")
+        .description("List unexpired prepaid credit (needs `bb auth login`)")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/billing/top-ups");
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const rows = (data ?? []).map((lot) => ({
+                kind: lot.kind,
+                purchased: euros(lot.purchasedCents),
+                remaining: euros(lot.remainingCents),
+                expires: lot.expiresAt?.slice(0, 10),
+            }));
+            formatList(rows, command, ["kind", "purchased", "remaining", "expires"]);
+        });
+    });
+    cmd
+        .command("buy")
+        .description("Start a Stripe Checkout for top-up packs and print its URL (admin)")
+        .requiredOption("--packs <n>", "Number of packs, 1-20")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const packs = parseWhole(String(opts.packs), "packs", 1, 20);
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/billing/top-ups", { body: { packs } });
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            console.log(`Open this page to pay: ${data?.checkoutUrl}`);
+            console.log(chalk.dim(`Expires: ${data?.expiresAt ?? "?"}`));
+        });
+    });
     return cmd;
 }
 //# sourceMappingURL=billing.js.map

package/dist/commands/installations.js

@@ -1,7 +1,22 @@
 import { Command } from "commander";
 import { getClient, runAction } from "../lib/client.js";
+import { CliUsageError } from "../lib/errors.js";
 import { formatPage, formatDetail, formatList, formatSuccess } from "../lib/output.js";
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+const MIN_MONTHLY_PERCENT = 0;
+const MAX_MONTHLY_PERCENT = 1000;
+/**
+ * Validated inside the action rather than as commander's argument parser, so the refusal
+ * travels through `runAction` and exits 2 like every other usage error (see `parsePort` in
+ * connectors.ts).
+ */
+function parseMonthlyPercent(value) {
+    const percent = /^\d+$/.test(value) ? Number(value) : NaN;
+    if (!Number.isInteger(percent) || percent < MIN_MONTHLY_PERCENT || percent > MAX_MONTHLY_PERCENT) {
+        throw new CliUsageError(`percent must be a whole number between ${MIN_MONTHLY_PERCENT} and ${MAX_MONTHLY_PERCENT}, not '${value}'`);
+    }
+    return percent;
+}
 export function makeInstallationsCommand() {
     const cmd = new Command("installations").description("Manage surface installations");
     const list = new Command("list").description("List installations");
@@ -73,7 +88,7 @@ export function makeInstallationsCommand() {
                 body.status = opts.status;
             const { data } = await client.PUT("/v1/installations/{id}", {
                 params: { path: { id } },
-                body: body,
+                body,
             });
             formatDetail(data, command);
         });
@@ -172,6 +187,36 @@ export function makeInstallationsCommand() {
         });
     });
     cmd.addCommand(keys);
+    const budget = new Command("budget").description("Manage an installation's monthly budget: a share of the organisation's pool");
+    budget
+        .command("get")
+        .description("Read an installation's current budget: percent, period, and usage")
+        .argument("<id>", "Installation ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/installations/{id}/budget", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    budget
+        .command("set")
+        .description("Set or change an installation's monthly budget share, 0-1000 percent")
+        .argument("<id>", "Installation ID")
+        .argument("<percent>", "Monthly percent of the organisation's pool, 0-1000")
+        .action(async (id, percent, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/installations/{id}/budget", {
+                params: { path: { id } },
+                body: { monthlyPercent: parseMonthlyPercent(percent) },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd.addCommand(budget);
     return cmd;
 }
 //# sourceMappingURL=installations.js.map

package/dist/commands/knowledge.js

@@ -47,6 +47,7 @@ export function makeKnowledgeCommand() {
         .option("--parent-chunk-size <n>", "Parent chunk size (hierarchical chunking)", parseInt)
         .option("--reranker-provider <id>", "Reranker provider ID")
         .option("--hybrid-search <bool>", "Enable hybrid search (true/false)")
+        .option("--text-search-language <name>", "Text-search language for the lexical leg (default simple)")
         .action(async (opts, command) => {
         await runAction(command, async () => {
             const client = getClient(command);
@@ -64,6 +65,7 @@ export function makeKnowledgeCommand() {
                     parentChunkSize: opts.parentChunkSize,
                     rerankerProviderId: opts.rerankerProvider,
                     hybridSearchEnabled: opts.hybridSearch !== undefined ? opts.hybridSearch === "true" : undefined,
+                    textSearchLanguage: opts.textSearchLanguage,
                 },
             });
             formatDetail(data, command);
@@ -83,6 +85,7 @@ export function makeKnowledgeCommand() {
         .option("--parent-chunk-size <n>", "New parent chunk size", parseInt)
         .option("--reranker-provider <id>", "New reranker provider ID")
         .option("--hybrid-search <bool>", "Enable hybrid search (true/false)")
+        .option("--text-search-language <name>", "Change the text-search language (reindexes in the background); omit to leave it untouched")
         .action(async (id, opts, command) => {
         await runAction(command, async () => {
             const client = getClient(command);
@@ -107,6 +110,8 @@ export function makeKnowledgeCommand() {
                 body.rerankerProviderId = opts.rerankerProvider;
             if (opts.hybridSearch !== undefined)
                 body.hybridSearchEnabled = opts.hybridSearch === "true";
+            if (opts.textSearchLanguage)
+                body.textSearchLanguage = opts.textSearchLanguage;
             const { data } = await client.PATCH("/v1/knowledge-bases/{id}", {
                 params: { path: { id } },
                 body: body,

package/dist/commands/tracing.js

@@ -77,6 +77,7 @@ export function makeTracingCommand() {
     const sessions = new Command("sessions").description("Session-level trace views (spans grouped by exporter-stamped session id)");
     const sessionsList = new Command("list").description("List trace sessions");
     sessionsList.option("--search <query>", "Free-text search across session id and name");
+    sessionsList.option("--session-id <sessionId>", "Exact match on the session.id the exporter stamped (slashes allowed)");
     sessionsList.option("--from <iso>", "Start of time range (ISO-8601)");
     sessionsList.option("--to <iso>", "End of time range (ISO-8601)");
     sessionsList.option("--page <n>", "Page index (0-based)", "0");
@@ -88,6 +89,7 @@ export function makeTracingCommand() {
                 params: {
                     query: {
                         search: opts.search,
+                        sessionId: opts.sessionId,
                         from: opts.from,
                         to: opts.to,
                         page: parseInt(opts.page, 10),
@@ -96,17 +98,17 @@ export function makeTracingCommand() {
                 },
             });
             const page = data;
-            formatList((page?.content ?? []), command, ["sessionId", "name", "startTime", "durationMs", "turnCount", "errorCount", "costUsd"]);
+            formatList((page?.content ?? []), command, ["id", "sessionId", "name", "startTime", "durationMs", "turnCount", "errorCount", "costUsd"]);
         });
     });
     sessions.addCommand(sessionsList);
     const sessionsGet = new Command("get").description("Get all spans of a session by id, sorted chronologically");
-    sessionsGet.argument("<sessionId>", "Session id");
-    sessionsGet.action(async (sessionId, _opts, command) => {
+    sessionsGet.argument("<id>", "Session id: the id column of `sessions list` (find one by session.id with --session-id)");
+    sessionsGet.action(async (id, _opts, command) => {
         await runAction(command, async () => {
             const client = getClient(command);
-            const { data } = await client.GET("/v1/traces/sessions/{sessionId}", {
-                params: { path: { sessionId } },
+            const { data } = await client.GET("/v1/traces/sessions/{id}", {
+                params: { path: { id } },
             });
             formatDetail(data, command);
         });

package/dist/lib/agent-decide.d.ts

@@ -22,21 +22,47 @@ export interface PromptAnswer {
     reason?: string;
     remember?: boolean;
 }
+/** One relayed tool call answered by `--output` or `--fail` (#671 D2, D3). */
+export interface ToolAnswer {
+    callId: string;
+    /** Sent verbatim as the item's `output` string. */
+    output: string;
+    failed: boolean;
+}
+export interface ToolAnswerIo {
+    readFile: (path: string) => string;
+    readStdin: () => string;
+}
+/**
+ * `--output` and `--fail` values as `<callId>=<value>`, split on the first `=`. `@<path>` reads a file and
+ * `@-` reads stdin, both verbatim. Only syntax is checked here: without stored state the CLI cannot list the
+ * calls a response released, so completeness is the server's check (#671 D4). Every check runs before any read.
+ */
+export declare function parseToolAnswers(outputs?: string[], fails?: string[], io?: ToolAnswerIo): ToolAnswer[];
 export declare function fetchPendingApprovals(client: ApiClient, agentId: string, responseId: string): Promise<ApprovalRow[]>;
 /**
  * The backend refuses a continuation that leaves any pending approval of the paused
  * response undecided (400 incomplete_tool_outputs), so the whole set is checked here first.
  */
 export declare function planDecisions(pending: ApprovalRow[], opts: DecideOptions, responseId: string): Decision[];
+/**
+ * The decisions a `decide` call sends beside its tool answers (#671 D5). A pure relay pause has no pending
+ * approval, so the approval flags are optional there: `--approve-all` / `--reject-all` add nothing (P1) and
+ * only explicit ids are refused. A mixed pause needs its approvals decided in the same call.
+ */
+export declare function planContinuation(pending: ApprovalRow[], opts: DecideOptions, toolAnswers: ToolAnswer[], responseId: string): Decision[];
 export declare function decisionsFromAnswers(pending: ApprovalRow[], answers: Map<string, PromptAnswer>): Decision[];
 /** Same item shape as n8n Decide Approval (#660). */
 export declare function toApprovalItems(decisions: Decision[]): Record<string, string>[];
+/** `failed: true` is Backbone's extension (#480): the tool's span ends ERROR. */
+export declare function toToolOutputItems(answers: ToolAnswer[]): Record<string, string | boolean>[];
 /**
  * Continues on `agent/<agentId>[@<label>][#<model>]` with the label and model override the run used: the
  * server resolves the continuation's tools, instructions and model from this reference, so both must match
  * the run's or the continuation drops to another version or the agent's default model.
  * Never the echoed `name@<versionNumber>` (it would 404 as a label).
  * With `mode`, the `backbone:mode` item follows the decisions (#656 D7); without it, nothing is added (D2).
+ * Tool answers go first, in flag order (#671 D6): the server replays accepted outputs ahead of other items.
  */
-export declare function continueWithDecisions(client: ApiClient, agentId: string, responseId: string, decisions: Decision[], label?: string, model?: string, mode?: ConversationMode): Promise<ResponsesResult>;
+export declare function continueWithDecisions(client: ApiClient, agentId: string, responseId: string, decisions: Decision[], label?: string, model?: string, mode?: ConversationMode, toolAnswers?: ToolAnswer[]): Promise<ResponsesResult>;
 //# sourceMappingURL=agent-decide.d.ts.map

package/dist/lib/agent-decide.js

@@ -1,6 +1,69 @@
+import { readFileSync } from "node:fs";
 import { modeItem } from "./agent-run.js";
 import { CliUsageError } from "./errors.js";
 import { paginationParams } from "./pagination.js";
+const defaultIo = {
+    readFile: (path) => readFileSync(path, "utf-8"),
+    // Not readStdinInput: that one trims, and a tool result is sent as read (P5).
+    readStdin: () => readFileSync(0, "utf-8"),
+};
+/**
+ * `--output` and `--fail` values as `<callId>=<value>`, split on the first `=`. `@<path>` reads a file and
+ * `@-` reads stdin, both verbatim. Only syntax is checked here: without stored state the CLI cannot list the
+ * calls a response released, so completeness is the server's check (#671 D4). Every check runs before any read.
+ */
+export function parseToolAnswers(outputs = [], fails = [], io = defaultIo) {
+    const entries = [
+        ...outputs.map((raw) => ({ raw, flag: "--output", noun: "value", failed: false })),
+        ...fails.map((raw) => ({ raw, flag: "--fail", noun: "message", failed: true })),
+    ].map(({ raw, flag, noun, failed }) => {
+        const eq = raw.indexOf("=");
+        if (eq < 0)
+            throw new CliUsageError(`Invalid ${flag} '${raw}': use <callId>=<${noun}>.`);
+        const callId = raw.slice(0, eq);
+        if (!callId)
+            throw new CliUsageError(`Invalid ${flag} '${raw}': the call id is empty.`);
+        return { callId, value: raw.slice(eq + 1), failed };
+    });
+    const seen = new Map();
+    for (const e of entries) {
+        const before = seen.get(e.callId);
+        if (before === undefined) {
+            seen.set(e.callId, e.failed);
+        }
+        else if (before === e.failed) {
+            throw new CliUsageError(`Tool call ${e.callId} is answered more than once.`);
+        }
+        else {
+            throw new CliUsageError(`Tool call ${e.callId} is answered by both --output and --fail.`);
+        }
+    }
+    if (entries.filter((e) => e.value === "@-").length > 1) {
+        throw new CliUsageError("Only one --output or --fail value can read stdin (@-).");
+    }
+    return entries.map(({ callId, value, failed }) => ({ callId, output: readAnswerValue(value, io), failed }));
+}
+function readAnswerValue(value, io) {
+    if (value === "@-") {
+        try {
+            return io.readStdin();
+        }
+        catch (err) {
+            // A closed or non-blocking stdin (EAGAIN, EOF) is a usage error like an unreadable file.
+            throw new CliUsageError(`stdin: cannot read (${err.code ?? err.message})`);
+        }
+    }
+    if (!value.startsWith("@"))
+        return value;
+    const path = value.slice(1);
+    try {
+        return io.readFile(path);
+    }
+    catch (err) {
+        const code = err.code;
+        throw new CliUsageError(`${path}: cannot read file (${code ?? err.message})`);
+    }
+}
 const MAX_PAGES = 50;
 export async function fetchPendingApprovals(client, agentId, responseId) {
     const rows = [];
@@ -41,7 +104,8 @@ export function planDecisions(pending, opts, responseId) {
         throw new CliUsageError("Use either --approve-all / --reject-all or explicit --approve / --reject ids, not both.");
     }
     if (!usesAll && approve.length === 0 && reject.length === 0) {
-        throw new CliUsageError("Choose a decision: --approve <ids...>, --reject <ids...>, --approve-all or --reject-all.");
+        throw new CliUsageError("Choose a decision: --approve <ids...>, --reject <ids...>, --approve-all or --reject-all " +
+            "(and answer relayed tool calls with --output / --fail).");
     }
     const choice = new Map();
     if (usesAll) {
@@ -84,6 +148,26 @@ export function planDecisions(pending, opts, responseId) {
         };
     });
 }
+/**
+ * The decisions a `decide` call sends beside its tool answers (#671 D5). A pure relay pause has no pending
+ * approval, so the approval flags are optional there: `--approve-all` / `--reject-all` add nothing (P1) and
+ * only explicit ids are refused. A mixed pause needs its approvals decided in the same call.
+ */
+export function planContinuation(pending, opts, toolAnswers, responseId) {
+    if (toolAnswers.length === 0)
+        return planDecisions(pending, opts, responseId);
+    const ids = [...(opts.approve ?? []), ...(opts.reject ?? [])];
+    if (pending.length === 0) {
+        if (ids.length)
+            throw new CliUsageError(`Not pending on ${responseId}: ${ids.join(", ")}`);
+        return [];
+    }
+    if (!opts.approveAll && !opts.rejectAll && ids.length === 0) {
+        throw new CliUsageError(`${responseId} also waits for approvals: every relayed tool call and every pending approval must be answered ` +
+            `in one call. Undecided: ${pending.map((r) => r.id).join(", ")} (add --approve-all, --reject-all or the ids).`);
+    }
+    return planDecisions(pending, opts, responseId);
+}
 export function decisionsFromAnswers(pending, answers) {
     return pending.map((r) => {
         const answer = answers.get(String(r.id));
@@ -109,20 +193,30 @@ export function toApprovalItems(decisions) {
         ...(d.remember ? { remember: d.remember } : {}),
     }));
 }
+/** `failed: true` is Backbone's extension (#480): the tool's span ends ERROR. */
+export function toToolOutputItems(answers) {
+    return answers.map((a) => ({
+        type: "function_call_output",
+        call_id: a.callId,
+        output: a.output,
+        ...(a.failed ? { failed: true } : {}),
+    }));
+}
 /**
  * Continues on `agent/<agentId>[@<label>][#<model>]` with the label and model override the run used: the
  * server resolves the continuation's tools, instructions and model from this reference, so both must match
  * the run's or the continuation drops to another version or the agent's default model.
  * Never the echoed `name@<versionNumber>` (it would 404 as a label).
  * With `mode`, the `backbone:mode` item follows the decisions (#656 D7); without it, nothing is added (D2).
+ * Tool answers go first, in flag order (#671 D6): the server replays accepted outputs ahead of other items.
  */
-export async function continueWithDecisions(client, agentId, responseId, decisions, label, model, mode) {
-    const approvals = toApprovalItems(decisions);
+export async function continueWithDecisions(client, agentId, responseId, decisions, label, model, mode, toolAnswers = []) {
+    const items = [...toToolOutputItems(toolAnswers), ...toApprovalItems(decisions)];
     const body = {
         model: `agent/${agentId}${label ? `@${label}` : ""}${model ? `#${model}` : ""}`,
         previous_response_id: responseId,
         stream: false,
-        input: mode ? [...approvals, modeItem(mode)] : approvals,
+        input: mode ? [...items, modeItem(mode)] : items,
     };
     // The generated body type does not model backbone: extension items, hence the cast.
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/lib/agent-run.d.ts

@@ -28,7 +28,8 @@ export interface PendingToolCall {
 /**
  * A connector the run waits for the user to connect, allow or reconnect in chat.2kw.ai: an open
  * `backbone:connector_auth_request` (#807 R12). The caller never answers the connect call; the
- * continuation re-checks access itself.
+ * continuation re-checks access itself. Decoded by `connect-pause.ts` (#1086), whose `id` and
+ * `callId` the envelope does not publish.
  */
 export interface PendingConnection {
     serverLabel: string;

package/dist/lib/agent-run.js

@@ -1,5 +1,6 @@
 import chalk from "chalk";
 import { DEFAULT_CHAT_URL } from "./config.js";
+import { connectCallIds, connectionsPhrase, pendingConnectionsOf } from "./connect-pause.js";
 import { CliUsageError } from "./errors.js";
 export const CONVERSATION_MODES = ["plan", "ask", "auto"];
 /** `--mode` help text, in the words of the embedded chat's mode chip (#655). */
@@ -92,53 +93,32 @@ export function shellQuote(value) {
         return value;
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-/** An open connector consent request; a continuation's projection carries another status. */
-function pendingConnectionsOf(output) {
-    return output
-        .filter((i) => i.type === "backbone:connector_auth_request" && (i.status === undefined || i.status === "in_progress"))
-        .map((i) => ({
-        serverLabel: String(i.server_label),
-        host: String(i.host),
-        reason: String(i.reason),
-        ...(Array.isArray(i.destinations) && i.destinations.length > 0
-            ? { destinations: i.destinations.map((d) => String(d)) }
-            : {}),
-    }));
-}
-/**
- * The call ids a connect pause withholds from the caller: the call each request names, and every
- * `mcp__<label>__connect` call for a pending connector (the model may call it more than once; one
- * request stands for all of them).
- */
-function connectCallIds(output, connections) {
-    const connectNames = new Set(connections.map((c) => `mcp__${c.serverLabel}__connect`));
-    const ids = new Set();
-    for (const item of output) {
-        if (item.type === "backbone:connector_auth_request" && (item.status === undefined || item.status === "in_progress")) {
-            ids.add(String(item.call_id));
-        }
-        else if (item.type === "function_call" && connectNames.has(String(item.name))) {
-            ids.add(String(item.call_id));
-        }
-    }
-    return ids;
-}
-function connectionPhrase(c) {
-    const target = `${c.serverLabel} (${c.host})`;
-    if (c.reason === "allow")
-        return `allow the agent to use ${target}`;
-    if (c.reason === "reconnect")
-        return `reconnect ${target}`;
-    return `connect ${target}`;
-}
 /** "Connect a (h), allow the agent to use b (h) and reconnect c (h)". */
 export function connectionsSentence(connections) {
-    const phrases = connections.map(connectionPhrase);
-    const joined = phrases.length > 1 ? `${phrases.slice(0, -1).join(", ")} and ${phrases.at(-1)}` : phrases[0] ?? "";
+    const joined = connectionsPhrase(connections);
     return joined.charAt(0).toUpperCase() + joined.slice(1);
 }
 /** Joins a connect pause's instruction to the command that continues it; {@link printRunText} breaks the line there. */
 const THEN_RUN = ", then run: ";
+/**
+ * The `decide` command that answers a relay pause (#671 D7): one `--output <callId>=@<file>` per pending call,
+ * plus `--approve-all` when approvals wait too. The call id is chosen by the model, so the suggested file name
+ * keeps only `[A-Za-z0-9_-]` (P2) and never repeats: it can be neither `../…` nor an absolute path.
+ */
+function relayDecideCommand(ref, responseId, calls, withApprovals) {
+    const used = new Set();
+    const outputs = calls.map((c) => {
+        const safe = c.callId.replace(/[^A-Za-z0-9_-]/g, "_");
+        let file = safe;
+        // Compared without case: on Windows and macOS `callA.out` and `calla.out` are one file.
+        for (let n = 2; used.has(file.toLowerCase()); n++)
+            file = `${safe}-${n}`;
+        used.add(file.toLowerCase());
+        return ` --output ${shellQuote(`${c.callId}=@${file}.out`)}`;
+    });
+    return (`2kw agents decide ${shellQuote(ref)} --response ${shellQuote(responseId)}${outputs.join("")}` +
+        (withApprovals ? " --approve-all" : ""));
+}
 /**
  * Output item types the envelope decodes, or that never hold a run: text, reasoning and finished
  * connector calls. A pause on anything else (a connector approval's `mcp_approval_request`) is named.
@@ -185,8 +165,15 @@ export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
         reason: typeof i.reason === "string" && i.reason ? i.reason : null,
         preview: i.preview && typeof i.preview === "object" && !Array.isArray(i.preview) ? i.preview : null,
     }));
-    const pendingConnections = pendingConnectionsOf(output);
-    const withheldCallIds = new Set([...pendingApprovals.map((a) => a.callId), ...connectCallIds(output, pendingConnections)]);
+    // The one decoding rule (#1086): only an open request with its id, call id, label and host.
+    const connectRequests = pendingConnectionsOf(output);
+    const pendingConnections = connectRequests.map(({ serverLabel, host, reason, destinations }) => ({
+        serverLabel,
+        host,
+        reason,
+        ...(destinations ? { destinations } : {}),
+    }));
+    const withheldCallIds = new Set([...pendingApprovals.map((a) => a.callId), ...connectCallIds(output, connectRequests)]);
     const toolCalls = [];
     const pendingToolCalls = [];
     for (const item of output) {
@@ -225,8 +212,16 @@ export function buildRunEnvelope(result, agentRef, chatUrl = DEFAULT_CHAT_URL) {
     if (status === "requires_approval" && ref && responseId) {
         next = `2kw agents decide ${shellQuote(ref)} --response ${responseId} --approve-all`;
     }
-    else if (status === "requires_tool_output" && pendingConnections.length > 0 && pendingToolCalls.length === 0 && responseId) {
-        // Not with a relayed call beside it: a continuation without that call's output is refused.
+    else if (status === "requires_tool_output" && pendingToolCalls.length > 0) {
+        // The engine answers the connect call itself on the continuation, so connecting first is enough.
+        if (ref && responseId) {
+            const decide = relayDecideCommand(ref, responseId, pendingToolCalls, pendingApprovals.length > 0);
+            next = pendingConnections.length > 0
+                ? `${connectionsSentence(pendingConnections)} in ${chatUrl}/connectors${THEN_RUN}${decide}`
+                : decide;
+        }
+    }
+    else if (status === "requires_tool_output" && pendingConnections.length > 0 && responseId) {
         // `agents run --continue` needs no input: the continuation re-checks access itself.
         const resume = ref
             ? `${THEN_RUN}2kw agents run ${shellQuote(ref)} --continue ${shellQuote(responseId)}`
@@ -272,19 +267,32 @@ export function printRunText(env) {
         console.log(chalk.dim(`\n── ${s(head.join(" · "))}`));
     if (env.toolCalls.length)
         console.log(chalk.dim(`   tools: ${env.toolCalls.map((c) => `${s(c.tool)} ${c.status === "incomplete" ? "✗" : "✓"}`).join("  ")}`));
+    const printApprovals = () => env.pendingApprovals.forEach((a, i) => {
+        console.log(`  ${i + 1}. ${s(a.tool)} [${s(a.policyClass)}] ${s(a.approvalId)}`);
+        // JSON.stringify escapes C0 controls but leaves DEL and C1 raw.
+        console.log(chalk.dim(`     ${s(JSON.stringify(a.arguments))}`));
+        if (a.reason)
+            console.log(chalk.dim(`     reason: ${s(a.reason)}`));
+    });
     if (env.status === "requires_approval") {
         console.log(chalk.yellow("\nPaused for approval:"));
-        env.pendingApprovals.forEach((a, i) => {
-            console.log(`  ${i + 1}. ${s(a.tool)} [${s(a.policyClass)}] ${s(a.approvalId)}`);
-            // JSON.stringify escapes C0 controls but leaves DEL and C1 raw.
-            console.log(chalk.dim(`     ${s(JSON.stringify(a.arguments))}`));
-            if (a.reason)
-                console.log(chalk.dim(`     reason: ${s(a.reason)}`));
-        });
+        printApprovals();
         if (env.next)
             console.log(`\nDecide with:\n  ${s(env.next)}`);
     }
     else if (env.status === "requires_tool_output") {
+        if (env.pendingToolCalls.length) {
+            console.log(chalk.yellow("\nPaused: the agent waits for client-side tool output:"));
+            env.pendingToolCalls.forEach((c) => {
+                console.log(`  - ${s(c.tool)} (${s(c.callId)})`);
+                console.log(chalk.dim(`    ${s(JSON.stringify(c.arguments))}`));
+            });
+            // The printed command carries --approve-all, so show what it approves (#671 P3).
+            if (env.pendingApprovals.length) {
+                console.log(chalk.yellow("\nIt also waits for approval:"));
+                printApprovals();
+            }
+        }
         if (env.pendingConnections.length) {
             console.log(chalk.yellow("\nPaused: the agent needs you to connect in chat:"));
             env.pendingConnections.forEach((c) => {
@@ -296,9 +304,8 @@ export function printRunText(env) {
             if (env.next)
                 console.log(`\n${s(env.next.replace(THEN_RUN, ", then run:\n  "))}`);
         }
-        if (env.pendingToolCalls.length) {
-            console.log(chalk.yellow("\nPaused: the agent needs client-side tool output this CLI cannot provide:"));
-            env.pendingToolCalls.forEach((c) => console.log(`  - ${s(c.tool)} (${s(c.callId)})`));
+        else if (env.pendingToolCalls.length && env.next) {
+            console.log(`\nAnswer with:\n  ${s(env.next)}`);
         }
         if (!env.pendingConnections.length && !env.pendingToolCalls.length) {
             console.log(chalk.yellow("\nPaused on something this CLI cannot show:"));

package/dist/lib/config.d.ts

@@ -52,12 +52,12 @@ export declare const DEFAULT_BASE_URL: string;
  */
 export declare const DEFAULT_AUTH_URL: string;
 export declare function defaultAuthUrlFor(baseUrl: string): string;
-/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
-export declare const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
+export { DEFAULT_CHAT_URL } from "./connect-pause.js";
 /**
  * The chat web host that belongs to an API base URL, where a member connects a connector
  * (`<chat>/connectors`). `AI_2KW_CHAT_URL` overrides the mapping, for deployments the map
- * does not know; a trailing slash is dropped so callers can append a path.
+ * does not know; a trailing slash is dropped so callers can append a path. The mapping itself
+ * is `connect-pause.ts`'s {@link chatOriginFor}, shared with the MCP server and n8n (#1086).
  */
 export declare function chatUrlFor(baseUrl: string, env?: NodeJS.ProcessEnv): string;
 declare const store: Conf<BackboneConfigStore>;

package/dist/lib/config.js

@@ -1,6 +1,7 @@
 import Conf from "conf";
 import { readFileSync, existsSync } from "node:fs";
 import { resolve } from "node:path";
+import { chatOriginFor } from "./connect-pause.js";
 /**
  * Fallback base URL when the user has no context, env var, or local config.
  * Override at runtime by setting AI_2KW_DEFAULT_BASE_URL (or the legacy
@@ -36,33 +37,18 @@ export function defaultAuthUrlFor(baseUrl) {
         return DEFAULT_AUTH_URL;
     }
 }
-/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
-export const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
-/** Known API-host → chat web host mappings; a connect pause points the user there (#807 R11). */
-const CHAT_URL_BY_API_HOST = {
-    "api.2kw.ai": "https://chat.2kw.ai",
-    "api-dev.2kw.ai": "https://chat-dev.2kw.ai",
-    "backbone.manfred-kunze.dev": "https://chat.2kw.ai",
-    "localhost:8080": "http://localhost:3000",
-    "127.0.0.1:8080": "http://localhost:3000",
-};
+export { DEFAULT_CHAT_URL } from "./connect-pause.js";
 /**
  * The chat web host that belongs to an API base URL, where a member connects a connector
  * (`<chat>/connectors`). `AI_2KW_CHAT_URL` overrides the mapping, for deployments the map
- * does not know; a trailing slash is dropped so callers can append a path.
+ * does not know; a trailing slash is dropped so callers can append a path. The mapping itself
+ * is `connect-pause.ts`'s {@link chatOriginFor}, shared with the MCP server and n8n (#1086).
  */
 export function chatUrlFor(baseUrl, env = process.env) {
     const override = env.AI_2KW_CHAT_URL?.trim();
     if (override)
         return override.replace(/\/+$/, "");
-    try {
-        const host = new URL(baseUrl).host;
-        // hasOwn, as in defaultAuthUrlFor: a host named after an Object.prototype key must not resolve.
-        return Object.hasOwn(CHAT_URL_BY_API_HOST, host) ? CHAT_URL_BY_API_HOST[host] : DEFAULT_CHAT_URL;
-    }
-    catch {
-        return DEFAULT_CHAT_URL;
-    }
+    return chatOriginFor(baseUrl);
 }
 // One-shot flag so we only print the deprecation warning once per process,
 // even if resolveConfig is called multiple times across commands.

package/dist/lib/connect-pause.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The connect pause, decoded one way for every client (#1086, spec §4, D4): an open
+ * `backbone:connector_auth_request` (#807 R12) is a connector the run waits for the user to
+ * connect, allow or reconnect in chat.2kw.ai.
+ *
+ * This file is canonical. `mcp/src/lib/connect-pause.ts` and
+ * `n8n/nodes/TwoKw/operations/connect-pause.ts` are byte copies of it under a header: edit it
+ * here, then run `npm run sync:connect-pause` in mcp/ and `npm run sync-connect-pause` in n8n/.
+ * Its golden fixture, `cli/tests/fixtures/connect-pause-cases.json`, is copied the same way into
+ * mcp/, n8n/ and surface/, and every client's decoder test runs every case of it.
+ *
+ * Plain TypeScript with no imports, no `process`, no Node types and no timers, so n8n's source
+ * scanner and its empty `dependencies` accept the copy. The CLI and the MCP server keep their
+ * `AI_2KW_CHAT_URL` override in their own code, around {@link chatOriginFor}.
+ */
+/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
+export declare const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
+/** Known API-host → chat web host mappings; a connect pause points the user there (#807 R11). */
+export declare const CHAT_URL_BY_API_HOST: Readonly<Record<string, string>>;
+/**
+ * The chat web host that belongs to an API base URL, where a member connects a connector
+ * (`<chat>/connectors`). An unknown host, an unparsable URL or no URL at all is chat.2kw.ai.
+ */
+export declare function chatOriginFor(baseUrl: unknown): string;
+/** What the user is asked to do: connect, allow the agent, or reconnect. */
+export type ConnectReason = "connect" | "allow" | "reconnect";
+export declare const CONNECT_REASONS: readonly ConnectReason[];
+/**
+ * One open connect request. `id` (`cauth_<call id>`) and `callId` (the first connect call for
+ * this connector) are what a client needs to withhold the connect calls; the CLI and the MCP
+ * server drop both from what they publish.
+ */
+export interface PendingConnection {
+    id: string;
+    callId: string;
+    serverLabel: string;
+    /** The MCP server's host: what the user is asked to connect to. */
+    host: string;
+    reason: ConnectReason;
+    /** The egress difference an allow is asked again for (#807 R9); absent otherwise, never empty. */
+    destinations?: string[];
+}
+/** Enough of a connection to name it in a sentence. */
+export interface ConnectTarget {
+    serverLabel: string;
+    host: string;
+    reason: string;
+}
+/** The synthetic tool a connector's connect pause is raised through (#806). */
+export declare function connectToolName(serverLabel: string): string;
+/**
+ * The connectors a response's `output` still waits on: every `in_progress` connect request whose
+ * id no other-status projection in the same list resolved, one per id, in order. An item without
+ * a non-empty `id`, `call_id`, `server_label` or `host` cannot be acted on and is skipped; a
+ * `reason` outside the three reads as `connect`, the action that always applies; only the string
+ * entries of `destinations` are kept, and none at all omits the field.
+ */
+export declare function pendingConnectionsOf(output: unknown): PendingConnection[];
+/**
+ * The call ids a connect pause withholds from the caller: the call each pending request names;
+ * the own `call_id` of every open connect request, even one {@link pendingConnectionsOf} could not
+ * describe (a missing `server_label` or `host`), since a connect call is the engine's to answer,
+ * never the client's (R7); and every `mcp__<label>__connect` call for a connector in
+ * `connections` (the model may call it more than once; one request stands for all of them).
+ */
+export declare function connectCallIds(output: unknown, connections: readonly Pick<PendingConnection, "callId" | "serverLabel">[]): Set<string>;
+/** "connect erp (erp.example.com)", "allow the agent to use …" or "reconnect …". */
+export declare function connectionPhrase(c: ConnectTarget): string;
+/** "connect a (h), allow the agent to use b (h) and reconnect c (h)"; empty for none. */
+export declare function connectionsPhrase(connections: readonly ConnectTarget[]): string;
+//# sourceMappingURL=connect-pause.d.ts.map

package/dist/lib/connect-pause.js

@@ -0,0 +1,147 @@
+/**
+ * The connect pause, decoded one way for every client (#1086, spec §4, D4): an open
+ * `backbone:connector_auth_request` (#807 R12) is a connector the run waits for the user to
+ * connect, allow or reconnect in chat.2kw.ai.
+ *
+ * This file is canonical. `mcp/src/lib/connect-pause.ts` and
+ * `n8n/nodes/TwoKw/operations/connect-pause.ts` are byte copies of it under a header: edit it
+ * here, then run `npm run sync:connect-pause` in mcp/ and `npm run sync-connect-pause` in n8n/.
+ * Its golden fixture, `cli/tests/fixtures/connect-pause-cases.json`, is copied the same way into
+ * mcp/, n8n/ and surface/, and every client's decoder test runs every case of it.
+ *
+ * Plain TypeScript with no imports, no `process`, no Node types and no timers, so n8n's source
+ * scanner and its empty `dependencies` accept the copy. The CLI and the MCP server keep their
+ * `AI_2KW_CHAT_URL` override in their own code, around {@link chatOriginFor}.
+ */
+/** Fallback chat.2kw.ai origin when the API host is not one we recognise. */
+export const DEFAULT_CHAT_URL = "https://chat.2kw.ai";
+/** Known API-host → chat web host mappings; a connect pause points the user there (#807 R11). */
+export const CHAT_URL_BY_API_HOST = {
+    "api.2kw.ai": "https://chat.2kw.ai",
+    "api-dev.2kw.ai": "https://chat-dev.2kw.ai",
+    "backbone.manfred-kunze.dev": "https://chat.2kw.ai",
+    "localhost:8080": "http://localhost:3000",
+    "127.0.0.1:8080": "http://localhost:3000",
+};
+/**
+ * The chat web host that belongs to an API base URL, where a member connects a connector
+ * (`<chat>/connectors`). An unknown host, an unparsable URL or no URL at all is chat.2kw.ai.
+ */
+export function chatOriginFor(baseUrl) {
+    try {
+        const host = new URL(String(baseUrl ?? "")).host;
+        // hasOwn, not a bare index: a host named after an Object.prototype key must not resolve.
+        return Object.hasOwn(CHAT_URL_BY_API_HOST, host) ? CHAT_URL_BY_API_HOST[host] ?? DEFAULT_CHAT_URL : DEFAULT_CHAT_URL;
+    }
+    catch {
+        return DEFAULT_CHAT_URL;
+    }
+}
+export const CONNECT_REASONS = ["connect", "allow", "reconnect"];
+const CONNECT_REQUEST = "backbone:connector_auth_request";
+function itemsOf(output) {
+    if (!Array.isArray(output))
+        return [];
+    return output.filter((item) => typeof item === "object" && item !== null && !Array.isArray(item));
+}
+function text(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+/** The synthetic tool a connector's connect pause is raised through (#806). */
+export function connectToolName(serverLabel) {
+    return `mcp__${serverLabel}__connect`;
+}
+/**
+ * The connectors a response's `output` still waits on: every `in_progress` connect request whose
+ * id no other-status projection in the same list resolved, one per id, in order. An item without
+ * a non-empty `id`, `call_id`, `server_label` or `host` cannot be acted on and is skipped; a
+ * `reason` outside the three reads as `connect`, the action that always applies; only the string
+ * entries of `destinations` are kept, and none at all omits the field.
+ */
+export function pendingConnectionsOf(output) {
+    const items = itemsOf(output);
+    const resolved = new Set();
+    for (const item of items) {
+        const id = text(item.id);
+        if (item.type === CONNECT_REQUEST && id && item.status !== "in_progress")
+            resolved.add(id);
+    }
+    const pending = new Map();
+    for (const item of items) {
+        if (item.type !== CONNECT_REQUEST || item.status !== "in_progress")
+            continue;
+        const id = text(item.id);
+        const callId = text(item.call_id);
+        const serverLabel = text(item.server_label);
+        const host = text(item.host);
+        if (!id || !callId || !serverLabel || !host || resolved.has(id) || pending.has(id))
+            continue;
+        const reason = text(item.reason);
+        const destinations = Array.isArray(item.destinations)
+            ? item.destinations.filter((entry) => typeof entry === "string")
+            : [];
+        pending.set(id, {
+            id,
+            callId,
+            serverLabel,
+            host,
+            reason: reason && CONNECT_REASONS.includes(reason) ? reason : "connect",
+            ...(destinations.length > 0 ? { destinations } : {}),
+        });
+    }
+    return [...pending.values()];
+}
+/**
+ * The call ids a connect pause withholds from the caller: the call each pending request names;
+ * the own `call_id` of every open connect request, even one {@link pendingConnectionsOf} could not
+ * describe (a missing `server_label` or `host`), since a connect call is the engine's to answer,
+ * never the client's (R7); and every `mcp__<label>__connect` call for a connector in
+ * `connections` (the model may call it more than once; one request stands for all of them).
+ */
+export function connectCallIds(output, connections) {
+    const names = new Set(connections.map((c) => connectToolName(c.serverLabel)));
+    const ids = new Set(connections.map((c) => c.callId));
+    const items = itemsOf(output);
+    // Every open connect request's own call id is withheld, even one pendingConnectionsOf could
+    // not fully describe (a missing server_label or host): the paired function_call must never be
+    // left for the caller to fabricate an output for (R7).
+    const resolved = new Set();
+    for (const item of items) {
+        const id = text(item.id);
+        if (item.type === CONNECT_REQUEST && id && item.status !== "in_progress")
+            resolved.add(id);
+    }
+    for (const item of items) {
+        if (item.type !== CONNECT_REQUEST || item.status !== "in_progress")
+            continue;
+        const id = text(item.id);
+        if (id && resolved.has(id))
+            continue;
+        const callId = text(item.call_id);
+        if (callId)
+            ids.add(callId);
+    }
+    for (const item of items) {
+        const callId = text(item.call_id);
+        if (item.type === "function_call" && callId && typeof item.name === "string" && names.has(item.name))
+            ids.add(callId);
+    }
+    return ids;
+}
+/** "connect erp (erp.example.com)", "allow the agent to use …" or "reconnect …". */
+export function connectionPhrase(c) {
+    const target = `${c.serverLabel} (${c.host})`;
+    if (c.reason === "allow")
+        return `allow the agent to use ${target}`;
+    if (c.reason === "reconnect")
+        return `reconnect ${target}`;
+    return `connect ${target}`;
+}
+/** "connect a (h), allow the agent to use b (h) and reconnect c (h)"; empty for none. */
+export function connectionsPhrase(connections) {
+    const phrases = connections.map(connectionPhrase);
+    if (phrases.length < 2)
+        return phrases[0] ?? "";
+    return `${phrases.slice(0, -1).join(", ")} and ${phrases[phrases.length - 1]}`;
+}
+//# sourceMappingURL=connect-pause.js.map

package/dist/lib/errors.js

@@ -95,7 +95,9 @@ const PENDING_APPROVALS_HINT = "The approval was already decided or its response
 const CODE_HINTS = {
     approval_hmac_mismatch: PENDING_APPROVALS_HINT,
     unknown_approval_id: PENDING_APPROVALS_HINT,
-    incomplete_tool_outputs: "Every pending approval of a paused response must be decided in one call. Use --approve-all or --reject-all, or name every id.",
+    incomplete_tool_outputs: "Every released tool call and every pending approval of a paused response must be answered in one call. " +
+        "Check pendingToolCalls and pendingApprovals in the run envelope.",
+    unknown_tool_output: "That call id was not released by this response. Use the responseId of the latest envelope.",
     conversation_agent_mismatch: "This conversation belongs to another agent. Start a new conversation or run the agent that owns it.",
 };
 /** The most specific hint for an API error: gateway code, then known messages, then the status table. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2kw/ai",
-  "version": "6.3.0-dev.96",
+  "version": "6.3.0",
   "description": "CLI for 2kw.ai — schema-driven document extraction, an OpenAI-compatible EU LLM gateway, transcription, prompts, datasets, and experiments from your terminal or agentic workflows. Ships as 2kw, backbone, and bb.",
   "keywords": [
     "cli",