comisai 1.0.45 → 1.0.46

package/node_modules/@comis/agent/dist/executor/prompt-assembly.js

@@ -29,14 +29,14 @@ import { resolveScaffoldDefaults } from "./scaffold-defaults.js";
 import { economiseForReadOnlyChild } from "../spawn/child-prompt-economy.js";
 import * as os from "node:os";
 // ---------------------------------------------------------------------------
-// C2/S1: Prompt mode resolution for ModelProfile
+// Prompt mode resolution for ModelProfile
 // ---------------------------------------------------------------------------
 /**
  * Resolve the effective PromptMode for a given execution context.
  *
  * Priority (highest to lowest):
- * 1. Compact-secure for small/nano capabilityClass (C2/S1) — wins even for
- *    cron/heartbeat turns (WR-03: security holds independent of model + operation).
+ * 1. Compact-secure for small/nano capabilityClass — wins even for
+ *    cron/heartbeat turns (security holds independent of model + operation).
  * 2. Cron/heartbeat auto-upgrade: "full" → "operational" (frontier/mid + no-profile).
  * 3. baseMode (operator-explicit or "full" default).
  *
@@ -45,24 +45,24 @@ import * as os from "node:os";
  *   - profile.capabilityClass is "small" or "nano"
  *   - baseMode is "full" (respect explicit operator overrides)
  *
- * WR-03: the compact-secure check is evaluated BEFORE the cron/heartbeat →
- * operational downgrade. The milestone's premise is "weaker class ⇒ stricter
- * securityLevel", and compact-secure carries the S1 anti-injection sender-trust
+ * The compact-secure check is evaluated BEFORE the cron/heartbeat →
+ * operational downgrade. The design premise is "weaker class ⇒ stricter
+ * securityLevel", and compact-secure carries the anti-injection sender-trust
  * hardening. A cron/heartbeat turn on a small/nano model must NOT silently lose
  * that hardening — it gets compact-secure, not operational. The operational
  * downgrade is reserved for frontier/mid (and no-profile) cron/heartbeat turns,
  * which never enter compact-secure anyway.
  *
  * Frontier/mid: never compact-secure. This is the behavior-neutral guarantee
- * for large-tier models — their prompt stays byte-identical to pre-152 output.
+ * for large-tier models — their prompt is unaffected by this mode selection.
  *
  * @internal exported for tests only
  */
 export function resolvePromptModeForProfile(baseMode, operationType, profile, compactPromptConfig) {
     // compact-secure: only for small/nano with config flag enabled (default: true).
-    // NEVER for frontier/mid — behavior-neutral guarantee (T-152-05). Evaluated
-    // FIRST so a cron/heartbeat turn on a weak model keeps the S1 hardening (WR-03)
-    // instead of being downgraded to "operational".
+    // NEVER for frontier/mid — behavior-neutral guarantee. Evaluated
+    // FIRST so a cron/heartbeat turn on a weak model keeps the sender-trust
+    // hardening instead of being downgraded to "operational".
     if ((compactPromptConfig?.enabled ?? true) &&
         profile !== undefined &&
         (profile.capabilityClass === "small" || profile.capabilityClass === "nano") &&
@@ -121,7 +121,7 @@ const sessionCacheSafeParams = new Map();
 const sessionPromptSkillsXmlSnapshots = new Map();
 /** Per-session location→skillName index, parsed once from the frozen prompt
  *  skills XML snapshot at the same freeze point as
- *  `sessionPromptSkillsXmlSnapshots`. ATTR-01 (skill-use attribution): the
+ *  `sessionPromptSkillsXmlSnapshots`. Skill-use attribution: the
  *  pi-event-bridge consults this index to map a `read` tool's path back to the
  *  skill the model invoked. Empty when no visible skills are listed (the
  *  default until learned skills exist), so the attribution path is a no-op. */
@@ -129,8 +129,8 @@ const sessionPromptSkillLocations = new Map();
 /** Reuse-attribution carrier: per-session, per-TURN set of the learned-skill NAMES whose stored
  *  common-core (topicTokens) the CURRENT turn instantiates (`topicMatchedSkillNames`). The
  *  pi-event-bridge UNIONS these into the turn's `usedSkillIds`, so a skill APPLIED from the surfaced
- *  `<available_skills>` summary / recall — without an explicit `read` of its SKILL.md (the ATTR-01
- *  path) — still promotes on success. Overwritten every prompt assembly (the same per-turn lifecycle
+ *  `<available_skills>` summary / recall — without an explicit `read` of its SKILL.md (the
+ *  read-attribution path) — still promotes on success. Overwritten every prompt assembly (the same per-turn lifecycle
  *  as the XML/location snapshots). Empty/no-match ⇒ the no-op default. */
 const sessionPromptTopicMatchedSkills = new Map();
 /** Read the per-turn topic-matched learned-skill names for a session. The pi-event-bridge
@@ -164,7 +164,7 @@ export function clearSessionPromptMemoryInjected(snapshotKey) {
  * each carrying `<name>`, `<description>`, `<location>`) into a
  * `location → skillName` Map. The location is the raw absolute path the `read`
  * tool reports, so XML entities are unescaped (the inverse of `escapeXml`) to
- * make the keys/values match raw text. ATTR-01.
+ * make the keys/values match raw text.
  *
  * Pure + total: never throws. `undefined`/empty/no-`<skill>` input yields an
  * empty Map. A `<skill>` block missing either `<name>` or `<location>` is
@@ -208,7 +208,7 @@ function unescapeXml(str) {
 }
 /**
  * Read the frozen location→skillName index for a session. The pi-event-bridge
- * calls this on a `read` tool execution to attribute skill use (ATTR-01).
+ * calls this on a `read` tool execution to attribute skill use.
  * Returns undefined when no snapshot has been frozen for the session yet.
  *
  * @param snapshotKey - The formatted session key used at the freeze point.
@@ -216,10 +216,10 @@ function unescapeXml(str) {
 export function getSessionPromptSkillLocations(snapshotKey) {
     return sessionPromptSkillLocations.get(snapshotKey);
 }
-/** Per-agent dedup for the WR-02 "S1: sender-trust not injected in compact-secure"
+/** Per-agent dedup for the "S1: sender-trust not injected in compact-secure"
  *  WARN. The trigger (compact-secure promptMode + senderTrustDisplayConfig disabled)
  *  is STATIC per agent, so emitting it once-per-prompt-assembly spams the log on every
- *  turn (live finding, 2026-06-12 UC-4 run: 9× in a 9-turn small-model session). The
+ *  turn (observed live: 9× in a 9-turn small-model session). The
  *  operator signal is preserved once per agent; the per-turn repetition is dropped. */
 const wr02SenderTrustWarnedAgents = new Set();
 // ---------------------------------------------------------------------------
@@ -266,11 +266,11 @@ export function clearSessionBootstrapFileSnapshot(sessionKey) {
  */
 export function clearSessionPromptSkillsXmlSnapshot(sessionKey) {
     sessionPromptSkillsXmlSnapshots.delete(sessionKey);
-    // ATTR-01: clear the parsed location index in lockstep with the XML snapshot.
+    // Clear the parsed location index in lockstep with the XML snapshot.
     sessionPromptSkillLocations.delete(sessionKey);
 }
 /**
- * Reset the per-agent WR-02 sender-trust WARN dedup. Test-only seam (mirrors
+ * Reset the per-agent sender-trust WARN dedup. Test-only seam (mirrors
  * the clearSession* snapshot resets) so suites don't leak the once-per-agent
  * state across cases.
  */
@@ -429,16 +429,16 @@ export async function assembleExecutionPrompt(params) {
     // of the explicit msg.metadata.lightContext flag. Callers that only set the
     // metadata flag OR only set operationType="heartbeat" produce identical
     // prompt output. Hoisted above the parent-cache reuse branch so BOTH paths
-    // share the same bootstrap filter dispatch (WR-01).
+    // share the same bootstrap filter dispatch.
     const effectiveLightContext = msg.metadata?.lightContext === true || params.operationType === "heartbeat";
-    // SD6 (Phase 159): capability-gated bootstrap.maxChars.
+    // Capability-gated bootstrap.maxChars.
     // resolveScaffoldDefaults handles the === 20_000 sentinel check internally.
     // Fail-closed: absent modelProfile → FAIL_CLOSED_PROFILE (nano) → 3_500 (conservative).
     const { bootstrapMaxChars, bootstrapTotalMaxChars } = resolveScaffoldDefaults(params.modelProfile ?? FAIL_CLOSED_PROFILE, config);
     // Snapshot-aware bootstrap load + per-turn filter dispatch + char-budget
     // build. Shared by the full-assembly path AND the parent-cache reuse path so
-    // the reuse path can resolve DET-02 tier-2 (USER.md preferred language)
-    // without drifting from the full path's filtering (WR-01). The session
+    // the reuse path can resolve reply-language tier-2 (USER.md preferred language)
+    // without drifting from the full path's filtering. The session
     // snapshot keeps loadWorkspaceBootstrapFiles to once per session and keeps the
     // system-prompt prefix stable across turns.
     async function resolveBootstrapContextFiles(mode) {
@@ -522,12 +522,12 @@ export async function assembleExecutionPrompt(params) {
         if (promptSkillsXml) {
             dynamicPreambleParts.push(`## Available Skills\n${promptSkillsXml}`);
         }
-        // WR-06 (ATTR-01): this reuse path re-emits the `## Available Skills` block
+        // This reuse path re-emits the `## Available Skills` block
         // (a learned-skill <location> can be visible to the model), so it MUST also
         // populate the location→skillName index the bridge reads — otherwise
         // getSessionPromptSkillLocations() returns undefined and skill-use
-        // attribution silently no-ops for the DOMINANT cache-reuse (sub-agent) path
-        // (the precise seam-mismatch class that bit Phase 200). The full-assembly
+        // attribution silently no-ops for the DOMINANT cache-reuse (sub-agent)
+        // path. The full-assembly
         // path freezes this in lockstep with its XML snapshot (see the
         // sessionPromptSkillLocations.set below); here we key on the same
         // formatSessionKey(sessionKey) and freeze once (don't clobber an index a
@@ -555,12 +555,12 @@ export async function assembleExecutionPrompt(params) {
                 workspaceDir: deps.spawnPacket.workspaceDir,
                 parentSummary: deps.spawnPacket.parentSummary,
                 agentWorkspaces: deps.spawnPacket.agentWorkspaces,
-                // GEN-03 (CR-01): the inherited conversation language was dropped on
-                // this cache-reuse path — the DOMINANT runtime path for same-model
-                // sub-agents — so a he/ar/ru sub-agent produced English output. Thread
+                // The inherited conversation language must not be dropped on this
+                // cache-reuse path — the DOMINANT runtime path for same-model
+                // sub-agents — or a he/ar/ru sub-agent produces English output. Thread
                 // it so both role-section call sites are symmetric. en/undefined emits
                 // nothing (buildSubagentRoleSection guards on `language && !== "en"`),
-                // so the en path stays byte-identical (I1).
+                // so the en path stays byte-identical.
                 language: deps.spawnPacket.language,
             });
             if (roleLines.length > 0)
@@ -601,10 +601,10 @@ export async function assembleExecutionPrompt(params) {
         }
         const dynamicPreamble = dynamicPreambleParts.join("\n\n");
         logger.info({ agentId, parentModel: parentCache.model, parentProvider: parentCache.provider }, "Using parent cache prefix (model/provider match)");
-        // WR-01: resolve DET-02 tier-2 (USER.md preferred language) on the reuse
-        // path too. Pre-fix this hardcoded `undefined`, so a sub-agent that took the
-        // (dominant) cache-reuse path resolved its degraded reply WITHOUT tier-2 —
-        // silently falling through to tier-3 (inbound script). Compute promptMode
+        // Resolve reply-language tier-2 (USER.md preferred language) on the reuse
+        // path too. If this were a hardcoded `undefined`, a sub-agent that took the
+        // (dominant) cache-reuse path would resolve its degraded reply WITHOUT tier-2
+        // — silently falling through to tier-3 (inbound script). Compute promptMode
         // (the same pure resolution as the full path) and load USER.md via the
         // shared snapshot-aware helper so the filtering (incl. group-chat USER.md
         // stripping) matches the full path. The system prompt itself is still the
@@ -613,7 +613,7 @@ export async function assembleExecutionPrompt(params) {
         const reusePromptMode = resolvePromptModeForProfile(reuseBaseMode, params.operationType, params.modelProfile, config.contextEngine?.compactPrompt);
         const { bootstrapContextFiles: reuseBootstrapFiles } = await resolveBootstrapContextFiles(reusePromptMode);
         const reuseUserLanguage = extractUserLanguage(reuseBootstrapFiles);
-        // STRIP-01/02 (cache-reuse path): the reused prefix is the PARENT's full
+        // Read-only-child input economy (cache-reuse path): the reused prefix is the PARENT's full
         // frozen prompt, so a read-only child drops the heavy blocks here too (else
         // the dominant same-model sub-agent path leaks the full inherited context).
         const reuseEconomised = deps.spawnPacket
@@ -627,15 +627,15 @@ export async function assembleExecutionPrompt(params) {
     // An explicit `config.bootstrap?.promptMode` wins for all modes including "minimal"/"none".
     const baseMode = config.bootstrap?.promptMode ?? "full";
     const promptMode = resolvePromptModeForProfile(baseMode, params.operationType, params.modelProfile, config.contextEngine?.compactPrompt);
-    // WR-02: warn when compact-secure is active but senderTrustDisplayConfig is disabled.
+    // Warn when compact-secure is active but senderTrustDisplayConfig is disabled.
     // The sender-trust section wiring is correct (MODES_FULL_MIN_COMPACT includes it), but
     // the data it receives is always an empty array when the feature is not configured —
     // producing a structurally-satisfied but content-empty section. Operators should
     // configure senderTrustDisplayConfig to get meaningful anti-injection trust display.
-    // WR-02 trigger is STATIC per agent (capabilityClass-derived promptMode +
+    // The trigger is STATIC per agent (capabilityClass-derived promptMode +
     // per-agent senderTrustDisplayConfig), so warn ONCE per agent — not per
-    // prompt assembly — to keep the log readable (the per-turn repetition was
-    // pure noise: 9× in a 9-turn small-model session, 2026-06-12 UC-4 run).
+    // prompt assembly — to keep the log readable (per-turn repetition would fire
+    // on every turn of a small-model session, which is pure noise).
     if (promptMode === "compact-secure" && !deps.senderTrustDisplayConfig?.enabled) {
         const wr02Key = agentId ?? config.name;
         if (!wr02SenderTrustWarnedAgents.has(wr02Key)) {
@@ -651,13 +651,13 @@ export async function assembleExecutionPrompt(params) {
     // snapshot-aware helper. `bootstrapFilesForReport` tracks the raw post-filter
     // shape so the SystemPromptReport can populate injectedWorkspaceFiles[] with
     // missing/truncated/rawChars/injectedChars accounting. The same helper feeds
-    // the parent-cache reuse path's tier-2 resolution (WR-01), so the filter
+    // the parent-cache reuse path's tier-2 language resolution, so the filter
     // dispatch can never drift between the two paths.
     const { bootstrapContextFiles, bootstrapFilesForReport } = await resolveBootstrapContextFiles(promptMode);
     // 3. RAG recall via createMemoryRecall + hybrid memory injector (non-fatal).
-    // `memorySections` = prompt content (retrieved sections + §7.3 guidance block when
-    // present); the `retrieved*` accumulators are telemetry truth — retrieved memory
-    // only, excluding the fixed guidance block.
+    // `memorySections` = prompt content (retrieved sections + the temporal-guidance
+    // block when present); the `retrieved*` accumulators are telemetry truth —
+    // retrieved memory only, excluding the fixed guidance block.
     let memorySections = [];
     let inlineMemory;
     // id + content of the recalled memories, surfaced on the result so the
@@ -692,8 +692,8 @@ export async function assembleExecutionPrompt(params) {
             // `scoring` below) — there is NO alpha on `feedback`.
             const ragFeedback = config.rag
                 .feedback;
-            // Recall scoring is the FIXED config.rag.scoring alphas (Phase 224, RECALL-02/03):
-            // the UCB online-tuning bandit + its per-intent tuned-alpha overlay are deleted, so
+            // Recall scoring is the FIXED config.rag.scoring alphas: there is no
+            // online-tuning bandit or per-intent tuned-alpha overlay, so
             // there is no learned-weight read on the recall hot path — ranking is fused RRF + the
             // cross-encoder reranker over the config-sourced alphas only. Deterministic + LLM-free.
             const recall = createMemoryRecall({
@@ -705,15 +705,15 @@ export async function assembleExecutionPrompt(params) {
                 tripleStore: deps.tripleStore,
                 embeddingStore: deps.embeddingStore,
                 usefulnessStore: deps.usefulnessStore,
-                // R6: wire the pinned-first lane store so Step 0 of the recall pipeline
+                // Wire the pinned-first lane store so Step 0 of the recall pipeline
                 // (`if (cfg_pinned?.enabled === true && deps.pinnedStore !== undefined)`) can fire
                 // at runtime. The same `memoryAdapter` already passed as `memoryPort` implements
                 // `MemoryPinnedStore`; the daemon composition root threads it here through
                 // PiExecutorDeps.pinnedStore → PromptAssemblyParams.deps.pinnedStore. Default-OFF
                 // byte-identity: with `rag.pinned.enabled=false` (the default) no query runs.
                 ...(deps.pinnedStore !== undefined ? { pinnedStore: deps.pinnedStore } : {}),
-                // DIST-03 (Phase 173, the C1→C2 carry-in): thread the provenance read
-                // store so createMemoryRecall's post-fusion down-weighting pass can fire
+                // Thread the provenance read store so createMemoryRecall's
+                // post-fusion down-weighting pass can fire
                 // live. The daemon composition root threads it here through
                 // PiExecutorDeps.provenanceStore → PromptAssemblyParams.deps.provenanceStore.
                 // DEFAULT-OFF byte-identity: absent OR no lcd_distilled result → no read.
@@ -728,7 +728,7 @@ export async function assembleExecutionPrompt(params) {
                 minScore: config.rag.minScore,
                 includeTrustLevels: config.rag.includeTrustLevels,
                 rerank: config.rag.rerank,
-                // Fixed config-sourced scoring alphas — no learned overlay (Phase 224, RECALL-02/03).
+                // Fixed config-sourced scoring alphas — no learned overlay.
                 scoring: config.rag.scoring,
                 lanes: config.rag.lanes,
                 entityLane: config.rag.entityLane,
@@ -745,26 +745,25 @@ export async function assembleExecutionPrompt(params) {
                 // score.ts forces forgetFactor to exactly 1.0 ⇒ byte-identical recall until an
                 // operator opts in (rag.forget.enabled); the neutral byte-identity holds even when on.
                 forget: config.rag.forget,
-                // R6: forward the pinned-memory injection config so Step 0 knows the cap.
+                // Forward the pinned-memory injection config so Step 0 knows the cap.
                 // A fully-defaulted RagConfig field (same posture as mmr/forget), so it passes DIRECTLY.
                 // Default-OFF (`enabled:false`) ⇒ the pinned lane is skipped (byte-identical).
                 pinned: config.rag.pinned,
-                // R3: forward the base-score floor gate.
-                // SD2 (Phase 158): capability-gated baseFloor.
+                // Forward the base-score floor gate — capability-gated baseFloor.
                 // Resolved: explicit config.rag.baseFloor (>0) wins; for small/nano with
                 // baseFloor===0 (schema default/"unset"), applies SMALL_NANO_DEFAULT_BASE_FLOOR=0.15.
                 // frontier/mid with no config: effective floor remains 0 (byte-identical).
                 // Fail-closed when modelProfile absent → 0 floor (frontier-equivalent behavior).
-                // T-153-poison: boosts cannot resurrect a low-base memory (floor gates pre-boost).
+                // Poison resistance: boosts cannot resurrect a low-base memory (floor gates pre-boost).
                 baseFloor: params.modelProfile !== undefined
                     ? resolveScaffoldDefaults(params.modelProfile, config).baseFloor
                     : config.rag.baseFloor,
-                // RETR-04 / WR-02 (Phase 173): thread the unified-arbiter-active signal so the
+                // Thread the unified-arbiter-active signal so the
                 // recall baseFloor gate is FAIL-CLOSED under the arbiter (an unconfigured floor
                 // resolves to the class default instead of silently skipping) AND the trust gate
                 // runs upstream of fusion. relevanceFirst=true only for small/nano non-caching
-                // models (resolveScaffoldDefaults); frontier/mid → false → recall byte-identical
-                // (LOCKED #2). Absent modelProfile → undefined → off (recency-first, byte-identical).
+                // models (resolveScaffoldDefaults); frontier/mid → false → recall byte-identical.
+                // Absent modelProfile → undefined → off (recency-first, byte-identical).
                 ...(params.modelProfile !== undefined
                     ? { relevanceFirst: resolveScaffoldDefaults(params.modelProfile, config).relevanceFirst }
                     : {}),
@@ -782,7 +781,7 @@ export async function assembleExecutionPrompt(params) {
                 // Budget accounting: subtract pinnedChars from maxContextChars BEFORE sizing
                 // fused recall. Pinned entries are identified by entry.pinned===true (set by
                 // rowToEntry from the DB column; the recall pipeline's Step-0 lane prepends them).
-                // CR-03: use entry.pinned to identify actual pinned entries rather than a positional
+                // Use entry.pinned to identify actual pinned entries rather than a positional
                 // slice(0, maxPinnedInjection). When real pins < cap, the positional slice over-counts
                 // and incorrectly measures fused entries in pinnedChars, silently dropping them from
                 // injector.split. The entry.pinned filter deducts only real-pin chars.
@@ -796,10 +795,10 @@ export async function assembleExecutionPrompt(params) {
                     const pinnedSection = formatMemorySection(pinnedSet, config.rag.maxContextChars);
                     pinnedChars = pinnedSection ? pinnedSection.length : 0;
                 }
-                // R3: small/nano profile count cap (3 items max) and chars cap (2000/1000).
+                // Small/nano profile count cap (3 items max) and chars cap (2000/1000).
                 // Applied AFTER the base-floor filter in the recall pipeline, at the injection site.
                 // Caps are conservative but generous for small models; frontier/mid are uncapped.
-                // T-153-03b: accepted DoS risk — caps are well above typical useful recall sets.
+                // Accepted DoS risk: caps are well above typical useful recall sets.
                 const maxRecallItems = params.modelProfile?.capabilityClass === "small" || params.modelProfile?.capabilityClass === "nano"
                     ? 3
                     : undefined;
@@ -821,7 +820,7 @@ export async function assembleExecutionPrompt(params) {
                 memorySections = [...injection.systemPromptSections];
                 retrievedSectionsChars = memorySections.reduce((sum, s) => sum + s.length, 0);
                 retrievedRagHits = memorySections.length + (inlineMemory ? 1 : 0);
-                // Read-time contradiction guidance: inject the §7.3 block when
+                // Read-time contradiction guidance: inject the temporal-guidance block when
                 // >=2 surfaced memories are co-retrieved for the same query. Pure formatter; no
                 // deletion, no content echo. The >=2 gate is tightened with entity overlap.
                 // FIXED guidance text, NOT a retrieved memory — excluded from telemetry above.
@@ -832,7 +831,7 @@ export async function assembleExecutionPrompt(params) {
                 // AFTER the trajectory bridge has subscribed. The inline assembly runs inside assembleTools,
                 // BEFORE attachTrajectoryToEventBus (pi-executor), so an inline emit fired to NO listener and
                 // the trajectory missed the RAG record on every turn — the same pre-bridge timing bug fixed
-                // for memory:skill_surfaced (finding A). Fires only on turns where the injector produced
+                // for memory:skill_surfaced. Fires only on turns where the injector produced
                 // content (this block is reached only then). Retrieved memory ONLY (inline + retrieved
                 // sections), never the guidance block — keeps charsInjected consistent with hitCount.
                 sessionPromptMemoryInjected.set(formatSessionKey(sessionKey), {
@@ -850,12 +849,11 @@ export async function assembleExecutionPrompt(params) {
     }
     // USER-PROFILE STANDING BLOCK: the LLM-free per-user-profile block is a DURABLE
     // standing block ("what we know about this user"), NOT a per-recall-conditional one.
-    // FOLD-01 (Phase 225 Plan 02): the source is REWIRED from the deleted
-    // `userRepresentationStore` to the v2.31 mental-model store — a `kind:"profile"`
+    // The source is the mental-model store — a `kind:"profile"`
     // Mental Model doc (`mentalModelStore.list(scope,"profile")` → `buildProfileBlock`).
     //
-    // It is injected on its OWN gate — `config.learning.enabled` (the collapsed
-    // learning flag, Phase 226 / SIMPLIFY-05; was learningSkills.enabled)
+    // It is injected on its OWN gate — `config.learning.enabled` (the single
+    // collapsed learning flag)
     // AND the optional store dep — INDEPENDENT of whether RAG ran, whether recall hit,
     // and independent of `rag.enabled`. This is why it lives OUTSIDE the
     // `if (deps.memoryPort && config.rag?.enabled ...)` recall block above: nesting it
@@ -868,7 +866,7 @@ export async function assembleExecutionPrompt(params) {
     // buildProfileBlock formatter (NO model call — the recall hot path stays LLM-free).
     // The profile groupKey is the userId, carried on the doc's `topicKey` (LearningScope
     // has only (tenant, agent)), so the CURRENT user's doc is selected by
-    // `topicKey === sessionKey.userId` — cross-user isolation at read (T-225-09). The
+    // `topicKey === sessionKey.userId` — cross-user isolation at read. The
     // formatter returns undefined on an empty/absent profile ⇒ nothing pushed ⇒
     // byte-identity. Non-fatal: a list err is swallowed so the agent proceeds without the
     // profile. The profile content was redaction-checked + validateLearnedDocBody-clean +
@@ -904,7 +902,7 @@ export async function assembleExecutionPrompt(params) {
                 // --- reuse-attribution by TOPIC MATCH (kind=skill).
                 // Credit any learned skill whose stored common-core (topicTokens) THIS turn instantiates,
                 // so a skill APPLIED from the surfaced `<available_skills>` summary / recall — without an
-                // explicit `read` of its SKILL.md (the ATTR-01 path) — still enters `usedSkillIds` and
+                // explicit `read` of its SKILL.md (the read-attribution path) — still enters `usedSkillIds` and
                 // promotes on success. Per-turn (the match depends on the turn's request text); the carrier
                 // is unioned into the turn's usedSkillIds by the pi-event-bridge.
                 const skills = docs.value.filter((d) => d.kind === "skill");
@@ -919,9 +917,9 @@ export async function assembleExecutionPrompt(params) {
                 if (matched.length > 0) {
                     logger.debug({ agentId, step: "skill-topic-match", skillsConsidered: skills.length, matchedCount: matched.length }, "reuse-attribution: turn topic-credited learned skill(s) without an explicit read");
                 }
-                // memory:skill_surfaced (finding A): the full reuse-attribution census. memory:skill_used
+                // memory:skill_surfaced: the full reuse-attribution census. memory:skill_used
                 // (post-execution) fires only when ≥1 skill is CREDITED, so a NEAR-MISS — a skill that
-                // overlapped the turn but missed the credit bar, or a legacy doc with no topicTokens — was
+                // overlapped the turn but missed the credit bar, or a doc with no topicTokens — was
                 // silent ("why wasn't my skill reused?" needed a debugger). Emit per turn when ≥1 learned
                 // skill has ANY token overlap (sharedCount>0) or is credited; carry a content-free score
                 // (name=id, rest=numbers; zero-overlap skills omitted as noise; capped). Best-effort.
@@ -952,11 +950,6 @@ export async function assembleExecutionPrompt(params) {
             }, "Learning standing-block read failed (non-fatal)");
         }
     }
-    // (The CHANNEL-RELATIONSHIP STANDING BLOCK — the LLM-free directional `<channel_relationships>`
-    //  injection, gated on `config.socialModeling.enabled && privacyReviewSignedOffBy` + the store dep —
-    //  was DELETED in Phase 226-04 with the rest of the social-modeling subsystem (the RelationshipStore
-    //  port + adapter, the `relationship` table, the offline directional-edge builder). Deleting the
-    //  injection removes a prompt-injected relationship-model surface; no dormant seam left (I1).)
     // 4. Build runtime info
     const runtimeInfo = {
         agentId: agentId ?? config.name,
@@ -1043,7 +1036,7 @@ export async function assembleExecutionPrompt(params) {
         sessionToolNameSnapshots.set(snapshotKey, toolNames);
     }
     const hasMemoryTools = stableToolNames.includes("memory_store") || stableToolNames.includes("memory_search");
-    // P2: include the Compressed-context uncertainty clause when the DAG (LCD)
+    // Include the Compressed-context uncertainty clause when the DAG (LCD)
     // engine is enabled. Gated on the per-session, operator-only
     // `contextEngine.version` (stable config) -- NOT per-turn store state -- so the
     // cache-stable system-prompt prefix is not thrashed on every compaction.
@@ -1055,7 +1048,7 @@ export async function assembleExecutionPrompt(params) {
     if (promptSkillsXml === undefined && !sessionPromptSkillsXmlSnapshots.has(snapshotKey)) {
         promptSkillsXml = deps.getPromptSkillsXml?.() ?? undefined;
         sessionPromptSkillsXmlSnapshots.set(snapshotKey, promptSkillsXml);
-        // ATTR-01: parse the frozen XML into the location→skillName index ONCE,
+        // Parse the frozen XML into the location→skillName index ONCE,
         // in lockstep with the XML snapshot, so the bridge can attribute skill use
         // from a `read` path. Empty when no skills are listed (the default).
         sessionPromptSkillLocations.set(snapshotKey, parseSkillLocationIndex(promptSkillsXml));
@@ -1126,7 +1119,7 @@ export async function assembleExecutionPrompt(params) {
         workspaceProfile: config.workspace?.profile,
         sepEnabled: params.sepEnabled,
         dagModeEnabled,
-        // C2/S1: securityLevel from ModelProfile drives lockdown tightening in compact-secure mode.
+        // securityLevel from ModelProfile drives lockdown tightening in compact-secure mode.
         // Only applied when promptMode === "compact-secure"; ignored for full/operational/minimal.
         securityLevel: params.modelProfile?.securityLevel,
     };
@@ -1135,8 +1128,8 @@ export async function assembleExecutionPrompt(params) {
     // Uses the same assemblerParams as assembleRichSystemPrompt() -- identity guaranteed
     // by shared buildAllSections().
     let systemPromptBlocks = assembleRichSystemPromptBlocks(assemblerParams);
-    // ROOT-CAUSE context-exhaustion guard — degenerate-window compact fallback
-    // (2026-06-22). The window-aware tool-budget fit pass (executor-tool-assembly)
+    // ROOT-CAUSE context-exhaustion guard — degenerate-window compact fallback.
+    // The window-aware tool-budget fit pass (executor-tool-assembly)
     // defers tools to fit, but the system prompt itself is non-evictable: a model
     // whose effective window is SMALLER than its full prompt (e.g. an ~8K window
     // mid-class model with a ~10K prompt — compact-secure never fires for mid/
@@ -1153,7 +1146,7 @@ export async function assembleExecutionPrompt(params) {
     if (fitBudget !== undefined &&
         promptMode !== "compact-secure" &&
         promptMode !== "none") {
-        // TOK-01: factor the prompt's own script (dense non-Latin prompts carry more
+        // Factor the prompt's own script (dense non-Latin prompts carry more
         // tokens/char), matching estimateSystemTokensFactored at toolOverheadChars=0.
         const systemPromptOnlyTokens = Math.ceil(systemPrompt.length / (CHARS_PER_TOKEN_RATIO * scriptTokenFactor(systemPrompt)));
         const minFixed = systemPromptOnlyTokens + fitBudget.outputHeadroom + fitBudget.messageFloorTokens;
@@ -1188,7 +1181,7 @@ export async function assembleExecutionPrompt(params) {
             systemPromptBlocks = assembleRichSystemPromptBlocks(compactParams);
         }
     }
-    // STRIP-01/02: read-only-child input economy. Gating + drop logic all live in
+    // Read-only-child input economy. Gating + drop logic all live in
     // spawn/child-prompt-economy.ts (blocks are always defined on this path).
     if (deps.spawnPacket) {
         const economised = economiseForReadOnlyChild(systemPrompt, systemPromptBlocks, stableToolNames);
@@ -1271,7 +1264,7 @@ export async function assembleExecutionPrompt(params) {
                 policyFilteredToolNames: deps.policyFilteredToolNames,
                 // memoryInjection reflects RETRIEVED memory only (inline + retrieved
                 // sections). The predicate gates on injected content (memorySections
-                // includes the §7.3 guidance block); the COUNTS use the retrieved-only
+                // includes the temporal-guidance block); the COUNTS use the retrieved-only
                 // accumulators so they never tally the fixed guidance text. The
                 // `?? 0` on inlineMemory.length is load-bearing for the sections-only
                 // branch (the outer predicate can be true with inlineMemory undefined).
@@ -1322,7 +1315,7 @@ export async function assembleExecutionPrompt(params) {
     if (apiSystemPrompt) {
         wrappedApiSystemPrompt = wrapExternalContent(apiSystemPrompt, { source: "api", includeWarning: true, onSuspiciousContent: deps.onSuspiciousContent });
     }
-    // Bootstrap content budget tracking (F4: denominator = systemPromptChars + toolDefOverheadChars)
+    // Bootstrap content budget tracking (denominator = systemPromptChars + toolDefOverheadChars)
     const bootstrapChars = bootstrapContextFiles.reduce((sum, f) => sum + f.content.length, 0);
     const systemPromptChars = systemPrompt.length;
     const toolDefOverheadChars = mergedCustomTools.reduce((sum, t) => {
@@ -1470,8 +1463,7 @@ export async function assembleExecutionPrompt(params) {
     // BOOTSTRAP.md onboarding content relocated from system prompt to dynamic preamble.
     // Specialist-profile agents (task workers spawned by pipelines, sub-agents, or
     // graphs) must never receive onboarding: the "greet the user, ask who I am"
-    // script hijacks task execution and wastes ~3 KB of context per turn. See
-    // audit finding F3 (2026-04-19).
+    // script hijacks task execution and wastes ~3 KB of context per turn.
     if (isOnboarding && config.workspace?.profile !== "specialist") {
         try {
             const bootstrapPath = safePath(deps.workspaceDir, "BOOTSTRAP.md");
@@ -1507,7 +1499,7 @@ export async function assembleExecutionPrompt(params) {
     }
     const dynamicPreamble = dynamicPreambleParts.join("\n\n");
     // Token budget breakdown for optimization measurement. Script-factored
-    // (TOK-01) so the operator-visible numbers stay consistent with the real
+    // so the operator-visible numbers stay consistent with the real
     // factored reservation in executor-tool-assembly.
     const systemPromptTokens = Math.ceil(systemPrompt.length / (CHARS_PER_TOKEN_RATIO * scriptTokenFactor(systemPrompt)));
     const dynamicPreambleTokens = Math.ceil(dynamicPreamble.length / (CHARS_PER_TOKEN_RATIO * scriptTokenFactor(dynamicPreamble)));

package/node_modules/@comis/agent/dist/executor/prompt-runner/envelope-wrapper.js

@@ -42,11 +42,11 @@ export function wrapEnvelope(params) {
     // all-zero counts) yields text === "" which .filter(Boolean) drops
     // automatically.
     const capabilityIndexContext = capabilityIndexResult.text;
-    // ISSUE #2 (2026-06-22): on a tight window where the system prompt dominates, the
+    // On a tight window where the system prompt dominates, the
     // capability-index + deferred-tools context (tool-DISCOVERY scaffolding, NOT needed
     // to answer the current message) can be the marginal overflow: the protected fresh
     // tail = preamble + message ships UNCONDITIONALLY, so when S + (preamble + message) +
-    // floorHeadroom > window the pre-flight throws (live turn-14: 5210 + (888 + 1744) +
+    // floorHeadroom > window the pre-flight throws (observed live: 5210 + (888 + 1744) +
     // 768 = 8610 > 8192; WITHOUT the preamble 5210 + 1744 + 768 = 7722 < 8192). Drop the
     // heavy components FIRST — keep the tiny `dynamicPreamble` (date/channel/metadata) and
     // the user's message — so the turn answers instead of exhausting. Only if the message
@@ -67,14 +67,14 @@ export function wrapEnvelope(params) {
     if (inlineMemory) {
         messageText = `${inlineMemory}\n${messageText}`;
     }
-    // R1: GoalAnchor tail injection — APPENDED after user message text.
-    // SD1 (Phase 158): GoalAnchor capability-gated default.
-    // Effective flag = explicit config ?? capability default (small/nano=true, frontier/mid=false).
+    // GoalAnchor tail injection — APPENDED after user message text.
+    // GoalAnchor has a capability-gated default:
+    // effective flag = explicit config ?? capability default (small/nano=true, frontier/mid=false).
     // Precedence: explicit false on small/nano → stays OFF. explicit true on frontier → turns ON.
     // resolveScaffoldDefaults reads config.goalAnchor?.enabled which is `boolean | undefined`
     // from PerAgentConfig (the block is .optional()); do NOT re-parse through GoalAnchorConfigSchema.
     // Fail-closed when modelProfile is absent (no profile → frontier-equivalent → no injection).
-    // T-153-02a: injection is bounded by maxChars (500 default); no untrusted data.
+    // Injection is bounded by maxChars (500 default); no untrusted data.
     if (modelProfile !== undefined &&
         resolveScaffoldDefaults(modelProfile, config).goalAnchorEnabled &&
         executionPlanRef.current?.active) {
@@ -87,7 +87,7 @@ export function wrapEnvelope(params) {
     const imageContents = Array.isArray(msg.metadata?.imageContents)
         ? msg.metadata.imageContents
         : [];
-    // L4: read supportsVision from the resolved ModelProfile (not directly from
+    // Read supportsVision from the resolved ModelProfile (not directly from
     // resolvedModel.input). Both are set from the same config field in model-profile.ts,
     // but reading from modelProfile ensures the single-resolve-point invariant and
     // makes the vision gate testable independently of the resolved model entry.
@@ -101,7 +101,7 @@ export function wrapEnvelope(params) {
             const rawHint = imageContents.length === 1
                 ? "[An image is attached to this message and is visible to you. Analyze it directly — do NOT call image_analyze, you can already see it.]"
                 : `[${imageContents.length} images are attached to this message and are visible to you. Analyze them directly — do NOT call image_analyze, you can already see them.]`;
-            // S7: flag image-derived hint as untrusted (vision input = injection vector).
+            // Flag the image-derived hint as untrusted (vision input = injection vector).
             // Apply wrapExternalContent ONLY to rawHint (not the full messageText) to
             // avoid double-wrapping already-wrapped content (memory, goal-anchor) in messageText.
             // includeWarning:false avoids visual noise — the real defense is the canary in
@@ -171,7 +171,7 @@ export function wrapEnvelope(params) {
  */
 function emitPreambleDebug(logger, capabilityIndexResult, fullDynamicPreamble, deferredContext) {
     const submoduleLogger = logger.child({ submodule: "executor.capability-index" });
-    // Script-factored estimates (TOK-01) — the preamble can carry non-Latin
+    // Script-factored estimates — the preamble can carry non-Latin
     // content (recalled memories, skills); numbers-only payload, no text logged.
     const fullPreambleText = fullDynamicPreamble ?? "";
     const deferredText = deferredContext ?? "";
@@ -182,7 +182,7 @@ function emitPreambleDebug(logger, capabilityIndexResult, fullDynamicPreamble, d
         deferredContextTokens,
         fullPreambleTokens,
         clusterCount: capabilityIndexResult.clusterCount,
-        // W6 (obs-llm-troubleshooting): cluster-view counts get their OWN payload
+        // Cluster-view counts get their OWN payload
         // names — the bare activeToolCount/deferredToolCount keys collided with the
         // executor-wide counts (agent-execute logs activeToolCount=83 while this
         // cluster view logs 24), making the two lines read as contradictory.
@@ -191,14 +191,14 @@ function emitPreambleDebug(logger, capabilityIndexResult, fullDynamicPreamble, d
         promptSkillCount: capabilityIndexResult.promptSkillCount,
     }, "Dynamic preamble assembled");
 }
-/** Factored token estimate (TOK-01) matching the pre-flight's chars/(3.5×scriptFactor). */
+/** Factored token estimate matching the pre-flight's chars/(3.5×scriptFactor). */
 function factoredTokens(text) {
     if (!text)
         return 0;
     return Math.ceil(text.length / (CHARS_PER_TOKEN_RATIO * scriptTokenFactor(text)));
 }
 /**
- * ISSUE #2 (2026-06-22): when the protected fresh tail (the dynamic preamble + the
+ * When the protected fresh tail (the dynamic preamble + the
  * current message, which the assembler ships UNCONDITIONALLY) would not fit the
  * window's residual room, DROP the heavy tool-DISCOVERY context — the capability index
  * + the `<deferred-tools>` block — keeping only the tiny `dynamicPreamble`
@@ -217,7 +217,7 @@ function factoredTokens(text) {
  * components, never the user's message or the date preamble. When even the message alone
  * still exceeds the residual, dropping is still correct (it minimizes the overflow) and
  * the pre-flight then honest-degrades as oversized_input. No S (frontier/mid wide window,
- * or getSystemTokensEstimate absent) ⇒ skip entirely → byte-identical to pre-ISSUE#2.
+ * or getSystemTokensEstimate absent) ⇒ skip entirely → the preamble ships unchanged.
  */
 function dropHeavyPreambleIfTight(parts, ctx) {
     const kept = {