specpi 0.15.0 → 0.17.0

package/docs/delegation/protocol.md

@@ -4,8 +4,12 @@ This is the implemented in-process API. It has no HTTP listener, daemon, child p
 or child session store. The broader [target protocol](design-protocol.md) remains a
 proposal; its stronger transport/attempt/cost gates are not supplied by this version.
 
-The extension loads through normal `pi` package discovery and remains disabled until
-the human runs `/delegate on`. Compatibility is checked through required public SDK
+The extension loads through normal `pi` package discovery and enables delegation at
+the first session start of each Pi process, including noninteractive modes. Startup
+preflights the host but launches no workers or model inference; Pi-owned authentication
+preparation may occur. `/delegate off` and safety revocations survive reloads and session
+switches; `/delegate on` re-enables it, and restarting Pi reapplies the on default.
+Compatibility is checked through required public SDK
 capabilities; there is no exact-version allowlist. Missing APIs prevent activation and
 are named in the error. The runtime also verifies the created session's thinking,
 tools and streaming interface. Tested versions are evidence, not an activation gate.
@@ -18,7 +22,7 @@ overrides, model-specific headers, startup proxy configuration and safe model-de
 mismatches fail preflight. Parent request hooks,
 ephemeral runtime settings, session affinity and ambient resources are not inherited.
 
-Command Guard is optional. Absent and Off states permit human activation; an installed
+Command Guard is optional. Absent and Off states permit activation; an installed
 Guard's Strict approvals and explicit locks remain enforced. Unready or duplicate
 Guard responders prevent activation with a specific error. Guard state changes revoke
 the current delegation generation. Snapshot tools and resource limits are enforced
@@ -51,7 +55,7 @@ policy rather than assuming the shipped default.
 
 ## Submit a batch
 
-After the human runs `/delegate on`, the parent calls the `delegate` tool:
+When delegation is enabled, the parent calls the `delegate` tool:
 
 ```json
 {
@@ -168,9 +172,18 @@ job selection and valid line ranges. `p1` denotes the submitted inline context;
 does not denote the parent transcript or prove repository behavior. `observed` requires
 at least one reference. At most eight findings and 16 KiB are retained.
 
-Malformed reports fail the attempt. There is no automatic retry. Provider exceptions
-are reduced to a generic failure message because raw errors may contain sensitive URLs
-or content. Missing usage is explicit; failed calls still consume invocation allowance.
+Malformed reports receive a correction prompt in the same child session. Previously
+read passages remain available; each correction must pass the normal inference admission
+and context/deadline checks. Ordinary selected-source argument errors return feedback
+and count their delivered JSON toward the tool-byte allowance. SDK argument-validation
+errors can also be corrected; source changes, revocation and quota exhaustion still abort.
+Provider requests are not automatically retried. Diagnostics distinguish
+source-tool failures, provider requests, stream/context/response bounds, output-token
+truncation, empty reports, JSON parsing, and schema/evidence validation. Only fixed stage
+messages and allowlisted validation reasons are returned; raw provider errors and rejected
+report text may contain sensitive URLs or content and are withheld. The original tool
+diagnostic survives SDK cancellation. Missing usage is explicit; failed calls still
+consume invocation allowance.
 
 ## Follow up and resolve
 
@@ -219,7 +232,8 @@ automatic tool execution, verified completion, or wishlist authorization.
 
 All mutations require `requestId`. Successful runs, follow-ups and final dispositions
 retain their replay receipts for the process lifetime; the fixed batch/job ceilings
-bound these to at most 20 entries. Replaying a retained request returns its stored
+bound these to at most five entries per admitted batch (160 at the default budget;
+1,280 at the maximum). Replaying a retained request returns its stored
 response without another request or transition. Reusing a retained ID with a different
 payload fails. Failed requests do not reserve IDs and may be corrected or retried.
 Successful cancellation and `needs_check` responses use a separate 128-entry oldest-first
@@ -241,14 +255,20 @@ SDK-visible stream/result and prompt settlement. Old payloads are discarded. Nei
 terminal receipt delivery nor SDK settlement proves physical remote execution has ended.
 
 The same in-memory controller survives `/reload` and session switches within the Pi
-process. Its ceilings are two active workers, four batches and 32 SDK model invocations
-per process, with two jobs and 8 invocations per batch and four invocations per logical
-job including one follow-up. Requested output is 8,192 tokens clamped to the model
-maximum. These are experiment limits, not research-derived optimal values.
+process. Defaults are two active workers, 32 batches and 256 SDK model invocations
+per process, with two jobs and 64 invocations per batch and 32 invocations per logical
+job including one follow-up. Source reading allows 96 calls and 512 KiB delivered
+JSON per job. Human `/delegate budget <multiplier>` (1–64, default 8) while off scales
+batch/model/tool counts, source-output bytes, serialized child context and SDK response bytes; it is
+saved across restarts and never resets spent counters or extends old jobs. Exhausted
+jobs reject follow-up admission rather than opening a child with no usable allowance.
+Requested output uses Pi's normal provider/model settings (`outputTokens: null`).
+SDK response acceptance defaults to 1 MiB and scales to 8 MiB at multiplier 64.
+These are experiment limits, not research-derived optimal values.
 Human off/on, task changes,
 branch navigation, model selection, guard changes and reloads revoke old generations;
 they do not create a new resource allowance. Normal parent turns do not revoke a job.
-Model and thinking selections retain the human's activation choice. The extension
+Model and thinking selections retain the default or human activation choice. The extension
 preflights the latest selected host and resumes dispatch automatically, without
 replaying old jobs. Unsupported selections pause dispatch and report `pauseReason`;
 a compatible selection resumes it. Status exposes `requested`, `updating` and

package/extensions/delegation/core.mjs

@@ -1,8 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { createSnapshot } from "./snapshot.mjs";
-import { LIMITS, digest, timeoutLimits, validateOperation } from "./protocol.mjs";
+import { LIMITS, digest, timeoutLimits, budgetLimits, validateOperation } from "./protocol.mjs";
 import { runWorker } from "./worker.mjs";
-import { DelegationError, publicErrorMessage } from "./errors.mjs";
+import { DelegationError, publicErrorMessage, workerFailureMessage } from "./errors.mjs";
 
 const terminal = new Set(["complete", "partial", "needs_context", "failed", "cancelled", "expired", "stale"]);
 const quiet = new Set(["cancelled", "expired", "stale"]);
@@ -21,7 +21,11 @@ export function createDelegationController({
         Object.fromEntries(
             Object.entries(LIMITS).map(([key, maximum]) => {
                 const value = limits[key] ?? maximum;
-                if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
+                const modelDefault = key === "outputTokens" && value === null;
+                if (
+                    !modelDefault &&
+                    (!Number.isSafeInteger(value) || value < 1 || (maximum !== null && value > maximum))
+                ) {
                     throw new DelegationError("Limits may only lower the fixed delegation ceilings");
                 }
 
@@ -137,6 +141,7 @@ export function createDelegationController({
         !batch.retired &&
         !quiet.has(job.state) &&
         !job.disposition &&
+        !job.limitReason &&
         Date.now() < Math.min(job.deadline, batch.deadline) &&
         (!terminal.has(job.state) || job.followUps < 1);
 
@@ -346,6 +351,7 @@ export function createDelegationController({
                                     batch.calls >= policy.batchCalls ||
                                     totalCalls >= policy.sessionCalls
                                 ) {
+                                    job.limitReason = "model-call allowance";
                                     throw new DelegationError("Delegation model-call allowance exhausted");
                                 }
 
@@ -370,14 +376,16 @@ export function createDelegationController({
                         assertJobLive();
                         checkSources(batch);
                         finish(batch, job, result.status, result);
-                    } catch {
+                    } catch (error) {
                         // Provider errors can contain URLs, credentials, or user content. Do not return them.
                         finish(
                             batch,
                             job,
                             "failed",
                             undefined,
-                            "Worker failed or exhausted a bound; inspect status and use one changed-input follow-up if appropriate.",
+                            job.limitReason
+                                ? `Worker exhausted its ${job.limitReason}. Review /delegate limits; a human can raise /delegate budget while off and start a fresh batch.`
+                                : workerFailureMessage(error),
                         );
                     } finally {
                         job.controller.abort();
@@ -520,6 +528,19 @@ export function createDelegationController({
 
         const { batch, job } = findBoundJob(input);
         if (input.operation === "follow_up") {
+            if (
+                job.limitReason ||
+                job.calls >= policy.jobCalls ||
+                batch.calls >= policy.batchCalls ||
+                totalCalls >= policy.sessionCalls ||
+                job.toolCalls >= policy.toolCalls ||
+                job.toolBytes >= policy.toolBytes
+            ) {
+                throw new DelegationError(
+                    "Follow-up has no usable budget remaining. A human can raise /delegate budget while off, then start a fresh batch.",
+                );
+            }
+
             if (
                 job.settling ||
                 job.followUps >= 1 ||
@@ -685,7 +706,7 @@ export function createDelegationController({
         try {
             entry.value = mutate(input);
             // Spending and final-disposition receipts fit the fixed batch/job ceilings
-            // (at most 4 runs + 8 follow-ups + 8 final dispositions). Never evict them.
+            // (one run and at most two follow-ups/two dispositions per batch). Never evict them.
             if (input.operation === "cancel" || (input.operation === "resolve" && input.decision === "needs_check")) {
                 recentRequests.set(input.requestId, entry);
                 if (recentRequests.size > 128) {
@@ -708,6 +729,16 @@ export function createDelegationController({
         presentation,
         invalidate,
         // Human command only; never exposed through execute() or the model schema.
+        setBudgetMultiplier(multiplier) {
+            const budget = budgetLimits(multiplier);
+            if (enabled) {
+                throw new DelegationError("Turn delegation off before changing its budget: /delegate off");
+            }
+
+            invalidate("budget policy changed");
+            policy = Object.freeze({ ...policy, ...budget });
+            changed();
+        },
         setTimeoutMinutes(minutes) {
             const times = timeoutLimits(minutes);
             if (enabled) {

package/extensions/delegation/errors.mjs

@@ -1,6 +1,70 @@
 /** Only code-owned diagnostics may cross the delegation UI/model boundary. */
 export class DelegationError extends Error {}
 
+const workerStages = new Map(
+    Object.entries({
+        setup: "Worker session setup failed; check Pi provider configuration.",
+        provider: "Worker provider request failed; raw provider details were withheld.",
+        stream: "Worker response stream failed validation or exceeded its retained-response allowance.",
+        context: "Worker request exceeded its context allowance or could not be serialized.",
+        response: "Worker provider response exceeded its retained-response allowance or was invalid.",
+        tool: "Worker source-tool request failed; check the selected source IDs and tool argument limits.",
+        policy: "Worker requested an unavailable tool or changed its inference policy.",
+        lease: "Worker lease was cancelled or expired; check the original deadline and current model/Guard state.",
+        incomplete: "Worker provider returned no complete assistant response.",
+        output: "Worker hit the provider output-token limit before completing its report; narrow the review or reduce thinking effort.",
+        empty: "Worker returned no report text.",
+        json: "Worker report was not valid JSON; the follow-up must request only the required JSON object without Markdown fences.",
+        result: "Worker report failed schema or evidence validation.",
+        size: "Worker report exceeded the final-result byte allowance; request a shorter report.",
+    }),
+);
+const workerDetails = new Set([
+    "Invalid closed delegation object",
+    "Invalid delegation text",
+    "Invalid delegation identifier",
+    "Invalid delegation list",
+    "Invalid delegation integer",
+    "Invalid worker result size or status",
+    "Worker referenced an unknown source",
+    "Worker requirement coverage is invalid",
+    "Worker must cover each requirement exactly once",
+    "Invalid finding confidence",
+    "Observed findings require a source reference",
+    "Worker finding identifiers must be unique",
+    "Source is not selected for this job",
+    "Snapshot read request rejected.",
+    "Snapshot search request rejected.",
+    "Snapshot search scope rejected.",
+    "Snapshot line exceeds response quota.",
+    "Snapshot source changed.",
+    "Snapshot source unavailable or changed.",
+    "Snapshot path binding changed.",
+    "Snapshot closed.",
+]);
+const workerMessages = new WeakMap();
+
+// Retain only fixed diagnostics, never an SDK cause, stack, response, or arbitrary message.
+export function workerFailure(stage, error) {
+    if (workerMessages.has(error)) {
+        return error;
+    }
+
+    const detail =
+        error instanceof DelegationError && workerDetails.has(error.message)
+            ? ` ${error.message.replace(/\.$/u, "")}.`
+            : "";
+    const message = (workerStages.get(stage) ?? "Worker failed; no safe diagnostic was available.") + detail;
+    const failure = new DelegationError(message);
+    workerMessages.set(failure, message);
+
+    return failure;
+}
+
+export function workerFailureMessage(error) {
+    return workerMessages.get(error) ?? "Worker failed; no safe diagnostic was available.";
+}
+
 export function publicErrorMessage(error) {
     return error instanceof DelegationError
         ? error.message

package/extensions/delegation/extension.mjs

@@ -1,10 +1,11 @@
 import { DelegationError, publicErrorMessage } from "./errors.mjs";
 import { randomUUID } from "node:crypto";
 import { createDelegationController } from "./core.mjs";
-import { DEFAULT_TIMEOUT_MINUTES, timeoutLimits } from "./protocol.mjs";
+import { DEFAULT_TIMEOUT_MINUTES, DEFAULT_BUDGET_MULTIPLIER, timeoutLimits, budgetLimits } from "./protocol.mjs";
 import { createLivePanel, createToolRenderers, readableLimits, readableStatus } from "./presentation.mjs";
 
-const USAGE = "Usage: /delegate [on|off|status|limits|timeout [<minutes>|reset]|cancel <batchId>]";
+const USAGE =
+    "Usage: /delegate [on|off|status|limits|budget [<multiplier>|reset]|timeout [<minutes>|reset]|cancel <batchId>]";
 
 const integer = { type: "integer", minimum: 0 };
 const string = { type: "string" };
@@ -58,7 +59,11 @@ export const DELEGATE_SCHEMA = {
                         mode: { type: "string", enum: ["review", "scout"] },
                         question: string,
                         context: string,
-                        sources: strings,
+                        sources: {
+                            ...strings,
+                            description:
+                                "Exact workspace-relative text filenames. Ordinary auth, credential, session and history source names are allowed. Private runtime storage, credential stores and keys are excluded; no directories, globs or absolute paths.",
+                        },
                         requirements: {
                             type: "array",
                             minItems: 1,
@@ -104,6 +109,7 @@ export function createDelegationExtension(
     let detach = () => {};
 
     let requested = false;
+    let startupActivation = true;
     let requestedGuard;
     let boundHost;
     let pending;
@@ -136,7 +142,13 @@ export function createDelegationExtension(
     let timeoutLoaded = !timeoutStore;
     const loadTimeout = () => {
         if (!timeoutLoaded) {
-            controller.setTimeoutMinutes(timeoutStore.load());
+            const minutes = timeoutStore.load();
+            const multiplier = timeoutStore.loadBudget?.();
+            if (multiplier !== undefined) {
+                controller.setBudgetMultiplier(multiplier);
+            }
+
+            controller.setTimeoutMinutes(minutes);
             timeoutLoaded = true;
         }
     };
@@ -166,7 +178,11 @@ export function createDelegationExtension(
         panel?.update();
     }
 
-    function invalidate(reason) {
+    function invalidate(reason, preserveStartupDefault = false) {
+        if (!preserveStartupDefault) {
+            startupActivation = false;
+        }
+
         requested = false;
         pending = undefined;
         boundHost = undefined;
@@ -197,7 +213,7 @@ export function createDelegationExtension(
         const isBound = () => issuedEpoch === bindingEpoch;
         toolsReady = false;
         prepareContext(undefined, true);
-        invalidate("runtime factory rebound");
+        invalidate("runtime factory rebound", true);
         currentPi = pi;
         currentContext = undefined;
         const refreshSelection = async (ctx) => {
@@ -336,7 +352,7 @@ export function createDelegationExtension(
             });
         }
 
-        pi.on("session_start", (_event, ctx) => {
+        pi.on("session_start", async (_event, ctx) => {
             if (!isBound()) {
                 return;
             }
@@ -344,13 +360,27 @@ export function createDelegationExtension(
             currentContext = ctx;
             toolsReady = true;
             panel?.bind(ctx);
-            invalidate("session started or resources reloaded");
+            invalidate("session started or resources reloaded", true);
             try {
                 loadTimeout();
                 prepareContext(ctx, true);
+                // Consume the default only after synchronous preparation, which
+                // may revoke it. Off and safety events cancel it even before startup.
+                const activate = startupActivation;
+                startupActivation = false;
+                if (activate && isBound()) {
+                    requested = true;
+                    requestedGuard = getGuard();
+                    await refreshSelection(ctx);
+                    if (isBound() && requested && pauseReason) {
+                        ctx.ui.notify(`Delegation paused: ${pauseReason}`, "warning");
+                    }
+                }
             } catch (error) {
                 pauseReason = publicErrorMessage(error);
                 ctx.ui.notify(`Delegation unavailable: ${pauseReason}`, "warning");
+            } finally {
+                startupActivation = false;
             }
         });
         pi.on("session_shutdown", () => {
@@ -380,13 +410,20 @@ export function createDelegationExtension(
             }
         });
         pi.registerCommand("delegate", {
-            description: "Enable read-only delegation, inspect limits, or save timeout <minutes> (1–60; reset: 10)",
+            description:
+                "Control delegation, inspect limits, or save budget <multiplier> (1–64; default 8) and timeout <minutes> (1–60; default 10)",
             getArgumentCompletions: (prefix) =>
                 [
                     "on",
                     "off",
                     "status",
                     "limits",
+                    "budget",
+                    "budget 8",
+                    "budget 16",
+                    "budget 32",
+                    "budget 64",
+                    "budget reset",
                     "timeout",
                     "timeout 5",
                     "timeout 10",
@@ -408,7 +445,7 @@ export function createDelegationExtension(
                 currentContext = ctx;
                 const [action = "status", id, extra] = args.trim().split(/\s+/u).filter(Boolean);
                 try {
-                    if (extra || (id && !["cancel", "timeout"].includes(action))) {
+                    if (extra || (id && !["cancel", "timeout", "budget"].includes(action))) {
                         throw new DelegationError(USAGE);
                     }
 
@@ -434,7 +471,36 @@ export function createDelegationExtension(
 
                         syncActiveTool(true);
                         ctx.ui.notify(
-                            `Delegation enabled: Pi child sessions for review and scout, ${state.model.provider}/${state.model.id}, thinking ${state.model.thinkingLevel ?? "Pi configured"}. At most 2 workers, 4 batches and 32 SDK inference calls per Pi process; ${state.limits.jobMs / 60_000} minutes per job, ${state.limits.batchMs / 60_000} minutes per batch. Configure with /delegate timeout <minutes> while off (saved across restarts). Workers see only supplied text and selected snapshots. Pi owns configured authentication; temporary parent provider/auth overrides and parent hooks are not inherited. No shell, edits, recursion, automatic retries or compaction. /delegate off cancels workers; SDK requests still settling retain their slots. These limits do not guarantee remote termination or a billing cap.`,
+                            `Delegation enabled: Pi child sessions for review and scout, ${state.model.provider}/${state.model.id}, thinking ${state.model.thinkingLevel ?? "Pi configured"}. At most ${state.limits.concurrency} workers, ${state.limits.sessionBatches} batches and ${state.limits.sessionCalls} SDK inference calls per Pi process; ${state.limits.jobMs / 60_000} minutes per job, ${state.limits.batchMs / 60_000} minutes per batch. Configure /delegate budget and /delegate timeout while off (saved across restarts). Workers see only supplied text and selected snapshots. Pi owns configured authentication; temporary parent provider/auth overrides and parent hooks are not inherited. No shell, edits, recursion, automatic provider retries or compaction. Workers can correct tool arguments and reports within their existing budgets. /delegate off cancels workers; SDK requests still settling retain their slots. These limits do not guarantee remote termination or a billing cap.`,
+                            "info",
+                        );
+                    } else if (action === "budget") {
+                        if (id) {
+                            if (!ctx.hasUI) {
+                                throw new DelegationError("Budget changes require a human interactive command");
+                            }
+
+                            if (requested || pending || controller.status().enabled) {
+                                throw new DelegationError(
+                                    "Turn delegation off before changing its budget: /delegate off",
+                                );
+                            }
+
+                            const multiplier =
+                                id === "reset" ? DEFAULT_BUDGET_MULTIPLIER : /^\d+$/u.test(id) ? Number(id) : NaN;
+                            budgetLimits(multiplier);
+                            if (!timeoutStore?.saveBudget) {
+                                throw new DelegationError("Persistent delegation settings are unavailable");
+                            }
+
+                            timeoutStore.saveBudget(multiplier);
+                            controller.setBudgetMultiplier(multiplier);
+                        } else {
+                            loadTimeout();
+                        }
+
+                        ctx.ui.notify(
+                            `${readableLimits(status())}\n${id ? "Budget saved. " : ""}Use /delegate budget <multiplier> (1–64; default 8) while off. Counts, source-output bytes and model-context bytes scale together; spent usage and deadlines do not reset.`,
                             "info",
                         );
                     } else if (action === "timeout") {
@@ -496,7 +562,7 @@ export function createDelegationExtension(
             name: "delegate",
             label: "Delegate",
             description:
-                "Delegate an independent frozen review or substantial selected-source analysis to a real Pi child session. Only after human /delegate on. review: check artifacts against assigned requirements in fresh context; scout: answer a distinct evidence question over selected sources. Prefer one worker and parent-only execution for small, sequential or routine work. No shell, edits or live web. run returns immediately; collect waits for advisory evidence, then resolve findings after verification. One changed-input follow_up shares the original budget/deadline. Never grants permission or proves task completion.",
+                "Delegate an independent frozen review or substantial selected-source analysis to a real Pi child session. Enabled by default at Pi startup; respect /delegate off and safety revocations. review: check artifacts against assigned requirements in fresh context; scout: answer a distinct evidence question over selected sources. Prefer one worker and parent-only execution for small, sequential or routine work. No shell, edits or live web. run returns immediately; collect waits for advisory evidence, then resolve findings after verification. One changed-input follow_up shares the original budget/deadline. Never grants permission or proves task completion.",
             parameters: DELEGATE_SCHEMA,
             ...(presentation ? createToolRenderers(presentation) : {}),
             execute: async (_id, input, signal, _update, ctx) => {

package/extensions/delegation/native.mjs

@@ -7,7 +7,7 @@ import { DelegationError } from "./errors.mjs";
 import { createTimeoutStore } from "./settings.mjs";
 
 const stateKey = Symbol.for("specpi.delegation.native.v1");
-const revision = 8;
+const revision = 9;
 
 export async function withPiCompatibility(sdk, loadCompatibility) {
     if (typeof sdk.clampThinkingLevel === "function") {

package/extensions/delegation/protocol.mjs

@@ -4,6 +4,25 @@ import { createHash } from "node:crypto";
 export const DEFAULT_TIMEOUT_MINUTES = 10;
 export const MAX_TIMEOUT_MINUTES = 60;
 export const MAX_JOB_MS = MAX_TIMEOUT_MINUTES * 60_000;
+export const DEFAULT_BUDGET_MULTIPLIER = 8;
+export const MAX_BUDGET_MULTIPLIER = 64;
+
+export function budgetLimits(multiplier) {
+    if (!Number.isSafeInteger(multiplier) || multiplier < 1 || multiplier > MAX_BUDGET_MULTIPLIER) {
+        throw new DelegationError(`Delegation budget must be a whole multiplier from 1 to ${MAX_BUDGET_MULTIPLIER}`);
+    }
+
+    return {
+        sessionBatches: 4 * multiplier,
+        sessionCalls: 32 * multiplier,
+        batchCalls: 8 * multiplier,
+        jobCalls: 4 * multiplier,
+        toolBytes: 64 * 1024 * multiplier,
+        toolCalls: 12 * multiplier,
+        contextBytes: 256 * 1024 * multiplier,
+        retainedResponseBytes: 128 * 1024 * multiplier,
+    };
+}
 
 export function timeoutLimits(minutes) {
     if (!Number.isSafeInteger(minutes) || minutes < 1 || minutes > MAX_TIMEOUT_MINUTES) {
@@ -15,18 +34,12 @@ export function timeoutLimits(minutes) {
 
 export const LIMITS = Object.freeze({
     concurrency: 2,
-    sessionBatches: 4,
-    sessionCalls: 32,
     batchJobs: 2,
-    batchCalls: 8,
-    jobCalls: 4,
+    ...budgetLimits(DEFAULT_BUDGET_MULTIPLIER),
     ...timeoutLimits(DEFAULT_TIMEOUT_MINUTES),
-    contextBytes: 256 * 1024,
-    retainedResponseBytes: 256 * 1024,
-    toolBytes: 64 * 1024,
-    toolCalls: 12,
+    packetBytes: 256 * 1024,
     resultBytes: 16 * 1024,
-    outputTokens: 8192,
+    outputTokens: null,
 });
 
 export function bytes(value) {
@@ -162,7 +175,7 @@ function validatePacketShape(packet) {
     if (
         !packet.jobs.length ||
         new Set(packet.jobs.map((job) => job.id)).size !== packet.jobs.length ||
-        bytes(packet) > LIMITS.contextBytes
+        bytes(packet) > LIMITS.packetBytes
     ) {
         throw new DelegationError("Delegation packet exceeds its bound or repeats job identifiers");
     }
@@ -200,7 +213,7 @@ export function validateOperation(input) {
         operations[input.operation],
         operations[input.operation].filter((key) => !optional.includes(key)),
     );
-    if (bytes(input) > LIMITS.contextBytes + 4096) {
+    if (bytes(input) > LIMITS.packetBytes + 4096) {
         throw new DelegationError("Delegation operation exceeds its bound");
     }