comisai 1.0.42 → 1.0.45

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

@@ -3,7 +3,7 @@
  * Token budget algebra for the context engine pipeline.
  *
  * Computes available history token budget using the formula:
- * H = W - S - O - M - R
+ * H = W - S - O - M - R - P
  *
  * Where:
  * - W = model context window (tokens)
@@ -11,6 +11,27 @@
  * - O = output reserve (tokens)
  * - M = safety margin (percentage-based with absolute floor)
  * - R = context rot buffer (percentage-based)
+ * - P = fresh-tail preamble estimate (the WHOLE `dynamicPreamble` + `inlineMemory`
+ *   block envelope-wrapper prepends into the latest user message; I1) — a SEPARATE
+ *   subtrahend, NEVER folded into S
+ *
+ * WR-01 (133): `P` is the WHOLE injected fresh-tail preamble, not just the recalled
+ * memory. `dynamicPreamble` accumulates the date/time lines, inbound metadata,
+ * channel context, verbosity guidance, the recalled memory block, active-skill
+ * content, sender-trust lines, the role block, MCP server instructions, deferred-
+ * tools context, the canary, BOOT/BOOTSTRAP, etc. — recalled memory is just ONE
+ * part. Counting the whole preamble here is DELIBERATE and load-bearing: the fresh
+ * tail (which carries this preamble inside the latest user message) ships
+ * UNCONDITIONALLY in the LCD assembler (`[...budgeted, ...freshTail]`) and is
+ * reserved NOWHERE else — S is `systemPrompt + toolDefOverhead` only (the preamble
+ * is relocated OUT of `systemPrompt` for cache stability) and O/M/R are
+ * constants/percentages. So subtracting the whole preamble here is the ONLY thing
+ * that reserves window headroom for it; measuring only the recalled bytes would
+ * UNDER-reserve H and risk a fresh-tail overflow on a heavy-skills / many-MCP
+ * agent. The over-reservation is conservative (it over-reserves H, never
+ * under-reserves) and preserves I1's intent: recalled memory is a strict SUBSET of
+ * the preamble, so a heavier recall block still grows `P` and compacts older
+ * history harder.
  *
  * This is a pure function with zero side effects. All constants come from
  * the centralized constants module (not user config, per locked decision).
@@ -27,9 +48,19 @@ import { SAFETY_MARGIN_PERCENT, MIN_SAFETY_MARGIN_TOKENS, OUTPUT_RESERVE_TOKENS,
  * @param contextWindow - Model context window size in tokens (W)
  * @param systemTokensEstimate - Estimated tokens for system prompt + tool definitions (S)
  * @param cacheFenceIndex - Message index at or below which content must not be modified (-1 = no fence)
+ * @param freshTailPreambleTokensEstimate - Estimated tokens for the WHOLE fresh-tail
+ *   preamble block (the `dynamicPreamble` + `inlineMemory` prepended into the latest
+ *   user message by envelope-wrapper; I1). NOT just recalled memory — see the module
+ *   doc (WR-01): it covers skills XML, MCP instructions, deferred-tools context,
+ *   date/channel lines, recalled memory, etc., because that whole blob rides the
+ *   UNCONDITIONALLY-shipped fresh tail and is reserved nowhere else. A SEPARATE
+ *   subtrahend of H — never folded into S — so a heavier preamble (and recalled
+ *   memory is a strict subset of it) compacts older history harder. Defaults to 0 for
+ *   callers that do not pass it (storeless / no-preamble callers are unchanged).
+ *   Clamped to `>= 0` (a negative estimate never adds to H).
  * @returns Token budget breakdown with all components
  */
-export function computeTokenBudget(contextWindow, systemTokensEstimate, cacheFenceIndex = -1) {
+export function computeTokenBudget(contextWindow, systemTokensEstimate, cacheFenceIndex = -1, freshTailPreambleTokensEstimate = 0) {
     const W = contextWindow;
     const S = systemTokensEstimate;
     // O: output reserve (capped at constant; future override possible via wrapper)
@@ -38,14 +69,43 @@ export function computeTokenBudget(contextWindow, systemTokensEstimate, cacheFen
     const M = Math.max(Math.ceil(W * SAFETY_MARGIN_PERCENT / 100), MIN_SAFETY_MARGIN_TOKENS);
     // R: context rot buffer -- percentage of window
     const R = Math.ceil(W * CONTEXT_ROT_BUFFER_PERCENT / 100);
+    // P: fresh-tail preamble estimate (I1 / WR-01) -- the WHOLE dynamicPreamble +
+    // inlineMemory blob that rides the unconditionally-shipped fresh tail, a SEPARATE
+    // subtrahend clamped to >= 0 so a negative estimate never widens H. NOT folded
+    // into S (preserves the recall-dag-budget-partition invariant) and deliberately
+    // the whole preamble, not just recall (the only window reservation for it).
+    const P = Math.max(0, freshTailPreambleTokensEstimate);
+    // B-1 (260605-oa7) — TOKEN-AUTHORITY DECISION (deliberate, do NOT "align"):
+    // The S and P this function subtracts are produced at the executor call sites
+    // (executor-tool-assembly.ts:518-519 / :530-531) by dividing CHARS by
+    // CHARS_PER_TOKEN_RATIO = 3.5, whereas the LCD history items the resulting H
+    // bounds carry their STORED tokenCount computed by estimateMessageTokens (4:1 for
+    // text, 3:1 for structured). This is a real unit mismatch, but its direction is
+    // CONSERVATIVE and intentional: for the SAME text, ÷3.5 yields MORE tokens than
+    // ÷4, so S and P OVER-reserve relative to how that text would be counted as
+    // history → H below comes out SMALLER (the ceiling is TIGHTER), and the assembled
+    // prompt stays UNDER the real free window. The real-LLM review's "H larger than
+    // the true free budget → overflow" reads the direction BACKWARDS (the same
+    // reversal the B-4 fix corrected, 260605-ney). Moving S/P from 3.5 → 4 would make
+    // them SMALLER and WIDEN H — the UNSAFE direction, and exactly what the
+    // recall-dag-budget-partition invariant guards against. So the 3.5 ratio at the
+    // call sites is kept on purpose. Executable proof + regression guard:
+    // executor/prompt-runner/lcd-token-authority-characterization.test.ts.
+    //
     // H: available history -- clamp to zero (not negative)
-    const H = Math.max(0, W - S - O - M - R);
+    const H = Math.max(0, W - S - O - M - R - P);
     return {
         windowTokens: W,
+        // Profile-unaware base: no capability-class cap is applied here, so the
+        // window IS the raw window. computeTokenBudgetForProfile overrides these
+        // two when its class cap actually clamps W (W1 cap provenance).
+        rawContextWindowTokens: W,
+        windowCapSource: "none",
         systemTokens: S,
         outputReserveTokens: O,
         safetyMarginTokens: M,
         contextRotBufferTokens: R,
+        freshTailPreambleTokens: P,
         availableHistoryTokens: H,
         cacheFenceIndex,
     };

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

@@ -0,0 +1,62 @@
+/**
+ * Transcript repair (A2) — the `tool_use`<->`tool_result` pairing invariant.
+ *
+ * A self-contained, pure transform over the canonical pi-ai `Message[]`
+ * (`AgentMessage[]` at the boundary). It runs as the FINAL step of LCD
+ * assembly (`lcd-assembler.ts`) on EVERY assembled array — in both the live
+ * loop and the provider-boundary harness — which is what makes the invariant
+ * un-skippable.
+ *
+ * Providers HARD-REJECT a transcript where an assistant `tool_use` block is
+ * not immediately followed by its matching `tool_result`, where a `tool_result`
+ * has no preceding call, or where a turn is left with a dangling unpaired call.
+ * The deleted DAG assembler had no such pass — emitting a flattened, unpaired
+ * array is exactly what produced the prior tool-call loop. This module
+ * guarantees a provider-valid pairing on ANY input:
+ *
+ *  - REORDER  — an out-of-order `tool_result` is re-placed immediately after
+ *    its `tool_use` (in tool_use BLOCK order for a multi-call turn).
+ *  - SYNTHESIZE — an assistant `tool_use` with no matching result gets a marked
+ *    error placeholder ({@link makeMissingToolResult}); no call is left unpaired.
+ *  - DROP ORPHAN — a `tool_result` whose `toolCallId` matches no call is dropped.
+ *  - DROP DUPLICATE — a second `tool_result` for an already-resolved id is dropped.
+ *  - STRIP ABORTED — an assistant turn with `stopReason "error" | "aborted"` has
+ *    its dangling `tool_use` blocks removed (text/thinking preserved, A5), so no
+ *    unpaired call survives and no result is synthesized for the aborted call.
+ *
+ * Reasoning (`ThinkingContent`) is never re-introduced, reordered, or dropped:
+ * the codec already excludes `topLevelReasoningOnly` reasoning on reconstruction
+ * (parts-codec.ts:118) and this pass runs on reconstructed messages, so blocks
+ * are carried through in place.
+ *
+ * Pure + deterministic: no DB, no clock read. The caller injects `now` for the
+ * synthesized placeholder timestamp (the assembler passes `deps.clock.now()`),
+ * which keeps the transform fully testable. Inputs are never mutated — every
+ * emitted assistant rewrite, every synthesized result, and the output array are
+ * fresh objects (the `orphaned-message-repair.ts` "preserve originals" stance).
+ *
+ * @module
+ */
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+/**
+ * Transcript repair (A2): guarantee a provider-valid `tool_use`<->`tool_result`
+ * pairing on the assembled array. The FINAL assembly step (`lcd-assembler.ts`).
+ *
+ * Three passes (RESEARCH §"Transcript Repair"):
+ *  - **Pass A** — index every assistant `toolCall.id` into `toolUseSeen`.
+ *  - **Pass B** — collect `tool_result` messages by `toolCallId`; DROP an orphan
+ *    (id not in `toolUseSeen`) and DROP a duplicate (id already collected).
+ *  - **Pass C** — rebuild in original order, SKIPPING `tool_result` messages
+ *    (re-placed here). For an aborted/errored assistant turn, push the
+ *    dangling-call-stripped rewrite and continue. For any other assistant turn,
+ *    push it, then for each `toolCall` block in BLOCK order push its collected
+ *    result or a synthesized placeholder. Every other message is passed through.
+ *
+ * Pure + deterministic — the caller injects `now` for synthesized timestamps.
+ *
+ * @param messages - the assembled pi-ai `Message[]` (may be malformed)
+ * @param now - injected wall-clock ms for synthesized placeholder timestamps
+ * @returns a provider-valid array where every `tool_use` is immediately
+ *   followed by its matching `tool_result`
+ */
+export declare function sanitizeToolUseResultPairing(messages: AgentMessage[], now: number): AgentMessage[];

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

@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Transcript repair (A2) — the `tool_use`<->`tool_result` pairing invariant.
+ *
+ * A self-contained, pure transform over the canonical pi-ai `Message[]`
+ * (`AgentMessage[]` at the boundary). It runs as the FINAL step of LCD
+ * assembly (`lcd-assembler.ts`) on EVERY assembled array — in both the live
+ * loop and the provider-boundary harness — which is what makes the invariant
+ * un-skippable.
+ *
+ * Providers HARD-REJECT a transcript where an assistant `tool_use` block is
+ * not immediately followed by its matching `tool_result`, where a `tool_result`
+ * has no preceding call, or where a turn is left with a dangling unpaired call.
+ * The deleted DAG assembler had no such pass — emitting a flattened, unpaired
+ * array is exactly what produced the prior tool-call loop. This module
+ * guarantees a provider-valid pairing on ANY input:
+ *
+ *  - REORDER  — an out-of-order `tool_result` is re-placed immediately after
+ *    its `tool_use` (in tool_use BLOCK order for a multi-call turn).
+ *  - SYNTHESIZE — an assistant `tool_use` with no matching result gets a marked
+ *    error placeholder ({@link makeMissingToolResult}); no call is left unpaired.
+ *  - DROP ORPHAN — a `tool_result` whose `toolCallId` matches no call is dropped.
+ *  - DROP DUPLICATE — a second `tool_result` for an already-resolved id is dropped.
+ *  - STRIP ABORTED — an assistant turn with `stopReason "error" | "aborted"` has
+ *    its dangling `tool_use` blocks removed (text/thinking preserved, A5), so no
+ *    unpaired call survives and no result is synthesized for the aborted call.
+ *
+ * Reasoning (`ThinkingContent`) is never re-introduced, reordered, or dropped:
+ * the codec already excludes `topLevelReasoningOnly` reasoning on reconstruction
+ * (parts-codec.ts:118) and this pass runs on reconstructed messages, so blocks
+ * are carried through in place.
+ *
+ * Pure + deterministic: no DB, no clock read. The caller injects `now` for the
+ * synthesized placeholder timestamp (the assembler passes `deps.clock.now()`),
+ * which keeps the transform fully testable. Inputs are never mutated — every
+ * emitted assistant rewrite, every synthesized result, and the output array are
+ * fresh objects (the `orphaned-message-repair.ts` "preserve originals" stance).
+ *
+ * @module
+ */
+/** The literal marker carried by every synthesized placeholder result (T-128-01). */
+const SYNTHESIZED_RESULT_MARKER = "[tool result missing — synthesized placeholder]";
+const ABORTED_STOP_REASONS = new Set(["error", "aborted"]);
+/**
+ * The set of `type` aliases a tool-call (a.k.a. tool_use) content block can
+ * carry at the context-engine boundary. The canonical pi-ai shape is
+ * `"toolCall"`, but the PIPELINE path operates on raw, un-normalized messages
+ * whose call blocks may also arrive as `"tool_call"`, `"toolUse"`, or
+ * `"tool_use"` (the Anthropic Messages-API shape) depending on the provider /
+ * persisted source. The other pipeline layers already accept these aliases
+ * (history-window: toolCall|toolUse; dead-content-evictor: toolCall|tool_use;
+ * signature-replay-scrubber: toolCall|tool_call) — transcript repair MUST too,
+ * or it would mistake a legitimately-paired call for ABSENT and DROP its result
+ * as an orphan. The DAG/LCD path only ever emits `"toolCall"`, so the extra
+ * aliases are a strict superset there (no behavior change).
+ */
+const TOOL_CALL_BLOCK_TYPES = new Set(["toolCall", "tool_call", "toolUse", "tool_use"]);
+function roleOf(m) {
+    return m.role;
+}
+/**
+ * Narrow to a structural {@link AssistantLike} (NOT `AgentMessage & ...`): the
+ * intersection would resolve `.content` to the pi-ai union element type, which
+ * lacks the index signature {@link isToolCallBlock} needs. We re-cast via
+ * `unknown` so the body iterates `ContentBlock[]`.
+ */
+function asAssistant(m) {
+    if (roleOf(m) !== "assistant")
+        return null;
+    const content = m.content;
+    if (!Array.isArray(content))
+        return null;
+    return m;
+}
+function asToolResult(m) {
+    if (roleOf(m) !== "toolResult")
+        return null;
+    if (typeof m.toolCallId !== "string")
+        return null;
+    return m;
+}
+function isToolCallBlock(b) {
+    return TOOL_CALL_BLOCK_TYPES.has(b.type) && typeof b.id === "string";
+}
+function isAbortedAssistant(m) {
+    const sr = m.stopReason;
+    return typeof sr === "string" && ABORTED_STOP_REASONS.has(sr);
+}
+// ---------------------------------------------------------------------------
+// Synthetic / rewrite builders (never mutate inputs).
+// ---------------------------------------------------------------------------
+/**
+ * Build a synthesized placeholder for an assistant `tool_use` that has no
+ * matching `tool_result`. Providers reject an unpaired call, so the invariant
+ * fills the gap rather than dropping the call.
+ *
+ * SECURITY (T-128-01): the placeholder is marked `isError: true` AND its only
+ * content is the explicit literal {@link SYNTHESIZED_RESULT_MARKER}, so the
+ * model can never read it as a genuine tool output. Both markers are asserted
+ * by Test 2.
+ */
+function makeMissingToolResult(toolCallId, toolName, now) {
+    return {
+        role: "toolResult",
+        toolCallId,
+        toolName: toolName ?? "unknown",
+        content: [{ type: "text", text: SYNTHESIZED_RESULT_MARKER }],
+        isError: true,
+        timestamp: now,
+    };
+}
+/**
+ * Return a NEW assistant message with all `toolCall` blocks removed from its
+ * content, preserving text/thinking and every other field (A5:
+ * strip-dangling-blocks-keep-text). Used for aborted/errored turns whose calls
+ * never completed — leaving the calls would put an unpaired `tool_use` in front
+ * of the provider. Never mutates the input.
+ */
+function stripDanglingToolUseBlocks(m, a) {
+    const kept = a.content.filter((b) => !isToolCallBlock(b));
+    return { ...m, content: kept };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Transcript repair (A2): guarantee a provider-valid `tool_use`<->`tool_result`
+ * pairing on the assembled array. The FINAL assembly step (`lcd-assembler.ts`).
+ *
+ * Three passes (RESEARCH §"Transcript Repair"):
+ *  - **Pass A** — index every assistant `toolCall.id` into `toolUseSeen`.
+ *  - **Pass B** — collect `tool_result` messages by `toolCallId`; DROP an orphan
+ *    (id not in `toolUseSeen`) and DROP a duplicate (id already collected).
+ *  - **Pass C** — rebuild in original order, SKIPPING `tool_result` messages
+ *    (re-placed here). For an aborted/errored assistant turn, push the
+ *    dangling-call-stripped rewrite and continue. For any other assistant turn,
+ *    push it, then for each `toolCall` block in BLOCK order push its collected
+ *    result or a synthesized placeholder. Every other message is passed through.
+ *
+ * Pure + deterministic — the caller injects `now` for synthesized timestamps.
+ *
+ * @param messages - the assembled pi-ai `Message[]` (may be malformed)
+ * @param now - injected wall-clock ms for synthesized placeholder timestamps
+ * @returns a provider-valid array where every `tool_use` is immediately
+ *   followed by its matching `tool_result`
+ */
+export function sanitizeToolUseResultPairing(messages, now) {
+    // A non-array input degrades to a PASS-THROUGH, never an empty array: the SDK
+    // transformContext contract is "return the original messages or another safe
+    // fallback" (context-engine.ts's "never no-op the whole context" stance), so
+    // nuking a malformed shape to [] would silently drop the entire conversation
+    // (WR-02). An EMPTY well-formed array is a genuine no-op and returns [].
+    if (!Array.isArray(messages))
+        return messages;
+    if (messages.length === 0)
+        return [];
+    // Pass A — index every tool_use id an assistant turn emitted.
+    const toolUseSeen = new Set();
+    for (const m of messages) {
+        const a = asAssistant(m);
+        if (!a)
+            continue;
+        for (const b of a.content) {
+            if (isToolCallBlock(b)) {
+                toolUseSeen.add(b.id);
+            }
+        }
+    }
+    // Pass B — collect results by toolCallId; drop orphans and duplicates.
+    const resultByCallId = new Map();
+    for (const m of messages) {
+        const r = asToolResult(m);
+        if (!r)
+            continue;
+        const id = r.toolCallId;
+        if (!toolUseSeen.has(id))
+            continue; // orphan — no matching call
+        if (resultByCallId.has(id))
+            continue; // duplicate — keep the first
+        resultByCallId.set(id, m);
+    }
+    // Pass C — rebuild: each tool_use turn immediately followed by its result(s).
+    const out = [];
+    for (const m of messages) {
+        if (asToolResult(m)) {
+            continue; // re-placed below, after its call
+        }
+        const a = asAssistant(m);
+        if (a) {
+            if (isAbortedAssistant(a)) {
+                // Incomplete turn: strip dangling calls (keep text), synthesize nothing.
+                out.push(stripDanglingToolUseBlocks(m, a));
+                continue;
+            }
+            out.push(m);
+            for (const b of a.content) {
+                if (!isToolCallBlock(b))
+                    continue;
+                const result = resultByCallId.get(b.id);
+                out.push(result ?? makeMissingToolResult(b.id, b.name, now));
+            }
+            continue;
+        }
+        // user (and any other top-level role) — passed through unchanged.
+        out.push(m);
+    }
+    return out;
+}

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

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import type { ComisLogger } from "@comis/core";
+import type { ComisLogger, TypedEventBus } from "@comis/core";
 import type { TokenAnchor } from "./types-anchor.js";
 /**
  * Dependencies for the LLM compaction layer.
@@ -24,11 +24,23 @@ export interface CompactionLayerDeps {
     /** Getter for API key for the current model's provider. */
     getApiKey: () => Promise<string>;
     /** Optional: resolved override model + apiKey for cheaper compaction.
-     *  When provided, compaction uses this model instead of the session model. */
+     *  When provided, compaction uses this model instead of the session model.
+     *  INT-W1: `servedWindow` is the provider-served window binding THIS override
+     *  model, provider-gated at the wiring site (executor-context-engine-setup)
+     *  against the Phase-176 `servedContextWindow` pair — see the identical
+     *  fields on `LeafSummarizerDeps` (lcd-leaf-summarizer.ts). */
     overrideModel?: {
         model: unknown;
         getApiKey: () => Promise<string>;
+        servedWindow?: number;
     };
+    /** INT-W1: the provider-served window binding the PRIMARY (session) model —
+     *  `windowProvenance.served`, already provider-gated by the executor
+     *  reconcile (WR-02). Consumed by the Step-4 model read in llm-compaction:
+     *  the served value is selected in the SAME branch that selects the
+     *  summarizer model, so clamp and call always agree. Absent ⇒ configured
+     *  window governs (byte-identical pre-INT-W1 behavior). */
+    primaryServedWindow?: number;
     /** Optional callback for reporting compaction stats. */
     onCompacted?: (stats: {
         fallbackLevel: 1 | 2 | 3;
@@ -42,6 +54,12 @@ export interface CompactionLayerDeps {
     /** Optional getter for the API-grounded token anchor.
      *  When provided, compaction threshold check uses anchor + delta instead of pure char estimation. */
     getTokenAnchor?: () => TokenAnchor | null;
+    /** Optional event bus for emitting context:compaction_routed (C4/S4). */
+    eventBus?: TypedEventBus;
+    /** Optional agent id for context:compaction_routed event payload. */
+    agentId?: string;
+    /** Optional session key for context:compaction_routed event payload. */
+    sessionKey?: string;
 }
 /**
  * Metrics from a single compaction layer run.

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

@@ -12,18 +12,73 @@ export type { TokenAnchor };
 /**
  * Token budget breakdown computed by `computeTokenBudget()`.
  *
- * Formula: H = W - S - O - M - R
+ * Formula: H = W - S - O - M - R - P
  * Where:
  * - W = windowTokens (model context window)
  * - S = systemTokens (system prompt + tools estimate)
  * - O = outputReserveTokens (reserved for model output)
  * - M = safetyMarginTokens (percentage-based with absolute floor)
  * - R = contextRotBufferTokens (percentage-based decay buffer)
+ * - P = freshTailPreambleTokens (the WHOLE fresh-tail preamble estimate; I1/WR-01)
  * - H = availableHistoryTokens (remaining budget for conversation history)
  */
+/**
+ * What clamped the effective window below the model's configured contextWindow.
+ * "none" = no clamp (frontier/mid, explicit 0 = uncapped, or the configured
+ * window already fits). Closed union — but the member names are NO LONGER all
+ * `contextEngine.budget.*` knob names (KNOB-02 ended that invariant):
+ * `effectiveContextCapSmall` / `effectiveContextCapNano` ARE knob names (the
+ * budget's OWN cap bit — raising that config key genuinely works), while
+ * `"served"` means the Ollama-served window bound (its knobs live in Ollama:
+ * the `OLLAMA_CONTEXT_LENGTH` env on `ollama serve`, or a Modelfile
+ * `PARAMETER num_ctx`) and `"capabilityClass"` (WR-01) means the EXECUTOR-side
+ * `DEFAULT_EFFECTIVE_CAP_BY_CLASS` cap bound upstream because the operator
+ * pinned `providers.entries.<id>.capabilities.capabilityClass` — that pin is
+ * the only working lever; the budget knob is inert on this branch. Consumers
+ * MUST build knob strings via the errors.ts branching helpers
+ * (`describeWindowCap` / `CAP_KNOB_BY_SOURCE`) — NEVER template
+ * `contextEngine.budget.${source}` (renders a nonsense knob for "served" /
+ * "capabilityClass").
+ */
+export type WindowCapSource = "effectiveContextCapSmall" | "effectiveContextCapNano" | "served" | "capabilityClass" | "none";
+/**
+ * Window provenance threaded from the executor's resolveEffectiveContextWindow
+ * reconcile (pi-executor) into computeTokenBudgetForProfile (KNOB-02). Absent ⇒
+ * byte-identical pre-provenance behavior (I3 frontier/mid pin). reconcileSource
+ * reuses the EffectiveContextWindowResult.source vocabulary.
+ */
+export interface WindowProvenance {
+    /** The model's TRUE configured contextWindow (registry-enriched), BEFORE the
+     *  executor overwrote profile.contextWindow with the reconciled value. */
+    configuredWindow: number;
+    /** The Ollama-served num_ctx discovered by the boot probe (absent when no
+     *  probe result exists for the provider). */
+    served?: number;
+    /** Which constraint won the executor-side reconcile. */
+    reconcileSource: "configured" | "served" | "capability";
+}
+/**
+ * Capped-window provenance carried into the exhaustion throw / WARN / events
+ * (W1 obs-llm-troubleshooting). A strict subset of TokenBudget so call sites
+ * can pass the budget's own fields without re-deriving anything.
+ * servedWindowTokens (KNOB-02) lets the double-cap message name the whole
+ * chain (configured → served → class cap).
+ */
+export type ContextWindowCapInfo = Pick<TokenBudget, "rawContextWindowTokens" | "windowCapSource" | "servedWindowTokens">;
 export interface TokenBudget {
     /** W: model context window size in tokens. */
     windowTokens: number;
+    /** The model's DECLARED contextWindow before any capability-class cap was
+     *  applied (== windowTokens when no cap bit). Lets the exhaustion error and
+     *  budget logs name the clamp instead of reporting a window the operator
+     *  never configured (W1 obs-llm-troubleshooting). */
+    rawContextWindowTokens: number;
+    /** Which knob clamped windowTokens below rawContextWindowTokens ("none" when
+     *  uncapped). See WindowCapSource. */
+    windowCapSource: WindowCapSource;
+    /** Ollama-served num_ctx when served-window provenance was threaded
+     *  (KNOB-02); absent otherwise. */
+    servedWindowTokens?: number;
     /** S: estimated tokens consumed by system prompt and tool definitions. */
     systemTokens: number;
     /** O: tokens reserved for model output generation. */
@@ -32,6 +87,15 @@ export interface TokenBudget {
     safetyMarginTokens: number;
     /** R: context rot buffer tokens (percentage-based). */
     contextRotBufferTokens: number;
+    /** P: fresh-tail preamble tokens subtracted from H (I1 / WR-01) — the WHOLE
+     *  `dynamicPreamble` + `inlineMemory` block prepended into the latest user
+     *  message by envelope-wrapper (skills XML, MCP instructions, deferred-tools
+     *  context, date/channel lines, recalled memory, …), NOT just recalled memory.
+     *  Counting the whole preamble is deliberate: that blob rides the
+     *  unconditionally-shipped fresh tail and is reserved nowhere else, so this is
+     *  the only window-headroom reservation for it. A SEPARATE term, never folded
+     *  into S (preserves the recall-dag-budget partition invariant). Clamped to >= 0. */
+    freshTailPreambleTokens: number;
     /** H: available tokens for conversation history (clamped to >= 0). */
     availableHistoryTokens: number;
     /** Message index at or below which content must not be modified.
@@ -120,16 +184,31 @@ export interface ContextEngineDeps {
     eventBus?: {
         emit(event: string, data: unknown): void;
     };
-    /** Agent ID for event attribution and structured logging. */
+    /** Agent ID for event attribution and structured logging. Also the R4 read
+     *  scope (132-03): the dag assembler builds a ContextStoreScope from it so LCD
+     *  reads are agent-isolated (WR-02). */
     agentId?: string;
     /** Formatted session key for event correlation and structured logging. */
     sessionKey?: string;
+    /** Tenant ID for the R4 LCD read scope (132-03). The dag assembler builds a
+     *  ContextStoreScope { conversationId, agentId, tenantId, sessionKey } from it
+     *  so reads filter by tenant + agent (WR-02). Threaded from
+     *  executor-context-engine-setup.ts (the same source executor-post-execution
+     *  uses: deps.tenantId ?? sessionKey.tenantId). */
+    tenantId?: string;
     /** Subagent objective for post-compaction reinforcement. */
     objective?: string;
     /** Lazy getter for the estimated system prompt + tool definition tokens.
      *  Called on each pipeline run so the value can update after prompt assembly.
      *  Returns 0 when not provided (backward-compatible). */
     getSystemTokensEstimate?: () => number;
+    /** Lazy getter for the WHOLE fresh-tail preamble token estimate (the
+     *  `dynamicPreamble` + `inlineMemory` block prepended by envelope-wrapper —
+     *  skills XML, MCP instructions, deferred-tools context, date/channel lines,
+     *  recalled memory, …, NOT just recall; see WR-01). Called on each run.
+     *  Subtracted from H as a SEPARATE budget term (NOT folded into S — preserves
+     *  the recall-dag-budget-partition invariant). Returns 0 when not provided. */
+    getFreshTailPreambleTokensEstimate?: () => number;
     /** Called when observation masking modifies content (maskedCount > 0).
      *  Used by cache break detector to suppress false-positive CacheBreakEvents. */
     onContentModified?: () => void;
@@ -158,13 +237,76 @@ export interface ContextEngineDeps {
      *  static value is used. Used by idle thinking clear to strip all thinking
      *  blocks when the cache is cold (>1h idle). */
     getThinkingKeepTurnsOverride?: () => number | undefined;
-    /** Optional getter for the per-execute() memoized replay drift decision.
-     *  When the getter returns a DriftCheck with `drop: true`, the
-     *  signature-replay-scrubber layer activates for this pipeline run. When
-     *  undefined or `drop: false`, the layer no-ops. The drift result is
-     *  memoized at the executor layer so all pipeline runs within a single
-     *  execute() see a consistent decision. */
-    getReplayDriftMode?: () => import("../executor/replay-drift-detector.js").DriftCheck | undefined;
+    /** Injected core ContextStorePort (the LCD lossless store) for dag-mode
+     *  assembly. TYPE-only from `@comis/core` — the agent NEVER imports
+     *  `@comis/memory` (the agent↛memory architecture cut); the daemon injects
+     *  the concrete `createLcdStore`. Absent ⇒ dag falls back to the pipeline. */
+    contextStore?: import("@comis/core").ContextStorePort;
+    /** Conversation id for the dag-mode store read (= `formatSessionKey(sessionKey)`).
+     *  Absent ⇒ dag falls back to the pipeline. */
+    conversationId?: string;
+    /** Injected wall-clock for the dag-mode assembler's timestamps (assembly
+     *  duration + the synthesized-tool-result `timestamp` in transcript repair).
+     *  Production code never calls `Date.now()` directly (the globals gate); the
+     *  daemon threads its `ClockPort` here via setupContextEngine. Falls back to
+     *  `Date.now()` only when absent (a unit context with no injected clock). */
+    clock?: import("@comis/core").ClockPort;
+    /** C1 (Phase 152/165): the resolved ModelProfile for the current turn.
+     *  Used by the dag assembler to call computeTokenBudgetForProfile (profile-aware
+     *  budget with 8K-starvation fix and 256K-overfill cap for small/nano).
+     *  Absent ⇒ lcd-assembler applies the fail-closed nano cap + emits a config WARN. */
+    modelProfile?: import("../executor/model-profile.js").ModelProfile;
+    /** KNOB-02 (Phase 176): window provenance from the executor's
+     *  resolveEffectiveContextWindow reconcile, passed as the 7th argument to
+     *  computeTokenBudgetForProfile so a served-bound budget reports the TRUE
+     *  configured window and names "served" as the cap source.
+     *  Absent ⇒ budget reports profile.contextWindow as raw (pre-KNOB-02 behavior). */
+    windowProvenance?: WindowProvenance;
+    /** Phase 166 T-S4: security-pin markers for the dag eviction filter.
+     *  When provided, messages containing canaryToken/contentDelimiter/senderTrustPrefix
+     *  are NEVER evicted from history, regardless of window pressure.
+     *  Source: deps.canaryToken threaded from pi-executor at the setupContextEngine call site.
+     *  isSecurityRelevantMessage is fail-closed: absent/empty content → pin. */
+    securityPinMarkers?: import("./security-context-pinner.js").SecurityPinMarkers;
+    /** Phase 166: callback invoked by the pre-flight fit check when assembled input tokens
+     *  are measured. Plan 04 sets a getter here so config-resolver can clamp max_tokens. */
+    onAssembledInputTokens?: (tokens: number) => void;
+    /** Phase 166: callback invoked when the effective window is known (budget.windowTokens).
+     *  Plan 04 sets this to populate effectiveWindowRef for dynamic max_tokens clamping.
+     *  ONE callback per transformContext call — emit after budget is computed. */
+    onEffectiveWindow?: (windowTokens: number) => void;
+    /** Phase 166: callback invoked when the thinking-effort governor down-shifts thinkingLevel.
+     *  Plan 04 sets this to call session.setThinkingLevel(level) for the current dispatch.
+     *  Wired at the pi-executor.ts setupContextEngine call site where the SDK session object
+     *  is in scope (setupStreamWrappers only receives sm: SessionManager, not the SDK session). */
+    onThinkingDownshifted?: (level: string) => void;
+    /** Phase 166: getter returning the current thinking level for this dispatch.
+     *  Source: the agent config's thinkingLevel field, read at call time.
+     *  When absent, the pre-flight check falls back to "medium" (conservative). */
+    getThinkingLevel?: () => string | undefined;
+    /** WR-02 (Phase 166): operator-configurable minimum visible output token floor.
+     *  Sourced from contextEngine.budget.minVisibleOutputTokens in the agent config.
+     *  When absent, the pre-flight check uses the compile-time constant MIN_VISIBLE_OUTPUT_TOKENS (768).
+     *  This makes the schema field live rather than dead config. Frontier/mid: default 768
+     *  → byte-identical result (MIN_VISIBLE_OUTPUT_TOKENS=768). */
+    minVisibleOutputTokens?: number;
+    /** RETR-02/03 (Phase 173): the resolved relevance-first policy signal for this turn.
+     *  Resolved ONCE in scaffold-defaults (the capability + supportsPromptCache gate;
+     *  explicit > capability-default > off) and threaded from setupContextEngine — the
+     *  assembler CONSUMES the boolean, it does NOT recompute the gate. When `true` (small/
+     *  nano non-caching, or an explicit opt-in) the dag assembler runs the margin arbiter
+     *  (marginArbitrate) at the evict seam instead of evictHistoryUnderBudget; when `false`
+     *  or ABSENT (frontier/mid + caching) the existing recency-first eviction runs VERBATIM
+     *  — frontier/mid byte-identical (LOCKED #2: the arbiter does not run for them). */
+    relevanceFirst?: boolean;
+    /** RETR-02 (Phase 173): the shared relevance scorer (scoreRelevance) injected for the
+     *  margin arbiter's FUSED-RANK cross-tier allocation. INJECTED from setupContextEngine
+     *  (executor/, which may import the rag layer) so the context-engine never imports `rag/`
+     *  (the I2 cut). On the C2 assembly path the LTM/KG candidate lanes are EMPTY, so the
+     *  scorer is never actually invoked (the history band is recency-ordered within its slot);
+     *  it is threaded for forward-compat (Phase 174 flows LTM candidates to assembly). Absent
+     *  ⇒ the arbiter uses a no-op identity scorer (safe — never called with empty lanes). */
+    relevanceScorer?: import("./margin-arbiter.js").RelevanceScorerFn;
 }
 /**
  * Metrics collected during a single context engine pipeline run.

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

@@ -5,8 +5,6 @@
  * - types-core.ts: Token budget, layers, metrics, guards
  * - types-eviction.ts: Dead content evictor stats
  * - types-compaction.ts: LLM compaction and rehydration
- * - types-dag.ts: DAG compaction, assembly, reconciliation
- * - types-integrity.ts: DAG integrity checking
  *
  * This barrel re-exports all types so existing `from "./types.js"` imports
  * continue to resolve without changes.
@@ -16,5 +14,3 @@
 export * from "./types-core.js";
 export * from "./types-eviction.js";
 export * from "./types-compaction.js";
-export * from "./types-dag.js";
-export * from "./types-integrity.js";

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

@@ -6,8 +6,6 @@
  * - types-core.ts: Token budget, layers, metrics, guards
  * - types-eviction.ts: Dead content evictor stats
  * - types-compaction.ts: LLM compaction and rehydration
- * - types-dag.ts: DAG compaction, assembly, reconciliation
- * - types-integrity.ts: DAG integrity checking
  *
  * This barrel re-exports all types so existing `from "./types.js"` imports
  * continue to resolve without changes.
@@ -17,5 +15,3 @@
 export * from "./types-core.js";
 export * from "./types-eviction.js";
 export * from "./types-compaction.js";
-export * from "./types-dag.js";
-export * from "./types-integrity.js";