@pellux/goodvibes-sdk 0.38.0 → 1.1.0

package/dist/platform/agents/orchestrator.js

@@ -19,7 +19,16 @@ export { summarizeToolArgs } from './orchestrator-utils.js';
  * `orchestrator-runner.ts`; this class owns shared registry/state wiring.
  */
 export class AgentOrchestrator {
-    fullRegistry = null;
+    /**
+     * Keyed by working directory. A ToolRegistry is permanently bound to one
+     * cwd at construction (every tool factory closes over it — see
+     * tools/index.ts registerAllTools), so a distinct cwd genuinely needs its
+     * own registry, not a mutable field. The default cwd
+     * (`this.toolDeps.workingDirectory`) is cached under its own key exactly
+     * like the single `fullRegistry` field this replaces — same lazy-build,
+     * same channel-version invalidation, same object identity once built.
+     */
+    fullRegistries = new Map();
     fullRegistryChannelVersion = -2;
     toolDeps = null;
     featureFlagManager = null;
@@ -42,7 +51,7 @@ export class AgentOrchestrator {
         this.featureFlagManager = manager;
     }
     /**
-     * Wire the Wave-3 Part C6 conversation-snapshot bridge (see
+     * Wire the conversation-snapshot bridge (Part C6; see
      * AgentConversationSink). Pass null to detach — createRunContext() then
      * omits the register/release callbacks entirely and orchestrator-runner's
      * `?.()` calls become no-ops.
@@ -51,7 +60,7 @@ export class AgentOrchestrator {
         this.conversationSink = sink;
     }
     /**
-     * Wire the Wave-4 cancellation bridge (see AgentCancellationSource). Pass
+     * Wire the cancellation bridge (see AgentCancellationSource). Pass
      * null to detach — createRunContext() then omits getCancellationSignal
      * entirely and orchestrator-runner's `?.()` call becomes a no-op, so every
      * tool call runs with `opts` undefined exactly as before this change.
@@ -158,30 +167,53 @@ export class AgentOrchestrator {
      */
     setDependencies(toolDeps) {
         this.toolDeps = toolDeps;
-        this.fullRegistry = null;
+        this.fullRegistries = new Map();
         this.fullRegistryChannelVersion = -2;
     }
     /**
-     * Returns the fully-populated ToolRegistry for this orchestrator.
-     * Used by companion chat to execute tool calls emitted by the LLM.
-     * Delegates to the lazy-initialized internal registry.
+     * Returns the fully-populated ToolRegistry for this orchestrator's DEFAULT
+     * working directory. Used by companion chat to execute tool calls emitted
+     * by the LLM — companion chat has no per-call cwd override, so this always
+     * resolves to `this.toolDeps.workingDirectory`. Delegates to the
+     * lazy-initialized internal registry cache.
      */
     getToolRegistry() {
         return this.getFullRegistry();
     }
-    /** Lazily build and cache the full ToolRegistry. */
-    getFullRegistry() {
+    /**
+     * Lazily build and cache the full ToolRegistry for `workingDirectory`
+     * (default: `this.toolDeps.workingDirectory`, unchanged from before this
+     * cache became keyed). A non-default cwd — a spawned agent's dedicated
+     * worktree (AgentRecord.workingDirectory, see AgentInput.workingDirectory)
+     * — gets its OWN fresh fileCache/projectIndex rather than reusing the
+     * shared session's: those are scoped to the default cwd and would
+     * otherwise silently index/search the wrong directory.
+     */
+    getFullRegistry(workingDirectory) {
         const channelVersion = this.channelRegistry?.getVersion() ?? -1;
-        if (!this.fullRegistry || this.fullRegistryChannelVersion !== channelVersion) {
+        if (this.fullRegistryChannelVersion !== channelVersion) {
+            this.fullRegistries.clear();
+            this.fullRegistryChannelVersion = channelVersion;
+        }
+        const defaultCwd = this.toolDeps?.workingDirectory ?? '';
+        const cwd = workingDirectory ?? defaultCwd;
+        let registry = this.fullRegistries.get(cwd);
+        if (!registry) {
             if (!this.toolDeps?.configManager || !this.toolDeps?.providerRegistry || !this.toolDeps?.toolLLM) {
                 throw new Error('AgentOrchestrator requires configManager, providerRegistry, and toolLLM dependencies before tool registration');
             }
-            this.fullRegistry = new ToolRegistry();
-            registerAllTools(this.fullRegistry, this.toolDeps);
-            registerChannelAgentTools(this.fullRegistry, this.toolDeps?.channelRegistry ?? this.channelRegistry);
-            this.fullRegistryChannelVersion = channelVersion;
+            registry = new ToolRegistry();
+            const isDefaultCwd = cwd === defaultCwd;
+            registerAllTools(registry, {
+                ...this.toolDeps,
+                workingDirectory: cwd,
+                fileCache: isDefaultCwd ? this.toolDeps.fileCache : undefined,
+                projectIndex: isDefaultCwd ? this.toolDeps.projectIndex : undefined,
+            });
+            registerChannelAgentTools(registry, this.toolDeps?.channelRegistry ?? this.channelRegistry);
+            this.fullRegistries.set(cwd, registry);
         }
-        return this.fullRegistry;
+        return registry;
     }
     /**
      * Build a ToolRegistry containing only the tools whose names appear in
@@ -347,9 +379,15 @@ export class AgentOrchestrator {
         }
         return routes;
     }
-    createRunContext() {
+    /**
+     * @param workingDirectory Per-call cwd override (AgentRecord.workingDirectory).
+     * Absent ⇒ `this.toolDeps.workingDirectory`, byte-identical to every run
+     * context built before this parameter existed.
+     */
+    createRunContext(workingDirectory) {
+        const cwd = workingDirectory ?? this.toolDeps?.workingDirectory ?? '';
         return {
-            workingDirectory: this.toolDeps?.workingDirectory ?? '',
+            workingDirectory: cwd,
             surfaceRoot: this.toolDeps?.surfaceRoot ?? '',
             runtimeBus: this.runtimeBus,
             featureFlagManager: this.featureFlagManager,
@@ -377,17 +415,27 @@ export class AgentOrchestrator {
             messageBus: this.messageBus,
             knowledgeService: this.toolDeps?.knowledgeService,
             memoryRegistry: this.toolDeps?.memoryRegistry,
+            codeIndex: this.toolDeps?.codeIndex,
+            isCodeInjectionSettingEnabled: this.toolDeps?.isCodeInjectionSettingEnabled,
+            onToolExecuted: this.toolDeps?.codeIndexReindexScheduler
+                ? (toolName, args, success) => this.toolDeps.codeIndexReindexScheduler.onToolExecuted(toolName, args, success)
+                : undefined,
             archetypeLoader: this.toolDeps?.archetypeLoader,
             providerOptimizer: this.toolDeps?.providerOptimizer,
             providerRegistry: this.toolDeps.providerRegistry,
-            getFullRegistry: () => this.getFullRegistry(),
+            getFullRegistry: () => this.getFullRegistry(cwd),
             buildScopedRegistry: (allowedNames, fullRegistry) => this.buildScopedRegistry(allowedNames, fullRegistry),
             resolveProviderForRecord: (providerRegistry, record, currentModel) => this.resolveProviderForRecord(providerRegistry, record, currentModel),
             resolveFallbackModelRoutes: (providerRegistry, record, currentModel, primaryRequestedModelId) => this.resolveFallbackModelRoutes(providerRegistry, record, currentModel, primaryRequestedModelId),
         };
     }
-    /** Run an agent task described by the given record. */
+    /**
+     * Run an agent task described by the given record. Honors
+     * `record.workingDirectory` when set (see AgentInput.workingDirectory) —
+     * every tool this run's registry exposes is bound to that cwd instead of
+     * the orchestrator's default.
+     */
     async runAgent(record) {
-        await runAgentTask(this.createRunContext(), record);
+        await runAgentTask(this.createRunContext(record.workingDirectory), record);
     }
 }

package/dist/platform/agents/planner-decomposition-runner.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Production `DecompositionRunner` backed by the real `AgentManager`.
+ *
+ * This is the concrete driver that spawns a bounded, READ-ONLY `planner`
+ * agent through the existing agents machinery and polls it to completion. It
+ * lives in the agents layer (not `core`) precisely so `core/plan-decomposition.ts`
+ * can stay free of any agent-machinery import and be unit-tested against a
+ * stubbed runner. The planning agent it spawns is an ordinary `AgentManager`
+ * agent, so it surfaces in the fleet like any other and honours kill/steer;
+ * an external kill lands here as a `'cancelled'` result → heuristic fallback.
+ *
+ * Bounds are enforced cooperatively by polling `AgentRecord.usage`:
+ *   - wall-clock: `cancel()` once `now() >= start + wallTimeoutMs`
+ *   - token ceiling: `cancel()` once input+output tokens exceed the ceiling
+ *   - turns: `cancel()` once `usage.turnCount` exceeds `maxTurns`
+ * All three collapse to a `'cancelled'` run result (with a `detail`), which the
+ * service turns into an honest `fallbackReason`.
+ */
+import type { AgentManager } from '../tools/agent/manager.js';
+import type { DecompositionRunner } from '../core/plan-decomposition.js';
+/** The read-only tool set the planner template resolves to. Kept in lockstep
+ *  with AGENT_TEMPLATES.planner and passed with restrictTools for a hard cap. */
+export declare const PLANNER_DECOMPOSITION_TOOLS: readonly ["read", "find", "analyze", "inspect"];
+export interface AgentManagerDecompositionRunnerDeps {
+    agentManager: Pick<AgentManager, 'spawn' | 'getStatus' | 'cancel'>;
+    /** Injectable clock (tests). */
+    now?: () => number;
+    /** Injectable sleep (tests). */
+    sleep?: (ms: number) => Promise<void>;
+    /** Poll interval in ms (default 50). */
+    pollIntervalMs?: number;
+    /** Optional model registry key override for the planner agent. */
+    model?: string | undefined;
+    /** Optional provider override for the planner agent. */
+    provider?: string | undefined;
+}
+export declare function createAgentManagerDecompositionRunner(deps: AgentManagerDecompositionRunnerDeps): DecompositionRunner;
+//# sourceMappingURL=planner-decomposition-runner.d.ts.map

package/dist/platform/agents/planner-decomposition-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-decomposition-runner.d.ts","sourceRoot":"","sources":["../../../src/platform/agents/planner-decomposition-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG9D,OAAO,KAAK,EACV,mBAAmB,EAGpB,MAAM,+BAA+B,CAAC;AAGvC;iFACiF;AACjF,eAAO,MAAM,2BAA2B,iDAAkD,CAAC;AAE3F,MAAM,WAAW,mCAAmC;IAClD,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,GAAG,WAAW,GAAG,QAAQ,CAAC,CAAC;IACnE,gCAAgC;IAChC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,gCAAgC;IAChC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,wCAAwC;IACxC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kEAAkE;IAClE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAyBD,wBAAgB,qCAAqC,CACnD,IAAI,EAAE,mCAAmC,GACxC,mBAAmB,CA+ErB"}

package/dist/platform/agents/planner-decomposition-runner.js

@@ -0,0 +1,113 @@
+/**
+ * Production `DecompositionRunner` backed by the real `AgentManager`.
+ *
+ * This is the concrete driver that spawns a bounded, READ-ONLY `planner`
+ * agent through the existing agents machinery and polls it to completion. It
+ * lives in the agents layer (not `core`) precisely so `core/plan-decomposition.ts`
+ * can stay free of any agent-machinery import and be unit-tested against a
+ * stubbed runner. The planning agent it spawns is an ordinary `AgentManager`
+ * agent, so it surfaces in the fleet like any other and honours kill/steer;
+ * an external kill lands here as a `'cancelled'` result → heuristic fallback.
+ *
+ * Bounds are enforced cooperatively by polling `AgentRecord.usage`:
+ *   - wall-clock: `cancel()` once `now() >= start + wallTimeoutMs`
+ *   - token ceiling: `cancel()` once input+output tokens exceed the ceiling
+ *   - turns: `cancel()` once `usage.turnCount` exceeds `maxTurns`
+ * All three collapse to a `'cancelled'` run result (with a `detail`), which the
+ * service turns into an honest `fallbackReason`.
+ */
+import { summarizeError } from '../utils/error-display.js';
+/** The read-only tool set the planner template resolves to. Kept in lockstep
+ *  with AGENT_TEMPLATES.planner and passed with restrictTools for a hard cap. */
+export const PLANNER_DECOMPOSITION_TOOLS = ['read', 'find', 'analyze', 'inspect'];
+function defaultSleep(ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        timer.unref?.();
+    });
+}
+function mapUsage(usage) {
+    if (!usage)
+        return undefined;
+    return {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadTokens: usage.cacheReadTokens,
+        cacheWriteTokens: usage.cacheWriteTokens,
+        totalTokens: usage.inputTokens + usage.outputTokens,
+    };
+}
+export function createAgentManagerDecompositionRunner(deps) {
+    const now = deps.now ?? Date.now;
+    const sleep = deps.sleep ?? defaultSleep;
+    const pollIntervalMs = deps.pollIntervalMs ?? 50;
+    return {
+        async run(request) {
+            const start = now();
+            const spawnInput = {
+                mode: 'spawn',
+                task: request.userPrompt,
+                template: 'planner',
+                tools: [...PLANNER_DECOMPOSITION_TOOLS],
+                restrictTools: true,
+                executionIntent: { filesystemPolicy: 'read-only', networkPolicy: 'deny', riskClass: 'safe' },
+                reviewMode: 'none',
+                dangerously_disable_wrfc: true,
+                systemPromptAddendum: request.systemPrompt,
+                ...(deps.model ? { model: deps.model } : {}),
+                ...(deps.provider ? { provider: deps.provider } : {}),
+            };
+            let agentId;
+            try {
+                const record = deps.agentManager.spawn(spawnInput);
+                agentId = record.id;
+            }
+            catch (err) {
+                return { status: 'failed', output: '', elapsedMs: now() - start, detail: summarizeError(err) };
+            }
+            const deadline = start + request.bounds.wallTimeoutMs;
+            let stopDetail;
+            // Poll until terminal or a bound trips.
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const cur = deps.agentManager.getStatus(agentId);
+                if (!cur) {
+                    return { status: 'failed', output: '', elapsedMs: now() - start, detail: 'agent record disappeared', agentId };
+                }
+                if (cur.status === 'completed' || cur.status === 'failed' || cur.status === 'cancelled')
+                    break;
+                const tokens = (cur.usage?.inputTokens ?? 0) + (cur.usage?.outputTokens ?? 0);
+                if (tokens > request.bounds.tokenCeiling) {
+                    stopDetail = `token ceiling exceeded (${tokens} > ${request.bounds.tokenCeiling})`;
+                    deps.agentManager.cancel(agentId, 'kill');
+                    break;
+                }
+                if ((cur.usage?.turnCount ?? 0) > request.bounds.maxTurns) {
+                    stopDetail = `max turns exceeded (${request.bounds.maxTurns})`;
+                    deps.agentManager.cancel(agentId, 'kill');
+                    break;
+                }
+                if (now() >= deadline) {
+                    stopDetail = `wall-timeout ${request.bounds.wallTimeoutMs}ms`;
+                    deps.agentManager.cancel(agentId, 'kill');
+                    break;
+                }
+                await sleep(pollIntervalMs);
+            }
+            const final = deps.agentManager.getStatus(agentId);
+            if (!final) {
+                return { status: 'failed', output: '', elapsedMs: now() - start, detail: 'agent record disappeared', agentId };
+            }
+            const elapsedMs = (final.completedAt ?? now()) - start;
+            const usage = mapUsage(final.usage);
+            const output = final.fullOutput ?? '';
+            if (final.status === 'completed') {
+                return { status: 'completed', output, ...(usage ? { usage } : {}), elapsedMs, agentId };
+            }
+            if (final.status === 'cancelled') {
+                return { status: 'cancelled', output, ...(usage ? { usage } : {}), elapsedMs, ...(stopDetail ? { detail: stopDetail } : {}), agentId };
+            }
+            return { status: 'failed', output, ...(usage ? { usage } : {}), elapsedMs, ...(final.error ? { detail: final.error } : {}), agentId };
+        },
+    };
+}

package/dist/platform/agents/turn-knowledge-injection.d.ts

@@ -1,5 +1,5 @@
 import type { ProviderMessage } from '../providers/interface.js';
-import type { MemoryRecord, MemoryRegistry, MemorySemanticSearchResult, MemoryVectorStats } from '../state/index.js';
+import type { CodeContextResult, CodeIndexStats, MemoryRecord, MemoryRegistry, MemorySemanticSearchResult, MemoryVectorStats } from '../state/index.js';
 /**
  * Default per-turn injection budget: min(800 tokens, 3% of the model's context window).
  * 800 is the static floor for models with an unknown/zero context window (0 short-circuits
@@ -19,8 +19,52 @@ export declare const DEFAULT_TURN_KNOWLEDGE_BUDGET_TOKENS = 800;
 export declare const DEFAULT_TURN_KNOWLEDGE_RELEVANCE_FLOOR = 95;
 /** Default candidate breadth passed through to selectKnowledgeForTaskScored. */
 export declare const DEFAULT_TURN_KNOWLEDGE_LIMIT = 3;
+/** Default candidate breadth for the code-index retrieval (Stage B). */
+export declare const DEFAULT_TURN_CODE_LIMIT = 3;
+/**
+ * Similarity → floor-scale projection for code-index hits (Stage B).
+ *
+ * Memory records are ranked on an ADDITIVE score scale (knowledge-injection.ts
+ * scoreKnowledge): confidence (>=55) + reviewState bonus + per-token match
+ * bonuses, with the default relevance floor of 95 = confidence 55 + 'fresh' 20
+ * + one token match 20. Code-index hits carry a cosine-derived `similarity` in
+ * [0,1] (code-index-store.ts distanceToSimilarity = clamp(1 - L2distance/2)),
+ * a DIFFERENT scale entirely. To let a single shared relevance floor govern
+ * BOTH sources honestly, a code hit's similarity is projected onto the memory
+ * score scale by:
+ *
+ *   codeScore = similarity * CODE_SIMILARITY_TO_SCORE_SCALE   (= similarity * 200)
+ *
+ * Consequences of scale = 200, stated so the mapping is auditable, not magic:
+ *   - The default floor 95 admits code at similarity >= 0.475.
+ *   - An orthogonal (unrelated) normalized-embedding pair has cosine 0, i.e.
+ *     L2 distance sqrt(2) ≈ 1.414, i.e. similarity ≈ 0.293 — BELOW 0.475, so
+ *     unrelated chunks never clear the floor.
+ *   - A genuinely similar chunk (similarity 0.5–1.0 → score 100–200) clears it.
+ *   - Because the SAME configurable floor scales both sources, raising the
+ *     floor (stricter memory) also raises the code similarity bar in lockstep,
+ *     and lowering it loosens both. There is no separate, silently-diverging
+ *     code threshold to keep in sync.
+ */
+export declare const CODE_SIMILARITY_TO_SCORE_SCALE = 200;
 /** Bounded ring size for AgentRecord.turnInjections (see recordTurnInjection). */
 export declare const DEFAULT_TURN_INJECTION_RING_SIZE = 20;
+/**
+ * Structural code-index surface the per-turn retrieval reads (Stage B). Kept
+ * structural (not `Pick<CodeIndexStore, ...>`) so tests can supply a minimal
+ * fake without constructing a real sqlite-backed store. `stats()` exposes the
+ * exact honesty signals the retrieval gates on: an empty index, a provider-
+ * space mismatch, or a hashed-only (no real semantic) provider each mean "do
+ * not auto-inject" — see collectCodeInjectionCandidates.
+ */
+export type TurnCodeIndexSource = {
+    search(query: string, opts?: {
+        limit?: number;
+    }): readonly CodeContextResult[];
+    stats(): Pick<CodeIndexStats, 'available' | 'indexedChunks' | 'embeddingProviderMismatch' | 'semanticRetrievalAvailable'>;
+};
+/** Source of one injected line: reviewable project memory vs the repo code index. */
+export type TurnInjectionSource = 'memory' | 'code-index';
 export declare function defaultTurnKnowledgeBudgetTokens(contextWindow: number): number;
 /**
  * Per-turn honesty record for one agent turn's passive-injection attempt. Stored on
@@ -33,10 +77,23 @@ export interface TurnInjectionRecord {
     readonly turn: number;
     /** The derived query actually sent through the ranking pipeline (task + conversation tail). */
     readonly query: string;
-    /** Count of scored, confidence-gated, not-already-injected candidates considered this turn. */
+    /** Count of scored, confidence-gated, not-already-injected MEMORY candidates considered this turn. */
     readonly candidatesConsidered: number;
+    /**
+     * Count of not-already-injected CODE-INDEX hits considered this turn (before the relevance floor).
+     * 0 when code injection was off / no code source was wired / the index was empty or mismatched
+     * (see codeInjectionSkipped for which). Stage B — memory-only records keep this at 0.
+     */
+    readonly codeCandidatesConsidered: number;
     /** Record ids actually injected into the prompt this turn (empty when block===null). */
     readonly injectedIds: readonly string[];
+    /**
+     * Source of each injected id, SAME ORDER as injectedIds: 'memory' for a reviewable
+     * project-memory record, 'code-index' for a repo source-tree chunk. Kept as a parallel
+     * array (not folded into ingestModes, which is a retrieval-quality label, not source
+     * plumbing) so /recall and the transcript can label a code hit as a code hit honestly.
+     */
+    readonly injectedSources: readonly TurnInjectionSource[];
     /** Record ids that cleared the relevance floor but were dropped to fit the token budget. */
     readonly droppedForBudget: readonly string[];
     /** Estimated token cost of the rendered block (0 when block===null). */
@@ -45,8 +102,20 @@ export interface TurnInjectionRecord {
     readonly budgetTokens: number;
     /** The relevance floor this turn was evaluated against. */
     readonly relevanceFloor: number;
-    /** Ingest mode (keyword/semantic/hybrid) of each injected record, same order as injectedIds. */
+    /**
+     * Retrieval-quality label of each injected record, same order as injectedIds: for a memory
+     * record its ingest mode (keyword/semantic/hybrid-ranked); for a code hit its honest match
+     * label ('semantic' when a real vector match, 'lexical' when a degraded name/path match).
+     */
     readonly ingestModes: readonly string[];
+    /**
+     * Present exactly when a code source WAS wired and enabled this turn but contributed no
+     * injected line, stating why in the store's own terms: 'code index empty', a provider-space
+     * mismatch string, 'no semantic embedding provider', or 'no code chunks cleared the relevance
+     * floor'. Undefined when code injected at least one line, or when code injection was off (the
+     * flag/setting gate never called into the index — nothing to explain).
+     */
+    readonly codeInjectionSkipped?: string | undefined;
     /** Honest embeddings signal: 'available' when the registry's vector index is enabled and
      *  usable, 'fallback-lexical' when memory-store.ts's searchSemantic() degraded to keyword
      *  ranking (no vector index, or the registry does not expose vectorStats at all). */
@@ -82,6 +151,22 @@ export interface BuildPerTurnKnowledgeInjectionInput {
     /** Ids never to re-list (the spawn-time baseline plus every id injected on prior turns). */
     readonly alreadyInjectedIds: readonly string[];
     readonly turn: number;
+    /**
+     * Stage B — repo code index. Optional; the two callers pass it only when a store is wired.
+     * Whether code hits are actually retrieved is gated by `codeInjectionEnabled` (below) AND
+     * the store's own honesty checks (empty index / provider mismatch / no semantic provider),
+     * so a wired-but-disabled source is a hard no-op with an honest record.
+     */
+    readonly codeIndex?: TurnCodeIndexSource | undefined;
+    /**
+     * Stage B — resolved code-injection gate for this turn: (the `agent-passive-code-injection`
+     * feature flag, DEFAULT OFF) AND (the embedder's storage.codeIndexEnabled setting). Resolved
+     * by the caller, not this pure function. Defaults to false — code injection never happens
+     * unless the caller explicitly opted in this turn, matching the flag's default-off posture.
+     */
+    readonly codeInjectionEnabled?: boolean | undefined;
+    /** Candidate breadth for the code-index retrieval. Defaults to DEFAULT_TURN_CODE_LIMIT. */
+    readonly codeLimit?: number | undefined;
 }
 export interface BuildPerTurnKnowledgeInjectionResult {
     readonly block: string | null;

package/dist/platform/agents/turn-knowledge-injection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"turn-knowledge-injection.d.ts","sourceRoot":"","sources":["../../../src/platform/agents/turn-knowledge-injection.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"turn-knowledge-injection.d.ts","sourceRoot":"","sources":["../../../src/platform/agents/turn-knowledge-injection.ts"],"names":[],"mappings":"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"}