opencode-swarm 7.154.2 → 7.155.0

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/repo-graph-injection.d.ts

@@ -16,25 +16,65 @@
  * bounded workspace probe gates use of the graph. Uncertified graphs and
  * complete drift above the configured refresh cap are suppressed;
  * inconclusive probes remain usable as freshness-unknown, without mutation.
+ *
+ * Storage modes (issue #1534): when `options.storage === 'indexed'`, the two
+ * FILE-SCOPED block builders may, on a full-graph LRU miss, serve a bounded
+ * subgraph read from `.swarm/repo-memory.sqlite` instead of parsing the whole
+ * JSON document. The kill switch, the stat gate and the freshness probe all
+ * run first and are unchanged, and the LRU hit — the common case — never
+ * touches SQLite. Whole-graph consumers (`buildLaneOrientationBlock`,
+ * `semantic-diff-injection`) always get the full JSON graph.
  */
 import { loadPluginConfigWithMetaAsync } from '../config/loader';
 import { type FreshnessOptions, probeFreshness, type RepoGraph } from '../tools/repo-graph';
+import { loadSubgraphForFiles } from '../tools/repo-graph/indexed-storage';
 export interface RepoGraphInjectionOptions extends FreshnessOptions {
     enabled?: boolean;
     refreshCap?: number;
+    /**
+     * Resolved `repo_graph.storage` mode (issue #1534). Passed in by the caller
+     * — this module deliberately never reads config synchronously (see the
+     * `loadPluginConfigWithMetaAsync` note on `_internals`), so the mode rides
+     * in beside `enabled` / `refreshCap`. Anything other than `'indexed'`
+     * (including `undefined`) keeps every path on the JSON document.
+     */
+    storage?: 'json' | 'indexed';
 }
 export declare const _internals: {
     probeFreshness: typeof probeFreshness;
     cacheSize: () => number;
+    subgraphCacheSize: () => number;
     renderLaneOrientationBlock: typeof renderLaneOrientationBlock;
     orientationFreshnessLine: typeof orientationFreshnessLine;
     loadPluginConfigWithMetaAsync: typeof loadPluginConfigWithMetaAsync;
+    loadSubgraphForFiles: typeof loadSubgraphForFiles;
+    subgraphCacheKey: typeof subgraphCacheKey;
 };
+/**
+ * Cache key for a subgraph request. The graph artifact's `{mtimeMs, size, ino}`
+ * is part of the key, so a graph change invalidates every cached subgraph for
+ * that directory without an explicit sweep — the identical invalidation
+ * contract the full-graph LRU uses. Files are sorted because the closure is a
+ * set union and is order-independent; the caller's own array order (which does
+ * drive `BlastRadiusResult.target` and the rendered target list) is never read
+ * from this key. NUL is the separator because it is the one character that
+ * cannot appear in a path component, so no two distinct requests can collide
+ * by concatenation.
+ */
+declare function subgraphCacheKey(directoryKey: string, stat: {
+    mtimeMs: number;
+    size: number;
+    ino: number;
+}, files: readonly string[], depth: number): string;
 /**
  * Load the repo graph for `directory`, using a bounded per-directory cache that
  * invalidates on file mtime/size change and a shared content-freshness gate.
  * Returns null if no graph exists or its workspace alignment is unsafe.
  *
+ * Always returns the WHOLE graph — `semantic-diff-injection` and
+ * `buildLaneOrientationBlock` are whole-graph consumers and must never receive
+ * a bounded subgraph.
+ *
  * Exported only for tests; production callers use the buildXxxBlock helpers below.
  */
 export declare function getCachedGraph(directory: string, options?: RepoGraphInjectionOptions): Promise<RepoGraph | null>;

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 {};