billion-context-pi 0.1.57 → 0.1.58-pr.268.115

package/dist/config.d.ts

@@ -107,6 +107,13 @@ export interface CompressSettings {
     /** Token growth threshold for soft compression nudges. Default: 50000.
      *  Maps to kernel nudge.growthFloor + nudge.growthCap. */
     nudgeGrowthTokens?: number;
+    /** Minimum reclaimable tokens for a pressure-band nudge (kernel #198).
+     *  Default: max(5000, round(limit×0.01)). Explicit 0 restores the legacy
+     *  any-pending behavior — useful for tiny windows (e.g. e2e scenarios with
+     *  modelContextLimit 1500) where a fixed 5000-token floor exceeds the whole
+     *  window and would suppress every nudge. Maps to kernel
+     *  nudge.minPressureBenefitTokens. */
+    minPressureBenefitTokens?: number;
 }
 /** Per-provider compression overrides. Carries the same tuning fields as the
  *  global level, plus an optional per-model map keyed by model id. */
@@ -125,9 +132,31 @@ export interface CompressConfig extends CompressSettings {
      *  models.json and `pi --provider`. */
     providers?: Record<string, ProviderCompress>;
 }
+/** Generic tool-call repetition guard. Detects the same tool being called
+ *  repeatedly with byte-identical arguments — a sequence-level attractor that
+ *  token-level penalties cannot break (greedy small models loop on e.g.
+ *  acp_status or bash polls forever, each round adding protected tokens that
+ *  the compression protection band then refuses to reclaim). Consecutive
+ *  identical calls accumulate per session: at `warn` a strong warning is
+ *  appended to that call's toolResult; at `abort` the call is refused (blocked,
+ *  error toolResult) and the turn aborted so the attractor breaks. Any change
+ *  to the arguments (or a switch to a different tool) resets the counter.
+ *  Accepts a boolean shorthand (`false` disables) or an object. Default:
+ *  enabled, warn=3, abort=5. See issue #308. */
+export interface RepetitionGuardConfig {
+    /** Enable/disable the guard. Default: true. */
+    enabled?: boolean;
+    /** Consecutive identical calls before a strong warning is appended to the
+     *  matching toolResult. Default: 3. */
+    warn?: number;
+    /** Consecutive identical calls before the call is refused and the turn
+     *  aborted. Default: 5. Must be greater than `warn`; clamped up
+     *  automatically if not. */
+    abort?: number;
+}
 /**
  * Adapter configuration. Maps onto acp-kernel's `Config` plus Pi-specific knobs
- * (live model context window, protected tools, state persistence).
+ *  (live model context window, protected tools, state persistence).
  */
 export interface AdapterConfig {
     /** Master switch. Default: true. Set `enabled: false` in acp.json (or
@@ -177,6 +206,11 @@ export interface AdapterConfig {
      *  disables) or a ThrottleRetryConfig object. Default: enabled, 10 retries,
      *  60s exponential base capped at 300s per kick. */
     throttleRetry?: boolean | ThrottleRetryConfig;
+    /** Generic tool-call repetition guard (see RepetitionGuardConfig). Accepts a
+     *  boolean shorthand (`false` disables) or an object. Default: enabled,
+     *  warn=3, abort=5. Stops greedy small models looping on byte-identical
+     *  tool calls (issue #308). */
+    repetitionGuard?: boolean | RepetitionGuardConfig;
     /** Legacy flat alias for `delegate.displayUsage`. Kept for backward
      *  compatibility with existing acp.json files. Prefer `delegate.displayUsage`. */
     displayUsage?: "merged" | "separate";
@@ -198,6 +232,20 @@ export declare const DEFAULT_TOOL_OUTPUT_MAX_BYTES = 200000;
  *  default (same convention as ACP_MODEL_CONTEXT_LIMIT). Invalid values fall
  *  back to the default with a logged warning — they never fail the session. */
 export declare function resolveDelegate(adapter: AdapterConfig): DelegatePolicy;
+/** Defaults for the generic tool-call repetition guard (issue #308). */
+export declare const REPETITION_GUARD_DEFAULTS: {
+    readonly warn: 3;
+    readonly abort: 5;
+};
+/** Resolve the repetition-guard configuration from the adapter, handling the
+ *  boolean shorthand (`false` disables) and clamping `abort` to stay strictly
+ *  above `warn` (a guard that aborts at or before its warn threshold would be
+ *  meaningless). Non-numeric / out-of-range values fall back to defaults. */
+export declare function resolveRepetitionGuard(adapter: AdapterConfig): {
+    enabled: boolean;
+    warn: number;
+    abort: number;
+};
 /** Per-field deepest-wins merge of the three compression levels (global →
  *  provider → model). An undefined field at a deeper level does NOT clear a
  *  value set at a shallower level — only a defined value overrides. */

package/dist/delegate-tool.d.ts

@@ -171,6 +171,10 @@ export declare function makeEventApplier(opts: {
  *  duration, so rescale them to seconds before clamping — otherwise 180 clamps
  *  to 1000ms and the wait times out in 1s. */
 export declare function resolveWaitTimeoutMs(raw: number | undefined): number;
+/** Resolve a per-call timeout override (minutes) to ms. Absent/invalid values
+ *  fall back to the configured default (fallbackMs); valid values are clamped
+ *  to MAX_PER_CALL_TIMEOUT_MINUTES. */
+export declare function resolvePerCallTimeoutMs(raw: number | undefined, fallbackMs: number | null): number | null;
 declare const DelegateParams: Type.TObject<{
     agent: Type.TString;
     task: Type.TOptional<Type.TString>;
@@ -180,6 +184,7 @@ declare const DelegateParams: Type.TObject<{
     thinkingLevel: Type.TOptional<Type.TString>;
     async: Type.TOptional<Type.TBoolean>;
     showThinking: Type.TOptional<Type.TBoolean>;
+    timeoutMinutes: Type.TOptional<Type.TNumber>;
 }>;
 type DelegateArgs = Static<typeof DelegateParams>;
 declare const CancelParams: Type.TObject<{
@@ -276,7 +281,7 @@ export declare function buildChildArgs(args: DelegateArgs, rolePrompt: string, c
 /** Model-facing summary of the ACTIVE async watchdog limits — built from the
  *  resolved policy so it stays truthful when timeouts are customized or
  *  disabled via acp.json/env. */
-export declare function asyncWatchdogDescription(): string;
+export declare function asyncWatchdogDescription(overrideAsyncMs?: number | null): string;
 /** Watchdog/EOF finalize arrives with code === null (the child was killed or
  *  never exited). If a result was delivered (non-empty reply or stderr), the
  *  run counts as completed (0); otherwise it stays null = genuine failure. */