comisai 1.0.36 → 1.0.40

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/types.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Request-body injector public types.
+ *
+ * Lifted out of request-body-injector.ts to break the factory's import
+ * cycle with the leaf modules. The barrel (index.ts) re-exports
+ * RequestBodyInjectorConfig under the canonical name.
+ *
+ * @module
+ */
+import type { CacheRetention } from "@earendil-works/pi-ai";
+import type { SessionLatch } from "../../session-latch.js";
+import type { BlockStabilityTracker } from "../../block-stability-tracker.js";
+/**
+ * Configuration for the request body injector wrapper.
+ * Controls cache breakpoints, 1M beta header, service_tier, and store injection.
+ */
+export interface RequestBodyInjectorConfig {
+    /** Wall-clock + monotonic time reads. */
+    clock: import("@comis/core").ClockPort;
+    /** Getter for per-execution cache retention override. */
+    getCacheRetention: () => CacheRetention | undefined;
+    /** Getter for conversation message retention. When provided, conversation
+     *  breakpoints use this retention instead of getCacheRetention().
+     *  Returns "short" for adaptive retention -- conversation content shifts every turn. */
+    getMessageRetention?: () => CacheRetention | undefined;
+    /** When true, inject service_tier: "auto" for Responses API providers. */
+    fastMode?: boolean;
+    /** When true, inject store: true for Responses API providers. */
+    storeCompletions?: boolean;
+    /** Callback invoked after cache breakpoints are placed.
+     *  Receives the highest message index that has a cache_control marker.
+     *  Used to set the cache fence for the next context engine run. */
+    onBreakpointsPlaced?: (highestBreakpointIndex: number) => void;
+    /** Optional getter overriding the per-model minTokens threshold.
+     *  Used to lower the threshold for sub-agent executions where sessions are short
+     *  but system prompt + tools are still worth caching. */
+    getMinTokensOverride?: () => number | undefined;
+    /** Callback invoked with the API-ready payload after cache breakpoint
+     *  placement. Used by the cache break detector to extract prompt state for
+     *  change detection. Receives the mutated params, the model, and (for Anthropic) the HTTP headers. */
+    onPayloadForCacheDetection?: (params: Record<string, unknown>, model: {
+        id: string;
+        provider: string;
+    }, headers?: Record<string, string>) => void;
+    /** Getter for structured system prompt blocks. Returns the blocks
+     *  produced by assembleRichSystemPromptBlocks() when available, or undefined
+     *  if blocks are not yet assembled (first call before prompt assembly completes). */
+    getSystemPromptBlocks?: () => {
+        staticPrefix: string;
+        attribution: string;
+        semiStableBody: string;
+    } | undefined;
+    /** Breakpoint strategy -- "auto" (default), "multi-zone", or "single". */
+    cacheBreakpointStrategy?: "auto" | "multi-zone" | "single";
+    /** Skip cache_control on final messages for sub-agent spawns. */
+    skipCacheWrite?: boolean;
+    /** Timestamp (ms since epoch) of the parent's last confirmed cache write.
+     *  Used by the TTL expiry guard to disable skipCacheWrite when the shared prefix
+     *  cache has likely expired (>80% of TTL elapsed). */
+    cacheWriteTimestamp?: number;
+    /** Parent's cache retention tier ("short" or "long"). Used alongside
+     *  cacheWriteTimestamp to determine the TTL boundary for the expiry guard. */
+    parentCacheRetention?: string;
+    /** Session key for rendered tool cache. When provided, tools rendered by
+     *  the SDK are cached and replayed byte-identically on subsequent turns. */
+    sessionKey?: string;
+    /** Getter for deferred tool names from tool deferral pipeline.
+     *  When provided and non-empty (for Anthropic non-Haiku models), tools matching
+     *  these names get defer_loading: true injected in onPayload, and a
+     *  tool_search_tool_regex server tool is appended. */
+    getDeferredToolNames?: () => Set<string>;
+    /** Getter for total MCP tool count. Used to detect all-deferred condition
+     *  where per-tool hash recomputation can be skipped. */
+    getTotalMcpToolCount?: () => number;
+    /** Feature flag hash string for tool cache key invalidation.
+     *  When provided, included in the rendered tool cache key so that
+     *  config changes affecting tool rendering invalidate stale cached schemas. */
+    featureFlagHash?: string;
+    /** Beta header latch -- once the anthropic-beta header is resolved,
+     *  subsequent calls return the latched value. Prevents mid-session header changes
+     *  that bust the cache prefix. */
+    getBetaHeaderLatch?: () => SessionLatch<string> | null;
+    /** Cache retention latch -- once retention escalates to "long",
+     *  subsequent calls return "long". Prevents retention downgrade mid-session. */
+    getRetentionLatch?: () => SessionLatch<CacheRetention> | null;
+    /** Getter for current model ID. Used by resolveCacheRetention()
+     *  to apply per-model cache retention overrides. */
+    getModelId?: () => string | undefined;
+    /** Getter for per-model cache retention overrides.
+     *  Keys are model ID prefixes (e.g., "claude-haiku", "claude-sonnet-4-6").
+     *  Longest-prefix-first matching. Overrides agent-level cacheRetention. */
+    getCacheRetentionOverrides?: () => Record<string, CacheRetention> | undefined;
+    /** Defer loading activation latch -- once defer_loading is activated
+     *  for a session, it stays active. Prevents toggling between client-side and
+     *  server-side discovery mid-session. */
+    getDeferLoadingLatch?: () => SessionLatch<boolean> | null;
+    /** Getter for the previous turn's cache fence index.
+     *  Used by microcompaction to skip clearing messages within the cached prefix.
+     *  Returns -1 when no fence exists (cold start). */
+    getCacheFenceIndex?: () => number;
+    /** Getter for elapsed ms since last assistant response.
+     *  Used for time-based microcompact to detect cold-start scenarios. */
+    getElapsedSinceLastResponse?: () => number | undefined;
+    /** When true, the recent-zone message breakpoint may be promoted from
+     *  "short" to "long" TTL based on observed inter-turn timing.
+     *  Requires sessionKey, getElapsedSinceLastResponse, AND getLastResponseTs. */
+    promoteRecentZoneOnSlowCadence?: boolean;
+    /** Getter for the raw `sessionLastResponseTs.ts` value (ms since epoch)
+     *  for this session, or undefined on cold-start. Used by the cadence
+     *  tracker to detect turn boundaries within a single execute(). */
+    getLastResponseTs?: () => number | undefined;
+    /** Number of recent tool results to preserve during microcompact.
+     *  Defaults to 25 (matches observation masker keep window). */
+    observationKeepWindow?: number;
+    /** Callback to suppress false cache break detection after microcompact. */
+    onContentModification?: () => void;
+    /** Callback to reset adaptive retention to cold-start after microcompact. */
+    onAdaptiveRetentionReset?: () => void;
+    /** Token ceiling for microcompaction trigger. When estimated input tokens
+     *  exceed this value, stale tool results and thinking blocks are cleared regardless
+     *  of TTL. Default: undefined (disabled). Set to 180000 for Anthropic models. */
+    microcompactTokenCeiling?: number;
+    /** Getter for eviction cooldown state. When defined and turnsRemaining > 0,
+     *  breakpoint budget is limited to 1 and retention forced to "short". */
+    getEvictionCooldown?: () => {
+        turnsRemaining: number;
+        evictedAt: number;
+    } | undefined;
+    /** Block stability tracker for adaptive TTL promotion.
+     *  When provided, message breakpoints whose zone content has been stable
+     *  for stabilityThreshold consecutive calls are promoted from 5m to 1h TTL. */
+    blockStabilityTracker?: BlockStabilityTracker;
+    /** Number of consecutive unchanged calls before promoting a
+     *  message breakpoint to 1h TTL. Default: 3. Only used when blockStabilityTracker is set. */
+    stabilityThreshold?: number;
+    /** Callback invoked after cache breakpoint placement with per-TTL token estimates.
+     *  Counts tokens under 5m vs 1h cache_control markers for accurate cost attribution.
+     *  The bridge normalizes these estimates against the actual SDK-reported cacheWriteTokens. */
+    onTtlSplitEstimate?: (estimate: {
+        cacheWrite5mTokens: number;
+        cacheWrite1hTokens: number;
+    }) => void;
+}

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/types.js

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Request-body injector public types.
+ *
+ * Lifted out of request-body-injector.ts to break the factory's import
+ * cycle with the leaf modules. The barrel (index.ts) re-exports
+ * RequestBodyInjectorConfig under the canonical name.
+ *
+ * @module
+ */
+export {};

package/node_modules/@comis/agent/dist/executor/stream-wrappers/stub-filter-injector.d.ts

@@ -19,7 +19,7 @@
  *
  * @module
  */
-import type { ComisLogger } from "@comis/infra";
+import type { ComisLogger } from "@comis/core";
 import type { StreamFnWrapper } from "./types.js";
 export interface StubFilterInjectorConfig {
     /** Getter for stub tool names. Filtered from the rendered API payload. */

package/node_modules/@comis/agent/dist/executor/stream-wrappers/tool-result-size-bouncer.d.ts

@@ -7,7 +7,7 @@
  *
  * @module
  */
-import type { ComisLogger } from "@comis/infra";
+import type { ComisLogger } from "@comis/core";
 import type { StreamFnWrapper } from "./types.js";
 /** Truncation summary accumulated across all LLM calls in one execution. */
 export interface TruncationSummary {

package/node_modules/@comis/agent/dist/executor/stream-wrappers/tool-schema-cache.js

@@ -3,12 +3,12 @@
  * Extracted tool schema cache module.
  *
  * Pure data structures for session-scoped rendered tool caching.
- * Leaf module: imports only from cache-break-detection.ts (computeHash).
- * Zero imports from request-body-injector.ts.
+ * Leaf module: imports only from cache-detection/ (computeHash).
+ * Zero imports from request-body/ (the post-Phase-42 split of request-body-injector.ts).
  *
  * @module
  */
-import { computeHash } from "../cache-break-detection.js";
+import { computeHash } from "../cache-detection/index.js";
 export const sessionRenderedToolCache = new Map();
 export function clearSessionRenderedToolCache(sessionKey) {
     sessionRenderedToolCache.delete(sessionKey);

package/node_modules/@comis/agent/dist/executor/stream-wrappers/turn-result-budget-wrapper.d.ts

@@ -6,7 +6,7 @@
  *
  * @module
  */
-import type { ComisLogger } from "@comis/infra";
+import type { ComisLogger } from "@comis/core";
 import type { StreamFnWrapper } from "./types.js";
 /** Summary of per-turn budget enforcement accumulated across all LLM calls. */
 export interface TurnBudgetSummary {

package/node_modules/@comis/agent/dist/executor/stream-wrappers/types.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import type { StreamFn } from "@mariozechner/pi-agent-core";
+import type { StreamFn } from "@earendil-works/pi-agent-core";
 /**
  * A StreamFn wrapper intercepts and decorates a StreamFn.
  * Takes the "next" function in the chain and returns a new StreamFn.

package/node_modules/@comis/agent/dist/executor/stream-wrappers/validation-error-formatter.d.ts

@@ -6,7 +6,7 @@
  *
  * @module
  */
-import type { ComisLogger } from "@comis/infra";
+import type { ComisLogger } from "@comis/core";
 import type { StreamFnWrapper } from "./types.js";
 /**
  * Create a wrapper that reformats AJV validation errors in toolResult messages

package/node_modules/@comis/agent/dist/executor/tool-deferral.d.ts

@@ -13,8 +13,8 @@
  *
  * @module
  */
-import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
-import type { ComisLogger } from "@comis/infra";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { ComisLogger } from "@comis/core";
 import type { EmbeddingPort } from "@comis/core";
 import type { DiscoveryTracker } from "./discovery-tracker.js";
 import type { ModelTier } from "../bootstrap/sections/tooling-sections.js";
@@ -47,9 +47,10 @@ export interface DeferralContext {
     /** Provider family for mid-turn injection awareness.
      *  "anthropic" and "google" support mid-turn tool injection, so MCP tools
      *  can be deferred behind discover_tools. Other providers (e.g., "openai",
-     *  "default") do not inject mid-turn, so MCP tools must be active from the
-     *  start. When undefined, defaults to deferring (backward compat). */
-    providerFamily?: string;
+     *  "default", "other") do not inject mid-turn, so MCP tools must be active
+     *  from the start. Required — pass the explicit family for the resolved
+     *  model; use "default" when no specific family applies. */
+    providerFamily: string;
     /** Names of tools currently ACTIVE in this session (post-deferral).
      *  Consumed by discover_tools to return "already active" guidance when
      *  queries re-ask for loaded MCPs. Must NOT include names that were
@@ -101,13 +102,16 @@ export declare function resolveModelTier(contextWindow: number): ModelTier;
  */
 export declare function resolveToolCallingTemperature(modelTier: ModelTier): number;
 /**
- * Anthropic models that support server-side tool_search_tool_regex
- * (defer_loading). Sonnet 4.x+, Opus 4.x+; NOT Haiku.
+ * Anthropic models that support server-side tool-search via defer_loading.
+ * Sonnet 4.x+, Opus 4.x+; NOT Haiku.
  *
- * When this returns true, request-body-injector strips client-side
- * `discover_tools` from the API payload and appends `tool_search_tool_regex`
- * instead -- so any model-facing teaching string about `discover_tools`
- * contradicts the actual tool list and must be suppressed.
+ * **Surviving caller:** `request-body-injector.ts` (the
+ * `if (supportsToolSearch(model.id)) {...}` gate inside the Anthropic
+ * `onPayload` handler). Used to gate the API-payload reshape that strips
+ * the client-side discovery tool, appends the server-side tool-search
+ * regex tool, and marks deferred tools `defer_loading: true`. This is a
+ * runtime API-payload concern, distinct from the deferred-tool prompt
+ * teaching emitted by `buildDeferredToolsContext`.
  *
  * Lowercase-normalize so provider-prefixed model ids
  * (`anthropic/claude-sonnet-4`, `bedrock/anthropic.claude-opus-4`) resolve
@@ -135,31 +139,19 @@ export declare function resolveToolDescription(tool: ToolDefinition): string;
  * Lists deferred tool names and descriptions so the LLM knows what's
  * available behind a discovery mechanism.
  *
- * The third line (the instruction line) is conditional on `useToolSearch`:
- *
- * - `useToolSearch=false` (default, every non-Anthropic provider + Haiku):
- *   teaches the model to call the client-side `discover_tools` tool, which
- *   IS present in those payloads.
- *
- * - `useToolSearch=true` (Anthropic Sonnet/Opus 4.x): the API payload no
- *   longer contains a client-side `discover_tools` tool -- the
- *   request-body-injector replaces it with the server-side
- *   `tool_search_tool_regex` and marks deferred tools `defer_loading: true`,
- *   meaning Anthropic auto-loads them on first direct invocation. The
- *   teaching string therefore points at direct invocation + tool-search by
- *   regex, never at `discover_tools`. Without this conditional, the model
- *   reads its own preamble ("call discover_tools") against a tool list that
- *   doesn't contain that tool and gives up (production repro).
+ * The instruction line is mechanism-neutral: it tells the model these
+ * tools are available but not loaded, and points it at "the discovery
+ * mechanism available in your active toolspace" without naming a specific
+ * tool. Provider-specific payload reshaping (stripping the client-side
+ * discovery tool and appending the server-side tool-search regex tool for
+ * Anthropic Sonnet/Opus 4.x) lives entirely in `request-body-injector.ts`
+ * and is gated by `supportsToolSearch(modelId)`. This separation is
+ * enforced by architecture-grep tests.
  *
  * @param entries - Deferred tool entries (remaining after discovery re-inclusion)
- * @param options - Optional flags. `useToolSearch=true` switches the third
- *   line to the tool-search-aware variant. Defaults to false (backward-
- *   compatible with the discover_tools teaching).
  * @returns XML block string, or empty string when no entries
  */
-export declare function buildDeferredToolsContext(entries: DeferredToolEntry[], options?: {
-    useToolSearch?: boolean;
-}): string;
+export declare function buildDeferredToolsContext(entries: DeferredToolEntry[]): string;
 /**
  * Apply unified tool deferral: rule-based, budget-based, small-model,
  * lifecycle merge, and operator overrides.
@@ -204,8 +196,9 @@ export interface ToolDiscoveryScoreConfig {
  * @param activeToolNames Names of tools currently ACTIVE in this session
  *   (post-deferral: active + discovered). Used to return "already active"
  *   guidance when queries re-ask for loaded MCPs. Must NOT include names
- *   that were deferred. Default empty set keeps callers backward-compatible.
+ *   that were deferred. Required — pass an empty set when no tools are
+ *   active rather than relying on a default.
  */
-export declare function createDiscoverTool(deferredEntries: DeferredToolEntry[], logger: ComisLogger, embeddingPort?: EmbeddingPort, scoreConfig?: ToolDiscoveryScoreConfig, activeToolNames?: ReadonlySet<string>): ToolDefinition;
+export declare function createDiscoverTool(deferredEntries: DeferredToolEntry[], logger: ComisLogger, embeddingPort: EmbeddingPort | undefined, scoreConfig: ToolDiscoveryScoreConfig | undefined, activeToolNames: ReadonlySet<string>): ToolDefinition;
 export declare const DEFERRAL_STUB_MARKER: "__comis_deferral_stub__";
 export declare function createAutoDiscoveryStubs(deferredEntries: DeferredToolEntry[], discoveryTracker: DiscoveryTracker, logger: ComisLogger): ToolDefinition[];

package/node_modules/@comis/agent/dist/executor/tool-deferral.js

@@ -15,7 +15,7 @@
  * @module
  */
 import { getToolMetadata } from "@comis/core";
-import { extractMcpServerName } from "../bridge/bridge-event-handlers.js";
+import { extractMcpServerName } from "@comis/shared";
 import { PRIVILEGED_TOOL_NAMES } from "../bootstrap/sections/tooling-sections.js";
 import { LEAN_TOOL_DESCRIPTIONS } from "../bootstrap/sections/tool-descriptions.js";
 // ---------------------------------------------------------------------------
@@ -96,13 +96,16 @@ export function resolveToolCallingTemperature(modelTier) {
     return modelTier === "small" ? 0.0 : 0.1;
 }
 /**
- * Anthropic models that support server-side tool_search_tool_regex
- * (defer_loading). Sonnet 4.x+, Opus 4.x+; NOT Haiku.
+ * Anthropic models that support server-side tool-search via defer_loading.
+ * Sonnet 4.x+, Opus 4.x+; NOT Haiku.
  *
- * When this returns true, request-body-injector strips client-side
- * `discover_tools` from the API payload and appends `tool_search_tool_regex`
- * instead -- so any model-facing teaching string about `discover_tools`
- * contradicts the actual tool list and must be suppressed.
+ * **Surviving caller:** `request-body-injector.ts` (the
+ * `if (supportsToolSearch(model.id)) {...}` gate inside the Anthropic
+ * `onPayload` handler). Used to gate the API-payload reshape that strips
+ * the client-side discovery tool, appends the server-side tool-search
+ * regex tool, and marks deferred tools `defer_loading: true`. This is a
+ * runtime API-payload concern, distinct from the deferred-tool prompt
+ * teaching emitted by `buildDeferredToolsContext`.
  *
  * Lowercase-normalize so provider-prefixed model ids
  * (`anthropic/claude-sonnet-4`, `bedrock/anthropic.claude-opus-4`) resolve
@@ -169,32 +172,21 @@ export function resolveToolDescription(tool) {
  * Lists deferred tool names and descriptions so the LLM knows what's
  * available behind a discovery mechanism.
  *
- * The third line (the instruction line) is conditional on `useToolSearch`:
- *
- * - `useToolSearch=false` (default, every non-Anthropic provider + Haiku):
- *   teaches the model to call the client-side `discover_tools` tool, which
- *   IS present in those payloads.
- *
- * - `useToolSearch=true` (Anthropic Sonnet/Opus 4.x): the API payload no
- *   longer contains a client-side `discover_tools` tool -- the
- *   request-body-injector replaces it with the server-side
- *   `tool_search_tool_regex` and marks deferred tools `defer_loading: true`,
- *   meaning Anthropic auto-loads them on first direct invocation. The
- *   teaching string therefore points at direct invocation + tool-search by
- *   regex, never at `discover_tools`. Without this conditional, the model
- *   reads its own preamble ("call discover_tools") against a tool list that
- *   doesn't contain that tool and gives up (production repro).
+ * The instruction line is mechanism-neutral: it tells the model these
+ * tools are available but not loaded, and points it at "the discovery
+ * mechanism available in your active toolspace" without naming a specific
+ * tool. Provider-specific payload reshaping (stripping the client-side
+ * discovery tool and appending the server-side tool-search regex tool for
+ * Anthropic Sonnet/Opus 4.x) lives entirely in `request-body-injector.ts`
+ * and is gated by `supportsToolSearch(modelId)`. This separation is
+ * enforced by architecture-grep tests.
  *
  * @param entries - Deferred tool entries (remaining after discovery re-inclusion)
- * @param options - Optional flags. `useToolSearch=true` switches the third
- *   line to the tool-search-aware variant. Defaults to false (backward-
- *   compatible with the discover_tools teaching).
  * @returns XML block string, or empty string when no entries
  */
-export function buildDeferredToolsContext(entries, options) {
+export function buildDeferredToolsContext(entries) {
     if (entries.length === 0)
         return "";
-    const useToolSearch = options?.useToolSearch === true;
     // Separate MCP tools (group by server) from non-MCP tools (individual listing)
     const mcpByServer = new Map();
     const nonMcpEntries = [];
@@ -220,9 +212,9 @@ export function buildDeferredToolsContext(entries, options) {
         const shortNames = tools.map(t => t.name.startsWith(prefix) ? t.name.slice(prefix.length) : t.name);
         lines.push(`[${server}] (${tools.length} tools): ${shortNames.join(", ")}`);
     }
-    const instruction = useToolSearch
-        ? "These tools auto-load on first invocation -- call them directly by name with the right arguments. To preview a tool's schema before calling, use tool_search_tool_regex with a regex matching the tool name (e.g., tool_search_tool_regex(pattern: \"agents_manage\"))."
-        : "Call discover_tools to search by keyword or server name (e.g., discover_tools(\"yfinance\")).";
+    const instruction = "These tools are connected but not currently loaded into your active context. " +
+        "To use one, invoke the discovery mechanism available in your active toolspace, " +
+        "then call the loaded tool with the appropriate arguments.";
     return [
         "<deferred-tools>",
         "The following tools are available but not loaded.",
@@ -271,8 +263,7 @@ export function applyToolDeferral(tools, _contextWindow, deferralContext, logger
     // Providers without mid-turn injection (OpenAI, xAI, etc.) get MCP tools from the start,
     // because sub-agents only call execute() once and there is no "next execution" for
     // discovered tools to appear in.
-    const skipMcpDeferral = deferralContext.providerFamily !== undefined
-        && deferralContext.providerFamily !== "anthropic"
+    const skipMcpDeferral = deferralContext.providerFamily !== "anthropic"
         && deferralContext.providerFamily !== "google";
     if (!skipMcpDeferral) {
         for (const t of tools) {
@@ -428,7 +419,7 @@ function structuredSearch(deferredTools, query, maxResults) {
         if (prefixMatches.length > 0)
             return prefixMatches;
     }
-    // Mode 4: Server name match (e.g., "yfinance" -> all mcp__yfinance--* tools)
+    // Mode 4: Server name match (e.g., bare server token -> all mcp__<server>--* tools)
     const serverPrefix = `mcp__${q}--`;
     const serverMatches = deferredTools.filter(t => t.name.toLowerCase().startsWith(serverPrefix));
     if (serverMatches.length > 0)
@@ -458,9 +449,11 @@ const DEFAULT_TOOL_DISCOVERY_SCORES = {
  * @param activeToolNames Names of tools currently ACTIVE in this session
  *   (post-deferral: active + discovered). Used to return "already active"
  *   guidance when queries re-ask for loaded MCPs. Must NOT include names
- *   that were deferred. Default empty set keeps callers backward-compatible.
+ *   that were deferred. Required — pass an empty set when no tools are
+ *   active rather than relying on a default.
  */
-export function createDiscoverTool(deferredEntries, logger, embeddingPort, scoreConfig = DEFAULT_TOOL_DISCOVERY_SCORES, activeToolNames = new Set()) {
+export function createDiscoverTool(deferredEntries, logger, embeddingPort, scoreConfig, activeToolNames) {
+    const resolvedScoreConfig = scoreConfig ?? DEFAULT_TOOL_DISCOVERY_SCORES;
     // Build ToolDefinition[] view for structuredSearch compatibility
     const deferredTools = deferredEntries.map(e => e.original);
     /**
@@ -561,7 +554,7 @@ export function createDiscoverTool(deferredEntries, logger, embeddingPort, score
                 }
             }
             // ---------- Floor check ----------
-            const floor = embeddingUsed ? scoreConfig.minHybridScore : scoreConfig.minBm25Score;
+            const floor = embeddingUsed ? resolvedScoreConfig.minHybridScore : resolvedScoreConfig.minBm25Score;
             const normalizedTopScore = ranked[0]?.score ?? 0;
             const filtered = ranked.filter(r => r.score >= floor);
             const topResults = filtered.slice(0, 10);
@@ -622,7 +615,7 @@ export function createDiscoverTool(deferredEntries, logger, embeddingPort, score
                 return {
                     content: [{
                             type: "text",
-                            text: "No matching tools found. Try an exact tool name, MCP server name (e.g. 'yfinance'), or select:tool1,tool2 syntax.",
+                            text: "No matching tools found. Try an exact tool name, MCP server name, or select:tool1,tool2 syntax.",
                         }],
                     isError: false,
                     details: undefined,
@@ -648,12 +641,11 @@ export function createDiscoverTool(deferredEntries, logger, embeddingPort, score
  * Match modes (checked in order, first non-empty wins):
  * 1. Exact name match (case-insensitive) against the full query.
  * 2. `mcp__` / `mcp:` prefix match against the full query.
- * 3. Bare server-name match on full query (`"yfinance"` -> all `mcp__yfinance--*`).
+ * 3. Bare server-name match on full query (e.g., bare server token -> all `mcp__<server>--*`).
  * 4. Per-token server-name fallback: for multi-word queries like
- *    `"yfinance get_stock"`, check each whitespace-separated token as a
- *    potential MCP server name. Catches the srv1593437 08:06:39Z scenario
- *    where the agent emits `{query: "yfinance get_stock"}` rather than just
- *    `{query: "yfinance"}`.
+ *    `"<server> <verb>"`, check each whitespace-separated token as a
+ *    potential MCP server name. Catches the case where the agent emits
+ *    `{query: "<server> <verb>"}` rather than just `{query: "<server>"}`.
  */
 function findActiveToolMatches(query, activeToolNames) {
     const q = query.toLowerCase().trim();
@@ -679,7 +671,7 @@ function findActiveToolMatches(query, activeToolNames) {
     // Mode 4: per-token server fallback for multi-word queries.
     // Each whitespace-separated token is probed as a server name. The first
     // token that resolves to >= 1 active tool wins. This handles the common
-    // "{server} {verb}" pattern like "yfinance get_stock".
+    // "<server> <verb>" pattern like "<bare-server-token> <verb>".
     const tokens = q.split(/\s+/).filter(t => /^[a-z0-9_-]+$/.test(t));
     for (const token of tokens) {
         const tokenServerPrefix = `mcp__${token}--`;

package/node_modules/@comis/agent/dist/executor/tool-parallelism.d.ts

@@ -13,13 +13,7 @@
  *
  * @module
  */
-import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
-/**
- * Set of tool names that are safe to run concurrently.
- * These tools only read state and never modify filesystem, database,
- * or external services.
- */
-export declare const READ_ONLY_TOOLS: Set<string>;
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 /** Minimal logger interface for parallelism warnings. */
 interface ParallelismLogger {
     warn(obj: Record<string, unknown>, msg: string): void;
@@ -27,14 +21,13 @@ interface ParallelismLogger {
 /**
  * Determine whether a tool is read-only (safe for concurrent execution).
  *
- * Three-tier fallback chain:
+ * Two-tier classification chain:
  *   1. Explicit metadata declaration (getToolMetadata registry)
  *   2. MCP heuristic (mcp__-prefixed tools manage their own state)
- *   3. Legacy READ_ONLY_TOOLS set (backward compat)
  *
  * Unknown tools default to false (mutating) as a safety measure.
  */
-export declare function isReadOnlyTool(name: string, logger?: ParallelismLogger): boolean;
+export declare function isReadOnlyTool(name: string, _logger?: ParallelismLogger): boolean;
 /**
  * Determine whether a tool is safe for concurrent execution.
  *

package/node_modules/@comis/agent/dist/executor/tool-parallelism.js

@@ -15,60 +15,16 @@
  * @module
  */
 import { getToolMetadata } from "@comis/core";
-// ---------------------------------------------------------------------------
-// Read-only tool classification
-// ---------------------------------------------------------------------------
-/**
- * Set of tool names that are safe to run concurrently.
- * These tools only read state and never modify filesystem, database,
- * or external services.
- */
-export const READ_ONLY_TOOLS = new Set([
-    // File system reads
-    "read",
-    "grep",
-    "find",
-    "ls",
-    // Web reads
-    "web_search",
-    "web_fetch",
-    "browser",
-    // Memory/session reads
-    "memory_search",
-    "memory_get",
-    "session_search",
-    // Session reads
-    "sessions_list",
-    "session_status",
-    "sessions_history",
-    // Context reads
-    "ctx_search",
-    "ctx_inspect",
-    "ctx_expand",
-    "ctx_recall",
-    // Media analysis (read-only inference)
-    "image_analyze",
-    "describe_video",
-    "extract_document",
-    "transcribe_audio",
-    // Platform reads
-    "obs_query",
-    "models_manage",
-    // Discovery
-    "discover_tools",
-    // NOTE: "process" is intentionally EXCLUDED — its kill action is mutating (SIGTERM/SIGKILL).
-]);
 /**
  * Determine whether a tool is read-only (safe for concurrent execution).
  *
- * Three-tier fallback chain:
+ * Two-tier classification chain:
  *   1. Explicit metadata declaration (getToolMetadata registry)
  *   2. MCP heuristic (mcp__-prefixed tools manage their own state)
- *   3. Legacy READ_ONLY_TOOLS set (backward compat)
  *
  * Unknown tools default to false (mutating) as a safety measure.
  */
-export function isReadOnlyTool(name, logger) {
+export function isReadOnlyTool(name, _logger) {
     // Priority 1: explicit metadata declaration
     const meta = getToolMetadata(name);
     if (meta?.isReadOnly !== undefined)
@@ -76,12 +32,8 @@ export function isReadOnlyTool(name, logger) {
     // Priority 2: MCP heuristic (MCP servers manage their own state)
     if (name.startsWith("mcp__"))
         return true;
-    // Priority 3: legacy hardcoded set (backward compat)
-    const legacyResult = READ_ONLY_TOOLS.has(name);
-    if (logger && legacyResult) {
-        logger.warn({ toolName: name, hint: "Register isReadOnly metadata for this tool", errorKind: "config" }, "isReadOnlyTool() fell back to legacy READ_ONLY_TOOLS set");
-    }
-    return legacyResult;
+    // Unknown tool: default to mutating for safety.
+    return false;
 }
 /**
  * Determine whether a tool is safe for concurrent execution.

package/node_modules/@comis/agent/dist/executor/ttl-guard.d.ts

@@ -10,8 +10,8 @@
  *
  * @module
  */
-import type { CacheRetention } from "@mariozechner/pi-ai";
-import type { ComisLogger } from "@comis/infra";
+import type { CacheRetention } from "@earendil-works/pi-ai";
+import type { ComisLogger, ClockPort } from "@comis/core";
 import type { StreamFnWrapper } from "./stream-wrappers/types.js";
 export interface TtlGuardConfig {
     /** Session key for timestamp lookup. */
@@ -22,6 +22,8 @@ export interface TtlGuardConfig {
     onTtlExpiry: () => void;
     /** Logger for debug output. */
     logger: ComisLogger;
+    /** Wall-clock + monotonic time reads. */
+    clock: ClockPort;
 }
 /**
  * Create a stream wrapper that checks wall-clock TTL expiry for Anthropic sessions.
@@ -36,7 +38,7 @@ export declare function createTtlGuard(config: TtlGuardConfig): StreamFnWrapper;
  * Record the timestamp and retention for the last assistant response in a session.
  * Called after each successful LLM response to update the TTL baseline.
  */
-export declare function recordLastResponseTs(sessionKey: string, retention: CacheRetention): void;
+export declare function recordLastResponseTs(sessionKey: string, retention: CacheRetention, clock: ClockPort): void;
 /**
  * Clear the last response timestamp for a session.
  * Called during session cleanup (co-located with clearSessionCacheWarm, etc.).
@@ -47,7 +49,7 @@ export declare function clearSessionLastResponseTs(sessionKey: string): void;
  * Returns undefined if no response has been recorded (cold-start).
  * Used by the idle-based thinking clear to determine if cache is cold.
  */
-export declare function getElapsedSinceLastResponse(sessionKey: string): number | undefined;
+export declare function getElapsedSinceLastResponse(sessionKey: string, clock: ClockPort): number | undefined;
 /**
  * Get the raw timestamp of the last recorded response for a session.
  * Returns undefined if no response has been recorded (cold-start).