comisai 1.0.45 → 1.0.46

package/node_modules/@comis/agent/dist/rag/score.d.ts

@@ -5,7 +5,7 @@
  * (architecture.test.ts "agent -> memory cut"). Precedent for pure ranking math in
  * the agent package: executor/tool-deferral.ts (inline BM25).
  *
- * Boost shape (design §5.4 — each sub-signal is centered on 0.5 so a NEUTRAL signal
+ * Boost shape (each sub-signal is centered on 0.5 so a NEUTRAL signal
  * contributes a factor of exactly 1.0):
  *
  *   boosted = base
@@ -20,11 +20,11 @@
  *
  * The proof signal is now LIVE — it is the read-side payoff of memory
  * consolidation, so a corroborated observation out-ranks the raw memories it summarizes:
- *   - `proofNorm` maps the typed `proofCount` through a log curve (design §5.4:
- *     `clamp(0.5 + log(proofCount)/10, 0, 1)` — proofCount 1→0.5, ~150→1.0, monotone in
+ *   - `proofNorm` maps the typed `proofCount` through a log curve
+ *     (`clamp(0.5 + log(proofCount)/10, 0, 1)` — proofCount 1→0.5, ~150→1.0, monotone in
  *     corroboration). A raw memory (no `proofCount`) → 0.5 (neutral).
  *   - `confidenceFactor` applies an explicit HALF-LIFE decay over the observation's typed
- *     `confidence` and its EVENT age (design §16.6 / Open decision 6 — LOCKED to half-life):
+ *     `confidence` and its EVENT age:
  *     `confidence * 0.5^(ageDays / CONFIDENCE_HALF_LIFE_DAYS)`. A raw memory (no `confidence`)
  *     → 1.0 (neutral).
  *   - `decayedProof` multiplies the ABOVE-neutral portion of `proofNorm` by that decayed
@@ -49,7 +49,7 @@ import type { MemorySearchResult, UsefulnessSignal } from "@comis/core";
  * Per-memory multiplicative score breakdown. The six factors are the
  * EXACT multiplicands score() folds into the boosted score, surfaced so the recall
  * trace can record WHY a memory ranked where it did. Pure numbers — no redaction
- * concern (RESEARCH: the breakdown is safe to persist). Invariant:
+ * concern (the breakdown is safe to persist). Invariant:
  *   final === base * recency * temporal * proof * trust * usefulness * forget
  * A neutral sub-signal contributes a factor of exactly 1.0 (recency/temporal/proof/
  * trust/usefulness are each centered on 0.5; forget is centered on its 1.0 neutral and is
@@ -71,7 +71,7 @@ export interface ScoreBreakdown {
     /** Usefulness factor `1 + usefulnessAlpha * (usefulnessNorm - 0.5)`; 1.0 when the signal is absent. */
     usefulness: number;
     /**
-     * OBS-02 (Verified Learning WS3): the OUTCOME-attributed usefulness CONTRIBUTION,
+     * The OUTCOME-attributed usefulness CONTRIBUTION,
      * surfaced as a DISTINCT annotation so `comis explain` can show how much of a memory's
      * rank came from the learned recall-utility / outcome feedback (the per-id reward the
      * daemon reward seam accrues into `memory_usefulness` on a `success`/`failure`/`corrected`
@@ -80,7 +80,7 @@ export interface ScoreBreakdown {
      * memory, `-` demotes a recalled-but-ignored one, and EXACTLY `0` when no usefulness signal
      * is present (the no-reorder-when-absent point). This is an ANNOTATION, **not** a multiplicand
      * — it is ABSENT from `final` (which stays the six-factor product), so adding it is byte-identical.
-     * A derived FACTOR share — never a raw tuned-alpha value (T-200-23: the breakdown is a per-memory
+     * A derived FACTOR share — never a raw tuned-alpha value (the breakdown is a per-memory
      * trace artifact carrying normalized shares, not the learner's alpha state).
      */
     usefulnessOutcomeShare: number;
@@ -108,14 +108,14 @@ export interface ScoringAlphas {
     trustAlpha: number;
     /**
      * Usefulness boost weight (bounded, same small magnitude as trust/proof so it
-     * CANNOT overturn trust-first — Pitfall 5). The single canonical knob: it traces to
+     * CANNOT overturn trust-first). The single canonical knob: it traces to
      * `rag.scoring.usefulnessAlpha` (no second knob on `rag.feedback`). Centered on a 0.5
      * used-rate, so an absent signal contributes a factor of exactly 1.0 at any alpha.
      */
     usefulnessAlpha: number;
     /**
      * FadeMem decay boost weight (bounded, same small magnitude as trust/proof/
-     * usefulness so the decay RANKS but CANNOT overturn trust-first — Pitfall 2). Blends the
+     * usefulness so the decay RANKS but CANNOT overturn trust-first). Blends the
      * forget factor between no-decay (alpha 0 → factor 1.0) and full-decay (alpha 1 → the raw
      * {@link fadeMemFactor}). The factor only ever demotes (∈ [0.5,1], neutral 1.0), gated by
      * `forget.enabled` at the fold site — OFF ⇒ forgetFactor forced to exactly 1.0 (byte-identity).
@@ -132,12 +132,12 @@ export interface ScoringAlphas {
  */
 export declare function betaForType(memoryType: MemorySearchResult["entry"]["memoryType"]): number;
 /**
- * FadeMem decay factor (RESEARCH §"The decay factor"). A 0.5-centered bounded
+ * FadeMem decay factor. A 0.5-centered bounded
  * multiplicand `0.5 + 0.5·exp(−λ·Δt^β)` ∈ [0.5,1] whose NEUTRAL value is 1.0 (so it already
  * has factor form — it is wrapped by `forgetAlpha` at the fold site to blend between no-decay
  * and full-decay). `λ = λ_base·exp(−μ·imp)` (importance shrinks the rate); `β` is the per-type
  * shape; `Δt` is EVENT age in days (`occurredAt ?? createdAt`, the SAME axis {@link confidenceFactor}
- * uses — score.ts:184-185 verbatim), future-dated clamped to 0 (no negative-age blow-up → factor
+ * uses), future-dated clamped to 0 (no negative-age blow-up → factor
  * 1.0). Lazy-at-read: pure over the INJECTED nowMs (never Date.now). The relevance + used-rate
  * imp signals are threaded in (`base` + `usefulnessSignal`) from the scorer's call site.
  *
@@ -150,8 +150,7 @@ export declare function fadeMemFactor(entry: MemorySearchResult["entry"], nowMs:
  * a bounded, saturating strength boost applied on access (recall). The `(1−v)` factor caps it
  * at 1.0; the `exp(−n/N)` factor makes each successive access (larger prior-access count `n`)
  * boost LESS (diminishing returns); at v→1 the boost → ~0. Deterministic, pure, bounded ∈ [0,1]
- * and ≥ v. Lazy-at-read (RESEARCH A4 — no persistence, no FEED-loop write, avoids the 3-hop
- * hazard); the tested pure helper a later live step consumes.
+ * and ≥ v. Lazy-at-read: no persistence and no feedback-loop write on the recall path.
  */
 export declare function consolidationBoost(v: number, n: number): number;
 /**

package/node_modules/@comis/agent/dist/rag/score.js

@@ -6,7 +6,7 @@
  * (architecture.test.ts "agent -> memory cut"). Precedent for pure ranking math in
  * the agent package: executor/tool-deferral.ts (inline BM25).
  *
- * Boost shape (design §5.4 — each sub-signal is centered on 0.5 so a NEUTRAL signal
+ * Boost shape (each sub-signal is centered on 0.5 so a NEUTRAL signal
  * contributes a factor of exactly 1.0):
  *
  *   boosted = base
@@ -21,11 +21,11 @@
  *
  * The proof signal is now LIVE — it is the read-side payoff of memory
  * consolidation, so a corroborated observation out-ranks the raw memories it summarizes:
- *   - `proofNorm` maps the typed `proofCount` through a log curve (design §5.4:
- *     `clamp(0.5 + log(proofCount)/10, 0, 1)` — proofCount 1→0.5, ~150→1.0, monotone in
+ *   - `proofNorm` maps the typed `proofCount` through a log curve
+ *     (`clamp(0.5 + log(proofCount)/10, 0, 1)` — proofCount 1→0.5, ~150→1.0, monotone in
  *     corroboration). A raw memory (no `proofCount`) → 0.5 (neutral).
  *   - `confidenceFactor` applies an explicit HALF-LIFE decay over the observation's typed
- *     `confidence` and its EVENT age (design §16.6 / Open decision 6 — LOCKED to half-life):
+ *     `confidence` and its EVENT age:
  *     `confidence * 0.5^(ageDays / CONFIDENCE_HALF_LIFE_DAYS)`. A raw memory (no `confidence`)
  *     → 1.0 (neutral).
  *   - `decayedProof` multiplies the ABOVE-neutral portion of `proofNorm` by that decayed
@@ -93,16 +93,17 @@ function temporalProx(entry, nowMs) {
 }
 /**
  * Confidence half-life: a stale observation's confidence contribution halves every
- * `CONFIDENCE_HALF_LIFE_DAYS` of EVENT age. Design §16.6 / Open decision 6 LOCKED the
- * decay shape to an explicit half-life but left the constant open; 30 days is the
+ * `CONFIDENCE_HALF_LIFE_DAYS` of EVENT age. The decay shape is deliberately an explicit
+ * half-life (not an arbitrary curve); the constant is tunable and 30 days is the
  * default (a month-old observation contributes half its confidence to the proof boost).
  *
  * NB: this is the PROOF-decay axis (decayedProof). The FadeMem factor uses its
  * OWN base rate {@link LAMBDA_BASE}, anchored to the SAME 30-day neutral half-life but as
- * a SEPARATE constant — do NOT repurpose this one (the RESEARCH anti-pattern).
+ * a SEPARATE constant — do NOT repurpose this one (the two decay channels must stay
+ * independently tunable).
  */
 const CONFIDENCE_HALF_LIFE_DAYS = 30;
-// ─── The per-type FadeMem decay factor (RESEARCH "## FadeMem Math") ───
+// ─── The per-type FadeMem decay factor ───
 // A 6th 0.5-centered bounded multiplicand `0.5 + 0.5·exp(−λ·Δt^β)` ∈ [0.5,1] (neutral → 1.0),
 // gated by `cfg.forget?.enabled` (which defaults ON; the only off-switch is the master cost
 // switch). λ = λ_base·exp(−μ·imp); imp is the Comis
@@ -114,8 +115,8 @@ const CONFIDENCE_HALF_LIFE_DAYS = 30;
 // event-age Δt=0 (the neutral-in-time point) the factor is `0.5 + 0.5·exp(0) = 1.0` EXACTLY,
 // independent of λ/β/imp — so a legacy/neutral fresh row scores byte-identical even when ON.
 /**
- * FadeMem base decay rate `λ_base = ln(2)/30 ≈ 0.0231 day⁻¹` — the PARITY anchor (RESEARCH
- * §FadeMem Math): with the parity β=1 (exponential) and neutral imp (μ·imp=0 → λ=λ_base),
+ * FadeMem base decay rate `λ_base = ln(2)/30 ≈ 0.0231 day⁻¹` — the PARITY
+ * anchor: with the parity β=1 (exponential) and neutral imp (μ·imp=0 → λ=λ_base),
  * `exp(−λ_base·Δt)` reproduces today's 30-day half-life `0.5^(Δt/30)`. A SEPARATE constant
  * from {@link CONFIDENCE_HALF_LIFE_DAYS} (the proof axis) — they share the 30-day anchor but
  * are distinct decay channels. The byte-identity gate is INDEPENDENT of this value (it rests
@@ -126,8 +127,8 @@ const LAMBDA_BASE = Math.LN2 / 30; // ≈ 0.0231 day⁻¹
  * Importance sensitivity μ (FadeMem Eq.5). Higher imp → smaller λ → slower decay (important
  * memories persist). [ASSUMED — FadeMem unreported, tuned for Comis]: 1.5 makes a max-imp
  * memory's λ ≈ λ_base·exp(−1.5) ≈ 0.22·λ_base (a ~4.5× longer half-life) — a meaningful
- * persistence gradient that, at the bounded `forgetAlpha`, never overturns trust-first
- * (Pitfall 2). The byte-identity gate is independent of μ.
+ * persistence gradient that, at the bounded `forgetAlpha`, never overturns trust-first.
+ * The byte-identity gate is independent of μ.
  */
 const MU = 1.5; // [ASSUMED — FadeMem unreported, tuned for Comis]
 /** Consolidation-boost increment Δv (FadeMem Eq.7). [ASSUMED — FadeMem unreported, tuned for Comis]. */
@@ -150,8 +151,8 @@ const W_REC = 0.15; // recency
 const W_TRUST = 0.2; // trust position
 const W_PROOF = 0.15; // corroboration
 /**
- * Proof-count normalization. Maps the typed `proofCount` through the design
- * §5.4 log curve `clamp(0.5 + log(proofCount)/10, 0, 1)`: proofCount 1 → 0.5 (neutral,
+ * Proof-count normalization. Maps the typed `proofCount` through the
+ * log curve `clamp(0.5 + log(proofCount)/10, 0, 1)`: proofCount 1 → 0.5 (neutral,
  * identical to a raw memory), ~150 → ~1.0, monotone-increasing and bounded in corroboration.
  * A raw memory (no `proofCount`) returns 0.5 → a neutral 1.0 factor (no reordering — the
  * seam's no-reorder-when-absent contract). `proofCount` is a typed optional MemoryEntry
@@ -196,7 +197,7 @@ function decayedProof(entry, nowMs) {
  *   - ABSENT signal (no map, or the id is not a key) → 0.5 → neutral 1.0 factor (the
  *     byte-identity guarantee: a memory with no usefulness history is never reordered).
  *   - total resolved (used + ignored) of 0 → 0.5 → neutral (recalled-but-never-attributed).
- *   - else the used-RATE `usedCount / (usedCount + ignoredCount)` in [0,1] (Pitfall 5: a
+ *   - else the used-RATE `usedCount / (usedCount + ignoredCount)` in [0,1] (a
  *     RATE, NOT raw counts — a memory "used" 1000× cannot explode the factor; the bounded
  *     `usefulnessAlpha` then keeps the boost from overturning trust-first).
  */
@@ -236,8 +237,8 @@ export function betaForType(memoryType) {
 }
 /**
  * Importance `imp` ∈ [0,1] — the Comis superset over the 5 EXISTING scoring signals
- * (RESEARCH §"The importance aggregation imp"; RQ4 — REUSE the helpers already in this file,
- * NO new store). Higher imp → smaller λ → slower decay (important memories persist). The
+ * (REUSES the helpers already in this file — NO new store).
+ * Higher imp → smaller λ → slower decay (important memories persist). The
  * relevance + used-rate terms are CALL-SITE values (the base relevance `result.score` and the
  * `usefulnessById` signal that `scoreWithBreakdown` already has), so they are threaded in as
  * parameters to keep this function pure over what the scorer holds.
@@ -258,12 +259,12 @@ function importance(entry, nowMs, base, usefulnessSignal) {
     return Math.min(1, Math.max(0, raw)); // clamp to [0,1]
 }
 /**
- * FadeMem decay factor (RESEARCH §"The decay factor"). A 0.5-centered bounded
+ * FadeMem decay factor. A 0.5-centered bounded
  * multiplicand `0.5 + 0.5·exp(−λ·Δt^β)` ∈ [0.5,1] whose NEUTRAL value is 1.0 (so it already
  * has factor form — it is wrapped by `forgetAlpha` at the fold site to blend between no-decay
  * and full-decay). `λ = λ_base·exp(−μ·imp)` (importance shrinks the rate); `β` is the per-type
  * shape; `Δt` is EVENT age in days (`occurredAt ?? createdAt`, the SAME axis {@link confidenceFactor}
- * uses — score.ts:184-185 verbatim), future-dated clamped to 0 (no negative-age blow-up → factor
+ * uses), future-dated clamped to 0 (no negative-age blow-up → factor
  * 1.0). Lazy-at-read: pure over the INJECTED nowMs (never Date.now). The relevance + used-rate
  * imp signals are threaded in (`base` + `usefulnessSignal`) from the scorer's call site.
  *
@@ -283,8 +284,7 @@ export function fadeMemFactor(entry, nowMs, base, usefulnessSignal) {
  * a bounded, saturating strength boost applied on access (recall). The `(1−v)` factor caps it
  * at 1.0; the `exp(−n/N)` factor makes each successive access (larger prior-access count `n`)
  * boost LESS (diminishing returns); at v→1 the boost → ~0. Deterministic, pure, bounded ∈ [0,1]
- * and ≥ v. Lazy-at-read (RESEARCH A4 — no persistence, no FEED-loop write, avoids the 3-hop
- * hazard); the tested pure helper a later live step consumes.
+ * and ≥ v. Lazy-at-read: no persistence and no feedback-loop write on the recall path.
  */
 export function consolidationBoost(v, n) {
     return Math.min(1, v + CONSOLIDATION_DV * (1 - v) * Math.exp(-n / CONSOLIDATION_N));
@@ -343,7 +343,7 @@ export function scoreWithBreakdown(results, alphas, nowMs, usefulnessById, forge
         // Absent signal → usefulnessNorm 0.5 → usefulnessFactor exactly 1.0 (byte-identity).
         const usefulnessSignal = usefulnessById?.get(result.entry.id);
         const usefulnessFactor = 1 + alphas.usefulnessAlpha * (usefulnessNorm(usefulnessSignal) - 0.5);
-        // OBS-02: the outcome-attributed usefulness CONTRIBUTION = the signed deviation of the
+        // The outcome-attributed usefulness CONTRIBUTION = the signed deviation of the
         // usefulness factor from its 1.0 neutral. An annotation for the trace (NOT a multiplicand):
         // exactly 0 when the signal is absent (factor 1.0 → no reorder), positive for a proven-useful
         // memory, negative for a recalled-but-ignored one. It is NOT folded into `final` below.

package/node_modules/@comis/agent/dist/rag/temporal-guidance.d.ts

@@ -1,6 +1,6 @@
 /**
- * Read-time contradiction guidance (design §7.3). A PURE formatter
- * over {@link MemorySearchResult}[] that returns the design-§7.3 guidance block — a FIXED
+ * Read-time contradiction guidance. A PURE formatter
+ * over {@link MemorySearchResult}[] that returns the contradiction-guidance block — a FIXED
  * constant string — iff >=2 memories are surfaced for a query, else `undefined`.
  *
  * The block is INJECTED TEXT that tells the agent HOW to resolve a surfaced contradiction
@@ -28,7 +28,7 @@
  */
 import type { MemorySearchResult } from "@comis/core";
 /**
- * Build the read-time §7.3 contradiction guidance block. Returns the FIXED block string when
+ * Build the read-time contradiction guidance block. Returns the FIXED block string when
  * `sharesTopic(results)` holds (>=2 surfaced memories, the conflict gate), else
  * `undefined` (no block — nothing to disambiguate). Pure and non-mutating: it reads only
  * `results.length` and never touches the entries (no content echo).

package/node_modules/@comis/agent/dist/rag/temporal-guidance.js

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Read-time contradiction guidance (design §7.3). A PURE formatter
- * over {@link MemorySearchResult}[] that returns the design-§7.3 guidance block — a FIXED
+ * Read-time contradiction guidance. A PURE formatter
+ * over {@link MemorySearchResult}[] that returns the contradiction-guidance block — a FIXED
  * constant string — iff >=2 memories are surfaced for a query, else `undefined`.
  *
  * The block is INJECTED TEXT that tells the agent HOW to resolve a surfaced contradiction
@@ -53,7 +53,7 @@ const TEMPORAL_GUIDANCE = `## Using these memories over time
 - If still disagreeing at equal trust and equal recency, say so rather than guess.
 - The current believed value of a contested fact is the higher-trust one; an older superseded value is not deleted — it still exists as history (the value that was believed true as of a past time) but it is not the current answer.`;
 /**
- * The baseline (Option A, RESEARCH.md Open Q5 RESOLVED): the co-retrieved recall set
+ * The baseline topic gate: the co-retrieved recall set
  * IS the "same topic" signal — all results were surfaced for the same query, so >=2 of them
  * means there is a contradiction worth guiding the LLM about. A later iteration TIGHTENS this seam
  * with resolved-entity overlap (two memories that share a resolved entity), once the entity
@@ -63,7 +63,7 @@ function sharesTopic(results) {
     return results.length >= 2;
 }
 /**
- * Build the read-time §7.3 contradiction guidance block. Returns the FIXED block string when
+ * Build the read-time contradiction guidance block. Returns the FIXED block string when
  * `sharesTopic(results)` holds (>=2 surfaced memories, the conflict gate), else
  * `undefined` (no block — nothing to disambiguate). Pure and non-mutating: it reads only
  * `results.length` and never touches the entries (no content echo).

package/node_modules/@comis/agent/dist/response-filter/reasoning-tags.d.ts

@@ -21,7 +21,7 @@ export type ReasoningTagTrim = "none" | "start" | "both";
  * - "strict": drops content after unclosed opening tag
  * - "preserve": keeps trailing content even with unclosed tags
  *
- * Unbalanced-tag robustness (Issue 3, small-model e2e 2026-06-12): an ORPHAN
+ * Unbalanced-tag robustness: an ORPHAN
  * closing tag — a `</think>` with no matching opener in the visible text,
  * outside code regions — strips everything up to and including itself. On the
  * Ollama reasoning path the opener can be consumed as a separate reasoning

package/node_modules/@comis/agent/dist/response-filter/reasoning-tags.js

@@ -24,7 +24,7 @@ const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>
  * - "strict": drops content after unclosed opening tag
  * - "preserve": keeps trailing content even with unclosed tags
  *
- * Unbalanced-tag robustness (Issue 3, small-model e2e 2026-06-12): an ORPHAN
+ * Unbalanced-tag robustness: an ORPHAN
  * closing tag — a `</think>` with no matching opener in the visible text,
  * outside code regions — strips everything up to and including itself. On the
  * Ollama reasoning path the opener can be consumed as a separate reasoning
@@ -75,7 +75,7 @@ export function stripReasoningTagsFromText(text, options) {
                 // separate reasoning chunk while the closing tag plus the pre-close
                 // draft land in the content body — everything before the orphan
                 // closer is, by construction, trailing reasoning. Drop it along
-                // with the tag (small-model e2e 2026-06-12, Issue 3).
+                // with the tag.
                 result = "";
             }
             else {

package/node_modules/@comis/agent/dist/safety/summarizer-spend-breaker.d.ts

@@ -1,5 +1,5 @@
 /**
- * R1: per-tenant summarizer spend cap + circuit breaker.
+ * Per-tenant summarizer spend cap + circuit breaker.
  *
  * Wraps the injected {@link LeafSummarizer} seam with (a) a per-tenant circuit
  * breaker and (b) a per-tenant rolling-window token-spend tracker. When the
@@ -8,19 +8,19 @@
  * ladder already catches a throw from `summarize(...)` and falls through to the
  * deterministic Level-3 floor (truncation-only assembly), so the turn proceeds
  * with no crash and no hang. It NEVER retries the inner call when the breaker is
- * open (the RESEARCH anti-pattern). On a successful inner call it records success
- * + actual token usage; on a thrown inner call it records a failure.
+ * open (a retry would defeat the breaker). On a successful inner call it records
+ * success + actual token usage; on a thrown inner call it records a failure.
  *
  * `safety/` is a sanctioned raw-throw boundary (`raw-throw.test.ts` exempts
  * `packages/*\/src/safety/`), so the degrade throw needs no `@allow-throw`.
  *
- * Per-TENANT by construction (design §1.4 / Pitfall 1): one tenant's failures or
+ * Per-TENANT by construction: one tenant's failures or
  * spend can never open another tenant's breaker or consume another tenant's
  * window — both are keyed in `Map<tenantId, …>` and lazily created per tenant.
  *
  * Pure mechanism: NO logging, NO infra import, NO message/summary content — it
  * operates on token COUNTS/estimates only. Observability (breaker-trip WARN +
- * eventBus) is added at the wiring site (132-05) where the injected logger lives.
+ * eventBus) is added at the wiring site, where the injected logger lives.
  * All time comes from the injected {@link ClockPort} (no raw clock/timer globals —
  * the globals gate).
  *
@@ -48,7 +48,7 @@ export interface SummarizerSpendBreakerDeps {
     /** Estimate OUTPUT tokens for the produced summary string. */
     estimateOutputTokens: (out: string) => number;
 }
-/** The R1 gate factory return shape. */
+/** The spend-breaker gate factory return shape. */
 export interface SummarizerSpendBreaker {
     /**
      * Wrap an inner {@link LeafSummarizer} with the given tenant's breaker + spend
@@ -58,7 +58,7 @@ export interface SummarizerSpendBreaker {
     gate(tenantId: string, inner: LeafSummarizer): LeafSummarizer;
 }
 /** Closed reason for a degrade BYPASS — maps 1:1 onto the `context:dag_degraded`
- *  reserved reasons so the wiring (132-05) can emit the right event/errorKind. */
+ *  reserved reasons so the wiring can emit the right event/errorKind. */
 export type SummarizerDegradeReason = "breaker_open" | "spend_cap";
 /**
  * The discriminated error the gate THROWS when it bypasses the inner LLM call

package/node_modules/@comis/agent/dist/safety/summarizer-spend-breaker.js

@@ -59,7 +59,7 @@ export function createSummarizerSpendBreaker(deps) {
                 if (breaker.isOpen()) {
                     // DEGRADE (breaker open): throw → leaf/condense ladder catches →
                     // deterministic L3 floor → truncation-only. No retry of inner
-                    // (anti-pattern); inner is NOT called. The breaker is checked FIRST so an
+                    // (a retry would defeat the breaker); inner is NOT called. The breaker is checked FIRST so an
                     // open breaker is reported as breaker_open even when also over-cap.
                     throw new SummarizerDegradeError("breaker_open");
                 }

package/node_modules/@comis/agent/dist/safety/token-estimator.d.ts

@@ -57,8 +57,8 @@ export declare function estimateContextChars(messages: Message[], cache?: WeakMa
  * weighted 2x to reflect their higher token density. Used ONLY by the
  * observation masker threshold check.
  *
- * Deliberately factor-free: a RELATIVE char-pressure heuristic — a script
- * factor would cancel (TOK-01, design §4).
+ * Deliberately factor-free: a RELATIVE char-pressure heuristic — applying
+ * the script token factor to both sides of the ratio would cancel out.
  */
 export declare function estimateContextCharsWithDualRatio(messages: Message[], cache?: WeakMap<Message, number>): number;
 /**
@@ -72,11 +72,11 @@ export declare function estimateContextCharsWithDualRatio(messages: Message[], c
  * - Images: fixed estimate (IMAGE_TOKEN_ESTIMATE)
  *
  * Each ratio is additionally multiplied by `scriptTokenFactor(text)` over
- * the EXACT string whose `.length` is divided (TOK-01, one rule every
- * site): dense non-Latin scripts (Hebrew/Arabic/CJK/...) tokenize at far
- * fewer chars/token than the flat ratios assume, so the divisor shrinks and
- * the estimate grows. Pure-ASCII text has factor 1.0 — byte-identical to
- * the unfactored math (I1).
+ * the EXACT string whose `.length` is divided (one rule, applied
+ * identically at every site): dense non-Latin scripts (Hebrew/Arabic/CJK/...)
+ * tokenize at far fewer chars/token than the flat ratios assume, so the
+ * divisor shrinks and the estimate grows. Pure-ASCII text has factor 1.0 —
+ * byte-identical to the unfactored math.
  */
 export declare function estimateMessageTokens(msg: Message): number;
 /**

package/node_modules/@comis/agent/dist/safety/token-estimator.js

@@ -58,8 +58,8 @@ export function estimateMessageChars(msg, cache) {
     }
     else if (Array.isArray(msg.content)) {
         for (const block of msg.content) {
-            // Defensive (LCD/codex turn-abort regression 2026-06-14): a malformed or
-            // undefined content block must NEVER throw out of estimation. The LCD
+            // Defensive: a malformed or undefined content block must NEVER throw
+            // out of estimation. The LCD
             // context-engine assembler runs this inside transformContext BEFORE the
             // LLM call, so a throw aborts the whole turn and surfaces to the user as a
             // silent "AI didn't produce a response". Flat-penalty anything that isn't
@@ -130,8 +130,8 @@ export function estimateContextChars(messages, cache) {
  * weighted 2x to reflect their higher token density. Used ONLY by the
  * observation masker threshold check.
  *
- * Deliberately factor-free: a RELATIVE char-pressure heuristic — a script
- * factor would cancel (TOK-01, design §4).
+ * Deliberately factor-free: a RELATIVE char-pressure heuristic — applying
+ * the script token factor to both sides of the ratio would cancel out.
  */
 export function estimateContextCharsWithDualRatio(messages, cache) {
     let total = 0;
@@ -163,11 +163,11 @@ const factoredTokensMemo = new WeakMap();
  * - Images: fixed estimate (IMAGE_TOKEN_ESTIMATE)
  *
  * Each ratio is additionally multiplied by `scriptTokenFactor(text)` over
- * the EXACT string whose `.length` is divided (TOK-01, one rule every
- * site): dense non-Latin scripts (Hebrew/Arabic/CJK/...) tokenize at far
- * fewer chars/token than the flat ratios assume, so the divisor shrinks and
- * the estimate grows. Pure-ASCII text has factor 1.0 — byte-identical to
- * the unfactored math (I1).
+ * the EXACT string whose `.length` is divided (one rule, applied
+ * identically at every site): dense non-Latin scripts (Hebrew/Arabic/CJK/...)
+ * tokenize at far fewer chars/token than the flat ratios assume, so the
+ * divisor shrinks and the estimate grows. Pure-ASCII text has factor 1.0 —
+ * byte-identical to the unfactored math.
  */
 export function estimateMessageTokens(msg) {
     const cached = factoredTokensMemo.get(msg);
@@ -187,14 +187,14 @@ function computeMessageTokens(msg) {
     let tokens = 0;
     const isStructured = msg.role === "toolResult";
     for (const block of msg.content) {
-        // Defensive (LCD/codex turn-abort regression 2026-06-14): a malformed or
-        // undefined content block must NEVER throw out of estimation. The LCD
+        // Defensive: a malformed or undefined content block must NEVER throw
+        // out of estimation. The LCD
         // context-engine assembler runs this inside transformContext BEFORE the LLM
         // call, so a throw aborts the whole turn and surfaces to the user as a
         // silent "AI didn't produce a response". Flat-penalty anything that isn't an
         // object with a string `type`.
         if (block == null || typeof block !== "object" || typeof block.type !== "string") {
-            // flat-by-design: a malformed/undefined block carries no source text to language-factor — UNKNOWN_BLOCK_CHARS is a fixed structural penalty, not derived from any string (TOK-01).
+            // flat-by-design: a malformed/undefined block carries no source text to language-factor — UNKNOWN_BLOCK_CHARS is a fixed structural penalty, not derived from any string.
             tokens += Math.ceil(UNKNOWN_BLOCK_CHARS / CHARS_PER_TOKEN);
             continue;
         }
@@ -220,13 +220,13 @@ function computeMessageTokens(msg) {
                     tokens += Math.ceil(json.length / (CHARS_PER_TOKEN_STRUCTURED * scriptTokenFactor(json)));
                 }
                 catch {
-                    // flat-by-design: constant penalty, no source text in scope (TOK-01)
+                    // flat-by-design: constant penalty, no source text in scope
                     tokens += Math.ceil(TOOL_STRINGIFY_FALLBACK / CHARS_PER_TOKEN_STRUCTURED);
                 }
                 break;
             }
             default:
-                // flat-by-design: constant penalty, no source text in scope (TOK-01)
+                // flat-by-design: constant penalty, no source text in scope
                 tokens += Math.ceil(UNKNOWN_BLOCK_CHARS / CHARS_PER_TOKEN);
                 break;
         }

package/node_modules/@comis/agent/dist/safety/tool-output-safety.js

@@ -10,7 +10,7 @@
 import { stripInvisible, containsTagBlockChars, IGNORE_PREV_INSTRUCTIONS, YOU_ARE_NOW, FORGET_EVERYTHING, NEW_INSTRUCTIONS, SYSTEM_COLON, SYSTEM_BRACKET, INST_BRACKET, SYSTEM_TAG, IMPORTANT_OVERRIDE, DISREGARD_INSTRUCTIONS, ACT_AS_ROLE, ASSISTANT_ROLE_MARKER, SPECIAL_TOKEN_DELIMITERS, CONTEXT_RESET, RULE_REPLACEMENT, OVERRIDE_SAFETY, } from "@comis/core";
 import sharp from "sharp";
 import { ok, err } from "@comis/shared";
-// --- Tool output text sanitization (formerly tool-sanitizer.ts) ---
+// --- Tool output text sanitization ---
 /**
  * Normalize text for secure pattern matching.
  * 1. Apply Unicode NFKC normalization (compatibility decomposition + canonical composition)
@@ -97,7 +97,7 @@ export function sanitizeToolOutput(text, maxChars = DEFAULT_MAX_CHARS, options)
     }
     return sanitized;
 }
-// --- Tool image sanitization (formerly tool-image-sanitizer.ts) ---
+// --- Tool image sanitization ---
 // Disable sharp cache to prevent memory accumulation across calls
 sharp.cache(false);
 /** Default limit for decompression bomb protection (268 million pixels). */

package/node_modules/@comis/agent/dist/safety/tool-result-size-guard.js

@@ -33,9 +33,10 @@ import { adjustSliceBoundary } from "@comis/core";
  * - Exit/return codes (exit code, return code, status code)
  */
 function hasImportantTail(text) {
-    // SAFE-01 EXCLUDED: this is a tail INSPECTION read (does the last 500 chars look
-    // important?), not a content-length truncation cut — never persisted/forwarded.
-    // A grapheme-snapped boundary here would change inspection semantics for nothing.
+    // Deliberately NOT grapheme-snapped: this is a tail INSPECTION read (does the
+    // last 500 chars look important?), not a content-length truncation cut — never
+    // persisted/forwarded. A grapheme-snapped boundary here would change inspection
+    // semantics for nothing.
     const tail = text.slice(-500);
     // Error indicators
     if (/error|exception|traceback|stack trace|failed|fatal/i.test(tail)) {
@@ -121,8 +122,8 @@ export function createToolResultSizeGuard(opts) {
     /** Maximum characters allowed for tool hint text. */
     const MAX_HINT_CHARS = 100;
     function formatMarker(removedChars, toolHint) {
-        // SAFE-01 EXCLUDED: this truncates a bounded ASCII hint string (decoration),
-        // not a content-length cut of ingested text — the design scopes it out, and a
+        // Deliberately NOT grapheme-snapped: this truncates a bounded ASCII hint
+        // string (decoration), not a content-length cut of ingested text — a
         // grapheme-snapped boundary here would only spend cycles for an ASCII no-op.
         const hintSuffix = toolHint
             ? ` Hint: ${toolHint.length > MAX_HINT_CHARS ? toolHint.slice(0, MAX_HINT_CHARS - 3) + "..." : toolHint}`
@@ -164,10 +165,11 @@ export function createToolResultSizeGuard(opts) {
         // Ensure head does not overlap with tail
         const effectiveHeadSize = Math.min(snappedHeadSize, snappedTailStart);
         const effectiveTailStart = Math.max(snappedTailStart, effectiveHeadSize);
-        // SAFE-01: snap each content-length cut back off a split surrogate pair or an
-        // orphaned combining/joiner/VS run so the preview is mojibake-free. The helper
-        // only moves the index backward (≤ original), so it never injects a codepoint —
-        // the marker (below) stays plain English + newline-isolated (no bidi control, I2).
+        // Grapheme safety: snap each content-length cut back off a split surrogate
+        // pair or an orphaned combining/joiner/VS run so the preview is mojibake-free.
+        // The helper only moves the index backward (≤ original), so it never injects a
+        // codepoint — the marker (below) stays plain English + newline-isolated (no
+        // bidi control characters).
         const adjHead = adjustSliceBoundary(text, effectiveHeadSize);
         const adjTailStart = adjustSliceBoundary(text, effectiveTailStart);
         const head = text.slice(0, adjHead);

package/node_modules/@comis/agent/dist/safety/tool-retry-breaker.d.ts

@@ -1,17 +1,15 @@
 /**
  * Tool retry circuit breaker: per-tool-signature consecutive failure tracking.
  *
- * Prevents infinite retry loops (the original repro: 48-call MCP-server retry incident) by blocking
- * tool calls after repeated failures and providing actionable LLM guidance with
- * alternative tool suggestions.
+ * Prevents infinite retry loops (e.g. an agent re-calling a failing MCP server
+ * tool dozens of times) by blocking tool calls after repeated failures and
+ * providing actionable LLM guidance with alternative tool suggestions.
  *
  * Two-level tracking:
  * - **Signature-level** (tool + sorted-args fingerprint): blocks after N consecutive
  *   failures for the exact same tool+args combination.
  * - **Tool-level** (tool name only): blocks after M total failures across all args
  *   for the same tool name.
- *
-
  *
  * @module
  */
@@ -24,15 +22,15 @@ export interface ToolRetryVerdict {
 /**
  * Transition verdict returned by `recordResult` when a tool-WIDE failure
  * counter crosses (or recovers from) its threshold. The breaker stays
- * emitter-free (design §5 D3 / §9.6 — lowest blast radius): it RETURNS this
- * verdict and the bridge (the sole holder of the event bus) emits the
- * `tool:breaker_opened` / `tool:breaker_reset` events.
+ * emitter-free (lowest blast radius): it RETURNS this verdict and the bridge
+ * (the sole holder of the event bus) emits the `tool:breaker_opened` /
+ * `tool:breaker_reset` events.
  *
  * Only tool-WIDE transitions surface (tool-level total + error-pattern, both of
  * which make the tool unavailable to the model); the args-specific
- * signature-level counter does NOT produce a transition (A1). `reset` fires
+ * signature-level counter does NOT produce a transition. `reset` fires
  * only on a success that recovers a non-zero counter — never on the lifecycle
- * `reset()` full-clear (A2).
+ * `reset()` full-clear.
  */
 export interface ToolBreakerTransition {
     transition: "opened" | "reset";
@@ -73,7 +71,7 @@ export interface ToolRetryBreaker {
      * crossing (tool-level total or error-pattern threshold, by EXACT equality)
      * or on a success that recovers a non-zero failure counter; otherwise
      * `undefined`. The breaker emits nothing itself — the bridge consumes this
-     * verdict (design §5 D3).
+     * verdict and emits the corresponding events.
      */
     recordResult(toolName: string, args: Record<string, unknown>, success: boolean, errorText?: string): ToolBreakerTransition | undefined;
     /** Return list of tool names that are fully blocked (tool-level). */
@@ -98,10 +96,9 @@ export declare function extractErrorTag(errorText: string): string;
  * not tool-execution failures. These are corrective feedback — the agent
  * can fix them by changing its args on the next call — so they MUST NOT
  * count toward the breaker's signature, tool-total, or error-pattern
- * counters. Counting them collapsed exec entirely during a legitimate
- * Cloudflare Pages deploy attempt when the agent iterated through several
- * command shapes looking for one that cleared the shell-substitution +
- * env-allowlist guards (Telegram session 678314278, jsonl lines 86–105).
+ * counters. Counting them collapses exec entirely during legitimate work —
+ * e.g. an agent iterating through several command shapes looking for one
+ * that clears the shell-substitution + env-allowlist guards.
  *
  * Real tool-execution failures (`permission_denied`, `not_found`,
  * `conflict`, `timeout`, EPERM sandbox denies, etc.) are unchanged —
@@ -126,11 +123,10 @@ export declare function isParameterValidationTag(tag: string): boolean;
  * exit 1), NOT evidence that the `exec`/`process` tool is unavailable. The
  * agent fixes its input and re-runs, so — exactly like PARAMETER_VALIDATION_TAGS
  * — these MUST NOT count toward the breaker's signature, tool-total, or
- * error-pattern thresholds. Counting them shut exec down mid-task in Telegram
- * session 678314278 (daemon.1.log, 2026-06-06 20:27): repeated `npm run build`
- * exits of 2 tripped maxConsecutiveErrorPatterns and the breaker told the model
- * exec was "unavailable. DO NOT retry this tool", killing the edit→build→fix
- * loop and forcing a bluffed completion.
+ * error-pattern thresholds. Counting them shuts exec down mid-task: repeated
+ * `npm run build` exits of 2 trip maxConsecutiveErrorPatterns and the breaker
+ * tells the model exec is "unavailable. DO NOT retry this tool", killing the
+ * edit→build→fix loop and forcing a bluffed completion.
  *
  * The discriminator is deliberately `details.exitCode` — the SAME field the
  * pi-event bridge inspects to flip toolSuccess=false in the first place
@@ -153,7 +149,7 @@ export declare function isCompletedCommandExit(errorText: string | undefined): b
  * @param errorTag - Normalized error tag extracted from lastError (used to branch on validation errors)
  * @param isToolLevel - Whether this is a tool-level (total) or signature-level (consecutive) block
  *
- * Exported as a test seam for R10b — the recordResult accumulation path is
+ * Exported as a test seam — the recordResult accumulation path is
  * unreachable for parameter-validation tags (early-return on
  * `PARAMETER_VALIDATION_TAGS.has(errorTag)` in `recordResult`),
  * so tests call this function directly.