comisai 1.0.45 → 1.0.46

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * 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
@@ -10,14 +10,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
  */
@@ -26,9 +27,9 @@ import { deriveTenantFromSessionKey } from "./setup-memory-usefulness-wiring.js"
 import { createSkillTrendTracker } from "./setup-learning-skill-trend.js";
 import { markTrajectoryResolved } from "./setup-learning-dedup.js";
 import { failureCorroborated, CORROBORATION_MIN_INDEPENDENT, MAX_TRACKED_FAILURE_MEMORIES, } from "./setup-learning-corroboration.js";
-// OUTCOME-04 judge fallback lives in its own leaf (no cycle: setup-learning → judge only).
+// The LLM outcome-judge fallback lives in its own leaf (no cycle: setup-learning → judge only).
 import { maybeUpgradeWithJudge } from "./setup-learning-judge.js";
-// SURFACE-04/05/06 skill promote/demote loop lives in its own leaf (no cycle: it imports
+// The skill promote/demote loop lives in its own leaf (no cycle: it imports
 // failureCorroborated from setup-learning-corroboration.ts, nothing from here).
 import { applySkillOutcomeTransitions } from "./setup-learning-skill-transitions.js";
 // Re-export for the existing importers (setup-learning.test.ts) — moved to the leaf
@@ -39,7 +40,7 @@ const DETERMINISTIC_CONFIDENCE = 0.9;
 /** Slightly lower confidence for a content/detector-classified (non-transport) tool failure. */
 const CLASSIFIED_FAILURE_CONFIDENCE = 0.8;
 /**
- * ATTR-02: confidence for a pure skill-attribution row (memory:skill_used → observe).
+ * Confidence for a pure skill-attribution row (memory:skill_used → observe).
  * LOW + paired with `outcome:"unknown"` so the row NEVER wins resolve() fusion — it
  * carries the `used_skill_ids` column only, asserting no outcome verdict.
  */
@@ -50,7 +51,7 @@ const ATTRIBUTION_CONFIDENCE = 0;
  * processed all carry agentId/traceId/sessionKey); ALS is the fallback (graph:completed
  * carries only graphId). Returns `undefined` when neither source yields an agentId AND a
  * trajectory identity (caller skips). Tenant defaults to "default" only when absent; the
- * agentId is NEVER collapsed across agents (cross-agent isolation, T-198-16).
+ * agentId is NEVER collapsed across agents (cross-agent isolation).
  */
 function resolveScope(payload) {
     const ctx = tryGetContext();
@@ -72,7 +73,7 @@ function resolveScope(payload) {
  * Persist one raw observation, fire-and-forget / non-fatal. NEVER throws out of
  * the bus handler. Counts/ids/closed-enums only ever reach the store.
  */
-function observeNonFatal(deps, scope, outcome, source, confidence, usedSkillIds, recalledIds) {
+function observeNonFatal(deps, scope, outcome, source, confidence, usedSkillIds, recalledIds, procedureDescriptor) {
     return deps.outcomeStore
         .observe({
         tenantId: scope.tenantId,
@@ -82,17 +83,23 @@ function observeNonFatal(deps, scope, outcome, source, confidence, usedSkillIds,
         outcome,
         source,
         confidence,
-        // ATTR-02: thread the per-turn used-skill ids onto observe() so the
+        // Thread the per-turn used-skill ids onto observe() so the
         // used_skill_ids COLUMN is written; resolve() union-dedups across rows. Omitted
-        // (the tool/pipeline paths) ⇒ the column stays NULL, byte-identical to pre-ATTR-02.
+        // (the tool/pipeline paths) ⇒ the column stays NULL — no behavior change for those paths.
         ...(usedSkillIds !== undefined && usedSkillIds.length > 0 ? { usedSkillIds: [...usedSkillIds] } : {}),
-        // OUTCOME-06 / RANK-01 (live 2026-06-18): thread the per-turn recalled+used memory
+        // Thread the per-turn recalled+used memory
         // ids onto observe() so the recalled_ids COLUMN is written; resolve() union-dedups
         // them onto `verdict.recalledIds`, which is what the outcome-gated reward seam keys
         // on (success→recordUsage, failure/corrected→recordFailure → failure_count). Omitted
-        // (tool/pipeline/skill paths) ⇒ NULL, byte-identical. Without this carrier the
-        // outcome-gated recall reward was DORMANT (recalledIds always empty).
+        // (tool/pipeline/skill paths) ⇒ NULL. Without this carrier the outcome-gated
+        // recall reward would be dormant (recalledIds always empty).
         ...(recalledIds !== undefined && recalledIds.length > 0 ? { recalledIds: [...recalledIds] } : {}),
+        // Thread the per-turn content-free tool-NAME descriptor onto observe() so the
+        // procedure_descriptor COLUMN is written (the orchestrate:run_summary carrier). Omitted
+        // (tool/pipeline/skill/recall paths) ⇒ the column stays NULL — no behavior change there.
+        ...(procedureDescriptor !== undefined && procedureDescriptor.length > 0
+            ? { procedureDescriptor: [...procedureDescriptor] }
+            : {}),
         observedAt: deps.clock.now(),
     })
         .then((r) => {
@@ -115,9 +122,9 @@ function observeNonFatal(deps, scope, outcome, source, confidence, usedSkillIds,
         }, "outcome observe threw (non-fatal)");
     });
 }
-// FORGET-03 corroboration gate (failureCorroborated + its constants) lives in
+// The failure-corroboration gate (failureCorroborated + its constants) lives in
 // ./setup-learning-corroboration.js (imported + re-exported above) — extracted to keep
-// this file under the 800-line cap; the gate logic is byte-identical.
+// this file under the 800-line cap; the gate logic is unchanged.
 /**
  * Run one usefulness-store reward/failure write, fire-and-forget / non-fatal.
  * NEVER throws out of the bus handler. `kind` tags the WARN so an operator sees
@@ -145,12 +152,12 @@ function recordNonFatal(deps, agentId, kind, run) {
         }, `outcome ${kind} write threw (non-fatal)`);
     });
 }
-// SURFACE-04/05/06: the learned-skill promote/demote loop (applySkillOutcomeTransitions
+// The learned-skill promote/demote loop (applySkillOutcomeTransitions
 // + runSkillTransition + skillGaugeKey + SkillOutcomeDeps) lives in the
 // setup-learning-skill-transitions.ts leaf (imported above) to keep this file under the
 // 800-line cap. It imports `failureCorroborated` from setup-learning-corroboration.ts
 // directly (no back-import here → no cycle).
-// OUTCOME-04: `maybeUpgradeWithJudge` (the unknown→judge upgrade) lives in the
+// `maybeUpgradeWithJudge` (the unknown→judge upgrade) lives in the
 // setup-learning-judge.ts leaf (imported above) to keep this file under the 800-line cap.
 /**
  * Stand up the observe/resolve subscriber on the daemon's bus. Fire-and-forget /
@@ -158,51 +165,53 @@ function recordNonFatal(deps, agentId, kind, run) {
  *
  * 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 function wireLearningOutcome(deps) {
     // Daemon-lifetime coverage gauge (resets on restart). Counts only.
     let total = 0;
     let resolved = 0;
-    // FORGET-03 corroboration tally: memoryId → the DISTINCT sessions that failed it
+    // Failure-corroboration tally: memoryId → the DISTINCT sessions that failed it
     // (within this subscriber's lifetime). A NON-deterministic failure accrues
     // `failure_count` only once this reaches ≥2 distinct sessions; a deterministic
     // failure (tool/pipeline) bypasses it. Mirrors the coverage gauge's in-process
     // counters (resets on restart) — counts/ids only, never bodies.
     const failureCorroborationTally = new Map();
-    // SURFACE-05: a SECOND, independent daemon-lifetime corroboration tally for the
+    // A SECOND, independent daemon-lifetime corroboration tally for the
     // learned-SKILL demote path (skillId → DISTINCT failing sessions). Kept separate
     // from the memory tally above so the two write paths never alias an id. Reuses the
     // SAME failureCorroborated() gate (≥2 distinct-session OR 1 deterministic).
     const skillFailureCorroborationTally = new Map();
-    // SURFACE-05: the in-process, daemon-lifetime decay-aware trend (the WHEN-to-demote
+    // The in-process, daemon-lifetime decay-aware trend (the WHEN-to-demote
     // decision). A corroborated failure demotes ONLY when the trend reaches WEAKENING —
-    // so a single induced failure on a well-reused procedure does NOT archive it. WR-05:
-    // its keys are scope-qualified (tenant+agent+name) by the caller (skillGaugeKey).
+    // so a single induced failure on a well-reused procedure does NOT archive it.
+    // Its keys are scope-qualified (tenant+agent+name) by the caller (skillGaugeKey).
     const skillTrend = createSkillTrendTracker();
-    // WR-01: the per-agent surface-cache refresh closure (looked up from the shared
+    // The per-agent surface-cache refresh closure (looked up from the shared
     // registry threaded via deps) — fired after a REAL promote/demote so the next
     // session sees the new active set. Undefined ⇒ no refresh (byte-identical).
     const refreshSurface = deps.refreshLearnedSkillSurface;
-    // CR (idempotency): the per-trajectory resolve-dedup set (see setup-learning-dedup.ts).
+    // Idempotency: the per-trajectory resolve-dedup set (see setup-learning-dedup.ts).
     const resolvedTrajectories = new Set();
     /**
-     * CR: the SHARED resolve→consume chain called by BOTH the `graph:completed` (DAG)
+     * The SHARED resolve→consume chain called by BOTH the `graph:completed` (DAG)
      * and `diagnostic:message_processed` (single-agent turn) handlers — factored out so
      * the reward/forget-accrual/skill-transition logic is NOT duplicated. Runs AT MOST
      * ONCE per trajectory ({@link markTrajectoryResolved}). The caller resolves the scope
-     * from its own source (graph: ALS; diagnostic: the payload, mirroring 199 CR-02) and,
-     * for the DAG path, observes the pipeline row FIRST. Non-fatal — never throws.
+     * from its own source (graph: ALS; diagnostic: the payload, which carries the ids
+     * because the emit happens outside the ALS context) and, for the DAG path, observes
+     * the pipeline row FIRST. Non-fatal — never throws.
      */
     function resolveAndConsume(scope, resolveStart) {
         // Dedup FIRST (synchronous check-and-mark before the async resolve) so a
@@ -221,7 +230,7 @@ export function wireLearningOutcome(deps) {
                 }, "outcome resolve failed (non-fatal)");
                 return;
             }
-            // OUTCOME-04: an `unknown` deterministic verdict (a CONVERSATIONAL turn with no
+            // An `unknown` deterministic verdict (a CONVERSATIONAL turn with no
             // tool/pipeline signal) gets ONE cheap-model judge pass as the fallback source;
             // a non-`unknown` verdict is returned unchanged (the judge never runs). The
             // dedup already ran at the top — this is the SAME chain (no second chain).
@@ -229,14 +238,14 @@ export function wireLearningOutcome(deps) {
             // Fail-closed coverage: an `unknown` verdict is NOT counted as resolved.
             if (verdict.outcome !== "unknown")
                 resolved += 1;
-            // ---- RANK-01 / FORGET-02 reward/failure write (the agent↛memory cut: the
+            // ---- Reward/failure write (the agent↛memory cut: the
             // daemon holds BOTH this verdict AND the usefulness adapter). intent OMITTED →
             // the global '' bucket; an `unknown` verdict writes NOTHING (fail-closed). ----
             let failureAccrued = 0;
             if (verdict.outcome === "success") {
                 if (deps.learningTuningEnabled(scope.agentId) && verdict.recalledIds.length > 0) {
                     const rewardScope = { tenantId: scope.tenantId, agentId: scope.agentId, now: deps.clock.now() };
-                    // IN-01: ONE batched reward write for ALL recalled ids (the store loops in
+                    // ONE batched reward write for ALL recalled ids (the store loops in
                     // one transaction); the FAILURE branch below stays per-id (gated per memory).
                     recordNonFatal(deps, scope.agentId, "reward", () => deps.usefulnessStore.recordUsage(verdict.recalledIds, [], rewardScope));
                 }
@@ -245,7 +254,7 @@ export function wireLearningOutcome(deps) {
                 if (deps.learningForgettingEnabled(scope.agentId)) {
                     const failScope = { tenantId: scope.tenantId, agentId: scope.agentId, now: deps.clock.now() };
                     for (const mid of verdict.recalledIds) {
-                        // FORGET-03 gate: accrue ONLY when corroborated (≥2 independent sessions
+                        // Corroboration gate: accrue ONLY when corroborated (≥2 independent sessions
                         // OR 1 deterministic source); past it the accrual is UNCONDITIONAL (no
                         // daemon-side proof/trust read — the eviction exemption is store-side).
                         if (failureCorroborated(mid, scope.sessionId, verdict.sources, failureCorroborationTally)) {
@@ -255,11 +264,11 @@ export function wireLearningOutcome(deps) {
                     }
                 }
             }
-            // ---- SURFACE-04/05/06 learned-SKILL promote/demote: iterate the ATTR-02
+            // ---- Learned-SKILL promote/demote: iterate the attributed
             // verdict.usedSkillIds — `success` PROMOTES each; a corroborated failure
             // DEMOTES only when the decay-aware trend reaches WEAKENING (anti-induced).
             // Gated default-OFF / no-store ⇒ byte-identical. AWAITS the store to read
-            // rows-changed so a 0-row write does NOT inflate the counters (CR-01). ----
+            // rows-changed so a 0-row write does NOT inflate the counters. ----
             if (deps.learnedSkillStore !== undefined &&
                 deps.learningSkillsEnabled?.(scope.agentId) === true) {
                 void applySkillOutcomeTransitions(deps, scope, verdict, {
@@ -283,7 +292,7 @@ export function wireLearningOutcome(deps) {
             // When corroborated failures accrued (failure_count++) this resolve, emit the
             // eviction-causation precursor (count only, bridged for comis explain) so "why did/didn't
             // this memory evict" has an event trail — not just a DB column that changes over time. The
-            // accrual is already FORGET-03 corroboration-gated above.
+            // accrual is already corroboration-gated above.
             if (failureAccrued > 0) {
                 deps.eventBus.emit("learning:memory_failure_attributed", {
                     agentId: scope.agentId,
@@ -291,7 +300,7 @@ export function wireLearningOutcome(deps) {
                     timestamp: deps.clock.now(),
                 });
             }
-            // OBS-01/02: one INFO completion line per resolve with durationMs + the
+            // One INFO completion line per resolve with durationMs + the
             // running coverage gauge + the corroborating `sources` (counts/ids only).
             deps.logger.info({
                 agentId: scope.agentId,
@@ -302,7 +311,7 @@ export function wireLearningOutcome(deps) {
                 totalCount: total,
                 durationMs: deps.clock.now() - resolveStart,
             }, "Outcome resolved for trajectory");
-            // OBS-01 DEBUG: the corroboration outcome (counts only) so the gate decision is
+            // DEBUG: the corroboration outcome (counts only) so the gate decision is
             // reconstructable — recalled vs accrued. Never alpha values / memory bodies.
             deps.logger.debug({
                 agentId: scope.agentId,
@@ -321,7 +330,7 @@ export function wireLearningOutcome(deps) {
             }, "outcome resolve threw (non-fatal)");
         });
     }
-    // ---- Deterministic tool signal (the only source that ships ACTIVE, OUTCOME-03) ----
+    // ---- Deterministic tool signal (the only source that ships ACTIVE) ----
     deps.eventBus.on("tool:executed", (p) => {
         // Byte-identity short-circuit (default OFF) — observe NOTHING.
         const agentId = p.agentId ?? tryGetContext()?.agentId;
@@ -340,8 +349,8 @@ export function wireLearningOutcome(deps) {
             : DETERMINISTIC_CONFIDENCE;
         void observeNonFatal(deps, scope, outcome, "tool", confidence);
     });
-    // ---- ATTR-02 skill-use attribution write-back (the loop-close, Plan 07) ----
-    // The agent emits `memory:skill_used` (Plan 03) after a turn whose `read` matched a
+    // ---- Skill-use attribution write-back ----
+    // The agent emits `memory:skill_used` after a turn whose `read` matched a
     // frozen learned-skill `<location>` — the per-turn used-skill ids (counts/ids only,
     // the memory:recall_used precedent). The daemon is the ONLY place holding BOTH the
     // bus AND the @comis/memory store (the agent↛memory cut), so the daemon does the
@@ -366,13 +375,13 @@ export function wireLearningOutcome(deps) {
         // (resolve() fuses the real tool/pipeline outcome; this row only carries ids).
         void observeNonFatal(deps, scope, "unknown", "explicit", ATTRIBUTION_CONFIDENCE, p.usedSkillIds);
     });
-    // ---- OUTCOME-06 / RANK-01 recall-use attribution write-back (live 2026-06-18) ----
+    // ---- Recall-use attribution write-back ----
     // The executor emits `memory:recall_used` after a turn (executor-post-execution.ts) with
     // the recalled+used memory ids. wireMemoryUsefulness consumes it for the CORROBORATING
-    // usage feed (used_count) — but nothing wrote those ids onto the OUTCOME ledger, so
-    // `verdict.recalledIds` was ALWAYS empty and the PRIMARY outcome-gated reward seam
-    // (resolve → success:recordUsage / failure:recordFailure→failure_count) was DORMANT.
-    // Mirror the ATTR-02 skill-use carrier: a neutral `explicit`/`unknown` row (NEVER wins
+    // usage feed (used_count) — but without this handler nothing writes those ids onto the
+    // OUTCOME ledger, so `verdict.recalledIds` stays empty and the PRIMARY outcome-gated
+    // reward seam (resolve → success:recordUsage / failure:recordFailure→failure_count) is
+    // dormant. Mirror the skill-use carrier: a neutral `explicit`/`unknown` row (NEVER wins
     // resolve() fusion — the deterministic tool/pipeline rows outrank it) that carries the
     // recalled ids so the recalled_ids COLUMN is written and resolve() union-dedups them.
     // Default-OFF via `learningOutcomeEnabled` (byte-identical when off); a non-empty
@@ -388,9 +397,33 @@ export function wireLearningOutcome(deps) {
             return;
         void observeNonFatal(deps, scope, "unknown", "explicit", ATTRIBUTION_CONFIDENCE, undefined, p.usedIds);
     });
-    // NB: `graph:driver_lifecycle` is intentionally NOT subscribed (WR-02) — it is
+    // ---- Procedure-descriptor attribution write-back ----
+    // The orchestrate tool emits `orchestrate:run_summary` at run completion, SYNCHRONOUSLY
+    // within the turn's ALS scope. It has NO other daemon-side ledger consumer (it is otherwise
+    // only bridged to the trajectory), so this is a NEW carrier: a neutral `explicit`/`unknown`
+    // row that threads the content-free `toolSequence` (the pre-flight tool-NAME footprint) onto
+    // the `procedure_descriptor` COLUMN, keyed on the turn traceId. The `unknown` outcome + low
+    // confidence means it NEVER wins resolve() fusion (the deterministic tool/pipeline rows
+    // outrank it) — a pure attribution carrier; the descriptor rides the column for the reflection
+    // input to read back. The payload carries NO agentId, so it resolves from the live ALS
+    // (`tryGetContext()`) — valid because the emit is synchronous within the turn's async context.
+    // Default-OFF via `learningOutcomeEnabled` (byte-identical when off); an empty toolSequence
+    // writes no row (mirrors the skill_used length===0 guard). Content-free (§2.7): only the
+    // tool-NAME set + correlators cross the bus — no body/args.
+    deps.eventBus.on("orchestrate:run_summary", (p) => {
+        const agentId = tryGetContext()?.agentId;
+        if (agentId === undefined || !deps.learningOutcomeEnabled(agentId))
+            return;
+        if (!p.toolSequence || p.toolSequence.length === 0)
+            return; // no descriptor → no carrier row
+        const scope = resolveScope({ agentId, traceId: p.traceId, sessionKey: p.sessionKey });
+        if (scope === undefined)
+            return;
+        void observeNonFatal(deps, scope, "unknown", "explicit", ATTRIBUTION_CONFIDENCE, undefined, undefined, p.toolSequence);
+    });
+    // NB: `graph:driver_lifecycle` is intentionally NOT subscribed — it is
     // PER NODE, so observing it floods the ledger with O(nodes) `pipeline` rows and
-    // amplifies the WR-01 fusion non-determinism. `graph:completed` is the SINGLE
+    // makes the resolve() fusion order-dependent. `graph:completed` is the SINGLE
     // trajectory-level pipeline signal.
     // ---- DAG pipeline signal: observe the pipeline row FIRST (visible to the resolve),
     // then the SHARED resolve→consume chain. graph:completed fires ONLY for DAG runs. ----
@@ -408,13 +441,13 @@ export function wireLearningOutcome(deps) {
         const resolveStart = deps.clock.now();
         void observeNonFatal(deps, scope, outcome, "pipeline", DETERMINISTIC_CONFIDENCE).then(() => resolveAndConsume(scope, resolveStart));
     });
-    // ---- CR: single-agent turn completion → resolve via the per-turn PAYLOAD ----
-    // graph:completed fires ONLY for DAG runs, so a single-agent turn never resolved —
-    // its tool:executed + memory:skill_used rows (keyed on traceId) went unresolved.
-    // diagnostic:message_processed fires once per turn for single-agent turns too
-    // (execution-pipeline.ts) and carries agentId/sessionKey/traceId on its PAYLOAD — so
-    // resolve keys off the payload NOT the ALS (the emit is outside runWithContext;
-    // mirrors 199 CR-02). The trajectoryId is the payload traceId = the SAME key the
+    // ---- Single-agent turn completion → resolve via the per-turn PAYLOAD ----
+    // graph:completed fires ONLY for DAG runs, so without this handler a single-agent turn
+    // never resolves — its tool:executed + memory:skill_used rows (keyed on traceId) go
+    // unresolved. diagnostic:message_processed fires once per turn for single-agent turns
+    // too (execution-pipeline.ts) and carries agentId/sessionKey/traceId on its PAYLOAD — so
+    // resolve keys off the payload NOT the ALS (the emit is outside runWithContext).
+    // The trajectoryId is the payload traceId = the SAME key the
     // tool/skill observe() wrote, so resolve finds the rows. NO pipeline observe; an
     // absent traceId → skip (fail-closed); the dedup makes a both-events DAG turn resolve once.
     deps.eventBus.on("diagnostic:message_processed", (p) => {
@@ -425,15 +458,14 @@ export function wireLearningOutcome(deps) {
             return; // no trajectory identity (absent traceId) → skip
         resolveAndConsume(scope, deps.clock.now());
     });
-    // ---- SURFACE-ADMIT (live-2026-06-18): refresh the per-agent surface the MOMENT a
+    // ---- Refresh the per-agent surface the MOMENT a
     // reflection run ADMITS a doc. Without this a freshly-admitted candidate stays invisible
     // until the next daemon boot — and promotion is USE-gated (the agent must SEE the skill to
     // use it), so the post-promote/demote refresh can NEVER fire: a second-order deadlock that
     // leaves a learned skill permanently dormant on a long-running daemon. `reflect:admitted.count`
-    // IS the admitted count (events-learning.ts emits v.admitted; RENAMED from
-    // learning:skill_synthesized in Phase 226). NOT gated by learningOutcomeEnabled (this is a
-    // SKILLS signal); refreshSurface is undefined when no registry is wired ⇒ byte-identical no-op.
-    // Mirrors the post-promote/demote refresh. ----
+    // IS the admitted count (events-learning.ts emits v.admitted). NOT gated by
+    // learningOutcomeEnabled (this is a SKILLS signal); refreshSurface is undefined when no
+    // registry is wired ⇒ byte-identical no-op. Mirrors the post-promote/demote refresh. ----
     deps.eventBus.on("reflect:admitted", (p) => {
         if (p.count > 0)
             refreshSurface?.(p.agentId);
@@ -460,7 +492,7 @@ export function wireLearningOutcome(deps) {
             // One INFO line per correction that credits ≥1 skill — the re-resolve is OTHERWISE silent until
             // the 3rd corroborated correction actually demotes (anti-flap), so a single real correction
             // couldn't be confirmed live. Counts/ids only — the skill COUNT, never the procedure body/id-list
-            // (the §2.7 / SEC-01 firewall). Rare + load-bearing (a user correction feeding the demote gate is
+            // (memory bodies never reach the logs). Rare + load-bearing (a user correction feeding the demote gate is
             // the acute signal), so INFO (not DEBUG) — diagnosability must not depend on logLevel:debug having
             // been set before the incident.
             deps.logger.info({
@@ -496,14 +528,12 @@ export function wireLearningOutcome(deps) {
  * 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 function setupLearningOutcomeWiring(deps) {
     // Master cost kill-switch: read defensively (`!== false`) so an absent block
@@ -512,10 +542,9 @@ export function setupLearningOutcomeWiring(deps) {
     // Hoist the typed agents map once (mirrors setup-schedulers.ts:107) so the per-agent
     // lookup is a bracket access on a known Record (not a dynamic optional-chain sink).
     const agents = deps.config.agents ?? {};
-    // M-1 (Phase 226): the single collapsed learning gate. The four reward/promote WRITES that
-    // were independently gated (each default-ON behind costFeatures) now share this one flag
-    // (default-ON `learning.enabled` under default-ON `memory.enabled`) — net enablement matches
-    // the prior opt-out posture; the per-feature split is gone by design (D-01).
+    // The single collapsed learning gate: the four reward/promote WRITES all share this
+    // one flag (`learning.enabled` under default-ON `memory.enabled`) — the per-feature
+    // split is deliberately absent.
     const learningEnabled = (agentId) => costFeaturesEnabled && agents[agentId]?.learning?.enabled === true;
     wireLearningOutcome({
         eventBus: deps.eventBus,
@@ -524,19 +553,19 @@ export function setupLearningOutcomeWiring(deps) {
         learnedSkillStore: deps.learnedSkillStore,
         clock: deps.clock,
         logger: deps.logger,
-        learningOutcomeEnabled: learningEnabled, // the observe/resolve/emit subscriber (Phase 198)
-        learningTuningEnabled: learningEnabled, // RANK-01 SUCCESS→reward write — STAYS wired
-        learningForgettingEnabled: learningEnabled, // FORGET-02 FAILURE→failure_count accrual — STAYS wired
-        // SURFACE-04/05: the learned-skill promote/demote gate — STAYS wired behind the one flag +
-        // the per-agent promote threshold now reads learning.reflect.promoteAtProofCount.
+        learningOutcomeEnabled: learningEnabled, // the observe/resolve/emit subscriber
+        learningTuningEnabled: learningEnabled, // SUCCESS→reward write
+        learningForgettingEnabled: learningEnabled, // FAILURE→failure_count accrual
+        // The learned-skill promote/demote gate — behind the one flag; the per-agent
+        // promote threshold reads learning.reflect.promoteAtProofCount.
         learningSkillsEnabled: learningEnabled,
         learningSkillsPromoteAt: (agentId) => agents[agentId]?.learning?.reflect?.promoteAtProofCount ?? 3,
-        // WR-01: route a post-transition re-refresh to the agent's surface cache (a no-op
+        // Route a post-transition re-refresh to the agent's surface cache (a no-op
         // for an unregistered/default-off agent). Undefined registry ⇒ undefined closure.
         refreshLearnedSkillSurface: deps.learnedSkillSurfaceRegistry
             ? (agentId) => deps.learnedSkillSurfaceRegistry.refresh(agentId)
             : undefined,
-        // OUTCOME-04: the conversational-breadth LLM-judge fallback (built in setup-memory via
+        // The conversational-breadth LLM-judge fallback (built in setup-memory via
         // buildOutcomeJudgeWiring). Absent ⇒ the upgrade path is never entered (byte-identical).
         outcomeJudge: deps.outcomeJudge,
         learningOutcomeJudgeEnabled: deps.learningOutcomeJudgeEnabled,

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

@@ -37,7 +37,7 @@ export function setupLogging(deps) {
             maxFiles: container.config.observability.logRotation.maxFiles,
         }
         : undefined;
-    // B (obs-sweep): the structured-log filePath must track the RESOLVED data dir. The schema
+    // The structured-log filePath must track the RESOLVED data dir. The schema
     // default (`~/.comis/logs/daemon.log`, schema-daemon.ts) is hardcoded to the DEFAULT home and
     // does NOT honor a custom COMIS_DATA_DIR / config.dataDir — and the root `daemon` field is
     // ALWAYS schema-defaulted (schema.ts), so `daemon.logging` is never undefined and that default

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

@@ -49,7 +49,7 @@ export interface MediaResult {
     ssrfFetcher: SsrfGuardedFetcher;
     /** File extractor for document attachment processing (optional -- disabled by config). */
     fileExtractor?: FileExtractionPort;
-    /** OBS-03 (196): the boot-resolved STT/TTS selections (`source`/`keyless`/
+    /** The boot-resolved STT/TTS selections (`source`/`keyless`/
      *  `provider` + the `onSkip` reasons), threaded to the daemon RPC handlers for
      *  the `media.stt.*`/`media.tts.*` trajectory emit. Present only when the audio
      *  selector ran AND resolved (`sel.ok`); undefined otherwise. */
@@ -66,7 +66,7 @@ export interface MediaResult {
  * `dataDir` is a stable boot value (`container.config.dataDir`) captured once and
  * threaded into the in-process `local` adapter's model-cache root on every
  * re-creation — the per-call wrapper rebuilds the adapter but the cache scope is
- * fixed at boot (Plan 02 LOCAL-01).
+ * fixed at boot.
  */
 export declare function createSTTProviderFactory(config: TranscriptionConfig, secretManager: SecretManager, dataDir: string): () => ReturnType<typeof createSTTProvider>;
 /**
@@ -77,7 +77,7 @@ export declare function createSTTProviderFactory(config: TranscriptionConfig, se
  * `dataDir` is a stable boot value (`container.config.dataDir`) captured once and
  * threaded into the in-process `local`/`piper` adapter's model-cache root
  * (`<dataDir>/models/tts/`) on every re-creation — mirrors
- * `createSTTProviderFactory` (TTS-02).
+ * `createSTTProviderFactory`.
  */
 export declare function createTTSProviderFactory(config: TtsConfig, secretManager: SecretManager, dataDir: string): () => ReturnType<typeof createTTSProvider>;
 /**
@@ -104,13 +104,13 @@ export declare function setupMedia(deps: {
     /** Optional callback for suspicious content detection */
     onSuspiciousContent?: WrapExternalContentOptions["onSuspiciousContent"];
     /**
-     * The keyless-first audio selector (Phase 193, built in the daemon via
+     * The keyless-first audio selector (built in the daemon via
      * `createAudioProviderSelector`). When present, STT/TTS construction is GATED
      * on `resolveStt()`/`resolveTts()` BEFORE `createSTTProvider`/`createTTSProvider`
      * — an honest-unavailable resolution (`sel.ok===false`) constructs NO adapter
      * (so a Codex/OAuth-only main never builds the empty-bearer OpenAI adapter →
-     * 401; the inbound path skip-don't-throws). Absent (test harnesses) → the
-     * pre-193 behavior (construct directly from config).
+     * 401; the inbound path skip-don't-throws). Absent (test harnesses) →
+     * construct directly from config.
      */
     audioSelector?: ReturnType<typeof createAudioProviderSelector>;
 }): Promise<MediaResult>;