comisai 1.0.44 → 1.0.46

package/node_modules/@comis/daemon/dist/api/obs-handlers/obs-explain-readers.js

@@ -5,7 +5,7 @@
  *
  * `obs.explain` assembles an IncidentReport from four telemetry sources. They
  * sit behind ONE interface so production reads real files while tests inject
- * fixture records (the X3 fixture-injection seam):
+ * fixture records (the fixture-injection seam):
  *
  *   1. readSessionRecords    — the per-session trajectory JSONL. The session
  *      lives in the REAL production layout the pi-agent session manager writes:
@@ -17,7 +17,7 @@
  *      same resolution `bundle-exporter.ts:readRuntimeTrajectory` performs).
  *      Returns ALL parsed lines — log shape AND event shape — WITHOUT the
  *      production bundle reader's `traceSchema === "comis-trajectory"` envelope
- *      filter, so the frozen pre-150 log fixtures pass through to
+ *      filter, so the frozen log-shape fixtures pass through to
  *      `toIncidentSignals`.
  *   2. readCacheTraceRecords — `<dataDir>/logs/cache-trace.jsonl`, filtered to
  *      the resolved session.
@@ -28,7 +28,7 @@
  *      then a SESSION-SCOPED filter by `row.sessionKey` (the F2 fallback).
  *      `DiagnosticQueryParams` has NO sessionKey filter, so `{limit:1}` would
  *      return the most-recent row across ALL sessions — the reader queries a
- *      window and filters AFTER. The window is a recency horizon (WR-01): see
+ *      window and filters AFTER. The window is a recency horizon: see
  *      `DIAGNOSTICS_QUERY_LIMIT` for why 1000 and the residual bound.
  *
  * Why the workspace base (not `<dataDir>/sessions`): the writer's source of
@@ -53,7 +53,7 @@ import { resolveTrajectoryPointerFilePath } from "@comis/observability";
  * intent at a report-appropriate scale — a post-mortem never needs more). */
 const MAX_RECORDS = 5_000;
 /**
- * Window queried from obs_diagnostics before the session-scoped filter (WR-01).
+ * Window queried from obs_diagnostics before the session-scoped filter.
  *
  * `DiagnosticQueryParams` has NO sessionKey predicate, so the reader queries a
  * window (ordered `timestamp DESC`) and filters by `row.sessionKey` AFTER. The
@@ -72,11 +72,11 @@ const MAX_RECORDS = 5_000;
 const DIAGNOSTICS_QUERY_LIMIT = 1000;
 /**
  * Bounded window queried from `obs_audit_events` (tenant-scoped) before the
- * caller's traceId filter (AUDIT-05). `AuditQueryParams` has no traceId predicate,
+ * caller's traceId filter. `AuditQueryParams` has no traceId predicate,
  * so the reader scopes by tenant + this cap and the assembler narrows to the
  * session's traceId AFTER — the same recency-horizon pattern as the diagnostics
- * rollup. The store ALSO clamps `limit` to its own hard ceiling (Plan 03), so this
- * is the read-side bound (GBIII I2 — bounded reports).
+ * rollup. The store ALSO clamps `limit` to its own hard ceiling, so this
+ * is the read-side bound (reports stay bounded).
  */
 const AUDIT_QUERY_LIMIT = 1000;
 /** Default data directory (lazy). Mirrors obs-trace.ts. */
@@ -87,7 +87,7 @@ function defaultDataDir() {
  * The `<sessionFile>.trajectory-path.json` pointer suffix the trajectory recorder
  * writes (`pointer-file.ts`). The pointer's `sessionId` is the VERBATIM formatted
  * SessionKey the writer used — the only authoritative key→file record on disk, and
- * the basis of the lossy-key fallback below (OBS-WEBHOOK-EXPLAIN-RESOLVE).
+ * the basis of the lossy-key fallback below.
  */
 const TRAJECTORY_POINTER_SUFFIX = ".trajectory-path.json";
 /**
@@ -114,7 +114,7 @@ function sessionArtifactsExist(sessionFile) {
  * `userId:"hook:devtask:<id>"`, `channelId:"webhook"` — is greedily mis-split into
  * channelId by the parser (the inverse of the writer's intent), so `sessionKeyToPath`
  * computes a path that does not exist and the readers report a false "nothing
- * happened" for a session that succeeded (OBS-WEBHOOK-EXPLAIN-RESOLVE).
+ * happened" for a session that succeeded.
  *
  * The authoritative key→file mapping lives ONLY on disk: each session's
  * `<file>.jsonl.trajectory-path.json` pointer carries the verbatim formatted key in
@@ -184,7 +184,7 @@ function findSessionFileByPointerSessionId(sessionKey, sessionsBase, encodedTena
  * whose computed artifacts exist on disk (telegram + any single-colon-field key);
  * (2) the FALLBACK — when the fast-path artifacts are absent, the key may have a
  * colon-bearing userId the parser mis-split (webhook sessions), so resolve via the
- * on-disk pointer whose `sessionId` matches verbatim (OBS-WEBHOOK-EXPLAIN-RESOLVE).
+ * on-disk pointer whose `sessionId` matches verbatim.
  *
  * Returns `undefined` when the key is not a parseable formatted sessionKey
  * (the reader then soft-fails to `[]`/`null`). `sessionKeyToPath` runs every
@@ -212,6 +212,40 @@ function resolveSessionFile(sessionKey, sessionsBase) {
     }
     return fastPath; // No pointer match — unchanged fast-path miss behavior (soft-fail).
 }
+/**
+ * Public sessionKey → real session `.jsonl` resolver — the authoritative
+ * pointer-discipline mapping, shared by the daemon `/export-trajectory` closure
+ * and the CLI support-bundle seam.
+ *
+ * Mirrors `makeRealReader`'s workspace base
+ * (`<dataDir>/workspace/sessions`, NOT a flat `<dataDir>/sessions`) and
+ * delegates to the private `resolveSessionFile` (fast path via
+ * `sessionKeyToPath`, then the on-disk pointer-`sessionId` fallback for
+ * lossy keys). Every path component runs through `safePath`, so a
+ * traversal-bearing key cannot escape the sessions base.
+ *
+ * The private resolver soft-fails to the fast path even on a miss (so
+ * `makeRealReader` can read an empty `[]`); this wrapper converts that into an
+ * HONEST `undefined` — it returns a path ONLY when the session artifacts (the
+ * `.jsonl`, its pointer, or its `_session-metadata.json`) exist on disk. A
+ * caller (the export closure) can then warn instead of stat-failing on a
+ * fabricated path.
+ *
+ * @param dataDir - the `~/.comis` root (empty → the default `~/.comis`).
+ * @param sessionKey - a formatted SessionKey (`tenant:user:channel[:peer:...]`).
+ * @returns the absolute session `.jsonl` path, or `undefined` on a genuine miss
+ *   (no artifacts) or an unparseable key.
+ */
+export function resolveSessionFilePath(dataDir, sessionKey) {
+    const base = dataDir.length > 0 ? dataDir : defaultDataDir();
+    const sessionsBase = safePath(base, "workspace", "sessions");
+    const resolved = resolveSessionFile(sessionKey, sessionsBase);
+    // Convert the private resolver's soft-fail (fast path returned even on a miss)
+    // into an honest undefined — a path is returned ONLY when it exists on disk.
+    if (resolved === undefined || !sessionArtifactsExist(resolved))
+        return undefined;
+    return resolved;
+}
 /**
  * Resolve the trajectory JSONL path for a session file, the canonical way:
  *   1. Read `<sessionFile>.trajectory-path.json` (pointer); if it fence-checks
@@ -323,7 +357,7 @@ export function makeRealReader(dataDir, obsStore) {
             // DiagnosticQueryParams has NO sessionKey filter — query a window and
             // filter by row.sessionKey AFTER (a {limit:1} would return the most-recent
             // row across ALL sessions, not this one). The window (DIAGNOSTICS_QUERY_LIMIT)
-            // is a recency horizon — widened to 1000 (WR-01) so older sessions are found.
+            // is a recency horizon — 1000 wide so older sessions are found.
             const rows = obsStore.queryDiagnostics({
                 category: "session_summary",
                 limit: DIAGNOSTICS_QUERY_LIMIT,

package/node_modules/@comis/daemon/dist/api/obs-handlers/obs-explain-recall-verdict.d.ts

@@ -1,5 +1,5 @@
 /**
- * RECALL-01: the `recall_miss` root-cause verdict predicate spliced into the
+ * The `recall_miss` root-cause verdict predicate spliced into the
  * `obs-explain-heuristics` registry.
  *
  * Extracted into this sibling (the `obs-explain-learning-verdicts.ts` /
@@ -13,7 +13,7 @@
  * (zeroHits === recalls), NO tool failures (so it never steals from the catch-all,
  * which REQUIRES failures — the two are mutually exclusive), and the authoritative
  * `degraded` flag (a zero-hit recall on a healthy turn is benign — the agent simply
- * didn't need memory — and never fires). Grounded in the v2.22 Hebrew / LM-3 runs
+ * didn't need memory — and never fires). Grounded in live Hebrew-language runs
  * where recall silently missed and `comis explain` root-caused nothing, so the
  * lane/scope gap had to be hand-queried from memory_fts. The return type is
  * structurally identical to the registry's `RootCause` (no cross-module type import

package/node_modules/@comis/daemon/dist/api/obs-handlers/obs-explain-recall-verdict.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * RECALL-01: the `recall_miss` root-cause verdict predicate spliced into the
+ * The `recall_miss` root-cause verdict predicate spliced into the
  * `obs-explain-heuristics` registry.
  *
  * Extracted into this sibling (the `obs-explain-learning-verdicts.ts` /
@@ -14,7 +14,7 @@
  * (zeroHits === recalls), NO tool failures (so it never steals from the catch-all,
  * which REQUIRES failures — the two are mutually exclusive), and the authoritative
  * `degraded` flag (a zero-hit recall on a healthy turn is benign — the agent simply
- * didn't need memory — and never fires). Grounded in the v2.22 Hebrew / LM-3 runs
+ * didn't need memory — and never fires). Grounded in live Hebrew-language runs
  * where recall silently missed and `comis explain` root-caused nothing, so the
  * lane/scope gap had to be hand-queried from memory_fts. The return type is
  * structurally identical to the registry's `RootCause` (no cross-module type import

package/node_modules/@comis/daemon/dist/api/obs-handlers/obs-explain-resolve.d.ts

@@ -1,8 +1,8 @@
 /**
- * `obs.explain` ref → sessionKey canonicalization (the X1 identity seam).
+ * `obs.explain` ref → sessionKey canonicalization (the identity seam).
  *
- * `obs.explain` accepts ONE of a `sessionKey`, a `traceId`, OR a `rootRunId`
- * (FLEET-05). So a single assembler path runs for all inputs — identity is
+ * `obs.explain` accepts ONE of a `sessionKey`, a `traceId`, OR a `rootRunId`.
+ * So a single assembler path runs for all inputs — identity is
  * structural, not parallel code paths — the by-`traceId` and by-`rootRunId`
  * inputs are resolved to their canonical `sessionKey` FIRST, then the rest of
  * the handler operates on that one key.
@@ -13,11 +13,11 @@
  * session whose TWO traceIds both index the ONE sessionKey — either traceId
  * resolves to the same canonical key.
  *
- * The FLEET-05 sibling {@link resolveRootRunToSession} canonicalizes an
+ * The sibling {@link resolveRootRunToSession} canonicalizes an
  * autonomy run's `rootRunId` (the synthetic in-process root by a pure
  * prefix-strip; a real socket/spawned root by the same day-keyed scan, matching
  * a `capability.audited` record's `rootRunId` and returning its `runId`). Both
- * soft-fail to `""` — NEVER fabricate a sessionKey (the G1 anti-pattern).
+ * soft-fail to `""` — NEVER fabricate a sessionKey.
  *
  * @module
  */
@@ -33,14 +33,14 @@ import type { DurableRunPort } from "@comis/core";
  *   Defaults to `~/.comis` when an empty string is passed.
  * @param traceId - the trace identifier to canonicalize.
  * @param includeSynthetic - when `false` (the default), rows stamped
- *   `synthetic === true` (D9 test/harness sessions) are skipped, so a synthetic
+ *   `synthetic === true` (test/harness sessions) are skipped, so a synthetic
  *   row never canonicalizes a traceId for `obs.explain`. Pass `true` to resolve
  *   them (the admin opt-in).
  * @returns the canonical sessionKey, or `""` when unresolvable.
  */
 export declare function resolveTraceToSession(dataDir: string, traceId: string, includeSynthetic?: boolean): Promise<string>;
 /**
- * FLEET-05 — resolve an autonomy run's `rootRunId` to its canonical `sessionKey`,
+ * Resolve an autonomy run's `rootRunId` to its canonical `sessionKey`,
  * so the `fleet → explain` drill-down (paste the worst run's `rootRunId`) shares
  * the ONE assembler path with the by-sessionKey/by-traceId inputs. The sibling of
  * {@link resolveTraceToSession}. TWO honest sources, in order:
@@ -60,12 +60,12 @@ export declare function resolveTraceToSession(dataDir: string, traceId: string,
  *      first and tolerates a flat top-level shape as a fallback.
  *
  * Soft-fail to `""` when neither source resolves — NEVER fabricate a
- * sessionKey/leaseId (the G1 anti-pattern). An empty return drives the WR-04
+ * sessionKey/leaseId. An empty return drives the
  * not-found marker in obs-explain.ts, so a typo'd `rootRunId` surfaces an honest
- * not-found verdict rather than a clean-looking empty report (T-220-06). The
- * session-index read is dataDir-scoped via `safePath` (no arbitrary-file read,
- * T-153-17) and uses `systemDateFrom(systemNowMs())` for day keys (no direct
- * wall-clock read — deterministic, the globals gate, T-220-09).
+ * not-found verdict rather than a clean-looking empty report. The
+ * session-index read is dataDir-scoped via `safePath` (no arbitrary-file read)
+ * and uses `systemDateFrom(systemNowMs())` for day keys (no direct
+ * wall-clock read — deterministic, the globals gate).
  *
  * @param dataDir - data directory containing `logs/session-index.*.jsonl`.
  *   Defaults to `~/.comis` when an empty string is passed.

package/node_modules/@comis/daemon/dist/api/obs-handlers/obs-explain-resolve.js

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // @allow-throw: RPC handler module — all throws are caught and converted to JSON-RPC error responses by rpc-dispatch.ts.
 /**
- * `obs.explain` ref → sessionKey canonicalization (the X1 identity seam).
+ * `obs.explain` ref → sessionKey canonicalization (the identity seam).
  *
- * `obs.explain` accepts ONE of a `sessionKey`, a `traceId`, OR a `rootRunId`
- * (FLEET-05). So a single assembler path runs for all inputs — identity is
+ * `obs.explain` accepts ONE of a `sessionKey`, a `traceId`, OR a `rootRunId`.
+ * So a single assembler path runs for all inputs — identity is
  * structural, not parallel code paths — the by-`traceId` and by-`rootRunId`
  * inputs are resolved to their canonical `sessionKey` FIRST, then the rest of
  * the handler operates on that one key.
@@ -15,11 +15,11 @@
  * session whose TWO traceIds both index the ONE sessionKey — either traceId
  * resolves to the same canonical key.
  *
- * The FLEET-05 sibling {@link resolveRootRunToSession} canonicalizes an
+ * The sibling {@link resolveRootRunToSession} canonicalizes an
  * autonomy run's `rootRunId` (the synthetic in-process root by a pure
  * prefix-strip; a real socket/spawned root by the same day-keyed scan, matching
  * a `capability.audited` record's `rootRunId` and returning its `runId`). Both
- * soft-fail to `""` — NEVER fabricate a sessionKey (the G1 anti-pattern).
+ * soft-fail to `""` — NEVER fabricate a sessionKey.
  *
  * @module
  */
@@ -50,7 +50,7 @@ function yesterdayKey() {
  *   Defaults to `~/.comis` when an empty string is passed.
  * @param traceId - the trace identifier to canonicalize.
  * @param includeSynthetic - when `false` (the default), rows stamped
- *   `synthetic === true` (D9 test/harness sessions) are skipped, so a synthetic
+ *   `synthetic === true` (test/harness sessions) are skipped, so a synthetic
  *   row never canonicalizes a traceId for `obs.explain`. Pass `true` to resolve
  *   them (the admin opt-in).
  * @returns the canonical sessionKey, or `""` when unresolvable.
@@ -80,7 +80,7 @@ export async function resolveTraceToSession(dataDir, traceId, includeSynthetic =
                 continue; // Skip malformed JSONL lines per standard convention.
             }
             if (rec.synthetic === true && !includeSynthetic)
-                continue; // D9 default-exclude
+                continue; // test/harness rows excluded by default
             if (rec.traceId !== traceId)
                 continue;
             // Canonical sessionKey is preferred; fall back to a sessionId-derived
@@ -96,7 +96,7 @@ export async function resolveTraceToSession(dataDir, traceId, includeSynthetic =
     return "";
 }
 /**
- * FLEET-05 — resolve an autonomy run's `rootRunId` to its canonical `sessionKey`,
+ * Resolve an autonomy run's `rootRunId` to its canonical `sessionKey`,
  * so the `fleet → explain` drill-down (paste the worst run's `rootRunId`) shares
  * the ONE assembler path with the by-sessionKey/by-traceId inputs. The sibling of
  * {@link resolveTraceToSession}. TWO honest sources, in order:
@@ -116,12 +116,12 @@ export async function resolveTraceToSession(dataDir, traceId, includeSynthetic =
  *      first and tolerates a flat top-level shape as a fallback.
  *
  * Soft-fail to `""` when neither source resolves — NEVER fabricate a
- * sessionKey/leaseId (the G1 anti-pattern). An empty return drives the WR-04
+ * sessionKey/leaseId. An empty return drives the
  * not-found marker in obs-explain.ts, so a typo'd `rootRunId` surfaces an honest
- * not-found verdict rather than a clean-looking empty report (T-220-06). The
- * session-index read is dataDir-scoped via `safePath` (no arbitrary-file read,
- * T-153-17) and uses `systemDateFrom(systemNowMs())` for day keys (no direct
- * wall-clock read — deterministic, the globals gate, T-220-09).
+ * not-found verdict rather than a clean-looking empty report. The
+ * session-index read is dataDir-scoped via `safePath` (no arbitrary-file read)
+ * and uses `systemDateFrom(systemNowMs())` for day keys (no direct
+ * wall-clock read — deterministic, the globals gate).
  *
  * @param dataDir - data directory containing `logs/session-index.*.jsonl`.
  *   Defaults to `~/.comis` when an empty string is passed.
@@ -178,8 +178,8 @@ export async function resolveRootRunToSession(dataDir, rootRunId, _durableRuns)
             if (typeof runId === "string" && runId.length > 0)
                 return runId;
             // A matching root with no usable runId is not a resolution — keep scanning;
-            // never fabricate a key (G1).
+            // never fabricate a key.
         }
     }
-    return ""; // unresolvable → WR-04 not-found marker fires in obs-explain.ts
+    return ""; // unresolvable → the not-found marker fires in obs-explain.ts
 }

package/node_modules/@comis/daemon/dist/api/obs-handlers/obs-explain-signal-folds.d.ts

@@ -6,31 +6,30 @@
  * the image/vision/video/voice folds used (`obs-explain-voice-fold.ts`). Houses
  * the pure reductions that turn one trajectory record's `data` into an
  * `IncidentSignals` field:
- *   - `accumulateLearningRecord` / `buildLearningSignal` — the OBS-02 (Phase 198)
+ *   - `accumulateLearningRecord` / `buildLearningSignal` — the
  *     learning outcome-signal block from `learning.outcome_observed` records.
- *   - `accumulateToolSchemaRecord` — the GBNF-02 (Phase 175) tool-schema-rejection
+ *   - `accumulateToolSchemaRecord` — the tool-schema-rejection
  *     block from `execution.tool_schema_unsupported` records.
  *
  * Every fold is content-free by construction: it reads ONLY ids / closed enums /
  * counts / booleans, dropping any off-vocabulary value (defence-in-depth — a
- * smuggled enum/body never enters the verdict surface; SEC-01 / T-175-17).
+ * smuggled enum/body never enters the verdict surface).
  *
  * @module
  */
-import type { IncidentSignals, IncidentContextBudget, IncidentPromptTimeout } from "@comis/core";
+import type { IncidentSignals, IncidentContextBudget, IncidentCronWakeGate, IncidentPromptTimeout } from "@comis/core";
 /** The reconstructed learning block (the non-optional shape of the signal). */
 export type IncidentLearningSignal = NonNullable<IncidentSignals["learning"]>;
 type LearningOutcome = NonNullable<IncidentLearningSignal["outcome"]>;
 type LearningSource = IncidentLearningSignal["sources"][number];
 /**
  * The mutable fold state accumulated across the session's learning records:
- * the `learning.outcome_observed` outcome/source signal (Phase 198) PLUS the
+ * the `learning.outcome_observed` outcome/source signal PLUS the
  * skill-invocation signal (`skill.prompt_invoked`) and the reflection funnel
- * (`reflect.admitted` / `reflect.funnel`, renamed Phase 226 — they contribute the
+ * (`reflect.admitted` / `reflect.funnel` — they contribute the
  * BENIGN abstain flag). `count` gates whether ANY learning-family record was seen
  * (an absent block ⇒ `undefined`), so it bumps for every fold — outcome AND
- * reflection — not just outcome records. The Phase-203 user-model-revision +
- * generalization fields were DELETED in Phase 226 with their 0-emit events.
+ * reflection — not just outcome records.
  */
 export interface LearningFoldState {
     count: number;
@@ -40,7 +39,7 @@ export interface LearningFoldState {
      * `outcome_unresolved` verdict means "NO signal tier resolved an outcome" — so it
      * must key on "ever resolved", NOT the LAST record (a trailing no-signal turn, e.g.
      * a tool-less recall reply, otherwise clobbers an earlier resolved success and the
-     * session is wrongly flagged unresolved). Live VPS finding 2026-06-18.
+     * session is wrongly flagged unresolved — a live-incident regression guard).
      */
     everResolved: boolean;
     sources: Set<LearningSource>;
@@ -48,18 +47,18 @@ export interface LearningFoldState {
     skillsUsed: Set<string>;
     /** A record carried the BENIGN synthesis-abstain signal (Defer ≠ Retry). */
     synthesisAbstained: boolean;
-    /** OBS-4: candidate→active promotions summed this session (`learning.skill_promoted`). Counts only. */
+    /** Candidate→active promotions summed this session (`learning.skill_promoted`). Counts only. */
     skillsPromoted: number;
-    /** OBS-4: skill demotions summed this session (`learning.skill_demoted`). Counts only. */
+    /** Skill demotions summed this session (`learning.skill_demoted`). Counts only. */
     skillsDemoted: number;
-    /** OBS-4b: memories that accrued a corroborated failure this session (`learning.memory_failure_attributed`). Counts only — eviction precursor. */
+    /** Memories that accrued a corroborated failure this session (`learning.memory_failure_attributed`). Counts only — eviction precursor. */
     failuresAttributed: number;
-    /** Finding A: surfaced-but-uncredited reuse NEAR-MISSES (`memory.skill_surfaced`) — skill name → best
+    /** Surfaced-but-uncredited reuse NEAR-MISSES (`memory.skill_surfaced`) — skill name → best
      *  coverage seen this session. Does NOT bump `count`/`everResolved` (telemetry-only; must not perturb
      *  the outcome_unresolved verdict), so it surfaces only when a real learning record already built the block. */
     skillsSurfacedButUncredited: Map<string, number>;
-    /** Finding C: the NAMES of skills demoted this session (`learning.skill_demoted.demotedSkillNames`) — so
-     *  `explain` answers WHICH skill demoted, not just how many. Ids only (SEC-01). */
+    /** The NAMES of skills demoted this session (`learning.skill_demoted.demotedSkillNames`) — so
+     *  `explain` answers WHICH skill demoted, not just how many. Ids only. */
     skillsDemotedNames: Set<string>;
 }
 /** A fresh, empty fold state (no learning records seen yet). */
@@ -75,26 +74,26 @@ export declare function accumulateLearningRecord(state: LearningFoldState, data:
  * Fold one `skill.prompt_invoked` record's `data` into the state (mutating):
  * the invoked learned-skill `skillName` joins `skillsUsed` (deduped). IDs ONLY —
  * a non-string `skillName` is dropped (a body smuggled as a name never enters
- * the surface; SEC-01 / T-201-43). Bumps `count` (a skill-only session still
+ * the surface). Bumps `count` (a skill-only session still
  * yields a learning block).
  */
 export declare function accumulateSkillInvokedRecord(state: LearningFoldState, data: Record<string, unknown>): void;
 /**
  * Fold one `memory.skill_used` record's `data` into the state (mutating): the per-turn
  * attributed `usedSkillIds` join `skillsUsed` (deduped). IDS ONLY — non-string entries are
- * dropped (SEC-01; a body smuggled as an id never enters the surface).
+ * dropped (a body smuggled as an id never enters the surface).
  *
- * IMP-3 / PD-OBS-1 (package-delivery-20260628): a reuse via INLINE skill-surfacing credits the
+ * A reuse via INLINE skill-surfacing credits the
  * skill through `memory:skill_used` → `outcome_events.used_skill_ids` (the topic-match path), NOT
- * an explicit `skill.prompt_invoked` file-read — so `skillsUsed` was `[]` while `skillsPromoted>0`
- * (an internally-inconsistent explain view; the credit was visible only via a DB hand-join). With
- * `memory:skill_used` now trajectory-bridged, this surfaces the credited skill ids on `explain`.
- * Bumps `count` (a skill-only session still yields a learning block).
+ * an explicit `skill.prompt_invoked` file-read — without this fold `skillsUsed` is `[]` while
+ * `skillsPromoted>0` (an internally-inconsistent explain view; the credit is visible only via a DB
+ * hand-join). With `memory:skill_used` trajectory-bridged, this surfaces the credited skill ids on
+ * `explain`. Bumps `count` (a skill-only session still yields a learning block).
  */
 export declare function accumulateSkillUsedRecord(state: LearningFoldState, data: Record<string, unknown>): void;
 /**
- * Fold one `memory.skill_surfaced` record's `data` into the state (mutating; finding A,
- * package-delivery-20260628): record the UNCREDITED entries (the reuse near-misses — a skill that
+ * Fold one `memory.skill_surfaced` record's `data` into the state
+ * (mutating): record the UNCREDITED entries (the reuse near-misses — a skill that
  * overlapped the turn but missed the credit bar) by NAME → best `coverage` seen. So `explain` can
  * answer "why wasn't my skill reused?" (it surfaced at coverage 0.45) instead of a debugger.
  *
@@ -102,12 +101,12 @@ export declare function accumulateSkillUsedRecord(state: LearningFoldState, data
  * turns, and forcing a learning block (with outcomeResolved=false) onto sessions that had none could
  * perturb the `outcome_unresolved` verdict. Near-misses therefore surface only when a real learning
  * record (skill_used/promote/outcome) already built the block — exactly the reuse-investigation case.
- * Names/numbers only; non-string names and non-number coverage are dropped (SEC-01).
+ * Names/numbers only; non-string names and non-number coverage are dropped.
  */
 export declare function accumulateSkillSurfacedRecord(state: LearningFoldState, data: Record<string, unknown>): void;
 /**
- * Fold one reflection-funnel record's `data` into the state (mutating; REFLECT,
- * renamed Phase 226 from `learning.skill_synthesized` — handles BOTH `reflect.admitted`
+ * Fold one reflection-funnel record's `data` into the state (mutating —
+ * handles BOTH `reflect.admitted`
  * and `reflect.funnel`): the only signal it contributes is the BENIGN abstain flag
  * (the payload is counts + a closed admissionOutcome enum only — no body crosses).
  * Bumps `count` (a reflection-only session still yields a learning block).
@@ -115,18 +114,18 @@ export declare function accumulateSkillSurfacedRecord(state: LearningFoldState,
 export declare function accumulateReflectFunnelRecord(state: LearningFoldState, data: Record<string, unknown>): void;
 /**
  * Fold one `learning.skill_promoted` / `learning.skill_demoted` record's `data` into the state
- * (mutating; SURFACE-06, COUNTS ONLY). `data.count` is the number promoted/demoted this resolve;
- * bump the matching tally + `count`. OBS-4 (hindsight-reflection-20260626): with `skill.prompt_invoked`
+ * (mutating; COUNTS ONLY). `data.count` is the number promoted/demoted this resolve;
+ * bump the matching tally + `count`. With `skill.prompt_invoked`
  * (already folded into `skillsUsed`) this makes the reuse→promote chain readable on the per-session
  * learning block — `comis explain <session>` shows "used skill X → promoted N" in one call instead of
- * a trajectory + outcome_events + mental_models hand-join. A non-numeric `count` is read as 0 (SEC-01).
+ * a trajectory + outcome_events + mental_models hand-join. A non-numeric `count` is read as 0.
  */
 export declare function accumulateSkillTransitionRecord(state: LearningFoldState, data: Record<string, unknown>, direction: "promoted" | "demoted"): void;
 /**
- * Fold one `learning.memory_failure_attributed` record's `data` into the state (mutating; OBS-4b,
+ * Fold one `learning.memory_failure_attributed` record's `data` into the state (mutating;
  * COUNTS ONLY). `data.count` is the number of memories that accrued a CORROBORATED failure this
  * resolve (the eviction-causation precursor — eviction needs failure_count >= floor); bump
- * `failuresAttributed` + `count`. A non-numeric `count` is read as 0 (SEC-01).
+ * `failuresAttributed` + `count`. A non-numeric `count` is read as 0.
  */
 export declare function accumulateMemoryFailureRecord(state: LearningFoldState, data: Record<string, unknown>): void;
 /**
@@ -136,25 +135,24 @@ export declare function accumulateMemoryFailureRecord(state: LearningFoldState,
  * `"unknown"` (the fail-closed coverage rule — an unresolved/unknown finish is
  * the `outcome_unresolved` verdict's trigger).
  *
- * `skillFailures` (P2): the session's used skills surface as failures when the
+ * `skillFailures`: the session's used skills surface as failures when the
  * terminal outcome is `failure`/`corrected` — "a learned procedure was used in a
  * failed/corrected trajectory" (the `learned_skill_failing` verdict's trigger).
- * (The Phase-201 sandbox-validation failure path was removed in Phase 226 with the
- * 0-emit event.) Counts/ids/closed enums only — no body/script crosses the surface.
+ * Counts/ids/closed enums only — no body/script crosses the surface.
  */
 export declare function buildLearningSignal(state: LearningFoldState): IncidentLearningSignal | undefined;
 /**
  * Build the `IncidentSignals["toolSchemaUnsupported"]` block from one
  * `execution.tool_schema_unsupported` record's `data` (LAST record wins — the
  * caller assigns it each time, so the terminal repair state explains the end).
- * Content-free (tool + keyword NAMES only — I7; string-array + exact-true reads
- * drop smuggled payload — T-175-17). The WR-05 reason is narrowed to its closed
- * vocabulary (off-vocabulary → undefined so pre-WR-05 records stay readable).
+ * Content-free (tool + keyword NAMES only; string-array + exact-true reads
+ * drop smuggled payload). The reason is narrowed to its closed
+ * vocabulary (off-vocabulary → undefined so a reason-less record stays readable).
  */
 export declare function accumulateToolSchemaRecord(data: Record<string, unknown>): NonNullable<IncidentSignals["toolSchemaUnsupported"]>;
 /**
- * Fold one `spend.exceeded` trajectory record (177-obs-loop WR-4
- * translateSpendPayload → `{scope, spentUsd, capUsd, estUsd}`, content-free) into
+ * Fold one `spend.exceeded` trajectory record
+ * (translateSpendPayload → `{scope, spentUsd, capUsd, estUsd}`, content-free) into
  * the `acc.spend` field. The LAST record wins (the terminal breach explains the
  * kill); the section's `totalUsd` maps from the record's `spentUsd` (the breaching
  * scope's spent total). A breach with no `scope` is defensively ignored (acc.spend
@@ -174,16 +172,16 @@ export declare function accumulateSpendExceeded(acc: {
  *  LearningFoldState from HERE, so the reverse import would be a cycle. */
 type SpawnNodeFold = NonNullable<IncidentSignals["spawnTree"]>[number];
 /**
- * Fold one `capability.audited` trajectory record (the per-cap audit Plan 01
- * emits at the gate chokepoint — the spawn-tree's per-node source) into the
+ * Fold one `capability.audited` trajectory record (the per-cap audit
+ * emitted at the gate chokepoint — the spawn-tree's per-node source) into the
  * lease-keyed `spawnNodesByLease` working map. Group by leaseId into ONE node per
- * lease; an in-process record (no real lease, G1) keys on its synthetic rootRunId
+ * lease; an in-process record (no real lease) keys on its synthetic rootRunId
  * (NEVER a fabricated lease-<id>). The node collects the attenuated caps it held
  * (deduped), the tool NAMES it invoked, and any CapabilityDeniedError cap (a
- * `deny` decision → denials[], TREE-02). The record is content-free by
+ * `deny` decision → denials[]). The record is content-free by
  * construction (the translator strips bodies/args); agentId rides the envelope
  * (`rec.agentId`, with the first-seen `accAgentId` fallback). budgetTokensUsed is
- * honestly omitted unless the record carries it (G3 — the live whoami is the
+ * honestly omitted unless the record carries it (the live whoami is the
  * authoritative remaining-budget surface; this is the post-mortem topology).
  *
  * Mutates the passed map (the learning-fold delegation mold); typed structurally
@@ -192,13 +190,13 @@ type SpawnNodeFold = NonNullable<IncidentSignals["spawnTree"]>[number];
  */
 export declare function accumulateCapabilityAuditedRecord(spawnNodesByLease: Map<string, SpawnNodeFold>, data: Record<string, unknown>, recAgentId: unknown, accAgentId: string | undefined): void;
 /**
- * Fold one `graph.node_spawned` trajectory record (finding D, TREE-01) into the
+ * Fold one `graph.node_spawned` trajectory record into the
  * spawn-tree working map. A graph DAG node spawns in-process (gatedSpawn →
  * subAgentRunner.spawn), so it never crosses the socket chokepoint that emits
  * `capability.audited` — and every node shares the graph's `rootRunId`, so the
  * capability fold's `leaseId ?? rootRunId` key would collapse them all into ONE
  * node. So graph nodes get their OWN key: the stable `graphId:nodeId` identity
- * (NOT a fabricated socket lease — G1 forbids that; this is a graph-node id that
+ * (NOT a fabricated socket lease — never fabricate one; this is a graph-node id that
  * just happens to live in the `leaseId` field, the same way the in-process leg's
  * synthetic rootRunId does). The node nests under the graph root via
  * `parentLeaseId = rootRunId`. One leaf per node (spawn fires once; the
@@ -206,18 +204,69 @@ export declare function accumulateCapabilityAuditedRecord(spawnNodesByLease: Map
  * (the translator forwards ids + the child agentId only — no task/output).
  */
 export declare function accumulateGraphNodeSpawnedRecord(spawnNodesByLease: Map<string, SpawnNodeFold>, data: Record<string, unknown>): void;
+/** The run skeleton the `orchestrate.run_summary` fold accumulates (one per
+ *  runId). Derived from IncidentSignals (already imported) so this fold does NOT
+ *  import the internal Acc from obs-explain-signals-acc.ts — that file imports
+ *  from HERE, so the reverse would cycle. `toolCalls` is joined at materialization
+ *  from the per-run leaseId tally, so the fold state OMITS it (ids + closed enums +
+ *  counts + savings only). */
+export type OrchestrateRunFold = Omit<NonNullable<IncidentSignals["orchestrate"]>[number], "toolCalls">;
+/** One tallied per-run tool call (tool NAME + capability + the closed decision +
+ *  a running count) — the inner-map value of `orchestrateToolCallsByLease`. */
+export type OrchestrateToolCallFold = NonNullable<IncidentSignals["orchestrate"]>[number]["toolCalls"][number];
 /**
- * Validate one `context.budget` record (W3 — the per-call budget equation from
+ * Fold one `orchestrate.run_summary` trajectory record into the run-keyed
+ * `orchestrateRunsByRunId` working map (one skeleton per `runId`, FIRST-SEEN kept —
+ * a duplicate re-emit is idempotent). Builds the content-free run skeleton from the
+ * record's `data` (the translator forwards ids + the closed `failureClass` enum +
+ * counts + token estimates; agentId/sessionKey/stderr never cross). `outcome` is
+ * derived from `exitCode` (0 → success, else failure) — a `lease_absent` run may
+ * ride a clean exit-0 (still outcome:success). A record with NO `runId` is not a
+ * reconstructable run — dropped (the accumulateCapabilityAuditedRecord malformed→drop
+ * precedent). `savings` is carried only when BOTH `estSavedTokens` and `savedRatio`
+ * are present (a sub-threshold run has neither). `toolCalls` are NOT set here — they
+ * are joined at materialization from the per-run leaseId tally (accumulateOrchestrateToolCall).
+ *
+ * Mutates the passed map (the learning-fold delegation mold); typed structurally to
+ * avoid importing the internal Acc (no cycle).
+ */
+export declare function accumulateOrchestrateRunSummaryRecord(orchestrateRunsByRunId: Map<string, OrchestrateRunFold>, data: Record<string, unknown>): void;
+/**
+ * Fold one `capability.audited` trajectory record into the per-run tool-call
+ * tally `orchestrateToolCallsByLease` — keyed by the record's `leaseId` (the
+ * daemon-minted PER-RUN child lease), then by the `${tool} ${capability} ${decision}`
+ * tuple → a `{tool,capability,decision,count}` running count. This is EXPLAIN-04:
+ * because the leaseId is per-run, a `decision:"deny"` groups under THE RUN that made
+ * the call, not the assembly. Reads the SAME records the spawn-tree fold sees (called
+ * alongside it — no duplicate event). Content-free (tool NAME + capability + the
+ * closed allow|deny decision + count only). A record with no `leaseId` (no run
+ * correlation), a missing tool/capability, or an off-vocabulary decision is dropped.
+ *
+ * Mutates the passed map (typed structurally — no Acc import, no cycle).
+ */
+export declare function accumulateOrchestrateToolCall(orchestrateToolCallsByLease: Map<string, Map<string, OrchestrateToolCallFold>>, data: Record<string, unknown>): void;
+/**
+ * Validate one `context.budget` record (the per-call budget equation from
  * the LCD pre-flight) wholesale; return the parsed value or `undefined` (a
  * malformed/partial record is ignored — forward-compatible). The caller keeps
  * the LAST successful parse (the terminal fit check explains the end state).
  */
 export declare function parseContextBudgetRecord(data: Record<string, unknown>): IncidentContextBudget | undefined;
 /**
- * Validate one `execution.prompt_timeout` record (LAT-04 — the terminal
+ * Validate one `execution.prompt_timeout` record (the terminal
  * prompt-timeout attribution) wholesale; return the parsed value or `undefined`
- * (the context.budget discipline, T-177-17 — pre-extension timeoutMs-only rows
+ * (the context.budget discipline — timeoutMs-only rows
  * still parse, every other field optional). The caller keeps the LAST parse.
  */
 export declare function parsePromptTimeoutRecord(data: Record<string, unknown>): IncidentPromptTimeout | undefined;
+/**
+ * Validate one `scheduler.wake_gate` record (a woke fire's content-free wake-gate
+ * fact) wholesale; return the parsed value or `undefined` (a malformed/partial
+ * record is ignored — the context.budget discipline). The caller keeps the LAST
+ * successful parse (the terminal fire explains the session). Only a fire the gate
+ * WOKE writes this record — a skip opens no session, so this fold never runs for a
+ * skip. Any off-vocabulary key (the record carries `agentId`; a caller could smuggle
+ * a finding) is stripped by the bounded schema — no gate body crosses into the report.
+ */
+export declare function parseWakeGateRecord(data: Record<string, unknown>): IncidentCronWakeGate | undefined;
 export {};