@graphorin/memory 0.6.0 → 0.7.0

package/dist/consolidator/scheduler.d.ts

@@ -1,6 +1,5 @@
-import { ConsolidatorTriggerSpec } from "./types.js";
+import { ConsolidatorTriggerReason, ConsolidatorTriggerSpec, PhaseOutcome } from "./types.js";
 import { ParsedTrigger } from "./triggers.js";
-import { Consolidator } from "./runtime.js";
 import { SessionScope } from "@graphorin/core";
 
 //#region src/consolidator/scheduler.d.ts
@@ -14,6 +13,21 @@ import { SessionScope } from "@graphorin/core";
  * @stable
  */
 type ConsolidatorCatchupPolicy = 'none' | 'last' | 'all';
+/**
+ * Subset of the `Consolidator` runtime surface the bridge needs.
+ * Defined structurally - mirroring {@link SchedulerLike} - so this
+ * module never imports `./runtime.js` (which imports the bridge) and
+ * the consolidator module graph stays acyclic (issue #22). The full
+ * `Consolidator` is assignable as-is.
+ *
+ * @stable
+ */
+interface ConsolidatorLike {
+  trigger(reason: ConsolidatorTriggerReason, scope: SessionScope): Promise<PhaseOutcome | null>;
+  config(): {
+    readonly triggers: ReadonlyArray<ConsolidatorTriggerSpec>;
+  };
+}
 /**
  * Subset of the `@graphorin/triggers` Scheduler surface the bridge
  * needs. Defined structurally so consumers can inject mocks in
@@ -105,7 +119,7 @@ interface RegisterTriggersResult {
  *
  * @stable
  */
-declare function registerConsolidatorTriggers(consolidator: Consolidator, scheduler: SchedulerLike, options: RegisterTriggersOptions): Promise<RegisterTriggersResult>;
+declare function registerConsolidatorTriggers(consolidator: ConsolidatorLike, scheduler: SchedulerLike, options: RegisterTriggersOptions): Promise<RegisterTriggersResult>;
 //#endregion
 export { ConsolidatorCatchupPolicy, RegisterTriggersOptions, RegisterTriggersResult, SchedulerLike, TriggerDeclarationLike, registerConsolidatorTriggers };
 //# sourceMappingURL=scheduler.d.ts.map

package/dist/consolidator/scheduler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scheduler.d.ts","names":[],"sources":["../../src/consolidator/scheduler.ts"],"sourcesContent":[],"mappings":";;;;;;;AAgEA;;;;;;;AAkCA;AAGmB,KA1EP,yBAAA,GA0EO,MAAA,GAAA,MAAA,GAAA,KAAA;;;;AAuBnB;;;;AAIW,UA5FM,aAAA,CA4FN;EAAR,QAAA,CAAA,WAAA,EA3FqB,sBA2FrB,CAAA,EA3F8C,OA2F9C,CAAA,OAAA,CAAA;EAAO,UAAA,EAAA,EAAA,EAAA,MAAA,CAAA,EA1FiB,OA0FjB,CAAA,IAAA,CAAA;;;;;;;;;;UA/EO,sBAAA;;;;mDAIkC;;6BAEtB;;;oBAGT;;;;;UAMH,uBAAA;;;;;;;kBAOC;;;;;;2BAMS;;;;;;kBAMT;;;;;;;qBAOG,cAAc;;;;;;;UAQlB,sBAAA;uBACM;;mBAEJ;;;oBAGC;;;;;;;;;;;;;;;;;;;iBAoBE,4BAAA,eACN,yBACH,wBACF,0BACR,QAAQ"}
+{"version":3,"file":"scheduler.d.ts","names":[],"sources":["../../src/consolidator/scheduler.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA8DA;;;;;AAeiB,KAnDL,yBAAA,GAmD4B,MAAA,GAAA,MAAA,GAAA,KAAA;;;;;;;AAkCxC;;;AAMoB,UAhFH,gBAAA,CAgFG;EAAa,OAAA,CAAA,MAAA,EA/Ef,yBA+Ee,EAAA,KAAA,EA/EmB,YA+EnB,CAAA,EA/EkC,OA+ElC,CA/E0C,YA+E1C,GAAA,IAAA,CAAA;EAoBX,MAAA,EAAA,EAAA;IACN,SAAA,QAAA,EAnGiB,aAmGjB,CAnG+B,uBAmG/B,CAAA;EACH,CAAA;;;;;;;;;UA1FI,aAAA;wBACO,yBAAyB;2BACtB;;;;;;;;;;UAWV,sBAAA;;;;mDAIkC;;6BAEtB;;;oBAGT;;;;;UAMH,uBAAA;;;;;;;kBAOC;;;;;;2BAMS;;;;;;kBAMT;;;;;;;qBAOG,cAAc;;;;;;;UAQlB,sBAAA;uBACM;;mBAEJ;;;oBAGC;;;;;;;;;;;;;;;;;;;iBAoBE,4BAAA,eACN,6BACH,wBACF,0BACR,QAAQ"}

package/dist/consolidator/scheduler.js.map

@@ -1 +1 @@
-{"version":3,"file":"scheduler.js","names":["catchupPolicy: ConsolidatorCatchupPolicy","registered: Array<{ id: string; kind: ParsedTrigger['kind']; raw: string }>","skipped: Array<{ raw: string; reason: 'unsupported-by-scheduler' | 'filtered-out' }>","declaration: TriggerDeclarationLike"],"sources":["../../src/consolidator/scheduler.ts"],"sourcesContent":["/**\n * Bridge helpers - wire a {@link Consolidator} into the\n * `@graphorin/triggers` Scheduler so trigger declarations fire on\n * the documented schedule (DEC-150 - \"same code path lib + server\").\n *\n * The bridge is structural: any object that exposes the same shape\n * as `@graphorin/triggers`'s `Scheduler` (a `register(declaration)`\n * method) works. The structural import keeps `@graphorin/memory`\n * dependency-free at the type level - the workspace consumer\n * supplies the actual scheduler at runtime.\n *\n * @packageDocumentation\n */\n\nimport type { SessionScope } from '@graphorin/core';\nimport type { Consolidator } from './runtime.js';\nimport { type ParsedTrigger, parseTriggerSpec, reasonFromTrigger } from './triggers.js';\nimport type { ConsolidatorTriggerSpec } from './types.js';\n\n/**\n * Catch-up policy applied when a trigger missed one or more fires\n * while the scheduler was offline. Mirrors\n * `@graphorin/triggers`'s `CatchupPolicy` - duplicated here so the\n * memory package stays import-free at the type level.\n *\n * @stable\n */\nexport type ConsolidatorCatchupPolicy = 'none' | 'last' | 'all';\n\n/**\n * Subset of the `@graphorin/triggers` Scheduler surface the bridge\n * needs. Defined structurally so consumers can inject mocks in\n * tests without taking the package dependency.\n *\n * @stable\n */\nexport interface SchedulerLike {\n  register(declaration: TriggerDeclarationLike): Promise<unknown>;\n  unregister?(id: string): Promise<void>;\n}\n\n/**\n * Subset of `@graphorin/triggers`'s `TriggerDeclaration` accepted\n * by {@link SchedulerLike.register}. Field names mirror the\n * upstream shape exactly so the structural type is interchangeable\n * with the real export.\n *\n * @stable\n */\nexport interface TriggerDeclarationLike {\n  readonly id: string;\n  readonly kind: 'cron' | 'interval' | 'idle' | 'event';\n  readonly spec: string;\n  readonly callback: (payload?: unknown) => void | Promise<void>;\n  readonly options: {\n    readonly catchupPolicy?: ConsolidatorCatchupPolicy;\n    readonly maxCatchupRuns?: number;\n    readonly catchupWindowMs?: number;\n    readonly tags?: ReadonlyArray<string>;\n    readonly acknowledgeLibMode?: boolean;\n  };\n}\n\n/** Options accepted by {@link registerConsolidatorTriggers}. */\nexport interface RegisterTriggersOptions {\n  /**\n   * Scope passed to `consolidator.trigger(...)` for every fire. The\n   * consolidator only operates on a single user/session at a time\n   * (DEC-005 single-user-per-process); multi-tenant deployments\n   * register one scheduler-trigger pair per scope.\n   */\n  readonly scope: SessionScope;\n  /**\n   * Catch-up policy applied to every registered trigger. Defaults\n   * to `'none'` per DEC-150 - safest for personal-assistant\n   * scenarios.\n   */\n  readonly catchupPolicy?: ConsolidatorCatchupPolicy;\n  /** Suppress the per-process library-mode WARN. Defaults to `true`. */\n  readonly acknowledgeLibMode?: boolean;\n  /** Optional id prefix - useful when multiple scopes share a scheduler. */\n  readonly idPrefix?: string;\n  /** Optional tags forwarded to the scheduler. */\n  readonly tags?: ReadonlyArray<string>;\n  /**\n   * Filter - only register the supplied subset of triggers. By\n   * default every parseable trigger declared on the consolidator is\n   * registered (turn / event triggers are skipped because the\n   * Scheduler has no way to fire them on its own).\n   */\n  readonly include?: ReadonlyArray<ConsolidatorTriggerSpec>;\n}\n\n/**\n * Outcome of {@link registerConsolidatorTriggers}.\n *\n * @stable\n */\nexport interface RegisterTriggersResult {\n  readonly registered: ReadonlyArray<{\n    readonly id: string;\n    readonly kind: ParsedTrigger['kind'];\n    readonly raw: string;\n  }>;\n  readonly skipped: ReadonlyArray<{\n    readonly raw: string;\n    readonly reason: 'unsupported-by-scheduler' | 'filtered-out';\n  }>;\n}\n\n/**\n * Register every cron / idle / interval trigger declared on the\n * supplied consolidator with the scheduler. Each trigger fires\n * `consolidator.trigger(reason, scope)` so the lib-mode + server\n * paths converge on the same handler.\n *\n * Turn triggers (`turn:N`) and event triggers (`event:NAME`) are\n * skipped - the scheduler cannot count user turns autonomously, and\n * event triggers fire from the consumer's emit path. The runtime\n * caller is responsible for those (e.g. invoking\n * `consolidator.trigger(...)` from the agent loop).\n *\n * @stable\n */\nexport async function registerConsolidatorTriggers(\n  consolidator: Consolidator,\n  scheduler: SchedulerLike,\n  options: RegisterTriggersOptions,\n): Promise<RegisterTriggersResult> {\n  const config = consolidator.config();\n  const include = options.include ?? config.triggers;\n  const acknowledgeLibMode = options.acknowledgeLibMode ?? true;\n  const catchupPolicy: ConsolidatorCatchupPolicy = options.catchupPolicy ?? 'none';\n  const registered: Array<{ id: string; kind: ParsedTrigger['kind']; raw: string }> = [];\n  const skipped: Array<{ raw: string; reason: 'unsupported-by-scheduler' | 'filtered-out' }> = [];\n  const seenSet = new Set(include);\n  for (const spec of config.triggers) {\n    if (!seenSet.has(spec)) {\n      skipped.push({ raw: spec, reason: 'filtered-out' });\n      continue;\n    }\n    const parsed = parseTriggerSpec(spec);\n    if (parsed.kind === 'turn' || parsed.kind === 'event' || parsed.kind === 'budget') {\n      skipped.push({ raw: parsed.raw, reason: 'unsupported-by-scheduler' });\n      continue;\n    }\n    const id = `${options.idPrefix ?? 'consolidator'}:${parsed.raw}`;\n    const kind: 'cron' | 'idle' | 'interval' = parsed.kind === 'cron' ? 'cron' : 'idle';\n    const declaration: TriggerDeclarationLike = {\n      id,\n      kind,\n      spec: parsed.kind === 'cron' ? parsed.expression : String(parsed.idleMs),\n      async callback() {\n        await consolidator.trigger(reasonFromTrigger(parsed), options.scope);\n      },\n      options: {\n        catchupPolicy,\n        acknowledgeLibMode,\n        ...(options.tags !== undefined ? { tags: options.tags } : {}),\n      },\n    };\n    await scheduler.register(declaration);\n    registered.push({ id, kind: parsed.kind, raw: parsed.raw });\n  }\n  return Object.freeze({\n    registered: Object.freeze(registered),\n    skipped: Object.freeze(skipped),\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA4HA,eAAsB,6BACpB,cACA,WACA,SACiC;CACjC,MAAM,SAAS,aAAa,QAAQ;CACpC,MAAM,UAAU,QAAQ,WAAW,OAAO;CAC1C,MAAM,qBAAqB,QAAQ,sBAAsB;CACzD,MAAMA,gBAA2C,QAAQ,iBAAiB;CAC1E,MAAMC,aAA8E,EAAE;CACtF,MAAMC,UAAuF,EAAE;CAC/F,MAAM,UAAU,IAAI,IAAI,QAAQ;AAChC,MAAK,MAAM,QAAQ,OAAO,UAAU;AAClC,MAAI,CAAC,QAAQ,IAAI,KAAK,EAAE;AACtB,WAAQ,KAAK;IAAE,KAAK;IAAM,QAAQ;IAAgB,CAAC;AACnD;;EAEF,MAAM,SAAS,iBAAiB,KAAK;AACrC,MAAI,OAAO,SAAS,UAAU,OAAO,SAAS,WAAW,OAAO,SAAS,UAAU;AACjF,WAAQ,KAAK;IAAE,KAAK,OAAO;IAAK,QAAQ;IAA4B,CAAC;AACrE;;EAEF,MAAM,KAAK,GAAG,QAAQ,YAAY,eAAe,GAAG,OAAO;EAE3D,MAAMC,cAAsC;GAC1C;GACA,MAHyC,OAAO,SAAS,SAAS,SAAS;GAI3E,MAAM,OAAO,SAAS,SAAS,OAAO,aAAa,OAAO,OAAO,OAAO;GACxE,MAAM,WAAW;AACf,UAAM,aAAa,QAAQ,kBAAkB,OAAO,EAAE,QAAQ,MAAM;;GAEtE,SAAS;IACP;IACA;IACA,GAAI,QAAQ,SAAS,SAAY,EAAE,MAAM,QAAQ,MAAM,GAAG,EAAE;IAC7D;GACF;AACD,QAAM,UAAU,SAAS,YAAY;AACrC,aAAW,KAAK;GAAE;GAAI,MAAM,OAAO;GAAM,KAAK,OAAO;GAAK,CAAC;;AAE7D,QAAO,OAAO,OAAO;EACnB,YAAY,OAAO,OAAO,WAAW;EACrC,SAAS,OAAO,OAAO,QAAQ;EAChC,CAAC"}
+{"version":3,"file":"scheduler.js","names":["catchupPolicy: ConsolidatorCatchupPolicy","registered: Array<{ id: string; kind: ParsedTrigger['kind']; raw: string }>","skipped: Array<{ raw: string; reason: 'unsupported-by-scheduler' | 'filtered-out' }>","declaration: TriggerDeclarationLike"],"sources":["../../src/consolidator/scheduler.ts"],"sourcesContent":["/**\n * Bridge helpers - wire a {@link Consolidator} into the\n * `@graphorin/triggers` Scheduler so trigger declarations fire on\n * the documented schedule (DEC-150 - \"same code path lib + server\").\n *\n * The bridge is structural: any object that exposes the same shape\n * as `@graphorin/triggers`'s `Scheduler` (a `register(declaration)`\n * method) works. The structural import keeps `@graphorin/memory`\n * dependency-free at the type level - the workspace consumer\n * supplies the actual scheduler at runtime.\n *\n * @packageDocumentation\n */\n\nimport type { SessionScope } from '@graphorin/core';\nimport { type ParsedTrigger, parseTriggerSpec, reasonFromTrigger } from './triggers.js';\nimport type { ConsolidatorTriggerReason, ConsolidatorTriggerSpec, PhaseOutcome } from './types.js';\n\n/**\n * Catch-up policy applied when a trigger missed one or more fires\n * while the scheduler was offline. Mirrors\n * `@graphorin/triggers`'s `CatchupPolicy` - duplicated here so the\n * memory package stays import-free at the type level.\n *\n * @stable\n */\nexport type ConsolidatorCatchupPolicy = 'none' | 'last' | 'all';\n\n/**\n * Subset of the `Consolidator` runtime surface the bridge needs.\n * Defined structurally - mirroring {@link SchedulerLike} - so this\n * module never imports `./runtime.js` (which imports the bridge) and\n * the consolidator module graph stays acyclic (issue #22). The full\n * `Consolidator` is assignable as-is.\n *\n * @stable\n */\nexport interface ConsolidatorLike {\n  trigger(reason: ConsolidatorTriggerReason, scope: SessionScope): Promise<PhaseOutcome | null>;\n  config(): { readonly triggers: ReadonlyArray<ConsolidatorTriggerSpec> };\n}\n\n/**\n * Subset of the `@graphorin/triggers` Scheduler surface the bridge\n * needs. Defined structurally so consumers can inject mocks in\n * tests without taking the package dependency.\n *\n * @stable\n */\nexport interface SchedulerLike {\n  register(declaration: TriggerDeclarationLike): Promise<unknown>;\n  unregister?(id: string): Promise<void>;\n}\n\n/**\n * Subset of `@graphorin/triggers`'s `TriggerDeclaration` accepted\n * by {@link SchedulerLike.register}. Field names mirror the\n * upstream shape exactly so the structural type is interchangeable\n * with the real export.\n *\n * @stable\n */\nexport interface TriggerDeclarationLike {\n  readonly id: string;\n  readonly kind: 'cron' | 'interval' | 'idle' | 'event';\n  readonly spec: string;\n  readonly callback: (payload?: unknown) => void | Promise<void>;\n  readonly options: {\n    readonly catchupPolicy?: ConsolidatorCatchupPolicy;\n    readonly maxCatchupRuns?: number;\n    readonly catchupWindowMs?: number;\n    readonly tags?: ReadonlyArray<string>;\n    readonly acknowledgeLibMode?: boolean;\n  };\n}\n\n/** Options accepted by {@link registerConsolidatorTriggers}. */\nexport interface RegisterTriggersOptions {\n  /**\n   * Scope passed to `consolidator.trigger(...)` for every fire. The\n   * consolidator only operates on a single user/session at a time\n   * (DEC-005 single-user-per-process); multi-tenant deployments\n   * register one scheduler-trigger pair per scope.\n   */\n  readonly scope: SessionScope;\n  /**\n   * Catch-up policy applied to every registered trigger. Defaults\n   * to `'none'` per DEC-150 - safest for personal-assistant\n   * scenarios.\n   */\n  readonly catchupPolicy?: ConsolidatorCatchupPolicy;\n  /** Suppress the per-process library-mode WARN. Defaults to `true`. */\n  readonly acknowledgeLibMode?: boolean;\n  /** Optional id prefix - useful when multiple scopes share a scheduler. */\n  readonly idPrefix?: string;\n  /** Optional tags forwarded to the scheduler. */\n  readonly tags?: ReadonlyArray<string>;\n  /**\n   * Filter - only register the supplied subset of triggers. By\n   * default every parseable trigger declared on the consolidator is\n   * registered (turn / event triggers are skipped because the\n   * Scheduler has no way to fire them on its own).\n   */\n  readonly include?: ReadonlyArray<ConsolidatorTriggerSpec>;\n}\n\n/**\n * Outcome of {@link registerConsolidatorTriggers}.\n *\n * @stable\n */\nexport interface RegisterTriggersResult {\n  readonly registered: ReadonlyArray<{\n    readonly id: string;\n    readonly kind: ParsedTrigger['kind'];\n    readonly raw: string;\n  }>;\n  readonly skipped: ReadonlyArray<{\n    readonly raw: string;\n    readonly reason: 'unsupported-by-scheduler' | 'filtered-out';\n  }>;\n}\n\n/**\n * Register every cron / idle / interval trigger declared on the\n * supplied consolidator with the scheduler. Each trigger fires\n * `consolidator.trigger(reason, scope)` so the lib-mode + server\n * paths converge on the same handler.\n *\n * Turn triggers (`turn:N`) and event triggers (`event:NAME`) are\n * skipped - the scheduler cannot count user turns autonomously, and\n * event triggers fire from the consumer's emit path. The runtime\n * caller is responsible for those (e.g. invoking\n * `consolidator.trigger(...)` from the agent loop).\n *\n * @stable\n */\nexport async function registerConsolidatorTriggers(\n  consolidator: ConsolidatorLike,\n  scheduler: SchedulerLike,\n  options: RegisterTriggersOptions,\n): Promise<RegisterTriggersResult> {\n  const config = consolidator.config();\n  const include = options.include ?? config.triggers;\n  const acknowledgeLibMode = options.acknowledgeLibMode ?? true;\n  const catchupPolicy: ConsolidatorCatchupPolicy = options.catchupPolicy ?? 'none';\n  const registered: Array<{ id: string; kind: ParsedTrigger['kind']; raw: string }> = [];\n  const skipped: Array<{ raw: string; reason: 'unsupported-by-scheduler' | 'filtered-out' }> = [];\n  const seenSet = new Set(include);\n  for (const spec of config.triggers) {\n    if (!seenSet.has(spec)) {\n      skipped.push({ raw: spec, reason: 'filtered-out' });\n      continue;\n    }\n    const parsed = parseTriggerSpec(spec);\n    if (parsed.kind === 'turn' || parsed.kind === 'event' || parsed.kind === 'budget') {\n      skipped.push({ raw: parsed.raw, reason: 'unsupported-by-scheduler' });\n      continue;\n    }\n    const id = `${options.idPrefix ?? 'consolidator'}:${parsed.raw}`;\n    const kind: 'cron' | 'idle' | 'interval' = parsed.kind === 'cron' ? 'cron' : 'idle';\n    const declaration: TriggerDeclarationLike = {\n      id,\n      kind,\n      spec: parsed.kind === 'cron' ? parsed.expression : String(parsed.idleMs),\n      async callback() {\n        await consolidator.trigger(reasonFromTrigger(parsed), options.scope);\n      },\n      options: {\n        catchupPolicy,\n        acknowledgeLibMode,\n        ...(options.tags !== undefined ? { tags: options.tags } : {}),\n      },\n    };\n    await scheduler.register(declaration);\n    registered.push({ id, kind: parsed.kind, raw: parsed.raw });\n  }\n  return Object.freeze({\n    registered: Object.freeze(registered),\n    skipped: Object.freeze(skipped),\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAyIA,eAAsB,6BACpB,cACA,WACA,SACiC;CACjC,MAAM,SAAS,aAAa,QAAQ;CACpC,MAAM,UAAU,QAAQ,WAAW,OAAO;CAC1C,MAAM,qBAAqB,QAAQ,sBAAsB;CACzD,MAAMA,gBAA2C,QAAQ,iBAAiB;CAC1E,MAAMC,aAA8E,EAAE;CACtF,MAAMC,UAAuF,EAAE;CAC/F,MAAM,UAAU,IAAI,IAAI,QAAQ;AAChC,MAAK,MAAM,QAAQ,OAAO,UAAU;AAClC,MAAI,CAAC,QAAQ,IAAI,KAAK,EAAE;AACtB,WAAQ,KAAK;IAAE,KAAK;IAAM,QAAQ;IAAgB,CAAC;AACnD;;EAEF,MAAM,SAAS,iBAAiB,KAAK;AACrC,MAAI,OAAO,SAAS,UAAU,OAAO,SAAS,WAAW,OAAO,SAAS,UAAU;AACjF,WAAQ,KAAK;IAAE,KAAK,OAAO;IAAK,QAAQ;IAA4B,CAAC;AACrE;;EAEF,MAAM,KAAK,GAAG,QAAQ,YAAY,eAAe,GAAG,OAAO;EAE3D,MAAMC,cAAsC;GAC1C;GACA,MAHyC,OAAO,SAAS,SAAS,SAAS;GAI3E,MAAM,OAAO,SAAS,SAAS,OAAO,aAAa,OAAO,OAAO,OAAO;GACxE,MAAM,WAAW;AACf,UAAM,aAAa,QAAQ,kBAAkB,OAAO,EAAE,QAAQ,MAAM;;GAEtE,SAAS;IACP;IACA;IACA,GAAI,QAAQ,SAAS,SAAY,EAAE,MAAM,QAAQ,MAAM,GAAG,EAAE;IAC7D;GACF;AACD,QAAM,UAAU,SAAS,YAAY;AACrC,aAAW,KAAK;GAAE;GAAI,MAAM,OAAO;GAAM,KAAK,OAAO;GAAK,CAAC;;AAE7D,QAAO,OAAO,OAAO;EACnB,YAAY,OAAO,OAAO,WAAW;EACrC,SAAS,OAAO,OAAO,QAAQ;EAChC,CAAC"}

package/dist/consolidator/types.d.ts

@@ -122,11 +122,25 @@ interface ConsolidatorConfig {
   /**
    * Weights for the multi-signal salience score (X-1) that orders both
    * threshold archiving and capacity eviction. Defaults to
-   * {@link DEFAULT_SALIENCE_WEIGHTS}; with neutral importance, active
+   * `DEFAULT_SALIENCE_WEIGHTS`; with neutral importance, active
    * status, and first-party provenance salience equals plain retention.
    */
   readonly salienceWeights: SalienceWeights;
   readonly maxStandardBatchSize: number;
+  /**
+   * Input-side transcript budget for the standard phase, in characters
+   * (W-081; chars/4 is the package's deterministic token proxy, so the
+   * 60k default approximates 15k tokens). `maxStandardBatchSize` bounds
+   * only the MESSAGE COUNT of a slice; without a size budget a batch of
+   * near-cap messages can render to hundreds of kilobytes, overflow a
+   * cheap-tier model context on every retry and wedge the cursor
+   * permanently. A transcript over this budget is half-split BEFORE the
+   * provider call (same convergent recursion as the
+   * `finishReason: 'length'` output handling); a single message that
+   * alone exceeds the budget is tail-truncated and recorded on the
+   * phase span. Conservative for CJK scripts by design.
+   */
+  readonly maxTranscriptChars: number;
   readonly maxDeepConflictsPerRun: number;
   readonly dlqMaxRetries: number;
   readonly dlqBaseBackoffMs: number;
@@ -177,6 +191,14 @@ interface ConsolidatorConfig {
   readonly importanceThreshold: number;
   /** Upper bound on salient questions reflection asks per pass. Defaults to `3`. */
   readonly reflectionMaxQuestions: number;
+  /**
+   * W-082: cap on the unreviewed (quarantined) insight queue. Quarantined
+   * insights are exempt from reflection pass-decay - their decay clock
+   * starts at validation - and this bound keeps the review queue from
+   * growing without limit: beyond it the oldest quarantined insights are
+   * pruned. Defaults to `100`.
+   */
+  readonly reflectionMaxQuarantinedInsights: number;
   /**
    * Contextual retrieval for facts written by the standard phase (P1-3).
    * `'late-chunk'` (default at every tier) relies on the offline
@@ -390,6 +412,8 @@ interface CreateConsolidatorOptions {
   /** Override the {@link ConsolidatorConfig.salienceWeights} default (X-1). */
   readonly salienceWeights?: SalienceWeights;
   readonly maxStandardBatchSize?: number;
+  /** Override the per-tier {@link ConsolidatorConfig.maxTranscriptChars} default (W-081). */
+  readonly maxTranscriptChars?: number;
   readonly maxDeepConflictsPerRun?: number;
   readonly dlqMaxRetries?: number;
   readonly dlqBaseBackoffMs?: number;
@@ -409,6 +433,8 @@ interface CreateConsolidatorOptions {
   readonly importanceThreshold?: number;
   /** Override the {@link ConsolidatorConfig.reflectionMaxQuestions} default (P1-1). */
   readonly reflectionMaxQuestions?: number;
+  /** Override the {@link ConsolidatorConfig.reflectionMaxQuarantinedInsights} default (W-082). */
+  readonly reflectionMaxQuarantinedInsights?: number;
   /** Override the per-tier {@link ConsolidatorConfig.contextualRetrieval} default (P1-3). */
   readonly contextualRetrieval?: ContextualRetrievalMode;
   /** Override the per-tier {@link ConsolidatorConfig.learnedContext} default (D3). */
@@ -431,11 +457,14 @@ declare const CONSOLIDATOR_TIER_DEFAULTS: Readonly<Record<ConsolidatorTier, {
   readonly cheapModel: string | null;
   readonly deepModel: string | null;
   readonly onExceed: OnBudgetExceed;
+  /** W-081: input transcript budget for one standard-phase slice. */
+  readonly maxTranscriptChars: number;
   readonly formEpisodes: boolean;
   readonly importanceScoring: boolean;
   readonly reflection: boolean;
   readonly importanceThreshold: number;
   readonly reflectionMaxQuestions: number;
+  readonly reflectionMaxQuarantinedInsights: number;
   readonly contextualRetrieval: ContextualRetrievalMode;
   readonly learnedContext: boolean;
   readonly learnedContextMaxChars: number;

package/dist/consolidator/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/consolidator/types.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;AAoNuD,KAxL3C,uBAAA,GAwL2C,QAAA,MAAA,EAAA,GAAA,QAAA,MAAA,EAAA,GAAA,QAAA,MAAA,EAAA,GAAA,SAAA,MAAA,EAAA,GAAA,UAAA,MAAA,EAAA;AAsBvD;AAcA;AAsBA;;;;;AAGmB,KAvOP,gBAAA,GAuOO,MAAA,GAAA,OAAA,GAAA,UAAA,GAAA,MAAA,GAAA,QAAA;;;;;AA6BnB;AAyBY,UAtRK,yBAAA,CAsRQ;EACd,SAAA,IAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,QAAA,GAAA,QAAA;EACS,SAAA,KAAA,CAAA,EAAA,MAAA,GAAA,MAAA;;;AAUpB;;;;;;;;;;;AAyCoB,UA1TH,oBAAA,CA0TG;EACU,SAAA,eAAA,EAAA,MAAA;EAAR,SAAA,aAAA,EAAA,MAAA;EACA;;;;;;EA+DI,SAAA,iBAAA,EAAA,MAAA;EAAY,SAAA,gBAAA,EAAA,MAAA;EAUzB;;;;;;;EACX,SAAA,UAAA,EAAA,MAAA;;;;;;;;;;;KAxWU,cAAA;;;;;;KAOA,iBAAA;;;;;;UAOK,kBAAA;qBACI,cAAc;iBAClB;mBACE,cAAc;qBACZ;qBACA;;;;;;;;;;;;;;;yBAeI;;;;;;;;;;;;;;;;;;;4BAmBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA+DI;;;;;;;;;;;;;;;;;;;;;UAsBf,oBAAA;;;;;;;;;;;;;UAcA,0BAAA;;;;;;;;;;;;;;;;;;;;;UAsBA,kBAAA;iBACA;qBACI,cAAc;mBAChB,cAAc;;;;;;uBAMV;;qBAEF;;;;;;;mBAOF;;;;;;;;;;;;;UAcF,YAAA;kBACC;;;;;;;;;;;;;;;;;;;;;;;KAwBN,aAAA,aACD;kBACS;oBACE;;;;;;;UASL,yBAAA;;;;;;kBAMC;;;;;;;qBAOG;;;;;;;sBAOC;;;;;;;qBAOD;;;;;;sBAMC;oBACF;;;;;sBAKE,cAAc;kBAClB;oBACE,cAAc;sBACZ,QAAQ;sBACR;;;;;;;;;;;;;;;;;;;;;;2BAmBK;;;;;0BAKD;;;;0BAIA;;;;;;;6BAOG;;;;;;;;;;;;;;;;;;;;;;iCAsBI;;;;;;0BAMP;;;;;;;;;cAUb,4BAA4B,SACvC,OACE;qBAEqB;mBACF,cAAc;;;qBAGZ;;;;;;gCAMW"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/consolidator/types.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;AA0OuD,KA9M3C,uBAAA,GA8M2C,QAAA,MAAA,EAAA,GAAA,QAAA,MAAA,EAAA,GAAA,QAAA,MAAA,EAAA,GAAA,SAAA,MAAA,EAAA,GAAA,UAAA,MAAA,EAAA;AAsBvD;AAcA;AAsBA;;;;;AAGmB,KA7PP,gBAAA,GA6PO,MAAA,GAAA,OAAA,GAAA,UAAA,GAAA,MAAA,GAAA,QAAA;;;;;AA6BnB;AAyBY,UA5SK,yBAAA,CA4SQ;EACd,SAAA,IAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,QAAA,GAAA,QAAA;EACS,SAAA,KAAA,CAAA,EAAA,MAAA,GAAA,MAAA;;;AAUpB;;;;;;;;;;;AAyCoB,UAhVH,oBAAA,CAgVG;EACU,SAAA,eAAA,EAAA,MAAA;EAAR,SAAA,aAAA,EAAA,MAAA;EACA;;;;;;EAmEI,SAAA,iBAAA,EAAA,MAAA;EAAY,SAAA,gBAAA,EAAA,MAAA;EAUzB;;;;;;;EACX,SAAA,UAAA,EAAA,MAAA;;;;;;;;;;;KAlYU,cAAA;;;;;;KAOA,iBAAA;;;;;;UAOK,kBAAA;qBACI,cAAc;iBAClB;mBACE,cAAc;qBACZ;qBACA;;;;;;;;;;;;;;;yBAeI;;;;;;;;;;;;;;;;;;;4BAmBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAqFI;;;;;;;;;;;;;;;;;;;;;UAsBf,oBAAA;;;;;;;;;;;;;UAcA,0BAAA;;;;;;;;;;;;;;;;;;;;;UAsBA,kBAAA;iBACA;qBACI,cAAc;mBAChB,cAAc;;;;;;uBAMV;;qBAEF;;;;;;;mBAOF;;;;;;;;;;;;;UAcF,YAAA;kBACC;;;;;;;;;;;;;;;;;;;;;;;KAwBN,aAAA,aACD;kBACS;oBACE;;;;;;;UASL,yBAAA;;;;;;kBAMC;;;;;;;qBAOG;;;;;;;sBAOC;;;;;;;qBAOD;;;;;;sBAMC;oBACF;;;;;sBAKE,cAAc;kBAClB;oBACE,cAAc;sBACZ,QAAQ;sBACR;;;;;;;;;;;;;;;;;;;;;;2BAmBK;;;;;0BAKD;;;;0BAIA;;;;;;;6BAOG;;;;;;;;;;;;;;;;;;;;;;;;;;iCA0BI;;;;;;0BAMP;;;;;;;;;cAUb,4BAA4B,SACvC,OACE;qBAEqB;mBACF,cAAc;;;qBAGZ;;;;;;;;;gCASW"}

package/dist/consolidator/types.js

@@ -19,11 +19,13 @@ const CONSOLIDATOR_TIER_DEFAULTS = Object.freeze({
 		cheapModel: null,
 		deepModel: null,
 		onExceed: "pause",
+		maxTranscriptChars: 6e4,
 		formEpisodes: false,
 		importanceScoring: false,
 		reflection: false,
 		importanceThreshold: 3,
 		reflectionMaxQuestions: 3,
+		reflectionMaxQuarantinedInsights: 100,
 		contextualRetrieval: "late-chunk",
 		learnedContext: false,
 		learnedContextMaxChars: 1200
@@ -40,11 +42,13 @@ const CONSOLIDATOR_TIER_DEFAULTS = Object.freeze({
 		cheapModel: null,
 		deepModel: null,
 		onExceed: "pause",
+		maxTranscriptChars: 6e4,
 		formEpisodes: false,
 		importanceScoring: false,
 		reflection: false,
 		importanceThreshold: 3,
 		reflectionMaxQuestions: 3,
+		reflectionMaxQuarantinedInsights: 100,
 		contextualRetrieval: "late-chunk",
 		learnedContext: false,
 		learnedContextMaxChars: 1200
@@ -65,11 +69,13 @@ const CONSOLIDATOR_TIER_DEFAULTS = Object.freeze({
 		cheapModel: null,
 		deepModel: null,
 		onExceed: "log",
+		maxTranscriptChars: 6e4,
 		formEpisodes: true,
 		importanceScoring: true,
 		reflection: false,
 		importanceThreshold: 3,
 		reflectionMaxQuestions: 3,
+		reflectionMaxQuarantinedInsights: 100,
 		contextualRetrieval: "late-chunk",
 		learnedContext: false,
 		learnedContextMaxChars: 1200
@@ -90,11 +96,13 @@ const CONSOLIDATOR_TIER_DEFAULTS = Object.freeze({
 		cheapModel: null,
 		deepModel: null,
 		onExceed: "log",
+		maxTranscriptChars: 12e4,
 		formEpisodes: true,
 		importanceScoring: true,
 		reflection: true,
 		importanceThreshold: 3,
 		reflectionMaxQuestions: 3,
+		reflectionMaxQuarantinedInsights: 100,
 		contextualRetrieval: "late-chunk",
 		learnedContext: false,
 		learnedContextMaxChars: 1200
@@ -111,11 +119,13 @@ const CONSOLIDATOR_TIER_DEFAULTS = Object.freeze({
 		cheapModel: null,
 		deepModel: null,
 		onExceed: "pause",
+		maxTranscriptChars: 6e4,
 		formEpisodes: false,
 		importanceScoring: false,
 		reflection: false,
 		importanceThreshold: 3,
 		reflectionMaxQuestions: 3,
+		reflectionMaxQuarantinedInsights: 100,
 		contextualRetrieval: "late-chunk",
 		learnedContext: false,
 		learnedContextMaxChars: 1200

package/dist/consolidator/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":["CONSOLIDATOR_TIER_DEFAULTS: Readonly<\n  Record<\n    ConsolidatorTier,\n    {\n      readonly ceilings: ConsolidatorCeilings;\n      readonly phases: ReadonlyArray<ConsolidatorPhase>;\n      readonly cheapModel: string | null;\n      readonly deepModel: string | null;\n      readonly onExceed: OnBudgetExceed;\n      readonly formEpisodes: boolean;\n      readonly importanceScoring: boolean;\n      readonly reflection: boolean;\n      readonly importanceThreshold: number;\n      readonly reflectionMaxQuestions: number;\n      readonly contextualRetrieval: ContextualRetrievalMode;\n      readonly learnedContext: boolean;\n      readonly learnedContextMaxChars: number;\n    }\n  >\n>"],"sources":["../../src/consolidator/types.ts"],"sourcesContent":["/**\n * Public types for the Phase 10c consolidator runtime.\n *\n * The consolidator is the background pipeline that turns raw\n * conversation turns into long-lived facts and episodes. The runtime\n * has three phases (`light` / `standard` / `deep`), an explicit cost\n * envelope, an idempotent cursor, a wait-then-defer lock, and a\n * dead-letter queue for retry-able failures. The binding architecture\n * references are DEC-133 / DEC-134 / ADR-038.\n *\n * @packageDocumentation\n */\n\nimport type { Provider, SessionScope, Tracer } from '@graphorin/core';\nimport type { ContextualRetrievalMode } from '../internal/contextualize.js';\nimport type { MemoryStoreAdapter } from '../internal/storage-adapter.js';\nimport type { EpisodicMemory } from '../tiers/episodic-memory.js';\nimport type { SemanticMemory } from '../tiers/semantic-memory.js';\nimport type { WorkingMemory } from '../tiers/working-memory.js';\nimport type { SalienceWeights } from './decay.js';\n\n/**\n * Trigger discriminator. The `'turn:N'` and `'idle:Xm'` variants are\n * the production defaults per DEC-133. `'cron:EXPR'`, `'event:NAME'`\n * and `'budget:N'` are opt-in.\n *\n * @stable\n */\nexport type ConsolidatorTriggerSpec =\n  | `turn:${number}`\n  | `idle:${string}`\n  | `cron:${string}`\n  | `event:${string}`\n  | `budget:${number}`;\n\n/**\n * Tier preset that selects a consolidator behaviour bundle. The\n * `'free'` preset is the default per DEC-144 / ADR-038 - no LLM call\n * fires until the operator opts in.\n *\n * @stable\n */\nexport type ConsolidatorTier = 'free' | 'cheap' | 'standard' | 'full' | 'custom';\n\n/**\n * Triggering reason surfaced through `Consolidator.trigger(...)`.\n *\n * @stable\n */\nexport interface ConsolidatorTriggerReason {\n  readonly kind: 'turn' | 'idle' | 'cron' | 'event' | 'budget' | 'manual';\n  readonly value?: string | number;\n}\n\n/**\n * Daily cost ceilings, tracked per budget window. How a breach is\n * handled depends on {@link OnBudgetExceed}: `'pause'` / `'throw'`\n * enforce, `'log'` (the shipped standard/full presets) only WARNs and\n * keeps running. The USD leg accumulates only when a `priceUsage`\n * pricer is configured (memory-consolidation-02) - without one every\n * call prices at $0 and `maxCostPerDay` can never trip. The default\n * ceiling shape per tier is captured in\n * {@link CONSOLIDATOR_TIER_DEFAULTS}.\n *\n * @stable\n */\nexport interface ConsolidatorCeilings {\n  readonly maxTokensPerDay: number;\n  readonly maxCostPerDay: number;\n  /**\n   * ADVISORY (MCON-8): the per-scope lock serializes runs, so effective\n   * concurrency is always 1 per scope regardless of this value. The\n   * field is retained for forward compatibility; it enforces nothing\n   * today.\n   */\n  readonly maxConcurrentRuns: number;\n  readonly maxRunDurationMs: number;\n  /**\n   * Minimum quiet period between non-manual runs per scope (MCON-8).\n   * After each run the runtime persists `nextEligibleAt = now +\n   * cooldownMs`; trigger-driven runs (`turn` / `idle` / `cron` /\n   * `event` / `budget`) inside that window defer with reason\n   * `'cooldown'`. Manual `fireNow(...)` and DLQ replays bypass it.\n   */\n  readonly cooldownMs: number;\n}\n\n/**\n * Behaviour applied by the budget enforcer when a ceiling is hit\n * mid-run. `'pause'` is the conservative default - the consolidator\n * skips subsequent runs until the next budget reset; `'log'` keeps\n * running with a WARN; `'throw'` raises a typed\n * {@link BudgetExceededError}.\n *\n * @stable\n */\nexport type OnBudgetExceed = 'pause' | 'log' | 'throw';\n\n/**\n * Phase identifier used by the runtime + audit rows.\n *\n * @stable\n */\nexport type ConsolidatorPhase = 'light' | 'standard' | 'deep';\n\n/**\n * Locked-down configuration accepted by `createConsolidator(...)`.\n *\n * @stable\n */\nexport interface ConsolidatorConfig {\n  readonly triggers: ReadonlyArray<ConsolidatorTriggerSpec>;\n  readonly tier: ConsolidatorTier;\n  readonly phases: ReadonlyArray<ConsolidatorPhase>;\n  readonly ceilings: ConsolidatorCeilings;\n  readonly onExceed: OnBudgetExceed;\n  /**\n   * Advisory label for the standard phase's model - recorded on spans /\n   * run telemetry only (MCON-7). Routing happens via\n   * `CreateConsolidatorOptions.cheapProvider`; this string disables\n   * nothing.\n   */\n  readonly cheapModel: string | null;\n  /**\n   * Advisory label for the deep phase's model - telemetry only\n   * (MCON-7). Routing happens via\n   * `CreateConsolidatorOptions.deepProvider`.\n   */\n  readonly deepModel: string | null;\n  readonly budgetResetSemantics: 'utc' | 'local' | 'sliding-24h';\n  readonly noiseFilters: ReadonlyArray<'default' | 'minimal' | 'none'>;\n  readonly lockWaitMs: number;\n  readonly decayTauDays: number;\n  readonly decayArchiveThreshold: number;\n  /**\n   * Capacity-bounded eviction target for the light phase (X-1). When set,\n   * each light pass archives the lowest-salience live facts in the LRU\n   * decay window down to this many - **cost / staleness control, not an\n   * accuracy lever**. `null` (the default at every tier) leaves storage\n   * unbounded, so behaviour is identical to pre-X-1. Archiving is a soft,\n   * recoverable move; nothing is hard-deleted.\n   */\n  readonly decayCapacity: number | null;\n  /**\n   * Weights for the multi-signal salience score (X-1) that orders both\n   * threshold archiving and capacity eviction. Defaults to\n   * {@link DEFAULT_SALIENCE_WEIGHTS}; with neutral importance, active\n   * status, and first-party provenance salience equals plain retention.\n   */\n  readonly salienceWeights: SalienceWeights;\n  readonly maxStandardBatchSize: number;\n  readonly maxDeepConflictsPerRun: number;\n  readonly dlqMaxRetries: number;\n  readonly dlqBaseBackoffMs: number;\n  readonly dlqMaxBackoffMs: number;\n  /**\n   * Auto-form a quarantined episode from each processed standard-phase\n   * slice (P1-2). Defaults on at the `standard`+ tiers, off at `free` /\n   * `cheap` / `custom`. The episode summary is one budgeted LLM call;\n   * when the budget is exhausted (or no episodic tier is wired) the\n   * phase degrades to fact-only behaviour.\n   */\n  readonly formEpisodes: boolean;\n  /**\n   * Ask the episode-summarization call for an LLM importance score\n   * (1-10, normalized to `[0, 1]`) so episodic triple-signal retrieval\n   * (recency × relevance × importance) runs on all three signals\n   * (P1-2). Importance is always a *soft* signal - it never gates\n   * retention. Defaults track {@link formEpisodes}.\n   */\n  readonly importanceScoring: boolean;\n  /**\n   * Auto-promotion policy (MCON-2). When `true`, the standard phase admits an\n   * injection-clean **extraction** fact as `active` instead of quarantined, so\n   * routine distillation surfaces in default recall without a manual\n   * `memory review --promote`. Injection-flagged facts always stay quarantined\n   * - the security gate is preserved - and episodes / insights / induced\n   * procedures are unaffected (they remain quarantined-until-validated).\n   * Defaults **off** at every tier: it trades the fail-safe default for\n   * convenience and is an explicit operator opt-in.\n   */\n  readonly autoPromoteExtraction: boolean;\n  /**\n   * Run the deep-phase reflection pass (P1-1): when accumulated episode\n   * importance crosses {@link importanceThreshold}, synthesize\n   * higher-order, cited insights over recent memories (Generative\n   * Agents). Insights land quarantined + `provenance: 'reflection'` and\n   * are ranked below the facts they cite. Defaults **on at the `full`\n   * tier only** (off at `free` / `cheap` / `standard` / `custom`) - it\n   * is the most LLM-intensive phase. A no-op without an episodic tier\n   * or an insight-capable storage adapter.\n   */\n  readonly reflection: boolean;\n  /**\n   * Sum of recent episode importance (each in `[0, 1]`) at or above\n   * which {@link reflection} fires. Below it the pass makes no LLM\n   * call. Defaults to `3`.\n   */\n  readonly importanceThreshold: number;\n  /** Upper bound on salient questions reflection asks per pass. Defaults to `3`. */\n  readonly reflectionMaxQuestions: number;\n  /**\n   * Contextual retrieval for facts written by the standard phase (P1-3).\n   * `'late-chunk'` (default at every tier) relies on the offline\n   * situating-context prefix the shared {@link SemanticMemory} computes\n   * for every write - no extra LLM call. `'llm'` is the opt-in\n   * enrichment: the standard phase spends one budgeted cheap-model call\n   * per additive write to author a 1-2 sentence situating prefix, then\n   * passes it as the write's index text. `'off'` indexes the bare text.\n   * The `'llm'` mode is **consolidator-only** by construction - the hot\n   * write path never has a provider for contextualization.\n   */\n  readonly contextualRetrieval: ContextualRetrievalMode;\n  /**\n   * Maintain the learned-context digest block (D3): after the deep\n   * phase, one budgeted LLM call rewrites the reserved\n   * `learned_context` working block from the previous digest + recent\n   * episodes / active insights / active procedures, so the system\n   * prompt carries a compact standing summary. Defaults **off at every\n   * tier** (Wave-D trial) - a no-op without a working tier handle.\n   */\n  readonly learnedContext: boolean;\n  /** Character bound enforced on the learned-context digest. Default `1200`. */\n  readonly learnedContextMaxChars: number;\n}\n\n/**\n * Per-phase last-run snapshot surfaced inside\n * {@link ConsolidatorStatus.lastRuns}. Each entry carries the\n * timestamp of the most recent **completed** invocation for that\n * phase (`undefined` when the phase has never run).\n *\n * @stable\n */\nexport interface ConsolidatorLastRuns {\n  readonly light?: string;\n  readonly standard?: string;\n  readonly deep?: string;\n}\n\n/**\n * Budget snapshot block of {@link ConsolidatorStatus}. Surfaces\n * both the absolute usage and the remaining envelope so consumers\n * (CLI, server health endpoint) can render the operator dashboard\n * without doing the math themselves.\n *\n * @stable\n */\nexport interface ConsolidatorBudgetSnapshot {\n  readonly tokensUsedToday: number;\n  readonly costUsedToday: number;\n  readonly tokensRemaining: number;\n  readonly costRemaining: number;\n  readonly resetAt: string;\n}\n\n/**\n * Status snapshot returned by {@link Consolidator.status}.\n *\n * Public shape: `{ tier, queueDepth, dlqSize, lastRuns,\n * budgetRemaining, deferredRuns }` - extended with a few additional\n * fields the server health endpoint and the\n * `graphorin consolidator status` CLI consume.\n *\n * `queueDepth` is an alias for {@link pendingConflicts} (the size\n * of the deep-phase queue); both fields are populated for backwards\n * compatibility.\n *\n * @stable\n */\nexport interface ConsolidatorStatus {\n  readonly tier: ConsolidatorTier;\n  readonly triggers: ReadonlyArray<ConsolidatorTriggerSpec>;\n  readonly phases: ReadonlyArray<ConsolidatorPhase>;\n  readonly running: boolean;\n  readonly paused: boolean;\n  /** Most recent completed run timestamp (any phase). */\n  readonly lastRunAt?: string;\n  /** Phase of the most recent completed run. */\n  readonly lastPhase?: ConsolidatorPhase;\n  /** Per-phase last-completed timestamps surfaced for CLI / dashboard. */\n  readonly lastRuns: ConsolidatorLastRuns;\n  /** Spec alias for {@link pendingConflicts}. */\n  readonly queueDepth: number;\n  readonly pendingConflicts: number;\n  readonly dlqSize: number;\n  readonly deferredRuns: number;\n  readonly emptyExtractions: number;\n  readonly budget: ConsolidatorBudgetSnapshot;\n  /** Spec alias - surfaces remaining-budget figures at the top level. */\n  readonly budgetRemaining: {\n    readonly tokens: number;\n    readonly costUsd: number;\n  };\n}\n\n/**\n * Outcome surfaced by every phase invocation. Recorded into\n * `consolidator_runs` and emitted on the AISpan.\n *\n * @stable\n */\nexport interface PhaseOutcome {\n  readonly phase: ConsolidatorPhase;\n  readonly status: 'completed' | 'failed' | 'deferred' | 'partial';\n  readonly factsCreated: number;\n  readonly factsUpdated: number;\n  readonly conflictsResolved: number;\n  /** Episodes auto-formed from the processed slice (P1-2). */\n  readonly episodesFormed: number;\n  /** Insights synthesized by the deep-phase reflection pass (P1-1). */\n  readonly insightsCreated: number;\n  /** True when the learned-context digest block was rewritten (D3). */\n  readonly learnedContextUpdated?: boolean;\n  readonly noiseFilteredCount: number;\n  readonly emptyExtractions: number;\n  readonly llmTokensUsed: number;\n  readonly llmCostUsd: number | null;\n  readonly errorMessage: string | null;\n}\n\n/**\n * Listener callback subscribed via\n * {@link Consolidator.onPhaseFinished}. Useful for tests + observers.\n *\n * @stable\n */\nexport type PhaseListener = (\n  outcome: PhaseOutcome & {\n    readonly scope: SessionScope;\n    readonly trigger: ConsolidatorTriggerReason;\n  },\n) => void;\n\n/**\n * Options accepted by {@link createConsolidator}.\n *\n * @stable\n */\nexport interface CreateConsolidatorOptions {\n  /**\n   * Storage adapter - supplies the consolidator state, runs, DLQ,\n   * and per-tier helpers. The default `@graphorin/store-sqlite`\n   * adapter exposes everything by construction.\n   */\n  readonly store: MemoryStoreAdapter;\n  /**\n   * The {@link SemanticMemory} tier instance from the parent\n   * `createMemory(...)` facade. The standard phase routes every\n   * extracted fact through `semantic.remember(...)` so the conflict\n   * pipeline (Phase 10b) handles dedup / supersede.\n   */\n  readonly semantic: SemanticMemory;\n  /**\n   * The {@link EpisodicMemory} tier instance from the parent\n   * `createMemory(...)` facade. When supplied (and `formEpisodes` is\n   * on) the standard phase auto-forms a quarantined episode per\n   * processed slice (P1-2). Omitted ⇒ episode formation is skipped.\n   */\n  readonly episodic?: EpisodicMemory;\n  /**\n   * The {@link WorkingMemory} tier instance from the parent\n   * `createMemory(...)` facade (D3). Required for the learned-context\n   * pass - without it the pass is a silent no-op even when\n   * `learnedContext` is enabled.\n   */\n  readonly working?: WorkingMemory;\n  /**\n   * Provider used by the standard + deep phases. Required when the\n   * tier enables either phase; ignored when the active phases\n   * collapse to `['light']`.\n   */\n  readonly provider?: Provider | null;\n  readonly tracer?: Tracer;\n  /** Override the wall clock - used by tests. */\n  readonly now?: () => number;\n  /** Random source for stable run ids - used by tests. */\n  readonly randomId?: () => string;\n  readonly triggers?: ReadonlyArray<ConsolidatorTriggerSpec>;\n  readonly tier?: ConsolidatorTier;\n  readonly phases?: ReadonlyArray<ConsolidatorPhase>;\n  readonly ceilings?: Partial<ConsolidatorCeilings>;\n  readonly onExceed?: OnBudgetExceed;\n  /**\n   * USD pricer for phase LLM usage (memory-consolidation-02). Wire it\n   * to `@graphorin/pricing`'s `calculateCost` (or any per-token rate)\n   * so the `maxCostPerDay` ceiling can actually accumulate spend -\n   * without it every phase prices its calls at $0 and the USD ceiling\n   * never trips at any tier.\n   *\n   * ```ts\n   * priceUsage: ({ promptTokens, completionTokens }) =>\n   *   (promptTokens * 3 + completionTokens * 15) / 1_000_000\n   * ```\n   */\n  readonly priceUsage?: (usage: { promptTokens: number; completionTokens: number }) => number;\n  /**\n   * Provider routed to the standard phase (extraction / episode /\n   * reconcile / situating-context calls) when set (MCON-7). Falls back\n   * to `provider`. Pair with `cheapModel` for the telemetry label.\n   */\n  readonly cheapProvider?: Provider | null;\n  /**\n   * Provider routed to the deep phase (conflict judge) and the\n   * reflection pass when set (MCON-7). Falls back to `provider`.\n   */\n  readonly deepProvider?: Provider | null;\n  readonly cheapModel?: string | null;\n  readonly deepModel?: string | null;\n  readonly budgetResetSemantics?: 'utc' | 'local' | 'sliding-24h';\n  readonly noiseFilters?: ReadonlyArray<'default' | 'minimal' | 'none'>;\n  readonly lockWaitMs?: number;\n  readonly decayTauDays?: number;\n  readonly decayArchiveThreshold?: number;\n  /** Override the {@link ConsolidatorConfig.decayCapacity} default (X-1). */\n  readonly decayCapacity?: number | null;\n  /** Override the {@link ConsolidatorConfig.salienceWeights} default (X-1). */\n  readonly salienceWeights?: SalienceWeights;\n  readonly maxStandardBatchSize?: number;\n  readonly maxDeepConflictsPerRun?: number;\n  readonly dlqMaxRetries?: number;\n  readonly dlqBaseBackoffMs?: number;\n  readonly dlqMaxBackoffMs?: number;\n  /** Override the per-tier {@link ConsolidatorConfig.formEpisodes} default (P1-2). */\n  readonly formEpisodes?: boolean;\n  /** Override the per-tier {@link ConsolidatorConfig.importanceScoring} default (P1-2). */\n  readonly importanceScoring?: boolean;\n  /**\n   * Opt in to auto-promotion of injection-clean extraction facts (MCON-2).\n   * Defaults `false`. See {@link ConsolidatorConfig.autoPromoteExtraction}.\n   */\n  readonly autoPromoteExtraction?: boolean;\n  /** Override the per-tier {@link ConsolidatorConfig.reflection} default (P1-1). */\n  readonly reflection?: boolean;\n  /** Override the {@link ConsolidatorConfig.importanceThreshold} default (P1-1). */\n  readonly importanceThreshold?: number;\n  /** Override the {@link ConsolidatorConfig.reflectionMaxQuestions} default (P1-1). */\n  readonly reflectionMaxQuestions?: number;\n  /** Override the per-tier {@link ConsolidatorConfig.contextualRetrieval} default (P1-3). */\n  readonly contextualRetrieval?: ContextualRetrievalMode;\n  /** Override the per-tier {@link ConsolidatorConfig.learnedContext} default (D3). */\n  readonly learnedContext?: boolean;\n  /** Override the {@link ConsolidatorConfig.learnedContextMaxChars} default (D3). */\n  readonly learnedContextMaxChars?: number;\n  /** Default scope used by event triggers + the manual `fireNow` path. */\n  readonly defaultScope?: SessionScope;\n}\n\n/**\n * Tier preset table. The defaults follow ADR-038 §4 - `'free'`\n * disables every LLM phase and pins zero ceilings, the upper tiers\n * widen the budget envelope progressively.\n *\n * @stable\n */\nexport const CONSOLIDATOR_TIER_DEFAULTS: Readonly<\n  Record<\n    ConsolidatorTier,\n    {\n      readonly ceilings: ConsolidatorCeilings;\n      readonly phases: ReadonlyArray<ConsolidatorPhase>;\n      readonly cheapModel: string | null;\n      readonly deepModel: string | null;\n      readonly onExceed: OnBudgetExceed;\n      readonly formEpisodes: boolean;\n      readonly importanceScoring: boolean;\n      readonly reflection: boolean;\n      readonly importanceThreshold: number;\n      readonly reflectionMaxQuestions: number;\n      readonly contextualRetrieval: ContextualRetrievalMode;\n      readonly learnedContext: boolean;\n      readonly learnedContextMaxChars: number;\n    }\n  >\n> = Object.freeze({\n  free: {\n    ceilings: {\n      maxTokensPerDay: 0,\n      maxCostPerDay: 0,\n      maxConcurrentRuns: 1,\n      maxRunDurationMs: 5 * 60 * 1000,\n      cooldownMs: 60_000,\n    },\n    phases: ['light'],\n    cheapModel: null,\n    deepModel: null,\n    onExceed: 'pause',\n    formEpisodes: false,\n    importanceScoring: false,\n    reflection: false,\n    importanceThreshold: 3,\n    reflectionMaxQuestions: 3,\n    contextualRetrieval: 'late-chunk',\n    learnedContext: false,\n    learnedContextMaxChars: 1200,\n  },\n  cheap: {\n    ceilings: {\n      maxTokensPerDay: 50_000,\n      maxCostPerDay: 0.2,\n      maxConcurrentRuns: 1,\n      maxRunDurationMs: 5 * 60 * 1000,\n      cooldownMs: 60_000,\n    },\n    phases: ['light', 'standard'],\n    cheapModel: null,\n    deepModel: null,\n    onExceed: 'pause',\n    formEpisodes: false,\n    importanceScoring: false,\n    reflection: false,\n    importanceThreshold: 3,\n    reflectionMaxQuestions: 3,\n    contextualRetrieval: 'late-chunk',\n    learnedContext: false,\n    learnedContextMaxChars: 1200,\n  },\n  standard: {\n    ceilings: {\n      maxTokensPerDay: 200_000,\n      maxCostPerDay: 1.0,\n      maxConcurrentRuns: 1,\n      maxRunDurationMs: 10 * 60 * 1000,\n      cooldownMs: 30_000,\n    },\n    phases: ['light', 'standard', 'deep'],\n    cheapModel: null,\n    deepModel: null,\n    onExceed: 'log',\n    formEpisodes: true,\n    importanceScoring: true,\n    reflection: false,\n    importanceThreshold: 3,\n    reflectionMaxQuestions: 3,\n    contextualRetrieval: 'late-chunk',\n    learnedContext: false,\n    learnedContextMaxChars: 1200,\n  },\n  full: {\n    ceilings: {\n      maxTokensPerDay: 1_000_000,\n      maxCostPerDay: 5.0,\n      maxConcurrentRuns: 2,\n      maxRunDurationMs: 15 * 60 * 1000,\n      cooldownMs: 10_000,\n    },\n    phases: ['light', 'standard', 'deep'],\n    cheapModel: null,\n    deepModel: null,\n    onExceed: 'log',\n    formEpisodes: true,\n    importanceScoring: true,\n    reflection: true,\n    importanceThreshold: 3,\n    reflectionMaxQuestions: 3,\n    contextualRetrieval: 'late-chunk',\n    learnedContext: false,\n    learnedContextMaxChars: 1200,\n  },\n  custom: {\n    ceilings: {\n      maxTokensPerDay: 0,\n      maxCostPerDay: 0,\n      maxConcurrentRuns: 1,\n      maxRunDurationMs: 5 * 60 * 1000,\n      cooldownMs: 60_000,\n    },\n    phases: ['light'],\n    cheapModel: null,\n    deepModel: null,\n    onExceed: 'pause',\n    formEpisodes: false,\n    importanceScoring: false,\n    reflection: false,\n    importanceThreshold: 3,\n    reflectionMaxQuestions: 3,\n    contextualRetrieval: 'late-chunk',\n    learnedContext: false,\n    learnedContextMaxChars: 1200,\n  },\n});\n"],"mappings":";;;;;;;;AAucA,MAAaA,6BAmBT,OAAO,OAAO;CAChB,MAAM;EACJ,UAAU;GACR,iBAAiB;GACjB,eAAe;GACf,mBAAmB;GACnB,kBAAkB,MAAS;GAC3B,YAAY;GACb;EACD,QAAQ,CAAC,QAAQ;EACjB,YAAY;EACZ,WAAW;EACX,UAAU;EACV,cAAc;EACd,mBAAmB;EACnB,YAAY;EACZ,qBAAqB;EACrB,wBAAwB;EACxB,qBAAqB;EACrB,gBAAgB;EAChB,wBAAwB;EACzB;CACD,OAAO;EACL,UAAU;GACR,iBAAiB;GACjB,eAAe;GACf,mBAAmB;GACnB,kBAAkB,MAAS;GAC3B,YAAY;GACb;EACD,QAAQ,CAAC,SAAS,WAAW;EAC7B,YAAY;EACZ,WAAW;EACX,UAAU;EACV,cAAc;EACd,mBAAmB;EACnB,YAAY;EACZ,qBAAqB;EACrB,wBAAwB;EACxB,qBAAqB;EACrB,gBAAgB;EAChB,wBAAwB;EACzB;CACD,UAAU;EACR,UAAU;GACR,iBAAiB;GACjB,eAAe;GACf,mBAAmB;GACnB,kBAAkB,MAAU;GAC5B,YAAY;GACb;EACD,QAAQ;GAAC;GAAS;GAAY;GAAO;EACrC,YAAY;EACZ,WAAW;EACX,UAAU;EACV,cAAc;EACd,mBAAmB;EACnB,YAAY;EACZ,qBAAqB;EACrB,wBAAwB;EACxB,qBAAqB;EACrB,gBAAgB;EAChB,wBAAwB;EACzB;CACD,MAAM;EACJ,UAAU;GACR,iBAAiB;GACjB,eAAe;GACf,mBAAmB;GACnB,kBAAkB,MAAU;GAC5B,YAAY;GACb;EACD,QAAQ;GAAC;GAAS;GAAY;GAAO;EACrC,YAAY;EACZ,WAAW;EACX,UAAU;EACV,cAAc;EACd,mBAAmB;EACnB,YAAY;EACZ,qBAAqB;EACrB,wBAAwB;EACxB,qBAAqB;EACrB,gBAAgB;EAChB,wBAAwB;EACzB;CACD,QAAQ;EACN,UAAU;GACR,iBAAiB;GACjB,eAAe;GACf,mBAAmB;GACnB,kBAAkB,MAAS;GAC3B,YAAY;GACb;EACD,QAAQ,CAAC,QAAQ;EACjB,YAAY;EACZ,WAAW;EACX,UAAU;EACV,cAAc;EACd,mBAAmB;EACnB,YAAY;EACZ,qBAAqB;EACrB,wBAAwB;EACxB,qBAAqB;EACrB,gBAAgB;EAChB,wBAAwB;EACzB;CACF,CAAC"}
+{"version":3,"file":"types.js","names":["CONSOLIDATOR_TIER_DEFAULTS: Readonly<\n  Record<\n    ConsolidatorTier,\n    {\n      readonly ceilings: ConsolidatorCeilings;\n      readonly phases: ReadonlyArray<ConsolidatorPhase>;\n      readonly cheapModel: string | null;\n      readonly deepModel: string | null;\n      readonly onExceed: OnBudgetExceed;\n      /** W-081: input transcript budget for one standard-phase slice. */\n      readonly maxTranscriptChars: number;\n      readonly formEpisodes: boolean;\n      readonly importanceScoring: boolean;\n      readonly reflection: boolean;\n      readonly importanceThreshold: number;\n      readonly reflectionMaxQuestions: number;\n      readonly reflectionMaxQuarantinedInsights: number;\n      readonly contextualRetrieval: ContextualRetrievalMode;\n      readonly learnedContext: boolean;\n      readonly learnedContextMaxChars: number;\n    }\n  >\n>"],"sources":["../../src/consolidator/types.ts"],"sourcesContent":["/**\n * Public types for the Phase 10c consolidator runtime.\n *\n * The consolidator is the background pipeline that turns raw\n * conversation turns into long-lived facts and episodes. The runtime\n * has three phases (`light` / `standard` / `deep`), an explicit cost\n * envelope, an idempotent cursor, a wait-then-defer lock, and a\n * dead-letter queue for retry-able failures. The binding architecture\n * references are DEC-133 / DEC-134 / ADR-038.\n *\n * @packageDocumentation\n */\n\nimport type { Provider, SessionScope, Tracer } from '@graphorin/core';\nimport type { ContextualRetrievalMode } from '../internal/contextualize.js';\nimport type { MemoryStoreAdapter } from '../internal/storage-adapter.js';\nimport type { EpisodicMemory } from '../tiers/episodic-memory.js';\nimport type { SemanticMemory } from '../tiers/semantic-memory.js';\nimport type { WorkingMemory } from '../tiers/working-memory.js';\nimport type { SalienceWeights } from './decay.js';\n\n/**\n * Trigger discriminator. The `'turn:N'` and `'idle:Xm'` variants are\n * the production defaults per DEC-133. `'cron:EXPR'`, `'event:NAME'`\n * and `'budget:N'` are opt-in.\n *\n * @stable\n */\nexport type ConsolidatorTriggerSpec =\n  | `turn:${number}`\n  | `idle:${string}`\n  | `cron:${string}`\n  | `event:${string}`\n  | `budget:${number}`;\n\n/**\n * Tier preset that selects a consolidator behaviour bundle. The\n * `'free'` preset is the default per DEC-144 / ADR-038 - no LLM call\n * fires until the operator opts in.\n *\n * @stable\n */\nexport type ConsolidatorTier = 'free' | 'cheap' | 'standard' | 'full' | 'custom';\n\n/**\n * Triggering reason surfaced through `Consolidator.trigger(...)`.\n *\n * @stable\n */\nexport interface ConsolidatorTriggerReason {\n  readonly kind: 'turn' | 'idle' | 'cron' | 'event' | 'budget' | 'manual';\n  readonly value?: string | number;\n}\n\n/**\n * Daily cost ceilings, tracked per budget window. How a breach is\n * handled depends on {@link OnBudgetExceed}: `'pause'` / `'throw'`\n * enforce, `'log'` (the shipped standard/full presets) only WARNs and\n * keeps running. The USD leg accumulates only when a `priceUsage`\n * pricer is configured (memory-consolidation-02) - without one every\n * call prices at $0 and `maxCostPerDay` can never trip. The default\n * ceiling shape per tier is captured in\n * {@link CONSOLIDATOR_TIER_DEFAULTS}.\n *\n * @stable\n */\nexport interface ConsolidatorCeilings {\n  readonly maxTokensPerDay: number;\n  readonly maxCostPerDay: number;\n  /**\n   * ADVISORY (MCON-8): the per-scope lock serializes runs, so effective\n   * concurrency is always 1 per scope regardless of this value. The\n   * field is retained for forward compatibility; it enforces nothing\n   * today.\n   */\n  readonly maxConcurrentRuns: number;\n  readonly maxRunDurationMs: number;\n  /**\n   * Minimum quiet period between non-manual runs per scope (MCON-8).\n   * After each run the runtime persists `nextEligibleAt = now +\n   * cooldownMs`; trigger-driven runs (`turn` / `idle` / `cron` /\n   * `event` / `budget`) inside that window defer with reason\n   * `'cooldown'`. Manual `fireNow(...)` and DLQ replays bypass it.\n   */\n  readonly cooldownMs: number;\n}\n\n/**\n * Behaviour applied by the budget enforcer when a ceiling is hit\n * mid-run. `'pause'` is the conservative default - the consolidator\n * skips subsequent runs until the next budget reset; `'log'` keeps\n * running with a WARN; `'throw'` raises a typed\n * {@link BudgetExceededError}.\n *\n * @stable\n */\nexport type OnBudgetExceed = 'pause' | 'log' | 'throw';\n\n/**\n * Phase identifier used by the runtime + audit rows.\n *\n * @stable\n */\nexport type ConsolidatorPhase = 'light' | 'standard' | 'deep';\n\n/**\n * Locked-down configuration accepted by `createConsolidator(...)`.\n *\n * @stable\n */\nexport interface ConsolidatorConfig {\n  readonly triggers: ReadonlyArray<ConsolidatorTriggerSpec>;\n  readonly tier: ConsolidatorTier;\n  readonly phases: ReadonlyArray<ConsolidatorPhase>;\n  readonly ceilings: ConsolidatorCeilings;\n  readonly onExceed: OnBudgetExceed;\n  /**\n   * Advisory label for the standard phase's model - recorded on spans /\n   * run telemetry only (MCON-7). Routing happens via\n   * `CreateConsolidatorOptions.cheapProvider`; this string disables\n   * nothing.\n   */\n  readonly cheapModel: string | null;\n  /**\n   * Advisory label for the deep phase's model - telemetry only\n   * (MCON-7). Routing happens via\n   * `CreateConsolidatorOptions.deepProvider`.\n   */\n  readonly deepModel: string | null;\n  readonly budgetResetSemantics: 'utc' | 'local' | 'sliding-24h';\n  readonly noiseFilters: ReadonlyArray<'default' | 'minimal' | 'none'>;\n  readonly lockWaitMs: number;\n  readonly decayTauDays: number;\n  readonly decayArchiveThreshold: number;\n  /**\n   * Capacity-bounded eviction target for the light phase (X-1). When set,\n   * each light pass archives the lowest-salience live facts in the LRU\n   * decay window down to this many - **cost / staleness control, not an\n   * accuracy lever**. `null` (the default at every tier) leaves storage\n   * unbounded, so behaviour is identical to pre-X-1. Archiving is a soft,\n   * recoverable move; nothing is hard-deleted.\n   */\n  readonly decayCapacity: number | null;\n  /**\n   * Weights for the multi-signal salience score (X-1) that orders both\n   * threshold archiving and capacity eviction. Defaults to\n   * `DEFAULT_SALIENCE_WEIGHTS`; with neutral importance, active\n   * status, and first-party provenance salience equals plain retention.\n   */\n  readonly salienceWeights: SalienceWeights;\n  readonly maxStandardBatchSize: number;\n  /**\n   * Input-side transcript budget for the standard phase, in characters\n   * (W-081; chars/4 is the package's deterministic token proxy, so the\n   * 60k default approximates 15k tokens). `maxStandardBatchSize` bounds\n   * only the MESSAGE COUNT of a slice; without a size budget a batch of\n   * near-cap messages can render to hundreds of kilobytes, overflow a\n   * cheap-tier model context on every retry and wedge the cursor\n   * permanently. A transcript over this budget is half-split BEFORE the\n   * provider call (same convergent recursion as the\n   * `finishReason: 'length'` output handling); a single message that\n   * alone exceeds the budget is tail-truncated and recorded on the\n   * phase span. Conservative for CJK scripts by design.\n   */\n  readonly maxTranscriptChars: number;\n  readonly maxDeepConflictsPerRun: number;\n  readonly dlqMaxRetries: number;\n  readonly dlqBaseBackoffMs: number;\n  readonly dlqMaxBackoffMs: number;\n  /**\n   * Auto-form a quarantined episode from each processed standard-phase\n   * slice (P1-2). Defaults on at the `standard`+ tiers, off at `free` /\n   * `cheap` / `custom`. The episode summary is one budgeted LLM call;\n   * when the budget is exhausted (or no episodic tier is wired) the\n   * phase degrades to fact-only behaviour.\n   */\n  readonly formEpisodes: boolean;\n  /**\n   * Ask the episode-summarization call for an LLM importance score\n   * (1-10, normalized to `[0, 1]`) so episodic triple-signal retrieval\n   * (recency × relevance × importance) runs on all three signals\n   * (P1-2). Importance is always a *soft* signal - it never gates\n   * retention. Defaults track {@link formEpisodes}.\n   */\n  readonly importanceScoring: boolean;\n  /**\n   * Auto-promotion policy (MCON-2). When `true`, the standard phase admits an\n   * injection-clean **extraction** fact as `active` instead of quarantined, so\n   * routine distillation surfaces in default recall without a manual\n   * `memory review --promote`. Injection-flagged facts always stay quarantined\n   * - the security gate is preserved - and episodes / insights / induced\n   * procedures are unaffected (they remain quarantined-until-validated).\n   * Defaults **off** at every tier: it trades the fail-safe default for\n   * convenience and is an explicit operator opt-in.\n   */\n  readonly autoPromoteExtraction: boolean;\n  /**\n   * Run the deep-phase reflection pass (P1-1): when accumulated episode\n   * importance crosses {@link importanceThreshold}, synthesize\n   * higher-order, cited insights over recent memories (Generative\n   * Agents). Insights land quarantined + `provenance: 'reflection'` and\n   * are ranked below the facts they cite. Defaults **on at the `full`\n   * tier only** (off at `free` / `cheap` / `standard` / `custom`) - it\n   * is the most LLM-intensive phase. A no-op without an episodic tier\n   * or an insight-capable storage adapter.\n   */\n  readonly reflection: boolean;\n  /**\n   * Sum of recent episode importance (each in `[0, 1]`) at or above\n   * which {@link reflection} fires. Below it the pass makes no LLM\n   * call. Defaults to `3`.\n   */\n  readonly importanceThreshold: number;\n  /** Upper bound on salient questions reflection asks per pass. Defaults to `3`. */\n  readonly reflectionMaxQuestions: number;\n  /**\n   * W-082: cap on the unreviewed (quarantined) insight queue. Quarantined\n   * insights are exempt from reflection pass-decay - their decay clock\n   * starts at validation - and this bound keeps the review queue from\n   * growing without limit: beyond it the oldest quarantined insights are\n   * pruned. Defaults to `100`.\n   */\n  readonly reflectionMaxQuarantinedInsights: number;\n  /**\n   * Contextual retrieval for facts written by the standard phase (P1-3).\n   * `'late-chunk'` (default at every tier) relies on the offline\n   * situating-context prefix the shared {@link SemanticMemory} computes\n   * for every write - no extra LLM call. `'llm'` is the opt-in\n   * enrichment: the standard phase spends one budgeted cheap-model call\n   * per additive write to author a 1-2 sentence situating prefix, then\n   * passes it as the write's index text. `'off'` indexes the bare text.\n   * The `'llm'` mode is **consolidator-only** by construction - the hot\n   * write path never has a provider for contextualization.\n   */\n  readonly contextualRetrieval: ContextualRetrievalMode;\n  /**\n   * Maintain the learned-context digest block (D3): after the deep\n   * phase, one budgeted LLM call rewrites the reserved\n   * `learned_context` working block from the previous digest + recent\n   * episodes / active insights / active procedures, so the system\n   * prompt carries a compact standing summary. Defaults **off at every\n   * tier** (Wave-D trial) - a no-op without a working tier handle.\n   */\n  readonly learnedContext: boolean;\n  /** Character bound enforced on the learned-context digest. Default `1200`. */\n  readonly learnedContextMaxChars: number;\n}\n\n/**\n * Per-phase last-run snapshot surfaced inside\n * {@link ConsolidatorStatus.lastRuns}. Each entry carries the\n * timestamp of the most recent **completed** invocation for that\n * phase (`undefined` when the phase has never run).\n *\n * @stable\n */\nexport interface ConsolidatorLastRuns {\n  readonly light?: string;\n  readonly standard?: string;\n  readonly deep?: string;\n}\n\n/**\n * Budget snapshot block of {@link ConsolidatorStatus}. Surfaces\n * both the absolute usage and the remaining envelope so consumers\n * (CLI, server health endpoint) can render the operator dashboard\n * without doing the math themselves.\n *\n * @stable\n */\nexport interface ConsolidatorBudgetSnapshot {\n  readonly tokensUsedToday: number;\n  readonly costUsedToday: number;\n  readonly tokensRemaining: number;\n  readonly costRemaining: number;\n  readonly resetAt: string;\n}\n\n/**\n * Status snapshot returned by {@link Consolidator.status}.\n *\n * Public shape: `{ tier, queueDepth, dlqSize, lastRuns,\n * budgetRemaining, deferredRuns }` - extended with a few additional\n * fields the server health endpoint and the\n * `graphorin consolidator status` CLI consume.\n *\n * `queueDepth` is an alias for {@link pendingConflicts} (the size\n * of the deep-phase queue); both fields are populated for backwards\n * compatibility.\n *\n * @stable\n */\nexport interface ConsolidatorStatus {\n  readonly tier: ConsolidatorTier;\n  readonly triggers: ReadonlyArray<ConsolidatorTriggerSpec>;\n  readonly phases: ReadonlyArray<ConsolidatorPhase>;\n  readonly running: boolean;\n  readonly paused: boolean;\n  /** Most recent completed run timestamp (any phase). */\n  readonly lastRunAt?: string;\n  /** Phase of the most recent completed run. */\n  readonly lastPhase?: ConsolidatorPhase;\n  /** Per-phase last-completed timestamps surfaced for CLI / dashboard. */\n  readonly lastRuns: ConsolidatorLastRuns;\n  /** Spec alias for {@link pendingConflicts}. */\n  readonly queueDepth: number;\n  readonly pendingConflicts: number;\n  readonly dlqSize: number;\n  readonly deferredRuns: number;\n  readonly emptyExtractions: number;\n  readonly budget: ConsolidatorBudgetSnapshot;\n  /** Spec alias - surfaces remaining-budget figures at the top level. */\n  readonly budgetRemaining: {\n    readonly tokens: number;\n    readonly costUsd: number;\n  };\n}\n\n/**\n * Outcome surfaced by every phase invocation. Recorded into\n * `consolidator_runs` and emitted on the AISpan.\n *\n * @stable\n */\nexport interface PhaseOutcome {\n  readonly phase: ConsolidatorPhase;\n  readonly status: 'completed' | 'failed' | 'deferred' | 'partial';\n  readonly factsCreated: number;\n  readonly factsUpdated: number;\n  readonly conflictsResolved: number;\n  /** Episodes auto-formed from the processed slice (P1-2). */\n  readonly episodesFormed: number;\n  /** Insights synthesized by the deep-phase reflection pass (P1-1). */\n  readonly insightsCreated: number;\n  /** True when the learned-context digest block was rewritten (D3). */\n  readonly learnedContextUpdated?: boolean;\n  readonly noiseFilteredCount: number;\n  readonly emptyExtractions: number;\n  readonly llmTokensUsed: number;\n  readonly llmCostUsd: number | null;\n  readonly errorMessage: string | null;\n}\n\n/**\n * Listener callback subscribed via\n * {@link Consolidator.onPhaseFinished}. Useful for tests + observers.\n *\n * @stable\n */\nexport type PhaseListener = (\n  outcome: PhaseOutcome & {\n    readonly scope: SessionScope;\n    readonly trigger: ConsolidatorTriggerReason;\n  },\n) => void;\n\n/**\n * Options accepted by {@link createConsolidator}.\n *\n * @stable\n */\nexport interface CreateConsolidatorOptions {\n  /**\n   * Storage adapter - supplies the consolidator state, runs, DLQ,\n   * and per-tier helpers. The default `@graphorin/store-sqlite`\n   * adapter exposes everything by construction.\n   */\n  readonly store: MemoryStoreAdapter;\n  /**\n   * The {@link SemanticMemory} tier instance from the parent\n   * `createMemory(...)` facade. The standard phase routes every\n   * extracted fact through `semantic.remember(...)` so the conflict\n   * pipeline (Phase 10b) handles dedup / supersede.\n   */\n  readonly semantic: SemanticMemory;\n  /**\n   * The {@link EpisodicMemory} tier instance from the parent\n   * `createMemory(...)` facade. When supplied (and `formEpisodes` is\n   * on) the standard phase auto-forms a quarantined episode per\n   * processed slice (P1-2). Omitted ⇒ episode formation is skipped.\n   */\n  readonly episodic?: EpisodicMemory;\n  /**\n   * The {@link WorkingMemory} tier instance from the parent\n   * `createMemory(...)` facade (D3). Required for the learned-context\n   * pass - without it the pass is a silent no-op even when\n   * `learnedContext` is enabled.\n   */\n  readonly working?: WorkingMemory;\n  /**\n   * Provider used by the standard + deep phases. Required when the\n   * tier enables either phase; ignored when the active phases\n   * collapse to `['light']`.\n   */\n  readonly provider?: Provider | null;\n  readonly tracer?: Tracer;\n  /** Override the wall clock - used by tests. */\n  readonly now?: () => number;\n  /** Random source for stable run ids - used by tests. */\n  readonly randomId?: () => string;\n  readonly triggers?: ReadonlyArray<ConsolidatorTriggerSpec>;\n  readonly tier?: ConsolidatorTier;\n  readonly phases?: ReadonlyArray<ConsolidatorPhase>;\n  readonly ceilings?: Partial<ConsolidatorCeilings>;\n  readonly onExceed?: OnBudgetExceed;\n  /**\n   * USD pricer for phase LLM usage (memory-consolidation-02). Wire it\n   * to `@graphorin/pricing`'s `calculateCost` (or any per-token rate)\n   * so the `maxCostPerDay` ceiling can actually accumulate spend -\n   * without it every phase prices its calls at $0 and the USD ceiling\n   * never trips at any tier.\n   *\n   * ```ts\n   * priceUsage: ({ promptTokens, completionTokens }) =>\n   *   (promptTokens * 3 + completionTokens * 15) / 1_000_000\n   * ```\n   */\n  readonly priceUsage?: (usage: { promptTokens: number; completionTokens: number }) => number;\n  /**\n   * Provider routed to the standard phase (extraction / episode /\n   * reconcile / situating-context calls) when set (MCON-7). Falls back\n   * to `provider`. Pair with `cheapModel` for the telemetry label.\n   */\n  readonly cheapProvider?: Provider | null;\n  /**\n   * Provider routed to the deep phase (conflict judge) and the\n   * reflection pass when set (MCON-7). Falls back to `provider`.\n   */\n  readonly deepProvider?: Provider | null;\n  readonly cheapModel?: string | null;\n  readonly deepModel?: string | null;\n  readonly budgetResetSemantics?: 'utc' | 'local' | 'sliding-24h';\n  readonly noiseFilters?: ReadonlyArray<'default' | 'minimal' | 'none'>;\n  readonly lockWaitMs?: number;\n  readonly decayTauDays?: number;\n  readonly decayArchiveThreshold?: number;\n  /** Override the {@link ConsolidatorConfig.decayCapacity} default (X-1). */\n  readonly decayCapacity?: number | null;\n  /** Override the {@link ConsolidatorConfig.salienceWeights} default (X-1). */\n  readonly salienceWeights?: SalienceWeights;\n  readonly maxStandardBatchSize?: number;\n  /** Override the per-tier {@link ConsolidatorConfig.maxTranscriptChars} default (W-081). */\n  readonly maxTranscriptChars?: number;\n  readonly maxDeepConflictsPerRun?: number;\n  readonly dlqMaxRetries?: number;\n  readonly dlqBaseBackoffMs?: number;\n  readonly dlqMaxBackoffMs?: number;\n  /** Override the per-tier {@link ConsolidatorConfig.formEpisodes} default (P1-2). */\n  readonly formEpisodes?: boolean;\n  /** Override the per-tier {@link ConsolidatorConfig.importanceScoring} default (P1-2). */\n  readonly importanceScoring?: boolean;\n  /**\n   * Opt in to auto-promotion of injection-clean extraction facts (MCON-2).\n   * Defaults `false`. See {@link ConsolidatorConfig.autoPromoteExtraction}.\n   */\n  readonly autoPromoteExtraction?: boolean;\n  /** Override the per-tier {@link ConsolidatorConfig.reflection} default (P1-1). */\n  readonly reflection?: boolean;\n  /** Override the {@link ConsolidatorConfig.importanceThreshold} default (P1-1). */\n  readonly importanceThreshold?: number;\n  /** Override the {@link ConsolidatorConfig.reflectionMaxQuestions} default (P1-1). */\n  readonly reflectionMaxQuestions?: number;\n  /** Override the {@link ConsolidatorConfig.reflectionMaxQuarantinedInsights} default (W-082). */\n  readonly reflectionMaxQuarantinedInsights?: number;\n  /** Override the per-tier {@link ConsolidatorConfig.contextualRetrieval} default (P1-3). */\n  readonly contextualRetrieval?: ContextualRetrievalMode;\n  /** Override the per-tier {@link ConsolidatorConfig.learnedContext} default (D3). */\n  readonly learnedContext?: boolean;\n  /** Override the {@link ConsolidatorConfig.learnedContextMaxChars} default (D3). */\n  readonly learnedContextMaxChars?: number;\n  /** Default scope used by event triggers + the manual `fireNow` path. */\n  readonly defaultScope?: SessionScope;\n}\n\n/**\n * Tier preset table. The defaults follow ADR-038 §4 - `'free'`\n * disables every LLM phase and pins zero ceilings, the upper tiers\n * widen the budget envelope progressively.\n *\n * @stable\n */\nexport const CONSOLIDATOR_TIER_DEFAULTS: Readonly<\n  Record<\n    ConsolidatorTier,\n    {\n      readonly ceilings: ConsolidatorCeilings;\n      readonly phases: ReadonlyArray<ConsolidatorPhase>;\n      readonly cheapModel: string | null;\n      readonly deepModel: string | null;\n      readonly onExceed: OnBudgetExceed;\n      /** W-081: input transcript budget for one standard-phase slice. */\n      readonly maxTranscriptChars: number;\n      readonly formEpisodes: boolean;\n      readonly importanceScoring: boolean;\n      readonly reflection: boolean;\n      readonly importanceThreshold: number;\n      readonly reflectionMaxQuestions: number;\n      readonly reflectionMaxQuarantinedInsights: number;\n      readonly contextualRetrieval: ContextualRetrievalMode;\n      readonly learnedContext: boolean;\n      readonly learnedContextMaxChars: number;\n    }\n  >\n> = Object.freeze({\n  free: {\n    ceilings: {\n      maxTokensPerDay: 0,\n      maxCostPerDay: 0,\n      maxConcurrentRuns: 1,\n      maxRunDurationMs: 5 * 60 * 1000,\n      cooldownMs: 60_000,\n    },\n    phases: ['light'],\n    cheapModel: null,\n    deepModel: null,\n    onExceed: 'pause',\n    maxTranscriptChars: 60_000,\n    formEpisodes: false,\n    importanceScoring: false,\n    reflection: false,\n    importanceThreshold: 3,\n    reflectionMaxQuestions: 3,\n    reflectionMaxQuarantinedInsights: 100,\n    contextualRetrieval: 'late-chunk',\n    learnedContext: false,\n    learnedContextMaxChars: 1200,\n  },\n  cheap: {\n    ceilings: {\n      maxTokensPerDay: 50_000,\n      maxCostPerDay: 0.2,\n      maxConcurrentRuns: 1,\n      maxRunDurationMs: 5 * 60 * 1000,\n      cooldownMs: 60_000,\n    },\n    phases: ['light', 'standard'],\n    cheapModel: null,\n    deepModel: null,\n    onExceed: 'pause',\n    maxTranscriptChars: 60_000,\n    formEpisodes: false,\n    importanceScoring: false,\n    reflection: false,\n    importanceThreshold: 3,\n    reflectionMaxQuestions: 3,\n    reflectionMaxQuarantinedInsights: 100,\n    contextualRetrieval: 'late-chunk',\n    learnedContext: false,\n    learnedContextMaxChars: 1200,\n  },\n  standard: {\n    ceilings: {\n      maxTokensPerDay: 200_000,\n      maxCostPerDay: 1.0,\n      maxConcurrentRuns: 1,\n      maxRunDurationMs: 10 * 60 * 1000,\n      cooldownMs: 30_000,\n    },\n    phases: ['light', 'standard', 'deep'],\n    cheapModel: null,\n    deepModel: null,\n    onExceed: 'log',\n    maxTranscriptChars: 60_000,\n    formEpisodes: true,\n    importanceScoring: true,\n    reflection: false,\n    importanceThreshold: 3,\n    reflectionMaxQuestions: 3,\n    reflectionMaxQuarantinedInsights: 100,\n    contextualRetrieval: 'late-chunk',\n    learnedContext: false,\n    learnedContextMaxChars: 1200,\n  },\n  full: {\n    ceilings: {\n      maxTokensPerDay: 1_000_000,\n      maxCostPerDay: 5.0,\n      maxConcurrentRuns: 2,\n      maxRunDurationMs: 15 * 60 * 1000,\n      cooldownMs: 10_000,\n    },\n    phases: ['light', 'standard', 'deep'],\n    cheapModel: null,\n    deepModel: null,\n    onExceed: 'log',\n    // Full-tier models carry wider contexts - a larger input budget\n    // keeps slices coarse (fewer calls) without risking overflow.\n    maxTranscriptChars: 120_000,\n    formEpisodes: true,\n    importanceScoring: true,\n    reflection: true,\n    importanceThreshold: 3,\n    reflectionMaxQuestions: 3,\n    reflectionMaxQuarantinedInsights: 100,\n    contextualRetrieval: 'late-chunk',\n    learnedContext: false,\n    learnedContextMaxChars: 1200,\n  },\n  custom: {\n    ceilings: {\n      maxTokensPerDay: 0,\n      maxCostPerDay: 0,\n      maxConcurrentRuns: 1,\n      maxRunDurationMs: 5 * 60 * 1000,\n      cooldownMs: 60_000,\n    },\n    phases: ['light'],\n    cheapModel: null,\n    deepModel: null,\n    onExceed: 'pause',\n    maxTranscriptChars: 60_000,\n    formEpisodes: false,\n    importanceScoring: false,\n    reflection: false,\n    importanceThreshold: 3,\n    reflectionMaxQuestions: 3,\n    reflectionMaxQuarantinedInsights: 100,\n    contextualRetrieval: 'late-chunk',\n    learnedContext: false,\n    learnedContextMaxChars: 1200,\n  },\n});\n"],"mappings":";;;;;;;;AAieA,MAAaA,6BAsBT,OAAO,OAAO;CAChB,MAAM;EACJ,UAAU;GACR,iBAAiB;GACjB,eAAe;GACf,mBAAmB;GACnB,kBAAkB,MAAS;GAC3B,YAAY;GACb;EACD,QAAQ,CAAC,QAAQ;EACjB,YAAY;EACZ,WAAW;EACX,UAAU;EACV,oBAAoB;EACpB,cAAc;EACd,mBAAmB;EACnB,YAAY;EACZ,qBAAqB;EACrB,wBAAwB;EACxB,kCAAkC;EAClC,qBAAqB;EACrB,gBAAgB;EAChB,wBAAwB;EACzB;CACD,OAAO;EACL,UAAU;GACR,iBAAiB;GACjB,eAAe;GACf,mBAAmB;GACnB,kBAAkB,MAAS;GAC3B,YAAY;GACb;EACD,QAAQ,CAAC,SAAS,WAAW;EAC7B,YAAY;EACZ,WAAW;EACX,UAAU;EACV,oBAAoB;EACpB,cAAc;EACd,mBAAmB;EACnB,YAAY;EACZ,qBAAqB;EACrB,wBAAwB;EACxB,kCAAkC;EAClC,qBAAqB;EACrB,gBAAgB;EAChB,wBAAwB;EACzB;CACD,UAAU;EACR,UAAU;GACR,iBAAiB;GACjB,eAAe;GACf,mBAAmB;GACnB,kBAAkB,MAAU;GAC5B,YAAY;GACb;EACD,QAAQ;GAAC;GAAS;GAAY;GAAO;EACrC,YAAY;EACZ,WAAW;EACX,UAAU;EACV,oBAAoB;EACpB,cAAc;EACd,mBAAmB;EACnB,YAAY;EACZ,qBAAqB;EACrB,wBAAwB;EACxB,kCAAkC;EAClC,qBAAqB;EACrB,gBAAgB;EAChB,wBAAwB;EACzB;CACD,MAAM;EACJ,UAAU;GACR,iBAAiB;GACjB,eAAe;GACf,mBAAmB;GACnB,kBAAkB,MAAU;GAC5B,YAAY;GACb;EACD,QAAQ;GAAC;GAAS;GAAY;GAAO;EACrC,YAAY;EACZ,WAAW;EACX,UAAU;EAGV,oBAAoB;EACpB,cAAc;EACd,mBAAmB;EACnB,YAAY;EACZ,qBAAqB;EACrB,wBAAwB;EACxB,kCAAkC;EAClC,qBAAqB;EACrB,gBAAgB;EAChB,wBAAwB;EACzB;CACD,QAAQ;EACN,UAAU;GACR,iBAAiB;GACjB,eAAe;GACf,mBAAmB;GACnB,kBAAkB,MAAS;GAC3B,YAAY;GACb;EACD,QAAQ,CAAC,QAAQ;EACjB,YAAY;EACZ,WAAW;EACX,UAAU;EACV,oBAAoB;EACpB,cAAc;EACd,mBAAmB;EACnB,YAAY;EACZ,qBAAqB;EACrB,wBAAwB;EACxB,kCAAkC;EAClC,qBAAqB;EACrB,gBAAgB;EAChB,wBAAwB;EACzB;CACF,CAAC"}

package/dist/context-engine/compaction/clear-tool-results.d.ts

@@ -7,7 +7,7 @@ import { Message } from "@graphorin/core";
 declare const CLEARED_TOOL_RESULT_MARKER = "[cleared tool result";
 /** Knobs for {@link clearOldToolResults} (mirrors the strategy variant). */
 interface ClearToolResultsOptions {
-  /** Most-recent tool results kept verbatim (default {@link DEFAULT_KEEP_TOOL_USES}). */
+  /** Most-recent tool results kept verbatim (default `DEFAULT_KEEP_TOOL_USES`). */
   readonly keepToolUses?: number;
   /** Only clear if at least this many tokens are reclaimable; else leave untouched (default 0). */
   readonly clearAtLeast?: number;

package/dist/context-engine/compaction/clear-tool-results.js

@@ -114,5 +114,5 @@ async function clearOldToolResults(messages, options, counter) {
 }
 
 //#endregion
-export { CLEARED_TOOL_RESULT_MARKER, DEFAULT_KEEP_TOOL_USES, clearOldToolResults };
+export { CLEARED_TOOL_RESULT_MARKER, clearOldToolResults };
 //# sourceMappingURL=clear-tool-results.js.map

package/dist/context-engine/compaction/clear-tool-results.js.map

@@ -1 +1 @@
-{"version":3,"file":"clear-tool-results.js","names":["toolIdx: number[]","replaced: ToolMessage","out: Message[]"],"sources":["../../../src/context-engine/compaction/clear-tool-results.ts"],"sourcesContent":["/**\n * SOTA-1: zero-LLM tool-result clearing - the cheapest pre-compaction tier.\n *\n * Mirrors Anthropic context editing (`clear_tool_uses_20250919`): when the\n * buffer crosses the compaction threshold, replace the oldest tool results with\n * a compact placeholder BEFORE paying for a summarizer LLM call. The most recent\n * `keepToolUses` results stay verbatim, `excludeTools` are never touched, and\n * clearing is skipped entirely when it would reclaim fewer than `clearAtLeast`\n * tokens (not worth the context churn). Pure + deterministic - no provider call.\n *\n * @packageDocumentation\n */\n\nimport type { Message, ToolMessage } from '@graphorin/core';\nimport {\n  type ContextTokenCounter,\n  countMessageTokens,\n  renderMessageText,\n} from '../token-counter.js';\n\n/** Placeholder prefix on a cleared tool result - makes clearing idempotent. */\nexport const CLEARED_TOOL_RESULT_MARKER = '[cleared tool result';\n\n/** Default count of most-recent tool results kept verbatim. */\nexport const DEFAULT_KEEP_TOOL_USES = 3;\n\n/** Knobs for {@link clearOldToolResults} (mirrors the strategy variant). */\nexport interface ClearToolResultsOptions {\n  /** Most-recent tool results kept verbatim (default {@link DEFAULT_KEEP_TOOL_USES}). */\n  readonly keepToolUses?: number;\n  /** Only clear if at least this many tokens are reclaimable; else leave untouched (default 0). */\n  readonly clearAtLeast?: number;\n  /** Tool names whose results are never cleared. */\n  readonly excludeTools?: ReadonlyArray<string>;\n  /** Placeholder builder; defaults to a one-line `[cleared tool result …]` marker. */\n  readonly placeholder?: (info: {\n    readonly toolCallId: string;\n    readonly toolName?: string;\n    readonly clearedTokens: number;\n  }) => string;\n  /**\n   * A6 / SOTA-2 - recoverable clearing. When provided, the original tool-result\n   * text of each cleared message is handed to this callback (wire it to a spill\n   * store / the `read_result` handle registry) and the placeholder references the\n   * returned handle id + preview, so the model can re-fetch the full result via\n   * `read_result` rather than losing it. Invoked only for clears that actually\n   * commit (after the `clearAtLeast` floor), so a rejected clearing never spills.\n   * Omitted ⇒ the bare `placeholder` (irrecoverable, byte-identical default).\n   */\n  readonly externalize?: (\n    content: string,\n    info: {\n      readonly toolCallId: string;\n      readonly toolName?: string;\n      readonly clearedTokens: number;\n    },\n  ) => Promise<{ readonly handleId: string; readonly preview?: string }>;\n  /**\n   * C4 (context-engine-11): the tool the externalized-handle placeholder\n   * advertises. The memory package cannot know whether the agent\n   * registered `read_result` (that depends on spill wiring), so callers\n   * whose runtime does NOT expose it pass `null` and the placeholder\n   * degrades to a tool-neutral phrasing instead of promising a tool the\n   * model cannot call. Default `'read_result'` (the agent built-in).\n   */\n  readonly readResultToolName?: string | null;\n  /**\n   * C4 (clear_tool_uses_20250919 parity): additionally blank the PAIRED\n   * assistant message's tool-call arguments for every cleared result,\n   * reclaiming the input side of verbose calls too. Default `false`.\n   */\n  readonly clearToolInputs?: boolean;\n}\n\n/** Result of a clearing pass. `clearedIndices` empty ⇒ nothing changed. */\nexport interface ClearToolResultsOutcome {\n  readonly messages: ReadonlyArray<Message>;\n  readonly clearedIndices: ReadonlyArray<number>;\n  readonly reclaimedTokens: number;\n}\n\nfunction defaultPlaceholder(info: { toolName?: string; clearedTokens: number }): string {\n  return `${CLEARED_TOOL_RESULT_MARKER} · ${info.toolName ?? 'tool'} · ${info.clearedTokens} tokens elided · re-run the tool if needed]`;\n}\n\n/** A6: a placeholder that points at the externalized handle (recoverable via read_result). */\nfunction handlePlaceholder(info: {\n  toolName?: string;\n  clearedTokens: number;\n  handleId: string;\n  preview?: string;\n  readToolName?: string | null;\n}): string {\n  const preview = info.preview !== undefined && info.preview.length > 0 ? ` · ${info.preview}` : '';\n  // C4 (context-engine-11): only advertise a retrieval tool the caller\n  // vouches exists; `null` degrades to a tool-neutral phrasing.\n  const retrieval =\n    info.readToolName === null\n      ? `full result externalized to handle: ${info.handleId}`\n      : `full result via ${info.readToolName ?? 'read_result'} handle: ${info.handleId}`;\n  return `${CLEARED_TOOL_RESULT_MARKER} · ${info.toolName ?? 'tool'} · ${info.clearedTokens} tokens · ${retrieval}${preview}]`;\n}\n\nfunction isAlreadyCleared(content: Message['content']): boolean {\n  return typeof content === 'string' && content.startsWith(CLEARED_TOOL_RESULT_MARKER);\n}\n\n/**\n * Replace the oldest clearable tool results with placeholders. Returns the new\n * buffer (same length - content is replaced in place, never removed) plus the\n * cleared indices and reclaimed token count. Idempotent: already-cleared\n * placeholders are skipped on a second pass.\n */\nexport async function clearOldToolResults(\n  messages: ReadonlyArray<Message>,\n  options: ClearToolResultsOptions,\n  counter: ContextTokenCounter,\n): Promise<ClearToolResultsOutcome> {\n  const keep = options.keepToolUses ?? DEFAULT_KEEP_TOOL_USES;\n  const exclude = new Set(options.excludeTools ?? []);\n  const placeholder = options.placeholder ?? defaultPlaceholder;\n\n  // toolCallId → toolName from every assistant tool-call in the buffer.\n  const toolNameById = new Map<string, string>();\n  for (const m of messages) {\n    if (m.role === 'assistant' && m.toolCalls) {\n      for (const tc of m.toolCalls) toolNameById.set(tc.toolCallId, tc.toolName);\n    }\n  }\n\n  // Indices of all not-yet-cleared tool-result messages, oldest first.\n  const toolIdx: number[] = [];\n  for (let i = 0; i < messages.length; i++) {\n    const m = messages[i];\n    if (m?.role === 'tool' && !isAlreadyCleared(m.content)) toolIdx.push(i);\n  }\n\n  // Keep the most-recent `keep`; older ones are candidates unless excluded.\n  const keptCutoff = toolIdx.length - Math.max(0, keep);\n  const replacements = new Map<number, ToolMessage>();\n  const clearedTokensByIdx = new Map<number, number>();\n  let reclaimable = 0;\n  for (let j = 0; j < toolIdx.length && j < keptCutoff; j++) {\n    const idx = toolIdx[j];\n    if (idx === undefined) continue;\n    const tm = messages[idx] as ToolMessage;\n    const name = toolNameById.get(tm.toolCallId);\n    if (name !== undefined && exclude.has(name)) continue;\n    const originalTokens = await countMessageTokens([tm], counter);\n    const replaced: ToolMessage = {\n      role: 'tool',\n      toolCallId: tm.toolCallId,\n      content: placeholder({\n        toolCallId: tm.toolCallId,\n        ...(name !== undefined ? { toolName: name } : {}),\n        clearedTokens: originalTokens,\n      }),\n    };\n    const placeholderTokens = await countMessageTokens([replaced], counter);\n    reclaimable += Math.max(0, originalTokens - placeholderTokens);\n    replacements.set(idx, replaced);\n    clearedTokensByIdx.set(idx, originalTokens);\n  }\n\n  const clearAtLeast = options.clearAtLeast ?? 0;\n  if (replacements.size === 0 || reclaimable < clearAtLeast) {\n    return { messages, clearedIndices: [], reclaimedTokens: 0 };\n  }\n\n  // A6: only now that the clearing commits, externalize each cleared result to a\n  // recoverable handle and rewrite its placeholder to reference it. Skipped\n  // clears (above) never reach here, so the spill never fires for nothing.\n  const externalize = options.externalize;\n  if (externalize !== undefined) {\n    for (const idx of replacements.keys()) {\n      const tm = messages[idx] as ToolMessage;\n      const name = toolNameById.get(tm.toolCallId);\n      const clearedTokens = clearedTokensByIdx.get(idx) ?? 0;\n      const content = typeof tm.content === 'string' ? tm.content : renderMessageText(tm);\n      const handle = await externalize(content, {\n        toolCallId: tm.toolCallId,\n        ...(name !== undefined ? { toolName: name } : {}),\n        clearedTokens,\n      });\n      replacements.set(idx, {\n        role: 'tool',\n        toolCallId: tm.toolCallId,\n        content: handlePlaceholder({\n          ...(name !== undefined ? { toolName: name } : {}),\n          clearedTokens,\n          handleId: handle.handleId,\n          ...(handle.preview !== undefined ? { preview: handle.preview } : {}),\n          ...(options.readResultToolName !== undefined\n            ? { readToolName: options.readResultToolName }\n            : {}),\n        }),\n      });\n    }\n  }\n\n  let out: Message[] = messages.map((m, i) => replacements.get(i) ?? m);\n\n  // C4 (clear_tool_uses parity): blank the paired assistant tool-call\n  // ARGUMENTS for every cleared result. The call's name and id survive\n  // (the transcript stays well-formed); only the argument payload is\n  // replaced with a marker object.\n  if (options.clearToolInputs === true && replacements.size > 0) {\n    const clearedCallIds = new Set<string>();\n    for (const idx of replacements.keys()) {\n      const tm = messages[idx] as ToolMessage;\n      clearedCallIds.add(tm.toolCallId);\n    }\n    out = out.map((m) => {\n      if (m.role !== 'assistant' || m.toolCalls === undefined) return m;\n      if (!m.toolCalls.some((tc) => clearedCallIds.has(tc.toolCallId))) return m;\n      return {\n        ...m,\n        toolCalls: m.toolCalls.map((tc) =>\n          clearedCallIds.has(tc.toolCallId)\n            ? { ...tc, args: { cleared: '[tool input elided by context clearing]' } }\n            : tc,\n        ),\n      };\n    });\n  }\n\n  return {\n    messages: out,\n    clearedIndices: [...replacements.keys()],\n    reclaimedTokens: reclaimable,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"clear-tool-results.js","names":["toolIdx: number[]","replaced: ToolMessage","out: Message[]"],"sources":["../../../src/context-engine/compaction/clear-tool-results.ts"],"sourcesContent":["/**\n * SOTA-1: zero-LLM tool-result clearing - the cheapest pre-compaction tier.\n *\n * Mirrors Anthropic context editing (`clear_tool_uses_20250919`): when the\n * buffer crosses the compaction threshold, replace the oldest tool results with\n * a compact placeholder BEFORE paying for a summarizer LLM call. The most recent\n * `keepToolUses` results stay verbatim, `excludeTools` are never touched, and\n * clearing is skipped entirely when it would reclaim fewer than `clearAtLeast`\n * tokens (not worth the context churn). Pure + deterministic - no provider call.\n *\n * @packageDocumentation\n */\n\nimport type { Message, ToolMessage } from '@graphorin/core';\nimport {\n  type ContextTokenCounter,\n  countMessageTokens,\n  renderMessageText,\n} from '../token-counter.js';\n\n/** Placeholder prefix on a cleared tool result - makes clearing idempotent. */\nexport const CLEARED_TOOL_RESULT_MARKER = '[cleared tool result';\n\n/** Default count of most-recent tool results kept verbatim. */\nexport const DEFAULT_KEEP_TOOL_USES = 3;\n\n/** Knobs for {@link clearOldToolResults} (mirrors the strategy variant). */\nexport interface ClearToolResultsOptions {\n  /** Most-recent tool results kept verbatim (default `DEFAULT_KEEP_TOOL_USES`). */\n  readonly keepToolUses?: number;\n  /** Only clear if at least this many tokens are reclaimable; else leave untouched (default 0). */\n  readonly clearAtLeast?: number;\n  /** Tool names whose results are never cleared. */\n  readonly excludeTools?: ReadonlyArray<string>;\n  /** Placeholder builder; defaults to a one-line `[cleared tool result …]` marker. */\n  readonly placeholder?: (info: {\n    readonly toolCallId: string;\n    readonly toolName?: string;\n    readonly clearedTokens: number;\n  }) => string;\n  /**\n   * A6 / SOTA-2 - recoverable clearing. When provided, the original tool-result\n   * text of each cleared message is handed to this callback (wire it to a spill\n   * store / the `read_result` handle registry) and the placeholder references the\n   * returned handle id + preview, so the model can re-fetch the full result via\n   * `read_result` rather than losing it. Invoked only for clears that actually\n   * commit (after the `clearAtLeast` floor), so a rejected clearing never spills.\n   * Omitted ⇒ the bare `placeholder` (irrecoverable, byte-identical default).\n   */\n  readonly externalize?: (\n    content: string,\n    info: {\n      readonly toolCallId: string;\n      readonly toolName?: string;\n      readonly clearedTokens: number;\n    },\n  ) => Promise<{ readonly handleId: string; readonly preview?: string }>;\n  /**\n   * C4 (context-engine-11): the tool the externalized-handle placeholder\n   * advertises. The memory package cannot know whether the agent\n   * registered `read_result` (that depends on spill wiring), so callers\n   * whose runtime does NOT expose it pass `null` and the placeholder\n   * degrades to a tool-neutral phrasing instead of promising a tool the\n   * model cannot call. Default `'read_result'` (the agent built-in).\n   */\n  readonly readResultToolName?: string | null;\n  /**\n   * C4 (clear_tool_uses_20250919 parity): additionally blank the PAIRED\n   * assistant message's tool-call arguments for every cleared result,\n   * reclaiming the input side of verbose calls too. Default `false`.\n   */\n  readonly clearToolInputs?: boolean;\n}\n\n/** Result of a clearing pass. `clearedIndices` empty ⇒ nothing changed. */\nexport interface ClearToolResultsOutcome {\n  readonly messages: ReadonlyArray<Message>;\n  readonly clearedIndices: ReadonlyArray<number>;\n  readonly reclaimedTokens: number;\n}\n\nfunction defaultPlaceholder(info: { toolName?: string; clearedTokens: number }): string {\n  return `${CLEARED_TOOL_RESULT_MARKER} · ${info.toolName ?? 'tool'} · ${info.clearedTokens} tokens elided · re-run the tool if needed]`;\n}\n\n/** A6: a placeholder that points at the externalized handle (recoverable via read_result). */\nfunction handlePlaceholder(info: {\n  toolName?: string;\n  clearedTokens: number;\n  handleId: string;\n  preview?: string;\n  readToolName?: string | null;\n}): string {\n  const preview = info.preview !== undefined && info.preview.length > 0 ? ` · ${info.preview}` : '';\n  // C4 (context-engine-11): only advertise a retrieval tool the caller\n  // vouches exists; `null` degrades to a tool-neutral phrasing.\n  const retrieval =\n    info.readToolName === null\n      ? `full result externalized to handle: ${info.handleId}`\n      : `full result via ${info.readToolName ?? 'read_result'} handle: ${info.handleId}`;\n  return `${CLEARED_TOOL_RESULT_MARKER} · ${info.toolName ?? 'tool'} · ${info.clearedTokens} tokens · ${retrieval}${preview}]`;\n}\n\nfunction isAlreadyCleared(content: Message['content']): boolean {\n  return typeof content === 'string' && content.startsWith(CLEARED_TOOL_RESULT_MARKER);\n}\n\n/**\n * Replace the oldest clearable tool results with placeholders. Returns the new\n * buffer (same length - content is replaced in place, never removed) plus the\n * cleared indices and reclaimed token count. Idempotent: already-cleared\n * placeholders are skipped on a second pass.\n */\nexport async function clearOldToolResults(\n  messages: ReadonlyArray<Message>,\n  options: ClearToolResultsOptions,\n  counter: ContextTokenCounter,\n): Promise<ClearToolResultsOutcome> {\n  const keep = options.keepToolUses ?? DEFAULT_KEEP_TOOL_USES;\n  const exclude = new Set(options.excludeTools ?? []);\n  const placeholder = options.placeholder ?? defaultPlaceholder;\n\n  // toolCallId → toolName from every assistant tool-call in the buffer.\n  const toolNameById = new Map<string, string>();\n  for (const m of messages) {\n    if (m.role === 'assistant' && m.toolCalls) {\n      for (const tc of m.toolCalls) toolNameById.set(tc.toolCallId, tc.toolName);\n    }\n  }\n\n  // Indices of all not-yet-cleared tool-result messages, oldest first.\n  const toolIdx: number[] = [];\n  for (let i = 0; i < messages.length; i++) {\n    const m = messages[i];\n    if (m?.role === 'tool' && !isAlreadyCleared(m.content)) toolIdx.push(i);\n  }\n\n  // Keep the most-recent `keep`; older ones are candidates unless excluded.\n  const keptCutoff = toolIdx.length - Math.max(0, keep);\n  const replacements = new Map<number, ToolMessage>();\n  const clearedTokensByIdx = new Map<number, number>();\n  let reclaimable = 0;\n  for (let j = 0; j < toolIdx.length && j < keptCutoff; j++) {\n    const idx = toolIdx[j];\n    if (idx === undefined) continue;\n    const tm = messages[idx] as ToolMessage;\n    const name = toolNameById.get(tm.toolCallId);\n    if (name !== undefined && exclude.has(name)) continue;\n    const originalTokens = await countMessageTokens([tm], counter);\n    const replaced: ToolMessage = {\n      role: 'tool',\n      toolCallId: tm.toolCallId,\n      content: placeholder({\n        toolCallId: tm.toolCallId,\n        ...(name !== undefined ? { toolName: name } : {}),\n        clearedTokens: originalTokens,\n      }),\n    };\n    const placeholderTokens = await countMessageTokens([replaced], counter);\n    reclaimable += Math.max(0, originalTokens - placeholderTokens);\n    replacements.set(idx, replaced);\n    clearedTokensByIdx.set(idx, originalTokens);\n  }\n\n  const clearAtLeast = options.clearAtLeast ?? 0;\n  if (replacements.size === 0 || reclaimable < clearAtLeast) {\n    return { messages, clearedIndices: [], reclaimedTokens: 0 };\n  }\n\n  // A6: only now that the clearing commits, externalize each cleared result to a\n  // recoverable handle and rewrite its placeholder to reference it. Skipped\n  // clears (above) never reach here, so the spill never fires for nothing.\n  const externalize = options.externalize;\n  if (externalize !== undefined) {\n    for (const idx of replacements.keys()) {\n      const tm = messages[idx] as ToolMessage;\n      const name = toolNameById.get(tm.toolCallId);\n      const clearedTokens = clearedTokensByIdx.get(idx) ?? 0;\n      const content = typeof tm.content === 'string' ? tm.content : renderMessageText(tm);\n      const handle = await externalize(content, {\n        toolCallId: tm.toolCallId,\n        ...(name !== undefined ? { toolName: name } : {}),\n        clearedTokens,\n      });\n      replacements.set(idx, {\n        role: 'tool',\n        toolCallId: tm.toolCallId,\n        content: handlePlaceholder({\n          ...(name !== undefined ? { toolName: name } : {}),\n          clearedTokens,\n          handleId: handle.handleId,\n          ...(handle.preview !== undefined ? { preview: handle.preview } : {}),\n          ...(options.readResultToolName !== undefined\n            ? { readToolName: options.readResultToolName }\n            : {}),\n        }),\n      });\n    }\n  }\n\n  let out: Message[] = messages.map((m, i) => replacements.get(i) ?? m);\n\n  // C4 (clear_tool_uses parity): blank the paired assistant tool-call\n  // ARGUMENTS for every cleared result. The call's name and id survive\n  // (the transcript stays well-formed); only the argument payload is\n  // replaced with a marker object.\n  if (options.clearToolInputs === true && replacements.size > 0) {\n    const clearedCallIds = new Set<string>();\n    for (const idx of replacements.keys()) {\n      const tm = messages[idx] as ToolMessage;\n      clearedCallIds.add(tm.toolCallId);\n    }\n    out = out.map((m) => {\n      if (m.role !== 'assistant' || m.toolCalls === undefined) return m;\n      if (!m.toolCalls.some((tc) => clearedCallIds.has(tc.toolCallId))) return m;\n      return {\n        ...m,\n        toolCalls: m.toolCalls.map((tc) =>\n          clearedCallIds.has(tc.toolCallId)\n            ? { ...tc, args: { cleared: '[tool input elided by context clearing]' } }\n            : tc,\n        ),\n      };\n    });\n  }\n\n  return {\n    messages: out,\n    clearedIndices: [...replacements.keys()],\n    reclaimedTokens: reclaimable,\n  };\n}\n"],"mappings":"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"}

package/dist/context-engine/compaction/compactor.d.ts

@@ -3,6 +3,7 @@ import { ContextTokenCounter } from "../token-counter.js";
 import { CompactionResult, CompactionSource, CompactionStrategy, CompactionSummarizer } from "./types.js";
 import * as _graphorin_core2 from "@graphorin/core";
 import { Message } from "@graphorin/core";
+import "@graphorin/observability/redaction";
 
 //#region src/context-engine/compaction/compactor.d.ts
 

package/dist/context-engine/compaction/compactor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compactor.d.ts","names":[],"sources":["../../../src/context-engine/compaction/compactor.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;cAiDa,6BAAA;;;;;;;;;;UA0CI,sBAAA;qBACI,cAAc;mBAChB;qBACE;uBACE;uBACA;0BACG;;;;;kBAAmB,gBAAA,CAKD;2BAAY,gBAAA,CACH;;oBAEjC;;;;;;;;;;iBAWE,iBAAA,QAAyB,yBAAyB,QAAQ"}
+{"version":3,"file":"compactor.d.ts","names":[],"sources":["../../../src/context-engine/compaction/compactor.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;cAqDa,6BAAA;;;;;;;;;;UA+DI,sBAAA;qBACI,cAAc;mBAChB;qBACE;uBACE;uBACA;0BACG;;;;;kBAAmB,gBAAA,CAKD;2BAAY,gBAAA,CACH;;oBAEjC;;;;;;;;;;iBAWE,iBAAA,QAAyB,yBAAyB,QAAQ"}

package/dist/context-engine/compaction/compactor.js

@@ -1,3 +1,4 @@
+import { UNTRUSTED_CONTENT_OPEN_PREFIX, wrapUntrusted } from "../../internal/envelope.js";
 import { HEURISTIC_TOKEN_COUNTER, countMessageTokens, renderMessageText } from "../token-counter.js";
 import { clearOldToolResults } from "./clear-tool-results.js";
 import { SUMMARY_TEMPLATE_NAME, SUMMARY_TEMPLATE_VERSION, buildSummarizerPrompt, renderFinalSummary } from "./templates/summary-9-section.js";
@@ -12,16 +13,32 @@ import { scanImperativePatterns } from "@graphorin/observability/redaction";
 */
 const DEFAULT_PRESERVE_RECENT_TURNS = 6;
 /** Opening marker of the inbound-untrusted envelope (tools sanitize layer). */
-const UNTRUSTED_MARKER = "<<<untrusted_content";
+const UNTRUSTED_MARKER = UNTRUSTED_CONTENT_OPEN_PREFIX;
 /**
 * Wall-clock budget for the CE-15 injection scan of the summarizer
 * output. The scanner's 5ms default exists for the per-tool-result
-* hot path; here a compaction already paid for an LLM call, and on a
-* contended host (slow CI runners included) scheduler noise can cross
-* 5ms between pattern iterations - making the scanner return `null`
-* (verdict unknown) and the security check silently fail open.
+* hot path; a compaction already paid for an LLM call, the summary
+* body is a single bounded text, and the pattern catalogue is fixed,
+* so the scan here runs UNBUDGETED - a wall-clock budget only turned
+* scheduler noise into a `null` verdict (a 50ms budget was observed
+* expiring on a degraded CI runner, silently failing the check open).
 */
-const COMPACTION_SCAN_BUDGET_MS = 50;
+const COMPACTION_SCAN_BUDGET_MS = Number.POSITIVE_INFINITY;
+/**
+* CE-15 trust decision for a freshly produced summary. Exported for
+* unit tests because the `scan === null` branch (scanner budget
+* exceeded) MUST fail closed: the scanner's contract is "null = the
+* caller applies its own best-effort degradation", and treating null
+* as "no hits" would commit a poisoned summary as trusted exactly on
+* the contended hosts where the budget expires.
+*
+* @internal
+*/
+function resolveSummaryTrust(windowUntrusted, scan) {
+	if (windowUntrusted) return "untrusted-derived";
+	if (scan === null) return "untrusted-derived";
+	return scan.hits.length > 0 ? "untrusted-derived" : "trusted";
+}
 /** CE-15: does the compacted window carry inbound-untrusted envelopes? */
 function windowContainsUntrusted(messages) {
 	return messages.some((message) => renderMessageText(message).includes(UNTRUSTED_MARKER));
@@ -31,9 +48,16 @@ function windowContainsUntrusted(messages) {
 * envelope. Envelope marker sequences inside the body are neutralized
 * first so summarizer output influenced by injected text cannot break
 * out of the envelope and masquerade as authoritative system text.
+* Delegates to the shared `internal/envelope.ts` helper (W-083) so the
+* whole memory package neutralizes markers with one scheme; the
+* output is byte-identical to the historical inline implementation on
+* literal-marker inputs.
 */
 function wrapSummaryAsDerived(body) {
-	return `<<<untrusted_content trust="derived" tool="compaction-summarizer">>>\n${body.replaceAll("<<</untrusted_content>>>", "[[/untrusted_content]]").replaceAll(UNTRUSTED_MARKER, "[[untrusted_content")}\n<<</untrusted_content>>>`;
+	return wrapUntrusted(body, {
+		trust: "derived",
+		tool: "compaction-summarizer"
+	});
 }
 /**
 * Perform a compaction call. Returns the result envelope containing
@@ -119,7 +143,7 @@ async function executeCompaction(input) {
 		preserveRecentTurns
 	};
 	const summaryScan = scanImperativePatterns(summarized.text, void 0, COMPACTION_SCAN_BUDGET_MS);
-	const summaryTrust = windowContainsUntrusted(olderMessages) || summaryScan !== null && summaryScan.hits.length > 0 ? "untrusted-derived" : "trusted";
+	const summaryTrust = resolveSummaryTrust(windowContainsUntrusted(olderMessages), summaryScan);
 	const finalSummary = renderFinalSummary({
 		template,
 		summaryFromLlm: summaryTrust === "untrusted-derived" ? wrapSummaryAsDerived(summarized.text) : summarized.text,