comisai 1.0.44 → 1.0.46

package/node_modules/@comis/daemon/dist/wiring/setup-learning-reactions.d.ts

@@ -1,25 +1,25 @@
 /**
- * Reaction + correction outcome wiring (Verified Learning WS1, Phase 199 P0.5).
+ * Reaction + correction outcome wiring (Verified Learning).
  *
  * Co-located beside {@link wireLearningOutcome} (setup-learning.ts) — the daemon
  * composition root holds BOTH the bus AND the `OutcomeSignalPort` adapter (the
  * agent↛memory cut). This module adds the TWO corroborating outcome sources that
- * the deterministic tool/pipeline signal (Phase 198) already outranks at fusion:
+ * the deterministic tool/pipeline signal already outranks at fusion:
  *
  *  - REACTION (`channel:reaction_received`): a chat reaction on an agent-authored
  *    OUTBOUND message. The `messageId → trajectory scope` map (captured ONLY at the
  *    outbound delivery ack — {@link ReactionTrajectoryMap}) resolves the trajectory;
  *    a reaction on a USER message / unknown id has NO entry → fail-closed SKIP
- *    (REACT-02 keystone). The emoji is matched against a CLOSED reactionMap
+ *    (keystone). The emoji is matched against a CLOSED reactionMap
  *    (unmapped → skip); confidence is SCALED by the channel-sender trust
- *    (`external` → near-zero, REACT-03/04); a per-sender rate limit caps a flood.
+ *    (`external` → near-zero); a per-sender rate limit caps a flood.
  *    Then `observe({ source: "reaction" })`.
  *
  *  - CORRECTION (`message:received`): a follow-up user turn classified by the
- *    cost-gated detector seam (Plan 03). The prior completed trajectory for the
+ *    cost-gated detector seam. The prior completed trajectory for the
  *    session is recorded from `diagnostic:message_processed` — the per-turn
  *    completion event that fires for single-agent turns too and carries
- *    agentId/sessionKey/traceId on its PAYLOAD (CR-02; the prior `graph:completed`
+ *    agentId/sessionKey/traceId on its PAYLOAD (the prior `graph:completed`
  *    + ALS wiring never fired for a single-agent turn and had no ALS at the emit).
  *    The recorded sessionKey is the SAME `formatSessionKey(...)` string the reader
  *    formats off the `message:received` payload (`formatSessionKey(p.sessionKey)`).
@@ -27,7 +27,7 @@
  *    that prior trajectory; the deterministic sources always outrank it.
  *
  * Counts/ids/closed-enums ONLY ever cross the bus or reach the store (AGENTS.md
- * §2.7 / SEC-01) — the emoji is matched against the closed map and never flows
+ * §2.7) — the emoji is matched against the closed map and never flows
  * into a prompt; no sender display names, no message bodies. Every observe is
  * fire-and-forget / non-fatal (WARN+errorKind+hint, never throws — the turn
  * already completed). `senderTrust` is provenance, NEVER raises authority.
@@ -41,7 +41,7 @@
  */
 import { type TypedEventBus, type MemoryConfig, type OutcomeSignalPort, type ClockPort, type ComisLogger, type TimerPort, type InjectionRateLimiter } from "@comis/core";
 import { type CorrectionVerdict } from "@comis/agent";
-/** The trajectory scope an agent-authored outbound message maps to (REACT-02). */
+/** The trajectory scope an agent-authored outbound message maps to. */
 export interface OutboundTrajectoryEntry {
     /** The trajectory identity (=== traceId; the trajectory + `comis explain` key). */
     traceId: string;
@@ -52,7 +52,7 @@ export interface OutboundTrajectoryEntry {
     /** Conversation/session identity (falls back to the trajectory id at capture). */
     sessionId: string;
     /**
-     * FLAG-2 (group reaction-spoof): the conversation PARTICIPANT — the inbound
+     * Group-reaction-spoof guard: the conversation PARTICIPANT — the inbound
      * sender whose message triggered this agent reply, captured from
      * `RequestContext.userId` at the delivery binding (the inbound pipeline sets
      * `ctx.userId = sessionKey.userId = msg.senderId`). It is the ONE reactor who
@@ -90,7 +90,7 @@ export declare function createReactionTrajectoryMap(deps: {
     entryTtlMs?: number;
     maxEntries?: number;
 }): ReactionTrajectoryMap;
-/** The closed emoji → outcome map (Unicode defaults; REACT-03). */
+/** The closed emoji → outcome map (Unicode defaults). */
 export interface ReactionEmojiMap {
     success: string[];
     failure: string[];
@@ -103,11 +103,11 @@ export interface LearningReactionsWiringDeps {
     outcomeStore: OutcomeSignalPort;
     /** Injected clock for `observedAt`. */
     clock: ClockPort;
-    /** Structured logger (OBS-01 INFO/durationMs + the non-fatal failure WARN). */
+    /** Structured logger (INFO/durationMs + the non-fatal failure WARN). */
     logger: ComisLogger;
     /** Per-agent effective learning-outcome enable (the byte-identity gate). */
     learningOutcomeEnabled: (agentId: string) => boolean;
-    /** The bounded outbound-trajectory map (REACT-02 fail-closed resolution). */
+    /** The bounded outbound-trajectory map (fail-closed resolution). */
     reactionTrajectoryMap: ReactionTrajectoryMap;
     /** Dedicated per-sender rate limiter for reactions (separate counters from injection detection). */
     reactionRateLimiter: InjectionRateLimiter;
@@ -116,7 +116,7 @@ export interface LearningReactionsWiringDeps {
     /**
      * Resolve the RAW channel-sender trust string for a reactor. Explicitly-mapped
      * reactors keep `senderTrustMap[reactorId]`. For an UNMAPPED reactor the result
-     * is participant-aware (FLAG-2): `defaultTrustLevel` applies ONLY when the
+     * is participant-aware: `defaultTrustLevel` applies ONLY when the
      * reactor IS the conversation `participantId` (the inbound sender); any other
      * unmapped reactor — a group bystander — resolves to `"external"` (inert). When
      * `participantId` is `undefined` (a legacy/unthreaded capture) it FAILS SAFE to
@@ -130,7 +130,7 @@ export interface LearningReactionsWiringDeps {
     /**
      * Record the most-recent completed trajectory + its scope for a session, keyed
      * on the `formatSessionKey(...)` string carried by the per-turn completion event
-     * (CR-02). The full scope is stored so the reader attributes the correction to
+     * The full scope is stored so the reader attributes the correction to
      * the trajectory's OWN (tenant, agent) — not the follow-up turn's ALS (which may
      * differ / be absent at the bus boundary).
      */
@@ -141,10 +141,10 @@ export interface LearningReactionsWiringDeps {
 /**
  * Stand up the `channel:reaction_received` → observe(source:"reaction") subscriber.
  *
- * Order (REACT-02/03/04):
+ * Order:
  *  1. Resolve the trajectory FIRST via the map — a miss (user message / unresolvable
  *     id) is a fail-closed SKIP (the keystone). The reaction NEVER calls resolve();
- *     the existing graph:completed resolve (198) fuses the reaction row with the
+ *     the existing graph:completed resolve fuses the reaction row with the
  *     deterministic rows, and a reaction NEVER outranks tool/pipeline.
  *  2. Byte-identity gate (now agentId is known from the entry).
  *  3. emoji → outcome via the closed reactionMap (unmapped → skip).
@@ -155,7 +155,7 @@ export interface LearningReactionsWiringDeps {
 export declare function wireLearningReactions(deps: LearningReactionsWiringDeps): void;
 /**
  * Stand up the correction path: record the prior completed trajectory per session
- * (`diagnostic:message_processed` — the per-turn completion event — CR-02) and
+ * (`diagnostic:message_processed` — the per-turn completion event) and
  * observe a `corrected` outcome on a classified follow-up turn (`message:received`).
  */
 export declare function wireLearningCorrection(deps: LearningReactionsWiringDeps): void;
@@ -214,7 +214,7 @@ export interface BuildReactionWiringResult {
     /** The bounded session→trajectory map (returned so the daemon can destroy it on shutdown). */
     sessionTrajectoryMap: ReactionTrajectoryMap;
     /**
-     * WR-01: tear down EVERY bounded-with-timers resource this wiring owns — the
+     * Tear down EVERY bounded-with-timers resource this wiring owns — the
      * reaction trajectory map, the session trajectory map, AND the dedicated
      * reaction rate limiter — cancelling each entry's `unref()`'d TTL timer. Threaded
      * into the daemon shutdown path beside the existing `injectionRateLimiter.destroy()`
@@ -228,8 +228,8 @@ export interface BuildReactionWiringResult {
  * byte-identity gate. Keeps the bulk OUT of setup-memory.ts (the 800-cap file) —
  * called in ONE line from the `setupLearningOutcomeWiring` site.
  *
- * Gates (mirror the 198 byte-identity computation):
- *  - `costFeaturesEnabled = memory.enabled !== false` (master switch, renamed from costFeatures.enabled in Phase 226).
+ * Gates (mirror the byte-identity computation):
+ *  - `costFeaturesEnabled = memory.enabled !== false` (master switch).
  *  - `learningOutcomeEnabled(id) = costFeaturesEnabled && agent.learningOutcome.enabled`.
  *  - `correctionEnabled(id) = learningOutcomeEnabled(id) && agent.learningOutcome.correction.enabled`.
  *  - `recordOutboundMessage` is built ONLY when SOME agent has learning-outcome on

package/node_modules/@comis/daemon/dist/wiring/setup-learning-reactions.js

@@ -1,26 +1,26 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Reaction + correction outcome wiring (Verified Learning WS1, Phase 199 P0.5).
+ * Reaction + correction outcome wiring (Verified Learning).
  *
  * Co-located beside {@link wireLearningOutcome} (setup-learning.ts) — the daemon
  * composition root holds BOTH the bus AND the `OutcomeSignalPort` adapter (the
  * agent↛memory cut). This module adds the TWO corroborating outcome sources that
- * the deterministic tool/pipeline signal (Phase 198) already outranks at fusion:
+ * the deterministic tool/pipeline signal already outranks at fusion:
  *
  *  - REACTION (`channel:reaction_received`): a chat reaction on an agent-authored
  *    OUTBOUND message. The `messageId → trajectory scope` map (captured ONLY at the
  *    outbound delivery ack — {@link ReactionTrajectoryMap}) resolves the trajectory;
  *    a reaction on a USER message / unknown id has NO entry → fail-closed SKIP
- *    (REACT-02 keystone). The emoji is matched against a CLOSED reactionMap
+ *    (keystone). The emoji is matched against a CLOSED reactionMap
  *    (unmapped → skip); confidence is SCALED by the channel-sender trust
- *    (`external` → near-zero, REACT-03/04); a per-sender rate limit caps a flood.
+ *    (`external` → near-zero); a per-sender rate limit caps a flood.
  *    Then `observe({ source: "reaction" })`.
  *
  *  - CORRECTION (`message:received`): a follow-up user turn classified by the
- *    cost-gated detector seam (Plan 03). The prior completed trajectory for the
+ *    cost-gated detector seam. The prior completed trajectory for the
  *    session is recorded from `diagnostic:message_processed` — the per-turn
  *    completion event that fires for single-agent turns too and carries
- *    agentId/sessionKey/traceId on its PAYLOAD (CR-02; the prior `graph:completed`
+ *    agentId/sessionKey/traceId on its PAYLOAD (the prior `graph:completed`
  *    + ALS wiring never fired for a single-agent turn and had no ALS at the emit).
  *    The recorded sessionKey is the SAME `formatSessionKey(...)` string the reader
  *    formats off the `message:received` payload (`formatSessionKey(p.sessionKey)`).
@@ -28,7 +28,7 @@
  *    that prior trajectory; the deterministic sources always outrank it.
  *
  * Counts/ids/closed-enums ONLY ever cross the bus or reach the store (AGENTS.md
- * §2.7 / SEC-01) — the emoji is matched against the closed map and never flows
+ * §2.7) — the emoji is matched against the closed map and never flows
  * into a prompt; no sender display names, no message bodies. Every observe is
  * fire-and-forget / non-fatal (WARN+errorKind+hint, never throws — the turn
  * already completed). `senderTrust` is provenance, NEVER raises authority.
@@ -45,7 +45,7 @@ import { createCorrectionDetectorSeam, resolveOperationModel, resolveProviderFam
 import { deriveTenantFromSessionKey } from "./setup-memory-usefulness-wiring.js";
 import { buildCustomJudgeModelSpec } from "./setup-learning-judge.js";
 /**
- * Evict the oldest-by-recency entry (bounded growth). WR-05: O(1) — `record()`
+ * Evict the oldest-by-recency entry (bounded growth). O(1) — `record()`
  * deletes-then-re-sets an updated key so the Map's insertion order IS the recency
  * order (most-recently-recorded last), making the FIRST key the genuine oldest.
  * `Map.keys().next().value` is O(1), replacing the prior O(n) min-`insertedAt`
@@ -62,7 +62,7 @@ function evictOldestMapEntry(buckets) {
 }
 export function createReactionTrajectoryMap(deps, config) {
     // A reaction usually arrives soon after the message; a day is generous. The map
-    // is in-memory daemon-lifetime (resolved decision A1) — a post-restart reaction
+    // is in-memory daemon-lifetime — a post-restart reaction
     // simply has no entry → fail-closed skip.
     const entryTtlMs = config?.entryTtlMs ?? 86_400_000; // 24h
     const maxEntries = config?.maxEntries ?? 50_000;
@@ -79,7 +79,7 @@ export function createReactionTrajectoryMap(deps, config) {
             const existing = buckets.get(messageId);
             if (existing) {
                 existing.timer.cancel();
-                // WR-05: delete BEFORE re-setting so the refreshed key moves to the Map's
+                // Delete BEFORE re-setting so the refreshed key moves to the Map's
                 // tail — keeps insertion order == recency order, which the O(1)
                 // `evictOldestMapEntry` (first key = oldest) depends on.
                 buckets.delete(messageId);
@@ -99,10 +99,10 @@ export function createReactionTrajectoryMap(deps, config) {
         },
     };
 }
-/** Base confidence for a clean reaction before trust scaling (REACT-03). */
+/** Base confidence for a clean reaction before trust scaling. */
 const REACTION_BASE_CONFIDENCE = 0.6;
 /**
- * WR-03: the minimum trust-scaled confidence a reaction must clear to be written
+ * The minimum trust-scaled confidence a reaction must clear to be written
  * to the append-only ledger. An `external`/unknown reactor yields
  * `REACTION_BASE_CONFIDENCE (0.6) * trustWeight("external") (0.05) = 0.03` — inert
  * (the deterministic tool/pipeline signal always outranks it at fusion), so rather
@@ -112,9 +112,9 @@ const REACTION_BASE_CONFIDENCE = 0.6;
  */
 const REACTION_MIN_CONFIDENCE_TO_WRITE = 0.05;
 /**
- * Channel-sender trust → confidence weight (REACT-03/04). The vocabulary is the
+ * Channel-sender trust → confidence weight. The vocabulary is the
  * channel-sender ladder (owner/admin/trusted/known/external) — NOT the tool-gate
- * guest/user/admin narrowing (Pitfall 4). An `external`/unknown reactor is
+ * guest/user/admin narrowing. An `external`/unknown reactor is
  * near-zero (a spoofed 👍 can never mint a strong reward; deterministic outranks
  * it regardless).
  */
@@ -187,7 +187,7 @@ function observeReactionNonFatal(deps, entry, outcome, confidence, senderTrust)
             }, "reaction observe failed (non-fatal)");
             return;
         }
-        // OBS-01: one INFO line per recorded reaction — counts/ids/closed-enums only
+        // One INFO line per recorded reaction — counts/ids/closed-enums only
         // (the observe latency as durationMs, the resolved senderTrust). Never the
         // emoji-as-content beyond the closed map, never a sender display name.
         deps.logger.info({ agentId: entry.agentId, outcome, source: "reaction", senderTrust, durationMs: deps.clock.now() - start }, "Reaction outcome observed for trajectory");
@@ -254,10 +254,10 @@ function observeCorrectionNonFatal(deps, scope, confidence) {
 /**
  * Stand up the `channel:reaction_received` → observe(source:"reaction") subscriber.
  *
- * Order (REACT-02/03/04):
+ * Order:
  *  1. Resolve the trajectory FIRST via the map — a miss (user message / unresolvable
  *     id) is a fail-closed SKIP (the keystone). The reaction NEVER calls resolve();
- *     the existing graph:completed resolve (198) fuses the reaction row with the
+ *     the existing graph:completed resolve fuses the reaction row with the
  *     deterministic rows, and a reaction NEVER outranks tool/pipeline.
  *  2. Byte-identity gate (now agentId is known from the entry).
  *  3. emoji → outcome via the closed reactionMap (unmapped → skip).
@@ -267,7 +267,7 @@ function observeCorrectionNonFatal(deps, scope, confidence) {
  */
 export function wireLearningReactions(deps) {
     deps.eventBus.on("channel:reaction_received", (p) => {
-        // 1. Fail-closed trajectory resolution (REACT-02 keystone).
+        // 1. Fail-closed trajectory resolution (keystone).
         const entry = deps.reactionTrajectoryMap.lookup(p.messageId);
         if (entry === undefined)
             return; // user message / unresolvable / evicted → SKIP
@@ -279,14 +279,14 @@ export function wireLearningReactions(deps) {
         if (outcome === undefined)
             return;
         // 4. RAW channel-sender trust → a confidence weight (external → near-zero).
-        //    FLAG-2: pass the bound conversation participant so an unmapped reactor
+        //    Pass the bound conversation participant so an unmapped reactor
         //    inherits defaultTrustLevel ONLY when it IS the participant (the inbound
         //    sender); an unmapped group bystander resolves to "external" (inert) and
         //    cannot spoof the reaction-learning signal. `entry.participantId` is
         //    undefined on legacy captures → fail-safe to defaultTrustLevel.
         const trust = deps.resolveSenderTrust(entry.agentId, p.reactorId, entry.participantId);
         const confidence = REACTION_BASE_CONFIDENCE * trustWeight(trust);
-        // 4b. WR-03: a near-zero (external/unknown) reaction is below the write floor →
+        // 4b. A near-zero (external/unknown) reaction is below the write floor →
         // skip entirely (no observe, no ledger row). The deterministic signal outranks
         // it regardless, so writing it only amplifies the append-only ledger.
         if (confidence < REACTION_MIN_CONFIDENCE_TO_WRITE)
@@ -308,13 +308,13 @@ export function wireLearningReactions(deps) {
 }
 /**
  * Stand up the correction path: record the prior completed trajectory per session
- * (`diagnostic:message_processed` — the per-turn completion event — CR-02) and
+ * (`diagnostic:message_processed` — the per-turn completion event) and
  * observe a `corrected` outcome on a classified follow-up turn (`message:received`).
  */
 export function wireLearningCorrection(deps) {
     // WRITER — record the most-recent completed trajectory for the session.
     //
-    // CR-02: keys off the `diagnostic:message_processed` PAYLOAD, NOT the ALS. The
+    // Keys off the `diagnostic:message_processed` PAYLOAD, NOT the ALS. The
     // prior writer hooked `graph:completed`, which (a) is emitted from the graph
     // coordinator's async tick loop OUTSIDE any `runWithContext` (so `tryGetContext()`
     // was always undefined → the writer always early-returned) and (b) only fires for
@@ -325,7 +325,7 @@ export function wireLearningCorrection(deps) {
     // string the reader formats the `message:received` payload into. An absent
     // sessionKey OR traceId records NOTHING (a later correction then fails-closed —
     // never mis-joined). The tenant is derived from the sessionKey's first segment
-    // (mirrors the 198 `deriveTenantFromSessionKey`).
+    // (mirrors `deriveTenantFromSessionKey`).
     deps.eventBus.on("diagnostic:message_processed", (p) => {
         if (deps.recordSessionTrajectory === undefined)
             return;
@@ -381,7 +381,7 @@ const DEFAULT_REACTION_MAP = { success: ["👍", "✅"], failure: ["👎", "❌"
 /** Per-call output bound for the cheap correction classification (a tiny JSON verdict). */
 const CORRECTION_MAX_OUTPUT_TOKENS = 1024;
 /**
- * Reaction-tuned rate-limit thresholds. WR-04: a TIGHT per-sender cap — the
+ * Reaction-tuned rate-limit thresholds. A TIGHT per-sender cap — the
  * handler skips at `audit` (count >= auditThreshold), so the effective per-sender
  * allowance is `auditThreshold - 1 = 3` reactions per 5-minute window. The prior
  * `auditThreshold: 10` let 9 reactions through per sender before skipping, which
@@ -392,10 +392,10 @@ const CORRECTION_MAX_OUTPUT_TOKENS = 1024;
 const REACTION_RATE_LIMIT = { windowMs: 300_000, warnThreshold: 2, auditThreshold: 4, entryTtlMs: 600_000, maxEntries: 50_000 };
 /**
  * Resolve + construct the cheap `fast`-tier correction detector for one agent
- * (the `outcomeJudge` operation tier — research A2, no new ModelOperationType).
+ * (the `outcomeJudge` operation tier — no new ModelOperationType).
  * Resolves the provider/modelId by NAME and the API key from the secret manager
  * (KEYLESS sentinel for keyless providers); returns `undefined` on a missing key
- * (a no-op branch — `Defer != Retry`). The seam itself is the Plan-03 clone.
+ * (a no-op branch — `Defer != Retry`). The seam itself reuses createCorrectionDetectorSeam.
  */
 function resolveCorrectionDetector(agent, container, agentId, clock, logger) {
     const agentProvider = agent.provider ?? "anthropic";
@@ -410,8 +410,8 @@ function resolveCorrectionDetector(agent, container, agentId, clock, logger) {
     const apiKeyName = providerEntry?.apiKeyName || `${resolved.provider.toUpperCase()}_API_KEY`;
     const apiKey = container.secretManager.get(apiKeyName) ??
         // Keyless by TYPE, not config NAME — a user-named ollama entry must resolve keyless, else the
-        // correction detector (DRIFT/supersede) is a silent no-op on a local keyless daemon
-        // (package-delivery-20260628). Guarded by test/architecture/keyless-provider-by-type.
+        // correction detector (DRIFT/supersede) is a silent no-op on a local keyless daemon.
+        // Guarded by test/architecture/keyless-provider-by-type.
         (KEYLESS_PROVIDER_TYPES.has(providerEntry?.type ?? resolved.provider) ? KEYLESS_API_KEY_SENTINEL : "");
     if (!apiKey)
         return undefined; // no key → no-op detector (Defer != Retry)
@@ -434,8 +434,8 @@ function resolveCorrectionDetector(agent, container, agentId, clock, logger) {
  * byte-identity gate. Keeps the bulk OUT of setup-memory.ts (the 800-cap file) —
  * called in ONE line from the `setupLearningOutcomeWiring` site.
  *
- * Gates (mirror the 198 byte-identity computation):
- *  - `costFeaturesEnabled = memory.enabled !== false` (master switch, renamed from costFeatures.enabled in Phase 226).
+ * Gates (mirror the byte-identity computation):
+ *  - `costFeaturesEnabled = memory.enabled !== false` (master switch).
  *  - `learningOutcomeEnabled(id) = costFeaturesEnabled && agent.learningOutcome.enabled`.
  *  - `correctionEnabled(id) = learningOutcomeEnabled(id) && agent.learningOutcome.correction.enabled`.
  *  - `recordOutboundMessage` is built ONLY when SOME agent has learning-outcome on
@@ -460,7 +460,7 @@ export function buildReactionWiringDeps(container, clock, timers) {
     // Resolve the RAW channel-sender trust string — the channel-sender vocabulary,
     // NOT the tool-gate narrowing.
     //
-    // FLAG-2 (group reaction-spoof): `defaultTrustLevel` is the privilege of the ONE
+    // Group reaction-spoof guard: `defaultTrustLevel` is the privilege of the ONE
     // conversation PARTICIPANT (the inbound sender whose message triggered the reply),
     // NOT a blanket grant to every unmapped group member. Resolution order:
     //   1. an EXPLICITLY-mapped reactor keeps `senderTrustMap[reactorId]` (an
@@ -530,7 +530,7 @@ export function buildReactionWiringDeps(container, clock, timers) {
     const recordOutboundMessage = someLearningOn
         ? (messageId, scope) => reactionTrajectoryMap.record(messageId, scope)
         : undefined;
-    // WR-01: one closure that cancels the timers of ALL THREE bounded resources.
+    // One closure that cancels the timers of ALL THREE bounded resources.
     // The daemon shutdown path invokes it beside injectionRateLimiter.destroy().
     const destroyReactionWiring = () => {
         reactionTrajectoryMap.destroy();

package/node_modules/@comis/daemon/dist/wiring/setup-learning-skill-transitions.d.ts

@@ -1,5 +1,5 @@
 /**
- * SURFACE-04/05/06 learned-skill promote/demote — the resolve-seam loop body.
+ * Learned-skill promote/demote — the resolve-seam loop body.
  *
  * Extracted to its own leaf (like `setup-learning-corroboration.ts`) so
  * `setup-learning.ts` stays under the 800-line cap. It imports `failureCorroborated`
@@ -8,10 +8,10 @@
  * `setup-learning.ts` (one-directional — no cycle). The caller's `deps` is a superset of
  * the narrow {@link SkillTransitionDeps} declared here, so it passes `deps` verbatim.
  *
- * The loop iterates `verdict.usedSkillIds` (skill NAMES, ATTR-01) and AWAITS the
- * name-keyed store transition to read rows-changed (CR-01) so a 0-row write never
- * inflates the counters/emits. It scope-qualifies the corroboration/trend keys (WR-05)
- * and refreshes the per-agent surface cache on a real transition (WR-01). NEVER throws
+ * The loop iterates `verdict.usedSkillIds` (skill NAMES) and AWAITS the
+ * name-keyed store transition to read rows-changed so a 0-row write never
+ * inflates the counters/emits. It scope-qualifies the corroboration/trend keys
+ * and refreshes the per-agent surface cache on a real transition. NEVER throws
  * (each store call is wrapped; a reject/err WARNs and is skipped).
  *
  * @module
@@ -40,23 +40,23 @@ export interface SkillOutcomeDeps {
     skillStore: MentalModelStorePort;
     /** The per-agent `promoteAtProofCount` threshold (candidate→active proof bar). */
     threshold: number;
-    /** WR-05: scope-qualified corroboration tally (skillGaugeKey → distinct failing sessions). */
+    /** Scope-qualified corroboration tally (skillGaugeKey → distinct failing sessions). */
     skillFailureCorroborationTally: Map<string, Set<string>>;
-    /** WR-05: the decay-aware trend tracker (keyed on the SAME scope-qualified key). */
+    /** The decay-aware trend tracker (keyed on the SAME scope-qualified key). */
     skillTrend: SkillTrendTracker;
-    /** WR-01: refresh the per-agent surface cache after a promote/demote moved a row, so
-     *  the NEXT session's freeze captures the new active set (SURFACE-03 next-session
+    /** Refresh the per-agent surface cache after a promote/demote moved a row, so
+     *  the NEXT session's freeze captures the new active set (next-session
      *  pickup, never a frozen-snapshot mutation). Absent ⇒ no refresh. */
     refreshSurface?: (agentId: string) => void;
 }
 /**
- * SURFACE-04/05/06 + OBS-01 — the resolve-seam learned-skill promote/demote body,
+ * The resolve-seam learned-skill promote/demote body,
  * fire-and-forget / non-fatal. AWAITS the name-keyed store transition to read
- * rows-changed (CR-01: the loop holds skill NAMES, not the hash id; the store resolves
+ * rows-changed (the loop holds skill NAMES, not the hash id; the store resolves
  * name→id internally AND reports whether a row moved) and increments the counter +
  * emits ONLY when a row actually transitioned (the telemetry stops lying about 0-row
- * writes). Scope-qualifies the corroboration/trend keys (WR-05). On a real transition
- * it refreshes the per-agent surface cache (WR-01). NEVER throws (each store call is
+ * writes). Scope-qualifies the corroboration/trend keys. On a real transition
+ * it refreshes the per-agent surface cache. NEVER throws (each store call is
  * wrapped; a reject/err WARNs and is skipped).
  */
 export declare function applySkillOutcomeTransitions(deps: SkillTransitionDeps, scope: SkillTransitionScope, verdict: ResolvedOutcome, skillDeps: SkillOutcomeDeps): Promise<void>;

package/node_modules/@comis/daemon/dist/wiring/setup-learning-skill-transitions.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * SURFACE-04/05/06 learned-skill promote/demote — the resolve-seam loop body.
+ * Learned-skill promote/demote — the resolve-seam loop body.
  *
  * Extracted to its own leaf (like `setup-learning-corroboration.ts`) so
  * `setup-learning.ts` stays under the 800-line cap. It imports `failureCorroborated`
@@ -9,17 +9,17 @@
  * `setup-learning.ts` (one-directional — no cycle). The caller's `deps` is a superset of
  * the narrow {@link SkillTransitionDeps} declared here, so it passes `deps` verbatim.
  *
- * The loop iterates `verdict.usedSkillIds` (skill NAMES, ATTR-01) and AWAITS the
- * name-keyed store transition to read rows-changed (CR-01) so a 0-row write never
- * inflates the counters/emits. It scope-qualifies the corroboration/trend keys (WR-05)
- * and refreshes the per-agent surface cache on a real transition (WR-01). NEVER throws
+ * The loop iterates `verdict.usedSkillIds` (skill NAMES) and AWAITS the
+ * name-keyed store transition to read rows-changed so a 0-row write never
+ * inflates the counters/emits. It scope-qualifies the corroboration/trend keys
+ * and refreshes the per-agent surface cache on a real transition. NEVER throws
  * (each store call is wrapped; a reject/err WARNs and is skipped).
  *
  * @module
  */
 import { failureCorroborated } from "./setup-learning-corroboration.js";
 /**
- * WR-05: build the scope-qualified key the in-process skill gauges (corroboration
+ * Build the scope-qualified key the in-process skill gauges (corroboration
  * tally + trend tracker) MUST key on — `(tenantId, agentId, skillName)`. Keying on
  * the bare skill NAME aliases two different (tenant, agent) scopes that each surface
  * a skill of the same name, so tenant A's failures could drive tenant B's skill
@@ -31,13 +31,13 @@ function skillGaugeKey(tenantId, agentId, skillName) {
     return `${tenantId} ${agentId} ${skillName}`;
 }
 /**
- * SURFACE-04/05/06 + OBS-01 — the resolve-seam learned-skill promote/demote body,
+ * The resolve-seam learned-skill promote/demote body,
  * fire-and-forget / non-fatal. AWAITS the name-keyed store transition to read
- * rows-changed (CR-01: the loop holds skill NAMES, not the hash id; the store resolves
+ * rows-changed (the loop holds skill NAMES, not the hash id; the store resolves
  * name→id internally AND reports whether a row moved) and increments the counter +
  * emits ONLY when a row actually transitioned (the telemetry stops lying about 0-row
- * writes). Scope-qualifies the corroboration/trend keys (WR-05). On a real transition
- * it refreshes the per-agent surface cache (WR-01). NEVER throws (each store call is
+ * writes). Scope-qualifies the corroboration/trend keys. On a real transition
+ * it refreshes the per-agent surface cache. NEVER throws (each store call is
  * wrapped; a reject/err WARNs and is skipped).
  */
 export async function applySkillOutcomeTransitions(deps, scope, verdict, skillDeps) {
@@ -46,24 +46,24 @@ export async function applySkillOutcomeTransitions(deps, scope, verdict, skillDe
     const skillStart = deps.clock.now();
     let promoted = 0;
     let demoted = 0;
-    // REFLECT-03: count of successful reuses whose promotion credit was VALUE-GATED (the skill
+    // Count of successful reuses whose promotion credit was VALUE-GATED (the skill
     // was in a sustained-failure standing → it must earn back trust before accruing proof).
     let promotionGated = 0;
-    // Finding C: collect the demoted skill NAMES (not just the count) so the emit can name WHICH
+    // Collect the demoted skill NAMES (not just the count) so the emit can name WHICH
     // skills demoted (id-class, never a body).
     const demotedNames = [];
-    // REFLECT-03: the skill NAMES whose promotion was value-gated this resolve (id-class, never a body)
+    // The skill NAMES whose promotion was value-gated this resolve (id-class, never a body)
     // — so "why didn't my skill promote despite a successful reuse?" is answerable from obs.
     const gatedNames = [];
     for (const skillName of verdict.usedSkillIds) {
-        // WR-05: never key the in-process gauges on the bare name (cross-tenant alias).
+        // Never key the in-process gauges on the bare name (cross-tenant alias).
         const gaugeKey = skillGaugeKey(scope.tenantId, scope.agentId, skillName);
         if (verdict.outcome === "success") {
-            // REFLECT-03 VALUE-GATED PROMOTION: PEEK the skill's standing BEFORE folding this success.
+            // VALUE-GATED PROMOTION: PEEK the skill's standing BEFORE folding this success.
             // A skill in a SUSTAINED-failure ("weakening") standing must EARN BACK trust — an interleaved
             // success recovers the trend but does NOT accrue promotion credit (proof_count), so promotion
-            // reflects a reliable track record, not raw reuse count (the package-delivery finding: a skill
-            // promoted on usage even when its reuses didn't help). A fresh/clean or single-failure skill is
+            // reflects a reliable track record, not raw reuse count (otherwise a skill promotes on usage
+            // even when its reuses did not help). A fresh/clean or single-failure skill is
             // "stable" (never "weakening") → promotes normally (no regression on the healthy loop).
             const standingBefore = skillTrend.peekSkillTrend(gaugeKey, deps.clock.now());
             // The success ALWAYS feeds the trend (so a recovering procedure re-strengthens) — peek was BEFORE.
@@ -73,17 +73,17 @@ export async function applySkillOutcomeTransitions(deps, scope, verdict, skillDe
                 gatedNames.push(skillName);
             }
             else {
-                // SURFACE-04: promoteByName bumps proof_count; candidate→active at the proof bar
-                // (store-side CASE). Count ONLY when a real row changed (CR-01).
+                // promoteByName bumps proof_count; candidate→active at the proof bar
+                // (store-side CASE). Count ONLY when a real row changed.
                 const changed = await runSkillTransition(deps, scope.agentId, "skill_promote", () => skillStore.promoteByName(skillName, skillScope, threshold));
                 if (changed)
                     promoted += 1;
             }
         }
         else if (verdict.outcome === "failure" || verdict.outcome === "corrected") {
-            // SURFACE-05: corroboration gate (≥2 distinct-session OR 1 deterministic), THEN
+            // Corroboration gate (≥2 distinct-session OR 1 deterministic), THEN
             // the decay-aware trend — demote ONLY on a WEAKENING standing so a single
-            // corroborated failure on a well-reused skill stays put (§12 first-RED).
+            // corroborated failure on a well-reused skill stays put.
             if (failureCorroborated(gaugeKey, scope.sessionId, verdict.sources, skillFailureCorroborationTally)) {
                 const trend = skillTrend.updateSkillTrend(gaugeKey, "failure", deps.clock.now());
                 if (trend === "weakening") {
@@ -96,22 +96,22 @@ export async function applySkillOutcomeTransitions(deps, scope, verdict, skillDe
             }
         }
     }
-    // SURFACE-06 emits — plain eventBus.emit (Plan 03 typed the keys + bridged them).
+    // Skill-transition emits — plain eventBus.emit (the keys are typed + bridged).
     // COUNTS ONLY — a body/script/id-list field is a compile error. Emitted ONLY on a
-    // REAL transition count (CR-01: a 0-row write never reaches here).
+    // REAL transition count (a 0-row write never reaches here).
     if (promoted > 0)
         deps.eventBus.emit("learning:skill_promoted", { agentId: scope.agentId, count: promoted, timestamp: deps.clock.now() });
     if (demoted > 0)
         deps.eventBus.emit("learning:skill_demoted", {
             agentId: scope.agentId,
             count: demoted,
-            // Finding C: name WHICH skills demoted + the trigger trajectory (the WHY) — content-free ids.
+            // Name WHICH skills demoted + the trigger trajectory (the WHY) — content-free ids.
             demotedSkillNames: demotedNames,
             triggerTrajectoryId: scope.trajectoryId,
             timestamp: deps.clock.now(),
         });
-    // OBS-01: one INFO completion line per resolve that moved a skill OR value-gated a promotion,
-    // with durationMs (counts/ids only — never a procedure body). REFLECT-03 adds promotionGated +
+    // One INFO completion line per resolve that moved a skill OR value-gated a promotion,
+    // with durationMs (counts/ids only — never a procedure body). Adds promotionGated +
     // the gated skill NAMES so a stalled-but-succeeding skill is diagnosable ("why no promote?").
     if (promoted > 0 || demoted > 0 || promotionGated > 0) {
         deps.logger.info({
@@ -123,8 +123,8 @@ export async function applySkillOutcomeTransitions(deps, scope, verdict, skillDe
             durationMs: deps.clock.now() - skillStart,
         }, "Learned-skill promote/demote complete");
     }
-    // WR-01: a real transition changed the active set — refresh the per-agent surface cache so the
-    // NEXT session's freeze captures it (next-session pickup, SURFACE-03). A value-GATED promotion
+    // A real transition changed the active set — refresh the per-agent surface cache so the
+    // NEXT session's freeze captures it (next-session pickup). A value-GATED promotion
     // moved NO row → no refresh.
     if (promoted > 0 || demoted > 0) {
         refreshSurface?.(scope.agentId);

package/node_modules/@comis/daemon/dist/wiring/setup-learning-skill-trend.d.ts

@@ -1,5 +1,5 @@
 /**
- * Decay-aware learned-skill TREND (Verified Learning WS4 / §17 hindsight Trend) —
+ * Decay-aware learned-skill TREND (Verified Learning — the hindsight trend) —
  * the in-process decision of WHEN a corroborated failure should drive a `demote()`.
  *
  * The promote/demote loop (setup-learning.ts) calls {@link createSkillTrendTracker}
@@ -10,12 +10,12 @@
  * `active → stale` move (the store's `demote()`) fires on a SUSTAINED corroborated
  * failure, not a raw counter.
  *
- * The load-bearing invariant (Pitfall 4 / the §12 first-RED, anti-induced-demotion):
+ * The load-bearing invariant (anti-induced-demotion):
  * a SINGLE corroborated failure against many recent successes keeps the standing
  * STABLE/STRENGTHENING — only SUSTAINED corroborated failure reaches WEAKENING. A
  * well-reused procedure is NOT archived by one (possibly induced) failure.
  *
- * Math — reuses the FORGET-02 saturating-penalty SHAPE (`f = fc/(fc+K)`, K=3, the
+ * Math — reuses the saturating-penalty SHAPE (`f = fc/(fc+K)`, K=3, the
  * READ-ONLY pattern at sqlite-memory-lifecycle-store.ts:354-359) adapted to a
  * recency-decayed score:
  *  - keep a per-skill `{ score, failureCount, lastUpdateMs }`;
@@ -30,7 +30,7 @@
  *  - classify against two bands: ≥ {@link STRENGTHENING_BAND} → "strengthening",
  *    ≤ {@link WEAKENING_BAND} → "weakening", else "stable".
  *
- * In-process / daemon-lifetime (A3 — resets on restart, exactly like the FORGET-03
+ * In-process / daemon-lifetime (resets on restart, exactly like the
  * corroboration tally). BOUNDED: the per-skill map caps at `maxTracked` and evicts the
  * OLDEST-touched skill (Map insertion order = recency, refreshed via delete-before-set)
  * so a busy/adversarial fleet never grows it without bound. Counts/ids only — never a
@@ -39,11 +39,11 @@
  *
  * @module
  */
-/** The §17 hindsight trend standing — a closed union (AGENTS.md §2.8: exhaustive). */
+/** The hindsight trend standing — a closed union (AGENTS.md §2.8: exhaustive). */
 export type SkillTrend = "strengthening" | "stable" | "weakening";
 /**
- * WR-01 bound on the number of tracked skills (daemon-lifetime, resets on restart).
- * Past this the oldest-touched skill id is evicted. Mirrors the FORGET-03 tally cap
+ * Bound on the number of tracked skills (daemon-lifetime, resets on restart).
+ * Past this the oldest-touched skill id is evicted. Mirrors the corroboration tally cap
  * (`MAX_TRACKED_FAILURE_MEMORIES`) — a soft forget of the stalest standing, never a
  * correctness loss (the store's durable proof_count/state is the source of truth).
  */
@@ -58,7 +58,7 @@ export interface SkillTrendTracker {
      */
     updateSkillTrend(skillId: string, outcome: "success" | "failure", nowMs: number): SkillTrend;
     /**
-     * READ-ONLY (REFLECT-03): the skill's CURRENT standing decayed to `nowMs`, WITHOUT
+     * READ-ONLY: the skill's CURRENT standing decayed to `nowMs`, WITHOUT
      * folding a new outcome — does NOT mutate the score, failureCount, recency, or the
      * Map. A never-seen skill returns `"stable"` (the neutral starting standing). The
      * promote path peeks this BEFORE applying a success so a skill in a SUSTAINED-failure