comisai 1.0.15 → 1.0.16

package/node_modules/@comis/agent/dist/bootstrap/types.d.ts

@@ -95,7 +95,7 @@ export interface BootstrapContextFile {
  * Workspace file names allowed in sub-agent bootstrap context.
  * Sub-agents only receive AGENTS.md (instructions) and TOOLS.md (tool notes).
  */
-export declare const SUBAGENT_BOOTSTRAP_ALLOWLIST: Set<"SOUL.md" | "IDENTITY.md" | "USER.md" | "AGENTS.md" | "ROLE.md" | "TOOLS.md" | "HEARTBEAT.md" | "BOOTSTRAP.md" | "BOOT.md">;
+export declare const SUBAGENT_BOOTSTRAP_ALLOWLIST: Set<"AGENTS.md" | "SOUL.md" | "IDENTITY.md" | "USER.md" | "ROLE.md" | "TOOLS.md" | "HEARTBEAT.md" | "BOOTSTRAP.md" | "BOOT.md">;
 /** Head portion ratio for truncation (first 70% of maxChars) */
 export declare const BOOTSTRAP_HEAD_RATIO = 0.7;
 /** Tail portion ratio for truncation (last 20% of maxChars) */

package/node_modules/@comis/agent/dist/bridge/pi-event-bridge.js

@@ -49,9 +49,14 @@ export function createPiEventBridge(deps) {
                 // -----------------------------------------------------------------
                 case "message_update": {
                     const ame = event.assistantMessageEvent;
-                    if (ame && ame.type === "text_delta") {
-                        m.textEmitted = true; // Track that visible text was produced in some turn
-                        if (deps.onDelta) {
+                    if (ame && (ame.type === "text_delta" || ame.type === "thinking_delta")) {
+                        if (ame.type === "text_delta") {
+                            // Track that visible text was produced in some turn.
+                            // thinking_delta intentionally excluded — empty-final-turn detection
+                            // depends on this flag reflecting user-visible text only.
+                            m.textEmitted = true;
+                        }
+                        if (deps.onDelta && typeof ame.delta === "string") {
                             try {
                                 deps.onDelta(ame.delta);
                             }
@@ -394,7 +399,7 @@ export function createPiEventBridge(deps) {
                             totalTokens: usage.totalTokens,
                             cost,
                             provider: deps.provider,
-                            model: deps.model,
+                            model: deps.getCurrentModel?.() ?? deps.model,
                             sessionKey: formatSessionKey(deps.sessionKey),
                             operationType: deps.operationType,
                         });
@@ -457,7 +462,7 @@ export function createPiEventBridge(deps) {
                             channelId: deps.channelId,
                             executionId: deps.executionId,
                             provider: deps.provider,
-                            model: deps.model,
+                            model: deps.getCurrentModel?.() ?? deps.model,
                             tokens: {
                                 prompt: usage.input,
                                 completion: usage.output,
@@ -475,7 +480,7 @@ export function createPiEventBridge(deps) {
                             cacheWriteTokens,
                             sessionKey: formatSessionKey(deps.sessionKey),
                             savedVsUncached,
-                            cacheEligible: getCacheProviderInfo(deps.provider, deps.model).cacheEligible,
+                            cacheEligible: getCacheProviderInfo(deps.provider, deps.getCurrentModel?.() ?? deps.model).cacheEligible,
                             responseId,
                             cacheCreation: effectiveCacheCreation,
                         });
@@ -561,17 +566,13 @@ export function createPiEventBridge(deps) {
                     // SEP: Extract plan from first LLM turn that has tool calls + assistant text.
                     // This runs inside the agentic loop so subsequent turns can track against the plan.
                     if (deps.executionPlan && deps.sepConfig && !deps.executionPlan.current) {
-                        const hasToolCalls = Array.isArray(assistantMsg?.content) && assistantMsg.content.some((c) => {
-                            const block = c;
-                            return block.type === "toolCall" || block.type === "tool_use";
-                        });
                         const assistantTextForPlan = Array.isArray(assistantMsg?.content)
                             ? assistantMsg.content
                                 .filter((c) => c?.type === "text")
                                 .map((c) => c.text ?? "")
                                 .join(" ")
                             : "";
-                        if (hasToolCalls && assistantTextForPlan.length > 0) {
+                        if (assistantTextForPlan.length > 0) {
                             const steps = extractPlanFromResponse(assistantTextForPlan, deps.sepConfig.maxSteps);
                             if (steps && steps.length >= deps.sepConfig.minSteps) {
                                 const plan = {

package/node_modules/@comis/agent/dist/context-engine/constants.d.ts

@@ -96,6 +96,17 @@ export declare const MCP_DEFERRAL_THRESHOLD = 0.1;
  *  this many blocks apart cannot see each other for prefix matching.
  *  Used by: lookback window enforcement in stream-wrappers.ts. */
 export declare const CACHE_LOOKBACK_WINDOW = 20;
+/** Maximum message blocks before cache-aware compaction trigger.
+ *  With 4 breakpoints (3 Comis + 1 SDK) and a 20-block lookback window,
+ *  optimal coverage spans 4 × 20 = 80 blocks. Trigger when the count
+ *  *exceeds* 60 (i.e. first fires at 61 blocks — 75% of theoretical max)
+ *  to leave headroom for multi-call turns.
+ *
+ *  APPROXIMATION NOTE: `messages.length` (AgentMessage[]) approximates
+ *  Anthropic's request-body `messages[]` block count but is not strictly 1:1.
+ *  Treat 60 as a defensive setpoint, not a calibrated threshold.
+ *  Used by: llm-compaction layer cache-aware trigger. */
+export declare const CACHE_AWARE_COMPACTION_BLOCK_THRESHOLD = 60;
 /** Context utilization percentage that triggers LLM compaction. Used by: llm-compaction layer. */
 export declare const COMPACTION_TRIGGER_PERCENT = 85;
 /** Default turns to wait before re-triggering compaction. Used by: llm-compaction layer. */

package/node_modules/@comis/agent/dist/context-engine/constants.js

@@ -155,6 +155,17 @@ export const MCP_DEFERRAL_THRESHOLD = 0.10;
  *  this many blocks apart cannot see each other for prefix matching.
  *  Used by: lookback window enforcement in stream-wrappers.ts. */
 export const CACHE_LOOKBACK_WINDOW = 20;
+/** Maximum message blocks before cache-aware compaction trigger.
+ *  With 4 breakpoints (3 Comis + 1 SDK) and a 20-block lookback window,
+ *  optimal coverage spans 4 × 20 = 80 blocks. Trigger when the count
+ *  *exceeds* 60 (i.e. first fires at 61 blocks — 75% of theoretical max)
+ *  to leave headroom for multi-call turns.
+ *
+ *  APPROXIMATION NOTE: `messages.length` (AgentMessage[]) approximates
+ *  Anthropic's request-body `messages[]` block count but is not strictly 1:1.
+ *  Treat 60 as a defensive setpoint, not a calibrated threshold.
+ *  Used by: llm-compaction layer cache-aware trigger. */
+export const CACHE_AWARE_COMPACTION_BLOCK_THRESHOLD = 60;
 // ---------------------------------------------------------------------------
 // LLM Compaction (Layer 5: )
 // ---------------------------------------------------------------------------

package/node_modules/@comis/agent/dist/context-engine/index.d.ts

@@ -8,7 +8,7 @@
  */
 export type { TokenBudget, TokenAnchor, ContextLayer, ContextEngine, ContextEngineDeps, ContextEngineMetrics, AssembledContext, LayerCircuitBreaker, MicrocompactionGuard, ObservationMasker, CacheOptimizationMetrics, CacheSessionStats, EvictionStats, } from "./types.js";
 export type { ToolMaskingTier } from "./constants.js";
-export { SAFETY_MARGIN_PERCENT, MIN_SAFETY_MARGIN_TOKENS, OUTPUT_RESERVE_TOKENS, CONTEXT_ROT_BUFFER_PERCENT, LAYER_CIRCUIT_BREAKER_THRESHOLD, DEFAULT_KEEP_WINDOW_TURNS, MAX_INLINE_TOOL_RESULT_CHARS, MAX_INLINE_MCP_TOOL_RESULT_CHARS, MAX_INLINE_FILE_READ_RESULT_CHARS, TOOL_RESULT_HARD_CAP_CHARS, DEFAULT_OBSERVATION_KEEP_WINDOW, OBSERVATION_MASKING_CHAR_THRESHOLD, TOOL_MASKING_TIERS, resolveToolMaskingTier, EPHEMERAL_TOOL_KEEP_WINDOW, CHARS_PER_TOKEN_RATIO, CHARS_PER_TOKEN_RATIO_STRUCTURED, SYSTEM_PROMPT_HASH_LENGTH, BOOTSTRAP_BUDGET_WARN_PERCENT, MIN_CACHEABLE_TOKENS, DEFAULT_MIN_CACHEABLE_TOKENS, MCP_DEFERRAL_THRESHOLD, CACHE_LOOKBACK_WINDOW, COMPACTION_TRIGGER_PERCENT, COMPACTION_COOLDOWN_TURNS, COMPACTION_MAX_RETRIES, OVERSIZED_MESSAGE_CHARS_THRESHOLD, COMPACTION_REQUIRED_SECTIONS, } from "./constants.js";
+export { SAFETY_MARGIN_PERCENT, MIN_SAFETY_MARGIN_TOKENS, OUTPUT_RESERVE_TOKENS, CONTEXT_ROT_BUFFER_PERCENT, LAYER_CIRCUIT_BREAKER_THRESHOLD, DEFAULT_KEEP_WINDOW_TURNS, MAX_INLINE_TOOL_RESULT_CHARS, MAX_INLINE_MCP_TOOL_RESULT_CHARS, MAX_INLINE_FILE_READ_RESULT_CHARS, TOOL_RESULT_HARD_CAP_CHARS, DEFAULT_OBSERVATION_KEEP_WINDOW, OBSERVATION_MASKING_CHAR_THRESHOLD, TOOL_MASKING_TIERS, resolveToolMaskingTier, EPHEMERAL_TOOL_KEEP_WINDOW, CHARS_PER_TOKEN_RATIO, CHARS_PER_TOKEN_RATIO_STRUCTURED, SYSTEM_PROMPT_HASH_LENGTH, BOOTSTRAP_BUDGET_WARN_PERCENT, MIN_CACHEABLE_TOKENS, DEFAULT_MIN_CACHEABLE_TOKENS, MCP_DEFERRAL_THRESHOLD, CACHE_LOOKBACK_WINDOW, CACHE_AWARE_COMPACTION_BLOCK_THRESHOLD, COMPACTION_TRIGGER_PERCENT, COMPACTION_COOLDOWN_TURNS, COMPACTION_MAX_RETRIES, OVERSIZED_MESSAGE_CHARS_THRESHOLD, COMPACTION_REQUIRED_SECTIONS, } from "./constants.js";
 export { computeTokenBudget } from "./token-budget.js";
 export { createContextEngine } from "./context-engine.js";
 export { createThinkingBlockCleaner } from "./thinking-block-cleaner.js";

package/node_modules/@comis/agent/dist/context-engine/index.js

@@ -8,7 +8,7 @@
  * @module
  */
 // Constants
-export { SAFETY_MARGIN_PERCENT, MIN_SAFETY_MARGIN_TOKENS, OUTPUT_RESERVE_TOKENS, CONTEXT_ROT_BUFFER_PERCENT, LAYER_CIRCUIT_BREAKER_THRESHOLD, DEFAULT_KEEP_WINDOW_TURNS, MAX_INLINE_TOOL_RESULT_CHARS, MAX_INLINE_MCP_TOOL_RESULT_CHARS, MAX_INLINE_FILE_READ_RESULT_CHARS, TOOL_RESULT_HARD_CAP_CHARS, DEFAULT_OBSERVATION_KEEP_WINDOW, OBSERVATION_MASKING_CHAR_THRESHOLD, TOOL_MASKING_TIERS, resolveToolMaskingTier, EPHEMERAL_TOOL_KEEP_WINDOW, CHARS_PER_TOKEN_RATIO, CHARS_PER_TOKEN_RATIO_STRUCTURED, SYSTEM_PROMPT_HASH_LENGTH, BOOTSTRAP_BUDGET_WARN_PERCENT, MIN_CACHEABLE_TOKENS, DEFAULT_MIN_CACHEABLE_TOKENS, MCP_DEFERRAL_THRESHOLD, CACHE_LOOKBACK_WINDOW, COMPACTION_TRIGGER_PERCENT, COMPACTION_COOLDOWN_TURNS, COMPACTION_MAX_RETRIES, OVERSIZED_MESSAGE_CHARS_THRESHOLD, COMPACTION_REQUIRED_SECTIONS, } from "./constants.js";
+export { SAFETY_MARGIN_PERCENT, MIN_SAFETY_MARGIN_TOKENS, OUTPUT_RESERVE_TOKENS, CONTEXT_ROT_BUFFER_PERCENT, LAYER_CIRCUIT_BREAKER_THRESHOLD, DEFAULT_KEEP_WINDOW_TURNS, MAX_INLINE_TOOL_RESULT_CHARS, MAX_INLINE_MCP_TOOL_RESULT_CHARS, MAX_INLINE_FILE_READ_RESULT_CHARS, TOOL_RESULT_HARD_CAP_CHARS, DEFAULT_OBSERVATION_KEEP_WINDOW, OBSERVATION_MASKING_CHAR_THRESHOLD, TOOL_MASKING_TIERS, resolveToolMaskingTier, EPHEMERAL_TOOL_KEEP_WINDOW, CHARS_PER_TOKEN_RATIO, CHARS_PER_TOKEN_RATIO_STRUCTURED, SYSTEM_PROMPT_HASH_LENGTH, BOOTSTRAP_BUDGET_WARN_PERCENT, MIN_CACHEABLE_TOKENS, DEFAULT_MIN_CACHEABLE_TOKENS, MCP_DEFERRAL_THRESHOLD, CACHE_LOOKBACK_WINDOW, CACHE_AWARE_COMPACTION_BLOCK_THRESHOLD, COMPACTION_TRIGGER_PERCENT, COMPACTION_COOLDOWN_TURNS, COMPACTION_MAX_RETRIES, OVERSIZED_MESSAGE_CHARS_THRESHOLD, COMPACTION_REQUIRED_SECTIONS, } from "./constants.js";
 // Token budget algebra
 export { computeTokenBudget } from "./token-budget.js";
 // Context engine factory

package/node_modules/@comis/agent/dist/context-engine/llm-compaction.js

@@ -25,7 +25,7 @@
  * @module
  */
 import { generateSummary } from "@mariozechner/pi-coding-agent";
-import { COMPACTION_TRIGGER_PERCENT, COMPACTION_MAX_RETRIES, OVERSIZED_MESSAGE_CHARS_THRESHOLD, COMPACTION_REQUIRED_SECTIONS, CHARS_PER_TOKEN_RATIO, MIN_MIDDLE_MESSAGES_FOR_COMPACTION, } from "./constants.js";
+import { COMPACTION_TRIGGER_PERCENT, COMPACTION_MAX_RETRIES, OVERSIZED_MESSAGE_CHARS_THRESHOLD, COMPACTION_REQUIRED_SECTIONS, CHARS_PER_TOKEN_RATIO, MIN_MIDDLE_MESSAGES_FOR_COMPACTION, CACHE_AWARE_COMPACTION_BLOCK_THRESHOLD, } from "./constants.js";
 import { estimateContextCharsWithDualRatio, estimateMessageChars, estimateWithAnchor, } from "../safety/token-estimator.js";
 // ---------------------------------------------------------------------------
 // Structured output instructions
@@ -258,27 +258,41 @@ export function createLlmCompactionLayer(config, deps) {
                 if (turnsSinceLastCompaction < config.compactionCooldownTurns) {
                     return messages;
                 }
-                // Step 3: Threshold check
-                // Use anchor-based estimation when available for accurate threshold check
-                /* eslint-disable @typescript-eslint/no-explicit-any */
-                const contextChars = estimateContextCharsWithDualRatio(messages);
-                /* eslint-enable @typescript-eslint/no-explicit-any */
-                const charBasedTokens = Math.ceil(contextChars / CHARS_PER_TOKEN_RATIO);
-                const anchor = deps.getTokenAnchor?.() ?? null;
-                const contextTokens = estimateWithAnchor(anchor, messages, charBasedTokens);
-                const thresholdTokens = Math.floor(budget.windowTokens * COMPACTION_TRIGGER_PERCENT / 100);
-                if (contextTokens <= thresholdTokens) {
-                    return messages;
+                // Step 2b: Cache-aware block count trigger.
+                // Fires BEFORE the token-based threshold because lookback overflow
+                // causes cache breaks regardless of how few tokens the messages contain.
+                const messageCount = messages.length;
+                const blockThreshold = CACHE_AWARE_COMPACTION_BLOCK_THRESHOLD;
+                const blockCountExceeded = messageCount > blockThreshold;
+                // Step 3: Token threshold check (only when block-count trigger didn't fire)
+                let contextTokens;
+                let thresholdTokens;
+                if (!blockCountExceeded) {
+                    /* eslint-disable @typescript-eslint/no-explicit-any */
+                    const contextChars = estimateContextCharsWithDualRatio(messages);
+                    /* eslint-enable @typescript-eslint/no-explicit-any */
+                    const charBasedTokens = Math.ceil(contextChars / CHARS_PER_TOKEN_RATIO);
+                    const anchor = deps.getTokenAnchor?.() ?? null;
+                    contextTokens = estimateWithAnchor(anchor, messages, charBasedTokens);
+                    thresholdTokens = Math.floor(budget.windowTokens * COMPACTION_TRIGGER_PERCENT / 100);
+                    if (contextTokens <= thresholdTokens) {
+                        return messages;
+                    }
                 }
-                // Step 4: Pipeline order guarantees observation masker ran before this layer
+                // Step 4: Unified log (conditional spread keeps JSON shape clean).
                 deps.logger.warn({
-                    contextTokens,
-                    thresholdTokens,
+                    messageCount,
+                    ...(blockCountExceeded
+                        ? { blockThreshold, trigger: "block_count" }
+                        : { contextTokens, thresholdTokens, trigger: "token_threshold" }),
                     windowTokens: budget.windowTokens,
-                    messageCount: messages.length,
                     errorKind: "resource",
-                    hint: "Context approaching capacity; LLM compaction will summarize older messages to free space",
-                }, "LLM compaction triggered: context exceeds 85% threshold");
+                    hint: blockCountExceeded
+                        ? "Message count approaching breakpoint lookback limit; compacting to prevent cache fragmentation"
+                        : "Context approaching capacity; LLM compaction will summarize older messages to free space",
+                }, blockCountExceeded
+                    ? "LLM compaction triggered: message count exceeds cache lookback threshold"
+                    : "LLM compaction triggered: context exceeds 85% threshold");
                 // Step 5: Resolve model
                 /* eslint-disable @typescript-eslint/no-explicit-any */
                 let model;

package/node_modules/@comis/agent/dist/executor/cache-break-diff-writer.d.ts

@@ -60,6 +60,8 @@ export interface CacheBreakDiffPayload {
         message: number;
         sdkAuto: number;
     };
+    /** Model ID for per-model cost attribution. Populated by pi-event-bridge.ts. */
+    model?: string;
 }
 export interface CacheBreakDiffWriterConfig {
     /** Directory for diff files (e.g., ~/.comis/cache-breaks) */

package/node_modules/@comis/agent/dist/executor/cache-break-diff-writer.js

@@ -12,6 +12,7 @@
 import { writeFileSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
 import { createPatch } from "diff";
 import { safePath } from "@comis/core";
+import { resolveModelPricing, ZERO_COST } from "../model/model-catalog.js";
 const MAX_DIFF_FILES = 50;
 /** DIFF-CONTENT: Maximum chars per category (system, tools) for snapshot content before diffing. */
 const MAX_SNAPSHOT_CHARS = 50_000;
@@ -40,6 +41,7 @@ export function buildDiffableContent(system, tools, model) {
  */
 export function createCacheBreakDiffWriter(config) {
     let dirEnsured = false;
+    const unknownModelWarnLatch = new Set();
     return (event) => {
         try {
             if (!dirEnsured) {
@@ -50,6 +52,24 @@ export function createCacheBreakDiffWriter(config) {
             const ts = new Date(event.timestamp).toISOString().replace(/[:.]/g, "-");
             const filename = `${ts}_${event.agentId}_${event.reason}.json`;
             const filePath = safePath(config.outputDir, filename);
+            // Cost attribution: compute estimated USD impact using per-model pricing.
+            const modelId = event.model ?? "";
+            const pricing = resolveModelPricing(event.provider, modelId);
+            const pricingKnown = pricing !== ZERO_COST && pricing.input > 0;
+            const retentionDisabled = event.ttlCategory === "none";
+            const writeRatePerToken = event.ttlCategory === "long" ? pricing.cacheWrite1h : pricing.cacheWrite;
+            const readRatePerToken = pricing.cacheRead;
+            const perTokenDelta = Math.max(0, writeRatePerToken - readRatePerToken);
+            const estimatedCostUsd = retentionDisabled
+                ? 0
+                : (pricingKnown ? event.tokenDrop * perTokenDelta : null);
+            if (!pricingKnown && !retentionDisabled && modelId) {
+                const latchKey = `${event.provider}:${modelId}`;
+                if (!unknownModelWarnLatch.has(latchKey)) {
+                    unknownModelWarnLatch.add(latchKey);
+                    config.logger.warn({ provider: event.provider, model: modelId, hint: "Cache break cost attribution unavailable for this model", errorKind: "config" }, "Unknown model pricing for cache break cost attribution");
+                }
+            }
             const diff = {
                 timestamp: new Date(event.timestamp).toISOString(),
                 agentId: event.agentId,
@@ -85,6 +105,22 @@ export function createCacheBreakDiffWriter(config) {
                 effortValue: event.effortValue,
                 // Breakpoint budget context
                 ...(event.breakpointBudget && { breakpointBudget: event.breakpointBudget }),
+                // Cost attribution
+                estimatedCostUsd: estimatedCostUsd === null
+                    ? null
+                    : Math.round(estimatedCostUsd * 100_000) / 100_000,
+                costBreakdown: {
+                    writeRatePerMTok: pricingKnown
+                        ? Math.round(writeRatePerToken * 1_000_000 * 100) / 100
+                        : null,
+                    readRatePerMTok: pricingKnown
+                        ? Math.round(readRatePerToken * 1_000_000 * 100) / 100
+                        : null,
+                    tokenDrop: event.tokenDrop,
+                    model: event.model ?? null,
+                    ttlCategory: event.ttlCategory,
+                    pricingKnown,
+                },
             };
             writeFileSync(filePath, JSON.stringify(diff, null, 2) + "\n");
             // DIFF-CONTENT: Generate unified diff file alongside JSON

package/node_modules/@comis/agent/dist/executor/executor-post-execution.d.ts

@@ -140,6 +140,18 @@ export interface PostExecutionParams {
  * @returns true if the turn qualifies for memory storage
  */
 export declare function shouldStorePairedMemory(userText: string, agentResponse: string): boolean;
+/**
+ * Check whether paired memory content was stored recently for this agent.
+ *
+ * Exact-content hashing (not semantic similarity) -- targets the cron pattern
+ * of identical prompt + identical NO_REPLY response. Lazy eviction keeps the
+ * cache bounded without a timer.
+ *
+ * Exported for unit tests.
+ */
+export declare function isDuplicatePairedMemory(content: string, agentId: string): boolean;
+/** Reset the paired-memory dedup cache. Exported for unit tests. */
+export declare function resetPairedMemoryDedupForTests(): void;
 /**
  * Run post-execution cleanup for a PiExecutor turn.
  *

package/node_modules/@comis/agent/dist/executor/executor-post-execution.js

@@ -19,7 +19,7 @@ import { mergeSessionStats } from "./pi-executor.js";
 import { recordLastResponseTs } from "./ttl-guard.js";
 import { stripDiscoverySchemas } from "./schema-stripping.js";
 import { getWorkspaceStatus } from "../workspace/index.js";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -61,6 +61,69 @@ export function shouldStorePairedMemory(userText, agentResponse) {
         return false;
     return true;
 }
+/**
+ * Operation types that must NOT create paired memories.
+ *
+ * Cron and heartbeat executions are stateless and repetitive -- storing their
+ * prompts pollutes the vector space and degrades RAG recall for interactive
+ * conversations. Compaction / taskExtraction / condensation are system-internal
+ * operations that have their own dedicated memory paths (compaction summaries,
+ * extracted tasks) and should not additionally create paired conversation
+ * entries. Interactive and subagent are deliberately excluded.
+ */
+const MEMORY_SKIP_OPERATIONS = new Set([
+    "cron",
+    "heartbeat",
+    "compaction",
+    "taskExtraction",
+    "condensation",
+]);
+/**
+ * In-memory dedup cache for paired memory content.
+ *
+ * Defense-in-depth for interactive conversations where the user sends the same
+ * message multiple times (retries, reconnects). The Layer-1 operationType gate
+ * is the primary defense against cron/heartbeat duplication; this Layer-2 hash
+ * dedup catches residual duplicates that slip through.
+ *
+ * Keyed by a 64-bit truncation of sha256(agentId || content). Single-process
+ * daemon deployment (pm2, no cluster) means this cache is always complete.
+ */
+const DEDUP_TTL_MS = 10 * 60 * 1000;
+const DEDUP_MAX_ENTRIES = 500;
+const pairedMemoryDedup = new Map();
+/**
+ * Check whether paired memory content was stored recently for this agent.
+ *
+ * Exact-content hashing (not semantic similarity) -- targets the cron pattern
+ * of identical prompt + identical NO_REPLY response. Lazy eviction keeps the
+ * cache bounded without a timer.
+ *
+ * Exported for unit tests.
+ */
+export function isDuplicatePairedMemory(content, agentId) {
+    const now = Date.now();
+    if (pairedMemoryDedup.size > DEDUP_MAX_ENTRIES) {
+        for (const [key, ts] of pairedMemoryDedup) {
+            if (now - ts > DEDUP_TTL_MS)
+                pairedMemoryDedup.delete(key);
+        }
+    }
+    const hash = createHash("sha256")
+        .update(agentId)
+        .update(content)
+        .digest("hex")
+        .slice(0, 16);
+    const existing = pairedMemoryDedup.get(hash);
+    if (existing != null && now - existing <= DEDUP_TTL_MS)
+        return true;
+    pairedMemoryDedup.set(hash, now);
+    return false;
+}
+/** Reset the paired-memory dedup cache. Exported for unit tests. */
+export function resetPairedMemoryDedupForTests() {
+    pairedMemoryDedup.clear();
+}
 // ---------------------------------------------------------------------------
 // Implementation
 // ---------------------------------------------------------------------------
@@ -292,38 +355,65 @@ export async function postExecution(params) {
     // Pairing user message with agent response creates entries that carry enough
     // context for meaningful RAG retrieval. Standalone user messages like "Hello"
     // or "you choose" have no semantic value without the agent's response.
-    // Runs for ALL execution paths: gateway, channels, cron.
+    //
+    // Two-layer dedup defense:
+    //   Layer 1: operationType gate -- skip cron/heartbeat/system-internal ops
+    //            which are stateless/repetitive and would pollute the vector
+    //            space with near-identical entries.
+    //   Layer 2: content-hash dedup -- safety net for interactive retries.
+    //
     // Non-blocking, non-fatal -- execution never fails due to memory store errors.
-    if (deps.memoryPort && result.response && msg.text && shouldStorePairedMemory(msg.text, result.response)) {
-        try {
-            const now = Date.now();
-            const userEntryId = randomUUID();
-            const pairedContent = buildPairedMemoryContent(msg.text, result.response);
-            const userStoreResult = await deps.memoryPort.store({
-                id: userEntryId,
-                tenantId: sessionKey.tenantId,
-                agentId: agentId ?? "default",
-                userId: sessionKey.userId,
-                content: pairedContent,
-                trustLevel: "learned",
-                source: { who: sessionKey.userId, channel: msg.channelType ?? "unknown" },
-                tags: ["conversation", "paired"],
-                createdAt: now,
-            });
-            if (!userStoreResult.ok) {
-                deps.logger.warn({ err: userStoreResult.error.message, hint: "Check database connectivity and disk space", errorKind: "dependency" }, "Memory store failed for user message");
+    const operationType = params.executionOverrides?.operationType;
+    const skipMemoryForOperation = operationType != null && MEMORY_SKIP_OPERATIONS.has(operationType);
+    if (deps.memoryPort &&
+        result.response &&
+        msg.text &&
+        !skipMemoryForOperation &&
+        shouldStorePairedMemory(msg.text, result.response)) {
+        const now = Date.now();
+        const pairedContent = buildPairedMemoryContent(msg.text, result.response);
+        const effectiveAgentId = agentId ?? "default";
+        if (isDuplicatePairedMemory(pairedContent, effectiveAgentId)) {
+            deps.logger.debug({ agentId: effectiveAgentId, sessionKey: formattedKey }, "Paired memory skipped: duplicate content within dedup window");
+        }
+        else {
+            try {
+                const userEntryId = randomUUID();
+                const userStoreResult = await deps.memoryPort.store({
+                    id: userEntryId,
+                    tenantId: sessionKey.tenantId,
+                    agentId: effectiveAgentId,
+                    userId: sessionKey.userId,
+                    content: pairedContent,
+                    trustLevel: "learned",
+                    source: {
+                        who: sessionKey.userId,
+                        channel: msg.channelType ?? "unknown",
+                        sessionKey: formattedKey,
+                    },
+                    tags: ["conversation", "paired"],
+                    createdAt: now,
+                });
+                if (!userStoreResult.ok) {
+                    deps.logger.warn({ err: userStoreResult.error.message, hint: "Check database connectivity and disk space", errorKind: "dependency" }, "Memory store failed for user message");
+                }
+                else if (deps.embeddingEnqueue) {
+                    deps.embeddingEnqueue(userEntryId, pairedContent);
+                }
             }
-            else if (deps.embeddingEnqueue) {
-                deps.embeddingEnqueue(userEntryId, pairedContent);
+            catch {
+                // Memory storage failure is non-fatal -- errors already logged per-entry
             }
         }
-        catch {
-            // Memory storage failure is non-fatal -- errors already logged per-entry
-        }
     }
     else if (deps.memoryPort && result.response && msg.text) {
-        // Quality gate filtered this turn -- log for observability
-        deps.logger.debug({ userLen: msg.text.trim().length, minUserChars: PAIRED_MIN_USER_CHARS, minCombinedChars: PAIRED_MIN_COMBINED_CHARS }, "Paired memory skipped: content below quality threshold");
+        // Memory not stored -- distinguish the two skip reasons for observability.
+        if (skipMemoryForOperation) {
+            deps.logger.debug({ operationType, sessionKey: formattedKey }, "Paired memory skipped: non-interactive operation type");
+        }
+        else {
+            deps.logger.debug({ userLen: msg.text.trim().length, minUserChars: PAIRED_MIN_USER_CHARS, minCombinedChars: PAIRED_MIN_COMBINED_CHARS }, "Paired memory skipped: content below quality threshold");
+        }
     }
     // Deregister active run before dispose
     if (deps.activeRunRegistry) {

package/node_modules/@comis/agent/dist/executor/executor-prompt-runner.d.ts

@@ -37,6 +37,7 @@ export interface PromptRunnerBridge {
             output?: number;
         };
         stepsExecuted?: number;
+        toolCallHistory?: string[];
     };
 }
 /** Parameters for runPrompt(). */

package/node_modules/@comis/agent/dist/executor/executor-prompt-runner.js

@@ -515,6 +515,17 @@ export async function runPrompt(params) {
             if (plan) {
                 executionPlanRef.current = plan;
                 deps.logger.debug({ agentId }, "SEP plan extracted (post-loop fallback)");
+                // Inline backfill: post-loop extraction means no mid-loop step tracking
+                // ran, so completedCount is stuck at 0 and the nudge cannot fire. Use
+                // the bridge's recorded tool history as a proxy for work done and mark
+                // the first N steps as "done" (N = min(toolHistoryLen, stepCount)).
+                // Tool-to-step attribution is advisory/observability only; over-counting
+                // is strictly better than the 0/N deadlock.
+                const toolHistoryLen = bridge.getResult().toolCallHistory?.length ?? 0;
+                const doneCount = Math.min(toolHistoryLen, plan.steps.length);
+                for (let i = 0; i < doneCount; i++)
+                    plan.steps[i].status = "done";
+                plan.completedCount = doneCount;
             }
         }
         if (sepEnabled && !executionPlanRef.current && extractedResponse && toolCallCount === 0) {
@@ -676,11 +687,12 @@ export async function runPrompt(params) {
                 // Estimated cache write cost for the system prompt portion.
                 // System prompt is sent as cacheable prefix; on first request it incurs cache write cost.
                 const estimatedCacheWriteTokens = Math.ceil(sysPromptChars / CHARS_PER_TOKEN_RATIO);
-                const pricing = resolveModelPricing(config.provider, config.model);
+                const effectiveModelId = resolvedModel?.id ?? config.model;
+                const pricing = resolveModelPricing(config.provider, effectiveModelId);
                 if (pricing.input === 0) {
                     deps.logger.warn({
                         provider: config.provider,
-                        model: config.model,
+                        model: effectiveModelId,
                         hint: "Model not found in pricing catalog; timeout cost estimate is $0 -- actual provider billing may differ",
                         errorKind: "config",
                     }, "Unknown model for timeout cost estimation");
@@ -699,7 +711,7 @@ export async function runPrompt(params) {
                     channelId: msg.channelId,
                     executionId,
                     provider: config.provider,
-                    model: config.model,
+                    model: effectiveModelId,
                     tokens: {
                         prompt: estimatedPromptTokens,
                         completion: 0,
@@ -717,7 +729,7 @@ export async function runPrompt(params) {
                     cacheWriteTokens: estimatedCacheWriteTokens,
                     sessionKey: formatSessionKey(sessionKey),
                     savedVsUncached: 0,
-                    cacheEligible: getCacheProviderInfo(config.provider).cacheEligible,
+                    cacheEligible: getCacheProviderInfo(config.provider, effectiveModelId).cacheEligible,
                 });
                 // Include ghost cost estimate in result for bridge accumulation
                 ghostCost = pricing.input > 0 ? {

package/node_modules/@comis/agent/dist/executor/executor-stream-setup.js

@@ -29,8 +29,9 @@
 import { safePath, } from "@comis/core";
 import { createToolResultSizeBouncer, createTurnResultBudgetWrapper, createConfigResolver, createCacheTraceWriter, createApiPayloadTraceWriter, createRequestBodyInjector, createValidationErrorFormatter, } from "./stream-wrappers/index.js";
 import { resolveToolCallingTemperature } from "./tool-deferral.js";
+import { createStubFilterInjector } from "./stream-wrappers/stub-filter-injector.js";
 import { computeFeatureFlagHash } from "./prompt-assembly.js";
-import { createTtlGuard, getElapsedSinceLastResponse } from "./ttl-guard.js";
+import { createTtlGuard, getElapsedSinceLastResponse, getLastResponseTs } from "./ttl-guard.js";
 import { isAnthropicFamily, isGoogleFamily } from "../provider/capabilities.js";
 import { createGeminiCacheInjector } from "./gemini-cache-injector.js";
 import { extractAnthropicPromptState, extractGeminiPromptState } from "./cache-break-detection.js";
@@ -142,6 +143,8 @@ export function setupStreamWrappers(params) {
         parentCacheRetention: executionOverrides?.spawnPacket?.cacheSafeParams?.cacheRetention,
         getCacheFenceIndex: () => getBreakpointIndex(formattedKey) ?? -1,
         getElapsedSinceLastResponse: () => getElapsedSinceLastResponse(formattedKey),
+        getLastResponseTs: () => getLastResponseTs(formattedKey),
+        promoteRecentZoneOnSlowCadence: config.advancedCacheOptimization?.enableRecentZonePromotion ?? true,
         observationKeepWindow: 25,
         microcompactTokenCeiling: 180_000,
         onContentModification: () => cacheBreakDetector.notifyContentModification(formattedKey),
@@ -231,6 +234,19 @@ export function setupStreamWrappers(params) {
             deps.logger.info({ outputDir, cacheTracePath, apiPayloadPath }, "JSONL tracing enabled");
         }
     }
+    // MUST be the last wrapper pushed (innermost). Runs its onPayload FIRST in
+    // the chain so all downstream wrappers operate on stub-free tools. Violating
+    // this ordering would (a) include stub schemas in the Anthropic rendered-tool
+    // cache hash, (b) persist stubs into the Gemini CachedContent entry for its
+    // whole lifetime, and (c) cause deferCount > 0 in the DEFER-TOOL block,
+    // unintentionally flipping Anthropic sessions to server-side tool_search.
+    wrappers.push(createStubFilterInjector({
+        getStubToolNames: () => {
+            if (!deferralResult?.deferredEntries.length)
+                return new Set();
+            return new Set(deferralResult.deferredEntries.map(e => e.name));
+        },
+    }, deps.logger));
     return {
         wrappers,
         contextEngineRef,

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

@@ -15,7 +15,7 @@
  */
 import { SettingsManager, } from "@mariozechner/pi-coding-agent";
 import { formatSessionKey, } from "@comis/core";
-import { applyToolDeferral, buildDeferredToolsContext, extractRecentlyUsedToolNames, resolveModelTier, CORE_TOOLS } from "./tool-deferral.js";
+import { applyToolDeferral, buildDeferredToolsContext, createDiscoverTool, createAutoDiscoveryStubs, extractRecentlyUsedToolNames, resolveModelTier, CORE_TOOLS } from "./tool-deferral.js";
 import { getOrCreateDiscoveryTracker } from "./discovery-tracker.js";
 import { getOrCreateTracker, DEFAULT_LIFECYCLE_CONFIG } from "./tool-lifecycle.js";
 import { isAnthropicFamily, isGoogleFamily } from "../provider/capabilities.js";
@@ -289,10 +289,36 @@ export async function assembleTools(params) {
             : undefined,
     };
     const deferralResult = applyToolDeferral(mergedCustomTools, contextWindow, deferralCtx, deps.logger, deps.embeddingPort, config.skills?.toolDiscovery);
+    // Rebuild discover_tools with the now-known active set so it can answer
+    // "already active" queries correctly. Post-deferral set (active +
+    // discovered) is the only factually-accurate set -- using mergedCustomTools
+    // (pre-deferral) would false-positive on currently-deferred tools and tell
+    // the agent "call directly, no discovery needed" for tools that aren't
+    // actually loaded. See design §4.2, §5.5, decision log row 4:
+    // .planning/design/discover-tools-bm25-fallback-fix.md
+    if (deferralResult.discoverTool) {
+        const activeAfterDeferral = new Set([
+            ...deferralResult.activeTools.map(t => t.name),
+            ...deferralResult.discoveredTools.map(t => t.name),
+        ]);
+        deferralResult.discoverTool = createDiscoverTool(deferralResult.deferredEntries, deps.logger, deps.embeddingPort, config.skills?.toolDiscovery, activeAfterDeferral);
+    }
     mergedCustomTools = [...deferralResult.activeTools, ...deferralResult.discoveredTools];
     if (deferralResult.discoverTool) {
         mergedCustomTools.push(deferralResult.discoverTool);
     }
+    // 7b. Auto-discovery stubs for deferred tools.
+    // Lightweight stubs so the SDK's agent-loop finds deferred tools during
+    // tool resolution. Prevents "Tool X not found" errors when skills
+    // reference deferred MCP tools directly. Stubs are filtered from the
+    // API request by createStubFilterInjector (see stream-wrappers/
+    // stub-filter-injector.ts) -- zero token cost guarantee.
+    // Position: BEFORE JIT guide wrapping / schema pruning / sideEffects
+    // wrapping -- stubs receive all downstream wrappers automatically.
+    if (deferralResult.deferredEntries.length > 0) {
+        const stubs = createAutoDiscoveryStubs(deferralResult.deferredEntries, discoveryTracker, deps.logger);
+        mergedCustomTools.push(...stubs);
+    }
     // Build deferred context for dynamic preamble injection
     let deferredContext = "";
     if (deferralResult.deferredEntries.length > 0) {