@xingular/harness 1.3.1-unstable.2 → 1.3.1-unstable.4

package/dist/sdk/sessions/runner.js

@@ -7,6 +7,7 @@ import { createWorkspaceBashOperations } from "../core/workspaceSandbox.js";
 import { withWorkspaceWriteAuthorization, workspaceEditOperations, workspaceWriteOperations } from "../core/workspaceWriteOperations.js";
 import { loadPi } from "../pi/runtime.js";
 import { CONTEXT_MESSAGE_TYPE, CONTEXT_SNAPSHOT_KEY } from "../prompt/compile.js";
+import { PLAN_REPAIR_CUSTOM_TYPE, PLAN_REPAIR_INSTRUCTIONS, finalizePlanOutcome } from "./planMode.js";
 import { MAX_CHECKPOINT_CHECKS, MAX_CHECKPOINT_FILES, MAX_CHECKPOINT_SUMMARY } from "./contracts.js";
 import { derivedReason } from "./workSlice.js";
 import { toolAttachmentRefsSchema } from "./contracts.js";
@@ -129,6 +130,21 @@ function contextToolSpecs(session) {
     });
     return { tools: tools.map((entry) => entry.spec), truncated: source.length > MAX_TOOL_SPECS || tools.some((entry) => entry.truncated) };
 }
+/** Pi's compaction settings for this session's model, when the session exposes them. */
+function compactionSettings(session) {
+    const manager = session.settingsManager;
+    if (!manager?.getCompactionSettings)
+        return null;
+    try {
+        const model = session.model?.id && session.model.provider ? { provider: session.model.provider, id: session.model.id } : undefined;
+        const settings = manager.getCompactionSettings(model);
+        return { enabled: settings.enabled === true, reserveTokens: Math.max(0, Math.round(settings.reserveTokens || 0)) };
+    }
+    catch {
+        // A model Pi cannot resolve keeps the reserve unknown rather than guessed.
+        return null;
+    }
+}
 const numberField = (event, key, fallback = 0) => (typeof event[key] === 'number' && Number.isFinite(event[key]) ? event[key] : fallback);
 const stringField = (event, key, fallback = '') => (typeof event[key] === 'string' ? event[key] : fallback);
 const lastLine = (text) => {
@@ -141,7 +157,6 @@ function derivedCheckpoint(state, ledger) {
         summary: ledger.lastText.trim().slice(0, MAX_CHECKPOINT_SUMMARY) || `The reply stopped after ${state.steps} steps at its work-slice boundary.`,
         done: [],
         next: '',
-        ...(state.endedBy === 'stuck' ? { blocked: (state.endedByLimit ?? 'Repeated work').slice(0, 500) } : {}),
         files: [...ledger.files].slice(-MAX_CHECKPOINT_FILES).map(([path, why]) => ({ path: path.slice(0, 300), why: why.slice(0, 200) })),
         checks: ledger.checks.slice(-MAX_CHECKPOINT_CHECKS),
         decisions: [],
@@ -183,10 +198,12 @@ export async function runTurn(run, session, params) {
     const systemPrompt = limitedText(session.systemPrompt ?? params.system, MAX_SYSTEM_PROMPT_CHARS);
     const contextUpdate = limitedText(params.update?.content ?? '', MAX_SYSTEM_PROMPT_CHARS);
     const toolSpecs = contextToolSpecs(session);
+    const compaction = compactionSettings(session);
     run.emit('context.snapshot', {
         systemPrompt: systemPrompt.text,
         ...(contextUpdate.text ? { contextUpdate: contextUpdate.text } : {}),
         tools: toolSpecs.tools,
+        ...(compaction ? { compaction } : {}),
         ...(systemPrompt.truncated ? { systemPromptTruncated: true } : {}),
         ...(contextUpdate.truncated ? { contextUpdateTruncated: true } : {}),
         ...(toolSpecs.truncated ? { toolsTruncated: true } : {})
@@ -522,11 +539,26 @@ export async function runTurn(run, session, params) {
         }
         if (!aborted && !lastError)
             await params.settle?.();
+        if (params.plan && params.repairPlan && !aborted && !lastError && !slice?.endedBy) {
+            const errorBeforeRepair = lastError;
+            const result = await finalizePlanOutcome(ledger.lastText, async () => {
+                if (!session.sendCustomMessage)
+                    throw new Error('Plan repair unavailable');
+                ledger.lastText = '';
+                await session.sendCustomMessage({ customType: PLAN_REPAIR_CUSTOM_TYPE, content: PLAN_REPAIR_INSTRUCTIONS, display: false, details: { reason: 'missing_plan_block' } }, { triggerTurn: true });
+                return ledger.lastText;
+            });
+            if (result.repaired && !aborted)
+                lastError = errorBeforeRepair;
+            if (result.outcome.kind === 'invalid' && !aborted) {
+                run.emit('extension.notice', { kind: 'notify', level: 'warning', text: 'The plan reply did not include a valid plan or blocked block.' });
+            }
+        }
         if (slice?.endedBy && !aborted && !lastError) {
             // The model stopped because its slice was over. Keep the state it did not write itself.
             if (!slice.checkpointWritten)
                 run.emit('checkpoint', derivedCheckpoint(slice, ledger));
-            run.finish('interrupted', undefined, slice.endedBy === 'stuck' ? 'stalled' : 'slice_complete');
+            run.finish('interrupted', undefined, 'slice_complete');
             return;
         }
         if (aborted)

package/dist/sdk/sessions/sessions.js

@@ -612,6 +612,7 @@ export class Sessions {
                 gate,
                 restrictTools: input.run.relation === 'subagent',
                 ...(input.plan ? { plan: true } : {}),
+                ...(stateEligible && input.plan ? { repairPlan: true } : {}),
                 cwd: input.cwd,
                 workspaceRoot,
                 sessionDir: input.sessionDir,

package/dist/sdk/sessions/subagentService.d.ts

@@ -5,7 +5,7 @@ import type { RunRegistry } from "./registry.js";
 import type { Effort } from "./runner.js";
 import type { SessionRunInput } from "./sessions.js";
 import type { PluginDescriptor } from "../plugins/types.js";
-import { type SubagentInput, type SubagentReceipt, type SubagentResult, type SubagentSelection } from "./subagents.js";
+import { type SubagentInput, type SubagentQuota, type SubagentReceipt, type SubagentResult, type SubagentSelection } from "./subagents.js";
 type Started = {
     runId: string;
     nativeSessionId: string | null;
@@ -35,11 +35,15 @@ export declare class Subagents {
     private readonly launch;
     private readonly options;
     private readonly parents;
+    /** Child runs reserved synchronously at spawn, before their record exists, so parallel calls cannot overspend. */
+    private readonly reserved;
     private readonly runtimeSettingsByRun;
     constructor(env: HarnessEnv, runs: RunRegistry, launch: (input: SessionRunInput) => Promise<Started>, options?: SubagentServiceOptions);
     /** Internal adapter contract: context comes from a live run, never from model arguments. */
     register(input: SessionRunInput, accountId: string, capabilities: CapabilitySet, deferUntilPrompt?: boolean): void;
     runtimeSettings(runId: string): SubagentRuntimeSettings | null;
+    /** The budget for a run, or the foundation defaults when it has not registered one. */
+    quota(runId: string): SubagentQuota;
     private rememberRuntimeSettings;
     resolvedModel(runId: string, model: string, effort?: Effort): void;
     private parent;
@@ -51,6 +55,12 @@ export declare class Subagents {
     private launchChild;
     /** The children this parent may read or continue: its own, and those recovered from its history. */
     private owned;
+    /** The run and the runs it was continued from, so a work-slice continuation keeps the budget. */
+    private ancestry;
+    /** Distinct child conversations this run has started, plus slots reserved before their record exists. */
+    private usage;
+    private reserve;
+    private release;
     /** The newest run in a continued child's chain, among the runs this parent owns. */
     private latestLink;
     /** The first run of a chain: its folder holds the child's history for every later link. */

package/dist/sdk/sessions/subagentService.js

@@ -10,7 +10,7 @@ import { planResearchEligibility } from "../agents/planResearch.js";
 import { resolveProfile } from "../agents/profiles.js";
 import { continuationOf } from "./continuation.js";
 import { findRun, loadRun, readEvents, recordedSubagents, recordSubagent, saveRun } from "./runStore.js";
-import { SPAWN_SUBAGENT, SUBAGENT_RELATION, SUBAGENT_OWNER, SUBAGENT_RECEIPT, SUBAGENT_RESULTS, briefTitle, continueHint, subagentHistory, subagentTitle } from "./subagents.js";
+import { SPAWN_SUBAGENT, SUBAGENT_RELATION, SUBAGENT_OWNER, SUBAGENT_RECEIPT, SUBAGENT_RESULTS, UNPROFILED_SUBAGENT, briefTitle, continueHint, subagentHistory, subagentProfileKey, subagentProfileLimit, subagentQuota, subagentTitle } from "./subagents.js";
 function until(promise, signal) {
     if (signal.aborted) {
         void promise.catch(() => { });
@@ -29,6 +29,8 @@ export class Subagents {
     launch;
     options;
     parents = new Map();
+    /** Child runs reserved synchronously at spawn, before their record exists, so parallel calls cannot overspend. */
+    reserved = new Map();
     runtimeSettingsByRun = new Map();
     constructor(env, runs, launch, options = {}) {
         this.env = env;
@@ -72,6 +74,10 @@ export class Subagents {
     runtimeSettings(runId) {
         return this.runtimeSettingsByRun.get(runId) ?? null;
     }
+    /** The budget for a run, or the foundation defaults when it has not registered one. */
+    quota(runId) {
+        return subagentQuota(this.parents.get(runId)?.input.subagents ?? undefined);
+    }
     rememberRuntimeSettings(runId, settings) {
         this.runtimeSettingsByRun.set(runId, settings);
         if (this.runtimeSettingsByRun.size > 500) {
@@ -174,44 +180,63 @@ export class Subagents {
                     throw invalid(`There is no agent profile named ${request.agent.trim()}.`);
             }
         }
-        await until(parent.ready, parent.stopped.signal);
-        let variant = input.variant ?? null;
-        let launch = input.launch;
-        let model = input.model;
-        let effort = input.effort;
-        if (profile) {
-            // A variant's own subagent works from its definition alone; a profile keeps the parent's
-            // variant unless it names another one, or none.
-            if (profile.source === 'variant' || profile.variant === 'none')
-                variant = null;
-            else if (profile.variant)
-                variant = { scope: profile.variant.scope, version: profile.variant.version };
-            if (profile.model)
-                model = profile.model;
-            if (profile.effort)
-                effort = profile.effort;
-            launch = { ...(input.launch ?? {}), sections: [...(input.launch?.sections ?? []).filter((section) => section.id !== 'subagent'), { id: 'subagent', title: `Your role: ${profile.name}`, body: profile.instructions || profile.description, budget: 16_000, order: 22 }] };
-        }
-        const narrowed = input.plan
-            ? { capabilities: planEligibility.capabilities, unavailable: planEligibility.unavailableTools }
-            : narrowForProfile(capabilities, profile, request.tools, this.options.descriptors?.() ?? []);
-        const childCapabilities = narrowed.capabilities;
-        const tools = childCapabilities.tools;
+        const quota = subagentQuota(input.subagents ?? undefined);
         const runId = randomUUID();
-        const sessionId = randomUUID();
-        const child = {
-            ...input,
-            run: { ...input.run, ...(input.plan ? { worktreeId: null } : {}), id: runId, sessionId, parentRunId: request.parentRunId, relation: SUBAGENT_RELATION, goal: takeChars(brief, 4000), title, attachmentCount: 0, resumedFromRunId: null, handoffId: null, profile: profile?.name ?? null },
-            accountId, poolId: null, sessionDir: join(input.sessionDir, 'subagents', runId), resume: null,
-            text: brief, images: undefined, requiresImageInput: false, preamble: null,
-            caller: { ...input.caller, runId: undefined, sessionId },
-            tools: { allow: tools, gated: (input.tools.gated ?? []).filter((name) => tools.includes(name)) },
-            capabilities: childCapabilities, depth: (input.depth ?? 0) + 1,
-            variant, launch, model, effort,
-            ...(input.plan ? { connections: false, subagents: null } : {})
-        };
-        const result = await this.launchChild(parent, request, child);
-        return { ...result, ...(profile ? { agent: profile.name } : {}), ...(narrowed.unavailable.length ? { unavailableTools: narrowed.unavailable } : {}) };
+        const usage = this.usage(request.parentRunId);
+        const slot = (count, of = '') => `${count} ${of}subagent slot${count === 1 ? '' : 's'}`;
+        if (usage.total >= quota.children)
+            throw invalid(`This run has used its ${slot(quota.children)}. Do the remaining work yourself.`);
+        const profileKey = subagentProfileKey(profile?.name);
+        const profileLimit = subagentProfileLimit(quota, profileKey);
+        const profileUsed = usage.byProfile.get(profileKey) ?? 0;
+        if (profileUsed >= profileLimit) {
+            const label = profileKey === UNPROFILED_SUBAGENT ? 'unprofiled ' : `${profileKey} `;
+            throw invalid(`This run has used its ${slot(profileLimit, label)}. Do the remaining work yourself.`);
+        }
+        // Reserve before the first await so two tool calls in one message cannot both pass the check.
+        this.reserve(request.parentRunId, runId, profileKey);
+        try {
+            await until(parent.ready, parent.stopped.signal);
+            let variant = input.variant ?? null;
+            let launch = input.launch;
+            let model = input.model;
+            let effort = input.effort;
+            if (profile) {
+                // A variant's own subagent works from its definition alone; a profile keeps the parent's
+                // variant unless it names another one, or none.
+                if (profile.source === 'variant' || profile.variant === 'none')
+                    variant = null;
+                else if (profile.variant)
+                    variant = { scope: profile.variant.scope, version: profile.variant.version };
+                if (profile.model)
+                    model = profile.model;
+                if (profile.effort)
+                    effort = profile.effort;
+                launch = { ...(input.launch ?? {}), sections: [...(input.launch?.sections ?? []).filter((section) => section.id !== 'subagent'), { id: 'subagent', title: `Your role: ${profile.name}`, body: profile.instructions || profile.description, budget: 16_000, order: 22 }] };
+            }
+            const narrowed = input.plan
+                ? { capabilities: planEligibility.capabilities, unavailable: planEligibility.unavailableTools }
+                : narrowForProfile(capabilities, profile, request.tools, this.options.descriptors?.() ?? []);
+            const childCapabilities = narrowed.capabilities;
+            const tools = childCapabilities.tools;
+            const sessionId = randomUUID();
+            const child = {
+                ...input,
+                run: { ...input.run, ...(input.plan ? { worktreeId: null } : {}), id: runId, sessionId, parentRunId: request.parentRunId, relation: SUBAGENT_RELATION, goal: takeChars(brief, 4000), title, attachmentCount: 0, resumedFromRunId: null, handoffId: null, profile: profile?.name ?? null },
+                accountId, poolId: null, sessionDir: join(input.sessionDir, 'subagents', runId), resume: null,
+                text: brief, images: undefined, requiresImageInput: false, preamble: null,
+                caller: { ...input.caller, runId: undefined, sessionId },
+                tools: { allow: tools, gated: (input.tools.gated ?? []).filter((name) => tools.includes(name)) },
+                capabilities: childCapabilities, depth: (input.depth ?? 0) + 1,
+                variant, launch, model, effort,
+                ...(input.plan ? { connections: false, subagents: null } : {})
+            };
+            const result = await this.launchChild(parent, request, child);
+            return { ...result, ...(profile ? { agent: profile.name } : {}), ...(narrowed.unavailable.length ? { unavailableTools: narrowed.unavailable } : {}) };
+        }
+        finally {
+            this.release(request.parentRunId, runId);
+        }
     }
     /** Records ownership, starts the child, and writes a failed record when it never opened. */
     async launchChild(parent, request, child) {
@@ -236,6 +261,63 @@ export class Subagents {
     owned(parentRunId, parent) {
         return new Set([...recordedSubagents(this.env.root, parentRunId), ...(parent?.recovered ?? [])]);
     }
+    /** The run and the runs it was continued from, so a work-slice continuation keeps the budget. */
+    ancestry(runId) {
+        const chain = [];
+        const seen = new Set();
+        let current = runId;
+        while (current && !seen.has(current) && chain.length < 20) {
+            seen.add(current);
+            chain.push(current);
+            current = findRun(this.env.root, current)?.resumedFromRunId ?? null;
+        }
+        return chain;
+    }
+    /** Distinct child conversations this run has started, plus slots reserved before their record exists. */
+    usage(parentRunId) {
+        const byProfile = new Map();
+        const seen = new Set();
+        let total = 0;
+        const add = (key) => {
+            total += 1;
+            byProfile.set(key, (byProfile.get(key) ?? 0) + 1);
+        };
+        for (const owner of this.ancestry(parentRunId)) {
+            for (const id of recordedSubagents(this.env.root, owner)) {
+                const record = findRun(this.env.root, id);
+                if (!record || record.relation !== SUBAGENT_RELATION)
+                    continue;
+                // Continuing a stopped child opens a new run of the same conversation: one slot.
+                const first = this.firstLink(record).id;
+                if (seen.has(first))
+                    continue;
+                seen.add(first);
+                add(subagentProfileKey(record.profile));
+            }
+        }
+        const reserved = this.reserved.get(parentRunId);
+        if (reserved)
+            for (const [id, key] of reserved) {
+                if (seen.has(id) || findRun(this.env.root, id))
+                    continue;
+                seen.add(id);
+                add(key);
+            }
+        return { total, byProfile };
+    }
+    reserve(parentRunId, runId, profile) {
+        const reserved = this.reserved.get(parentRunId) ?? new Map();
+        reserved.set(runId, profile);
+        this.reserved.set(parentRunId, reserved);
+    }
+    release(parentRunId, runId) {
+        const reserved = this.reserved.get(parentRunId);
+        if (!reserved)
+            return;
+        reserved.delete(runId);
+        if (!reserved.size)
+            this.reserved.delete(parentRunId);
+    }
     /** The newest run in a continued child's chain, among the runs this parent owns. */
     latestLink(start, owned) {
         const records = [...owned].flatMap((id) => findRun(this.env.root, id) ?? []);

package/dist/sdk/sessions/subagents.d.ts

@@ -7,7 +7,38 @@ export declare const MAX_SUBAGENT_DEPTH = 3;
 export interface SubagentOptions {
     /** Maximum consecutive native subagent levels below a caller (1 to 3). */
     maxDepth?: number;
+    /** Distinct child conversations a run may start. */
+    maxChildren?: number;
+    /** Children a run may start from one named profile; a name it omits uses `maxOther`. */
+    maxByProfile?: Record<string, number>;
+    /** Children allowed from a named profile `maxByProfile` does not list. */
+    maxOther?: number;
+    /** Children allowed when the caller starts one with no profile. */
+    maxUnprofiled?: number;
 }
+/** How many distinct children a run may start when the caller does not say. */
+export declare const DEFAULT_SUBAGENT_CHILDREN = 4;
+/** The most a host may allow, so a mistyped setting cannot lift the budget entirely. */
+export declare const MAX_SUBAGENT_CHILDREN = 50;
+/** Foundation limits for the profiles the harness ships; `maxByProfile` overrides them. */
+export declare const DEFAULT_SUBAGENT_PROFILE_CHILDREN: Readonly<Record<string, number>>;
+export declare const DEFAULT_SUBAGENT_OTHER_PROFILE = 1;
+export declare const DEFAULT_SUBAGENT_UNPROFILED = 1;
+/** The bucket a child with no profile counts against. No profile name can be `*`. */
+export declare const UNPROFILED_SUBAGENT = "*";
+/** The children one run may start, by profile and in total. */
+export interface SubagentQuota {
+    children: number;
+    profiles: Readonly<Record<string, number>>;
+    other: number;
+    unprofiled: number;
+}
+/** The effective budget: the caller's values merged over the foundation defaults. */
+export declare function subagentQuota(options: SubagentOptions | undefined): SubagentQuota;
+/** The bucket a child counts against: its profile name, or the unprofiled bucket. */
+export declare function subagentProfileKey(profile: string | null | undefined): string;
+/** How many children this profile may still start under the quota. */
+export declare function subagentProfileLimit(quota: SubagentQuota, key: string): number;
 export declare function subagentDepth(options: SubagentOptions | undefined): number;
 export interface SubagentInput {
     parentRunId: string;

package/dist/sdk/sessions/subagents.js

@@ -6,6 +6,51 @@ export const SUBAGENT_RELATION = 'subagent';
 /** How deep subagents may nest when the caller does not say. */
 export const DEFAULT_SUBAGENT_DEPTH = 1;
 export const MAX_SUBAGENT_DEPTH = 3;
+/** How many distinct children a run may start when the caller does not say. */
+export const DEFAULT_SUBAGENT_CHILDREN = 4;
+/** The most a host may allow, so a mistyped setting cannot lift the budget entirely. */
+export const MAX_SUBAGENT_CHILDREN = 50;
+/** Foundation limits for the profiles the harness ships; `maxByProfile` overrides them. */
+export const DEFAULT_SUBAGENT_PROFILE_CHILDREN = { worker: 2, explorer: 3 };
+export const DEFAULT_SUBAGENT_OTHER_PROFILE = 1;
+export const DEFAULT_SUBAGENT_UNPROFILED = 1;
+/** The bucket a child with no profile counts against. No profile name can be `*`. */
+export const UNPROFILED_SUBAGENT = '*';
+function limit(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.min(MAX_SUBAGENT_CHILDREN, Math.max(0, Math.trunc(value)));
+}
+/** The effective budget: the caller's values merged over the foundation defaults. */
+export function subagentQuota(options) {
+    const profiles = { ...DEFAULT_SUBAGENT_PROFILE_CHILDREN };
+    const given = options?.maxByProfile;
+    if (given && typeof given === 'object' && !Array.isArray(given)) {
+        for (const [raw, value] of Object.entries(given)) {
+            const name = raw.trim();
+            if (!name || name.length > 64 || /[\x00-\x1f\x7f]/u.test(name))
+                continue;
+            if (typeof value !== 'number' || !Number.isFinite(value))
+                continue;
+            profiles[name] = limit(value, profiles[name] ?? DEFAULT_SUBAGENT_OTHER_PROFILE);
+        }
+    }
+    return {
+        children: limit(options?.maxChildren, DEFAULT_SUBAGENT_CHILDREN),
+        profiles,
+        other: limit(options?.maxOther, DEFAULT_SUBAGENT_OTHER_PROFILE),
+        unprofiled: limit(options?.maxUnprofiled, DEFAULT_SUBAGENT_UNPROFILED)
+    };
+}
+/** The bucket a child counts against: its profile name, or the unprofiled bucket. */
+export function subagentProfileKey(profile) {
+    const name = typeof profile === 'string' ? profile.trim() : '';
+    return name || UNPROFILED_SUBAGENT;
+}
+/** How many children this profile may still start under the quota. */
+export function subagentProfileLimit(quota, key) {
+    return key === UNPROFILED_SUBAGENT ? quota.unprofiled : quota.profiles[key] ?? quota.other;
+}
 export function subagentDepth(options) {
     const value = Math.trunc(options?.maxDepth ?? DEFAULT_SUBAGENT_DEPTH);
     return Math.min(MAX_SUBAGENT_DEPTH, Math.max(1, Number.isFinite(value) ? value : DEFAULT_SUBAGENT_DEPTH));

package/dist/sdk/sessions/workSlice.d.ts

@@ -1,7 +1,7 @@
 import type { Checkpoint } from "./contracts.js";
 export declare const WORK_SLICE_EXTENSION = "work-slice";
 export interface WorkSliceInput {
-    /** False turns the guard off for this run: no budget, no stall notes, no continuation. */
+    /** False turns the guard off for this run: no budget, no handoff request, no continuation. */
     enabled?: boolean;
     /** Tool calls in one reply; 0 disables this limit. */
     maxToolCalls?: number;
@@ -32,7 +32,7 @@ export declare class WorkSliceError extends Error {
  * defaults.
  */
 export declare function parseWorkSlice(input: unknown): SlicePolicy;
-export type SliceEnd = 'budget' | 'stuck' | 'compaction-thrash';
+export type SliceEnd = 'budget' | 'compaction-thrash';
 /** What a live reply tracks for its slice; the runner reads it after the reply. */
 export interface SliceState {
     slice: number;
@@ -54,16 +54,12 @@ export declare function createSliceState(_policy: SlicePolicy, slice?: number, n
 export declare function resetSliceState(state: SliceState, now?: number): void;
 /** The first limit this reply has passed, named as a person would say it. */
 export declare function sliceLimitReached(policy: SlicePolicy, state: SliceState, now?: number): string | null;
-/** Commands that read as a check for the repeated-failure rule. */
-export declare function looksLikeCheck(command: string): boolean;
 interface ToolCall {
     toolName: string;
-    input?: unknown;
 }
 interface ToolResult {
     toolName: string;
     isError?: boolean;
-    input?: unknown;
 }
 /** The part of Pi's extension API this guard uses. Structural, so the module needs no Pi import. */
 interface GuardApi {
@@ -91,9 +87,9 @@ export interface WorkSliceGuardOptions {
     onEnd?: (end: SliceEnd, limit: string) => void;
 }
 /**
- * Bounds one reply and names repeated work. Refusals request a checkpoint when available; without
- * one, they ask for a partial report and prohibit further tools. A repeated call or failing command
- * is named once, then ends the reply.
+ * Bounds one reply. A call past the budget is refused, with one wrap-up request when a checkpoint
+ * is available, and an ended reply lets only a handoff call through. Three compactions in one reply
+ * end it too. Every other call is allowed, however often it is made.
  */
 export declare function workSliceGuard(options: WorkSliceGuardOptions): (pi: GuardApi) => void;
 /**