opencode-swarm 7.154.2 → 7.154.3

package/dist/hooks/final-context-accounting.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Final context accounting (#2107 §3).
+ *
+ * ONE final accounting step, run after every injector has contributed and after
+ * `consolidateSystemMessagesInPlace` — the last structure-mutating handler in
+ * the `experimental.chat.messages.transform` chain. It measures the actual
+ * final model-visible surface exactly once:
+ *
+ * - `output.messages` (post-consolidation; carries every messages-chain
+ *   injection: knowledge, memory recall, the advisory block) via
+ *   `computeContextUsage`, which prefers provider-reported token usage when the
+ *   latest assistant message carries it;
+ * - PLUS the system chain's `output.system` content (system-enhancer banners,
+ *   context capsules, the swarm-command banner). Those bytes live in a separate
+ *   output structure the messages chain never sees and consolidation never
+ *   merges (docs/context-map.md; engineering-invariants § v6.85.1), so they are
+ *   added from the per-turn injection ledger's `surface: 'system'` emissions.
+ *   Messages-surface producers are attribution-only — their bytes are already
+ *   inside the measurement and are NEVER added again.
+ *
+ * The limit is resolved through the exact same ladder physical pruning uses
+ * (`resolveModelLimit` with `context_budget.model_limits` overrides and the
+ * live `model.limit.context` relayed from the system.transform hook), so the
+ * warning/critical thresholds here are the same thresholds, against the same
+ * denominator, that `context-budget.ts` enforces. A 128K–1M-window model can
+ * no longer receive a warning computed against a phantom denominator.
+ *
+ * The warning this step emits is bounded, advisory-only (it never removes
+ * content and says so), suppressed to once per session per band, and its own
+ * token cost is included in the recorded total AND recorded as a ledger
+ * emission — it cannot escape accounting. Fail-open by design: an accounting
+ * failure must never break request composition. The step is registered
+ * inside the plugin's single composeHandlers chain for messages.transform
+ * (one handler per hook type is all the host allows), which wraps it in
+ * safeHook; the inner try/catch below is the intentional first-line
+ * fail-open and logs the failure itself, so the outer wrapper is only a
+ * redundant backstop, never the primary swallowing layer.
+ */
+import type { PluginConfig } from '../config/index.js';
+import type { MessageWithParts } from './knowledge-types.js';
+interface FinalAccountingOptions {
+    config: PluginConfig;
+    /** Same seam createContextBudgetHandler uses: resolves the
+     * configured target model for an agent name. */
+    resolveAgentModelFn?: (agentName: string) => string | undefined;
+}
+/**
+ * One-shot-per-band warning suppression (#2107 §3), backed by the
+ * session-keyed `finalAccountingWarningBandsBySession` map in state.ts so
+ * `resetSwarmState` covers it (AGENTS.md invariant 8). Deliberately NOT
+ * reset on compaction: "once per session per band" mirrors the
+ * established contextPressureWarningSent one-shot pattern; the compaction
+ * tiers have their own per-session hysteresis.
+ */
+/** Test seam: clear warning-suppression state. */
+export declare function _resetFinalAccountingState(): void;
+export declare function createFinalContextAccountingStep(options: FinalAccountingOptions): (input: unknown, output: {
+    messages?: MessageWithParts[];
+}) => Promise<void>;
+export {};

package/dist/hooks/index.d.ts

@@ -8,6 +8,7 @@ export { createDelegationGateHook, outputLooksLikeBackgroundRunning, } from './d
 export { createDelegationSanitizerHook } from './delegation-sanitizer';
 export { createDelegationTrackerHook } from './delegation-tracker';
 export { extractCurrentPhase, extractCurrentPhaseFromPlan, extractCurrentTask, extractCurrentTaskFromPlan, extractDecisions, extractIncompleteTasks, extractIncompleteTasksFromPlan, extractPatterns, } from './extractors';
+export { createFinalContextAccountingStep } from './final-context-accounting';
 export { createFullAutoInterceptHook } from './full-auto-intercept';
 export { checkFileAuthority, createGuardrailsHooks, DEFAULT_AGENT_AUTHORITY_RULES, } from './guardrails';
 export { classifyMessage, classifyMessages, containsPlanContent, getCompletedToolOutputs, getToolNames, getToolParts, isDuplicateToolRead, isStaleError, isToolResult, MessagePriority, type MessagePriorityType, type MessageWithParts, } from './message-priority';

package/dist/hooks/knowledge-injector.d.ts

@@ -99,7 +99,7 @@ export declare function matchesDelegateScope(entry: Pick<RankedEntry, 'applies_t
 /** Inserts the knowledge block just before the last user message (recency position). */
 declare function injectKnowledgeMessage(output: {
     messages?: MessageWithParts[];
-}, text: string): void;
+}, text: string, sessionId?: string): void;
 /**
  * Creates a knowledge injection hook that injects relevant knowledge into the
  * architect's message context at phase start. Supports caching for re-injection

package/dist/hooks/system-enhancer.d.ts

@@ -6,6 +6,7 @@
  * Reads plan.md and injects phase context into the system prompt.
  */
 import type { PluginConfig } from '../config';
+import type { RuntimePlan } from '../config/plan-schema';
 /**
  * Build the [spec-drift] advisory injected into the model's system prompt
  * after every loadPlan whenever spec staleness is detected (issue #853
@@ -29,6 +30,9 @@ export declare function buildSpecDriftAdvisory(args: {
         source: string;
     };
 }): string;
+declare function maybeAppendSpecDriftAdvisory(output: {
+    system: string[];
+}, directory: string, plan: RuntimePlan | null, sessionId?: string): void;
 /**
  * Build a retrospective injection string for the architect system message.
  * Tier 1: direct phase-scoped lookup for same-plan previous phase.
@@ -51,3 +55,12 @@ export type ArchitectMode = 'DISCOVER' | 'PLAN' | 'EXECUTE' | 'PHASE-WRAP' | 'UN
  * @returns The current architect mode based on plan state
  */
 export declare function detectArchitectMode(directory: string, cache?: Map<string, Promise<string | null>>): Promise<ArchitectMode>;
+/**
+ * Tier-0 test seam (knowledge-injector precedent): exposes the spec-drift
+ * advisory helper so the #2107 §2 attribution test can drive its direct
+ * output.system push and assert the ledger emission is recorded exactly once.
+ */
+export declare const _test_exports: {
+    maybeAppendSpecDriftAdvisory: typeof maybeAppendSpecDriftAdvisory;
+};
+export {};

package/dist/hooks/utils.d.ts

@@ -77,5 +77,16 @@ export declare function composeBlockingHandlers<I, O>(...fns: Array<HookHandler<
  */
 export declare function validateSwarmPath(directory: string, filename: string): string;
 export declare function readSwarmFileAsync(directory: string, filename: string, cache?: Map<string, Promise<string | null>>): Promise<string | null>;
+/**
+ * Estimate tokens from a character count using the canonical heuristic.
+ * This is the single sanctioned numeric form (issue #2107 §1).
+ */
+export declare function estimateTokensFromCharCount(chars: number): number;
+/**
+ * Inverse of the canonical estimator: the character budget that corresponds to a
+ * token budget. Floor, so the result never overruns the token budget when converted
+ * back with `estimateTokensFromCharCount`.
+ */
+export declare function estimateCharsForTokens(tokens: number): number;
 export declare function estimateTokens(text: string): number;
 export {};