comisai 1.0.45 → 1.0.46

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * 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}
@@ -11,12 +11,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 }`;
@@ -31,7 +31,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
@@ -51,7 +51,7 @@ const SUCCESS_STEP = 0.18;
 /** The MAX failure penalty (the `failurePenalty` of the saturating shape `p * fc/(fc+K)`). */
 const FAILURE_PENALTY = 0.55;
 /**
- * The FORGET-02 saturation constant — ~K failures reach half the penalty, so the
+ * The saturation constant — ~K failures reach half the penalty, so the
  * penalty saturates (a single failure barely moves a strong score; sustained failure
  * compounds). Mirrors `FAILURE_SATURATION_K` in sqlite-memory-lifecycle-store.ts.
  */
@@ -59,7 +59,7 @@ const FAILURE_SATURATION_K = 3;
 /**
  * Half-life of the recency decay: a success/failure's contribution to the standing
  * halves every ~3 days of idle time, so an OLD success protects LESS than a fresh one
- * (the recency-decayed §17 Trend). The score relaxes toward {@link NEUTRAL_SCORE}.
+ * (the recency-decayed Trend). The score relaxes toward {@link NEUTRAL_SCORE}.
  */
 const SCORE_HALF_LIFE_MS = 3 * 24 * 60 * 60 * 1000;
 /**
@@ -69,8 +69,8 @@ const SCORE_HALF_LIFE_MS = 3 * 24 * 60 * 60 * 1000;
  */
 const FAILURE_COUNT_HALF_LIFE_MS = 3 * 24 * 60 * 60 * 1000;
 /**
- * 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).
  */

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

@@ -1,5 +1,5 @@
 /**
- * Outcome-signal (Verified Learning WS1) write-back wiring.
+ * Outcome-signal write-back wiring.
  *
  * The composition-root glue between the deterministic completion bus events
  * (`tool:executed`, `graph:completed`, `diagnostic:message_processed`) and the
@@ -9,14 +9,15 @@
  * `wireMemoryUsefulness`. The resolve→consume chain is shared by the DAG
  * (`graph:completed`) AND single-agent (`diagnostic:message_processed`) seams and
  * runs at most ONCE per trajectory (resolve() is a pure read; both events can fire
- * for one DAG turn). Counts + ids + closed-enums ONLY cross the bus (§2.7 / SEC-01).
+ * for one DAG turn). Counts + ids + closed-enums ONLY cross the bus — never
+ * memory bodies or user content.
  *
  * BYTE-IDENTITY GATE: every handler's FIRST statement is the
  * `learningOutcomeEnabled(agentId)` short-circuit — default config observes/resolves/
  * emits NOTHING (the recall/score hot path is byte-identical). Fire-and-forget /
  * non-fatal: a failing observe/resolve warns and continues, never throwing out of the
  * handler or blocking the turn. An `unknown` resolved outcome derives no learning
- * (fail-closed, OUTCOME-05) and is NOT counted as resolved coverage.
+ * (fail-closed) and is NOT counted as resolved coverage.
  *
  * @module
  */
@@ -31,8 +32,8 @@ export interface LearningOutcomeWiringDeps {
     /** The sole @comis/memory adapter for the outcome port (the observe/resolve target). */
     outcomeStore: OutcomeSignalPort;
     /**
-     * The sole @comis/memory recall-utility adapter (the reward/failure write target,
-     * RANK-01/FORGET-02). The daemon is the ONLY place holding BOTH this AND
+     * The sole @comis/memory recall-utility adapter (the reward/failure write target).
+     * The daemon is the ONLY place holding BOTH this AND
      * `OutcomeSignalPort.resolve()` — the agent↛memory build cut means the agent
      * never imports the store (closed graph). Injected from setup-memory.ts where it
      * is already constructed.
@@ -40,52 +41,52 @@ export interface LearningOutcomeWiringDeps {
     usefulnessStore: MemoryUsefulnessStore;
     /** Injected clock for `observedAt` — the deterministic time source (no ambient wall clock). */
     clock: ClockPort;
-    /** Structured logger for the OBS-01 INFO completion line + the non-fatal failure WARN. */
+    /** Structured logger for the INFO completion line + the non-fatal failure WARN. */
     logger: ComisLogger;
     /**
      * Per-agent effective enable: true ONLY when the agent has `learning.enabled`
-     * (Phase 226 / M-1 — the ONE collapsed learning flag) AND the master
-     * `memory.enabled` switch is on. With `memory.enabled:false` → the subscriber is a no-op.
+     * (the ONE collapsed learning flag) AND the master `memory.enabled` switch is on.
+     * With `memory.enabled:false` → the subscriber is a no-op.
      */
     learningOutcomeEnabled: (agentId: string) => boolean;
     /**
-     * Per-agent reward-write enable (RANK-01): true ONLY when the agent has
+     * Per-agent reward-write enable: true ONLY when the agent has
      * `learning.enabled` AND the master `memory.enabled` switch is on. Gates the
-     * SUCCESS→`recordUsage` positive-reward write (STAYS wired behind the one flag — M-1).
+     * SUCCESS→`recordUsage` positive-reward write (wired behind the one collapsed flag).
      */
     learningTuningEnabled: (agentId: string) => boolean;
     /**
-     * Per-agent failure-accrual enable (FORGET-02): true ONLY when the agent has
+     * Per-agent failure-accrual enable: true ONLY when the agent has
      * `learning.enabled` AND the master `memory.enabled` switch is on. Gates the
-     * FAILURE/CORRECTED→`recordFailure` accrual (itself corroboration-gated, FORGET-03;
-     * STAYS wired behind the one flag — M-1).
+     * FAILURE/CORRECTED→`recordFailure` accrual (itself corroboration-gated;
+     * wired behind the one collapsed flag).
      */
     learningForgettingEnabled: (agentId: string) => boolean;
     /**
-     * The sole @comis/memory learned-skill adapter (the SURFACE-04/05 promote/demote
+     * The sole @comis/memory learned-skill adapter (the promote/demote
      * write target). The daemon is the ONLY place holding BOTH this AND
-     * `OutcomeSignalPort.resolve()` (the agent↛memory cut). OPTIONAL — when absent (a
-     * pre-Plan-05 caller, or learning disabled) the promote/demote loop is a no-op
+     * `OutcomeSignalPort.resolve()` (the agent↛memory cut). OPTIONAL — when absent
+     * (e.g. learning disabled) the promote/demote loop is a no-op
      * (byte-identical). Injected from setup-memory.ts where it is already constructed.
      */
     learnedSkillStore?: MentalModelStorePort;
     /**
-     * Per-agent learned-skill promote/demote enable (SURFACE-04/05): true ONLY when the
-     * agent has `learning.enabled` (M-1 — the ONE collapsed flag) AND the master
-     * `memory.enabled` switch is on. Gates the entire promote/demote loop (STAYS wired
+     * Per-agent learned-skill promote/demote enable: true ONLY when the
+     * agent has `learning.enabled` (the ONE collapsed flag) AND the master
+     * `memory.enabled` switch is on. Gates the entire promote/demote loop (wired
      * behind the one flag). With `memory.enabled:false` → no promote/demote/emit (byte-identical).
      */
     learningSkillsEnabled?: (agentId: string) => boolean;
     /**
-     * Per-agent promote threshold (the candidate→active transition crosses it — now
+     * Per-agent promote threshold (the candidate→active transition crosses it —
      * `learning.reflect.promoteAtProofCount`, schema default 3). Passed verbatim into
-     * `learnedSkillStore.promote(id, scope, threshold)` (the Plan 02 D2 store-side CASE gate).
+     * `learnedSkillStore.promote(id, scope, threshold)` (the store-side CASE gate).
      */
     learningSkillsPromoteAt?: (agentId: string) => number;
     /**
-     * WR-01: refresh a given agent's learned-skill SURFACE cache after a promote/demote
+     * Refresh a given agent's learned-skill SURFACE cache after a promote/demote
      * actually moved a row, so the NEXT session's prompt-skills freeze captures the new
-     * active set (SURFACE-03 next-SESSION pickup — never a mid-session mutation of an
+     * active set (next-SESSION pickup — never a mid-session mutation of an
      * already-frozen snapshot). The per-agent surface caches live in setup-agents-runtime
      * and are reached via a shared registry; this closure looks the agent's cache up and
      * fires its async refresh fire-and-forget. OPTIONAL — absent (no registry threaded, or
@@ -93,12 +94,12 @@ export interface LearningOutcomeWiringDeps {
      */
     refreshLearnedSkillSurface?: (agentId: string) => void;
     /**
-     * OUTCOME-04 conversational-breadth fallback (built in the setup-learning-judge leaf):
+     * Conversational-breadth fallback (built in the setup-learning-judge leaf):
      * the cost-gated LLM outcome-judge seam, invoked ONLY when the deterministic resolve fused
      * to `unknown` AND {@link learningOutcomeJudgeEnabled} is on — i.e. a CONVERSATIONAL turn
      * with no tool/pipeline signal. Returns the verdict's `outcome` + the CODE-capped reward
-     * (≤ 0.7) the daemon `observe()`s as a `source:"judge"` row. OPTIONAL — absent (a pre-judge
-     * caller, or the judge disabled for every agent) ⇒ the upgrade path is never entered
+     * (≤ 0.7) the daemon `observe()`s as a `source:"judge"` row. OPTIONAL — absent (no judge
+     * wired, or the judge disabled for every agent) ⇒ the upgrade path is never entered
      * (byte-identical). These three fields ARE the {@link JudgeUpgradeDeps} structural subset.
      */
     outcomeJudge?: OutcomeJudge;
@@ -113,16 +114,17 @@ export interface LearningOutcomeWiringDeps {
  *
  * Wiring:
  *  - `tool:executed`               → observe a `tool` outcome (`success===false`→failure).
- *  - `memory:skill_used`           → observe the ATTR-02 used-skill ids (attribution row).
+ *  - `memory:skill_used`           → observe the per-turn used-skill ids (attribution row).
+ *  - `orchestrate:run_summary`     → observe the run's content-free tool-NAME descriptor (attribution row).
  *  - `graph:completed` (DAG)       → observe a `pipeline` outcome, then the shared
  *                                    resolve→consume chain. (`graph:driver_lifecycle`
- *                                    is NOT observed — per-node, floods the ledger; WR-02.)
- *  - `diagnostic:message_processed` → the single-agent turn's resolve→consume (CR; the
+ *                                    is NOT observed — per-node, floods the ledger.)
+ *  - `diagnostic:message_processed` → the single-agent turn's resolve→consume (the
  *                                    common turn never fires graph:completed).
  *
- * The shared chain resolves the fused verdict, runs RANK/FORGET/SURFACE consumers,
+ * The shared chain resolves the fused verdict, runs the reward/forgetting/skill consumers,
  * emits `learning:outcome_observed` (counts/ids only), updates the fail-closed coverage
- * gauge (`resolved` counts only a non-`unknown` outcome, T-198-18), and runs at most
+ * gauge (`resolved` counts only a non-`unknown` outcome), and runs at most
  * ONCE per trajectory (a DAG turn fires BOTH completion events).
  */
 export declare function wireLearningOutcome(deps: LearningOutcomeWiringDeps): void;
@@ -131,16 +133,15 @@ export interface SetupLearningOutcomeDeps {
     eventBus: TypedEventBus;
     outcomeStore: OutcomeSignalPort;
     /**
-     * The recall-utility usefulness adapter (RANK-01/FORGET-02 reward/failure write
+     * The recall-utility usefulness adapter (the reward/failure write
      * target). Already constructed in setup-memory.ts; threaded through here so the
      * agent never imports the store (closed graph).
      */
     usefulnessStore: MemoryUsefulnessStore;
     /**
-     * The learned-skill adapter (SURFACE-04/05 promote/demote write target). Already
+     * The learned-skill adapter (the promote/demote write target). Already
      * constructed in setup-memory.ts; threaded through here so the agent never imports
-     * the store (closed graph). Folded onto the existing call so setup-memory.ts stays
-     * net-zero on lines.
+     * the store (closed graph).
      */
     learnedSkillStore: MentalModelStorePort;
     clock: ClockPort;
@@ -148,7 +149,7 @@ export interface SetupLearningOutcomeDeps {
     /** The parsed app config — the source of the master cost switch + per-agent flag. */
     config: AppConfig;
     /**
-     * WR-01: the shared per-agent learned-skill SURFACE registry (created in daemon.ts,
+     * The shared per-agent learned-skill SURFACE registry (created in daemon.ts,
      * also threaded into setupAgents where each agent registers its refresh closure). The
      * resolve-seam promote/demote loop calls `refresh(agentId)` on it after a real
      * transition so the next session sees the new active set. OPTIONAL — absent ⇒ no
@@ -156,7 +157,7 @@ export interface SetupLearningOutcomeDeps {
      */
     learnedSkillSurfaceRegistry?: import("./setup-agents/learned-skill-surface-registry.js").LearnedSkillSurfaceRegistry;
     /**
-     * OUTCOME-04: the cost-gated LLM outcome-judge fallback (built in the setup-learning-judge
+     * The cost-gated LLM outcome-judge fallback (built in the setup-learning-judge
      * leaf via `buildOutcomeJudgeWiring`, called from setup-memory.ts). OPTIONAL — when absent
      * (no agent has the judge on / no cheap-model key) the upgrade path is never entered.
      */
@@ -170,13 +171,11 @@ export interface SetupLearningOutcomeDeps {
  * Composition helper: compute the per-agent BYTE-IDENTITY enable gates from the
  * parsed config and stand up {@link wireLearningOutcome}.
  *
- * Every gate force-disables on the master cost switch
- * (`memory.enabled !== false` — renamed from costFeatures.enabled in Phase 226,
- * OUTCOME-09) AND requires the agent's own learning flag. Phase 226 / M-1 COLLAPSED
- * the four former per-feature flags (learningOutcome / learningTuning / learningForgetting /
- * learningSkills `.enabled`) into the ONE `learning.enabled` gate — the RANK-01 reward,
- * FORGET-02 accrual, and SURFACE-04 promote/demote WRITES all STAY wired, just behind the
- * single flag. With `memory.enabled:false` every gate is `false` for every agent → the
- * subscriber observes/resolves/emits/writes NOTHING → ranking/recall/replies are byte-identical.
+ * Every gate force-disables on the master cost switch (`memory.enabled !== false`)
+ * AND requires the agent's own learning flag. The ONE `learning.enabled` gate covers
+ * all four learning writes (outcome observe/resolve, reward, forgetting accrual, skill
+ * promote/demote) — there is deliberately no per-feature split. With
+ * `memory.enabled:false` every gate is `false` for every agent → the subscriber
+ * observes/resolves/emits/writes NOTHING → ranking/recall/replies are byte-identical.
  */
 export declare function setupLearningOutcomeWiring(deps: SetupLearningOutcomeDeps): void;