cognitive-core 0.2.4 → 0.3.1

package/dist/types/config.d.ts

@@ -17,6 +17,19 @@ export declare const LearningConfigSchema: z.ZodObject<{
     creditStrategy: z.ZodDefault<z.ZodEnum<["simple", "llm", "counterfactual"]>>;
     /** How to extract patterns */
     patternExtractor: z.ZodDefault<z.ZodEnum<["llm", "text", "both"]>>;
+    /**
+     * G2: When `patternExtractor` (or `creditStrategy`) requests an LLM-backed
+     * path but no agent backend is wired (no `taskRunner`; e.g. `createAtlas`
+     * with no backend or CLI ingest), extraction/analysis degrades to the
+     * heuristic implementation. That degradation is always made LOUD (a
+     * once-per-run warning). When `strictExtraction` is ON, the degradation
+     * instead THROWS so misconfiguration is caught up front.
+     *
+     * Default OFF (warn, don't throw) so headless ingest still functions —
+     * autonomous LLM extraction genuinely requires a backend, so headless
+     * runs must be allowed to fall back to the heuristic extractor.
+     */
+    strictExtraction: z.ZodDefault<z.ZodBoolean>;
     /** Minimum trajectories before batch learning */
     minTrajectories: z.ZodDefault<z.ZodNumber>;
     /** Minimum hours since last batch learning */
@@ -27,22 +40,40 @@ export declare const LearningConfigSchema: z.ZodObject<{
     deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
     /** Maximum experiences to keep during pruning (default: 1000) */
     maxExperiences: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Additive-consolidation similarity threshold (0..1). Only consulted when
+     * `features.additiveConsolidation` is ON. A freshly distilled playbook is
+     * MERGED into an existing one instead of minting a new `distilled-<uuid>`
+     * when their embeddings-optional similarity (cosine when both embeddings
+     * exist, else lexical textSimilarity over strategy + situations) meets this
+     * threshold AND they share a domain. Default 0.55 — deliberately below the
+     * 0.9 write-time dedup threshold (which almost never fires for distinct
+     * distilled titles) so genuine same-family repeats actually compound, while
+     * the domain-overlap hard gate + this floor guard against cross-family
+     * over-merge. Lower → more aggressive merging (evidence compounds faster but
+     * risk of conflating distinct lessons); higher → closer to proliferation.
+     */
+    additiveMergeThreshold: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     creditStrategy: "llm" | "simple" | "counterfactual";
-    patternExtractor: "llm" | "both" | "text";
+    patternExtractor: "llm" | "text" | "both";
+    strictExtraction: boolean;
     minTrajectories: number;
     deduplicationThreshold: number;
     maxExperiences: number;
+    additiveMergeThreshold: number;
     minHoursSinceLast?: number | undefined;
     minSuccessRate?: number | undefined;
 }, {
     creditStrategy?: "llm" | "simple" | "counterfactual" | undefined;
-    patternExtractor?: "llm" | "both" | "text" | undefined;
+    patternExtractor?: "llm" | "text" | "both" | undefined;
+    strictExtraction?: boolean | undefined;
     minTrajectories?: number | undefined;
     minHoursSinceLast?: number | undefined;
     minSuccessRate?: number | undefined;
     deduplicationThreshold?: number | undefined;
     maxExperiences?: number | undefined;
+    additiveMergeThreshold?: number | undefined;
 }>;
 export type LearningConfig = z.infer<typeof LearningConfigSchema>;
 /**
@@ -55,14 +86,32 @@ export declare const RouterConfigSchema: z.ZodObject<{
     useDomainRouting: z.ZodDefault<z.ZodBoolean>;
     /** Default search strategy */
     defaultStrategy: z.ZodDefault<z.ZodString>;
+    /**
+     * Difficulty-aware routing (G6). When ON, the router computes a general,
+     * domain-agnostic task-difficulty signal (`computeTaskDifficulty`) and:
+     *   - routes HARD tasks to the expensive refinement/exemplar strategy with a
+     *     deliberately LOWER `routing.confidence` (below `refinement
+     *     .confidenceThreshold`, default 0.85) so they auto-enter the G1
+     *     refinement loop;
+     *   - routes EASY tasks to the cheap/direct path with higher confidence so
+     *     they stay above the threshold and skip refinement;
+     *   - sets the multi-objective `prefer` axis from difficulty (hard → quality,
+     *     trivial → cheap) so the Pareto frontier query is actually exercised.
+     *
+     * Default ON (maintainer's call): degrades gracefully (no throw) when the
+     * frontier is cold or memory is empty.
+     */
+    difficultyAwareRouting: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     similarityThreshold: number;
     useDomainRouting: boolean;
     defaultStrategy: string;
+    difficultyAwareRouting: boolean;
 }, {
     similarityThreshold?: number | undefined;
     useDomainRouting?: boolean | undefined;
     defaultStrategy?: string | undefined;
+    difficultyAwareRouting?: boolean | undefined;
 }>;
 export type RouterConfig = z.infer<typeof RouterConfigSchema>;
 /**
@@ -104,6 +153,167 @@ export type MemoryCapacityConfig = z.infer<typeof MemoryCapacityConfigSchema>;
 /**
  * Memory retrieval configuration
  */
+export declare const PlaybookRetrievalConfigSchema: z.ZodObject<{
+    /**
+     * Playbook retrieval implementation.
+     * - legacy: cognitive-core's existing PlaybookLibrary matcher.
+     * - skill-tree-hybrid: convert playbooks to skill-tree Skills and score with
+     *   skill-tree's body-indexed hybrid scorer.
+     */
+    mode: z.ZodDefault<z.ZodEnum<["legacy", "skill-tree-hybrid"]>>;
+    /**
+     * Minimum retrieval score required before a playbook is injected, for LEXICAL
+     * (text-similarity) scoring. Lexical scores are sparse (~0.1 even for relevant
+     * matches), so this floor cannot separate signal from noise — embedding mode
+     * (`minScoreSemantic`) is what makes a meaningful floor possible. Serving
+     * relevance floor, separate from playbook confidence.
+     */
+    minScore: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Relevance floor when SEMANTIC (embedding-cosine) scoring is active (an
+     * EmbeddingProvider attached via `setEmbeddingProvider`). Cosine scores are
+     * denser than lexical, so a real floor (default 0.35 — below the ~0.5 "high
+     * similarity" bar so relevant matches survive) rejects noise WITHOUT omitting
+     * relevant playbooks, unlike a raised lexical floor.
+     */
+    minScoreSemantic: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Multiplier applied to the active floor on the GLOBAL (cross-domain) fallback
+     * retrieval — when a task's own domain has no playbooks and retrieval reaches
+     * across all domains, require a higher score (default 1.5×) so out-of-family
+     * playbooks need a strong match. Prevents cross-family negative transfer (see
+     * docs/runs/skillflow-playbook-ablation-3families-bedrock-haiku.md).
+     */
+    crossDomainFloorMultiplier: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Fusion strategy for skill-tree-hybrid mode. RRF only changes ordering when
+     * a dense embedder is attached; BM25-only scoring remains available.
+     */
+    fusion: z.ZodDefault<z.ZodEnum<["weighted", "rrf"]>>;
+    /**
+     * How an injected playbook is rendered into the prompt (roadmap §4.3 / Exp 4):
+     * - `full`: the whole playbook (strategy + all tactics/steps). Default.
+     * - `sectioned`: strategy + only the tactics/steps whose text shares cues with
+     *   the task. Lower token cost and less context interference for broad
+     *   playbooks where only a subskill applies. Deterministic (no LLM); a no-op
+     *   for already-atomic playbooks whose every tactic matches.
+     * (`refined`, an LLM task-specific rewrite, is a separate serve-time path and
+     * not selectable here yet.)
+     */
+    incorporation: z.ZodDefault<z.ZodEnum<["full", "sectioned"]>>;
+}, "strip", z.ZodTypeAny, {
+    mode: "legacy" | "skill-tree-hybrid";
+    minScore: number;
+    minScoreSemantic: number;
+    crossDomainFloorMultiplier: number;
+    fusion: "weighted" | "rrf";
+    incorporation: "full" | "sectioned";
+}, {
+    mode?: "legacy" | "skill-tree-hybrid" | undefined;
+    minScore?: number | undefined;
+    minScoreSemantic?: number | undefined;
+    crossDomainFloorMultiplier?: number | undefined;
+    fusion?: "weighted" | "rrf" | undefined;
+    incorporation?: "full" | "sectioned" | undefined;
+}>;
+export type PlaybookRetrievalConfig = z.infer<typeof PlaybookRetrievalConfigSchema>;
+export declare const PlaybookApplicabilityConfigSchema: z.ZodObject<{
+    /**
+     * Opt-in serving gate that decides whether a retrieved playbook is specific
+     * enough to inject.
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Floor for matches that lack trigger/situation cues. */
+    minSpecificityScore: z.ZodDefault<z.ZodNumber>;
+    /** Stronger floor for cross-domain matches without trigger/situation cues. */
+    crossDomainMinScore: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    minSpecificityScore: number;
+    crossDomainMinScore: number;
+}, {
+    enabled?: boolean | undefined;
+    minSpecificityScore?: number | undefined;
+    crossDomainMinScore?: number | undefined;
+}>;
+export type PlaybookApplicabilityConfig = z.infer<typeof PlaybookApplicabilityConfigSchema>;
+export declare const ProceduralMemoryConfigSchema: z.ZodObject<{
+    /**
+     * Stable procedural-memory authority. `filesystem` (the default) makes
+     * `.atlas/playbooks/<slug>/SKILL.md` canonical for stable playbook content;
+     * SQLite remains the runtime cache and operational ledger (operational state
+     * mirrored to `.ccore/state.json` so the DB rebuilds from files). `sqlite`
+     * preserves the legacy behavior where SQLite rows are the source of truth —
+     * used by migration tooling and the SQLite-only-drift / migration tests,
+     * which opt back in via `source: "sqlite"` explicitly.
+     */
+    source: z.ZodDefault<z.ZodEnum<["sqlite", "filesystem"]>>;
+    /** Canonical procedural-memory directory, relative to storage.baseDir. */
+    dir: z.ZodDefault<z.ZodString>;
+    /** Fail startup on file-first warnings instead of continuing best-effort. */
+    strictStartup: z.ZodDefault<z.ZodBoolean>;
+    /** Future destructive cleanup switch; defaults off for hard migration safety. */
+    pruneSqliteOnly: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Reindex-on-edit cascade (§6.2). When on, a debounced file watcher over the
+     * canonical `playbooks/` tree picks up external `SKILL.md` edits (hand edits,
+     * `git pull`) live via a durable queue — no reboot needed. Off by default:
+     * short-lived eval/CLI runs don't need it (startup reindex covers them), and
+     * only long-lived servers benefit. Requires `source: "filesystem"`.
+     */
+    watch: z.ZodDefault<z.ZodBoolean>;
+    /** Coalescing window (ms) for a burst of file events before the cascade drains. */
+    watchDebounceMs: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Poll for changes instead of native OS events. Needed on filesystems where
+     * native watching doesn't fire (NFS, Docker bind mounts, some CI). Off by
+     * default (native fsevents/inotify are cheaper).
+     */
+    watchUsePolling: z.ZodDefault<z.ZodBoolean>;
+    /** Poll interval (ms) when `watchUsePolling` is on. */
+    watchPollIntervalMs: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Legacy Phase 3 bridge. Prefer `source: "filesystem"` for hard-authority
+     * migration; this remains for callers that only want mirroring.
+     */
+    structuralDualWrite: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        dir: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        dir: string;
+    }, {
+        enabled?: boolean | undefined;
+        dir?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    source: "sqlite" | "filesystem";
+    dir: string;
+    strictStartup: boolean;
+    pruneSqliteOnly: boolean;
+    watch: boolean;
+    watchDebounceMs: number;
+    watchUsePolling: boolean;
+    watchPollIntervalMs: number;
+    structuralDualWrite: {
+        enabled: boolean;
+        dir: string;
+    };
+}, {
+    source?: "sqlite" | "filesystem" | undefined;
+    dir?: string | undefined;
+    strictStartup?: boolean | undefined;
+    pruneSqliteOnly?: boolean | undefined;
+    watch?: boolean | undefined;
+    watchDebounceMs?: number | undefined;
+    watchUsePolling?: boolean | undefined;
+    watchPollIntervalMs?: number | undefined;
+    structuralDualWrite?: {
+        enabled?: boolean | undefined;
+        dir?: string | undefined;
+    } | undefined;
+}>;
+export type ProceduralMemoryConfig = z.infer<typeof ProceduralMemoryConfigSchema>;
 export declare const MemoryConfigSchema: z.ZodObject<{
     /** Maximum experiences to retrieve */
     maxExperiences: z.ZodDefault<z.ZodNumber>;
@@ -148,6 +358,206 @@ export declare const MemoryConfigSchema: z.ZodObject<{
         autoPrune?: boolean | undefined;
         preserveDomainCoverage?: boolean | undefined;
     }>>;
+    /**
+     * Use the Pareto frontier to select playbooks when a signature has
+     * recorded outcomes, falling back to text-similarity matching otherwise.
+     *
+     * Default ON (G6, maintainer's call): the frontier path is headless-safe —
+     * a cold store (signature with no recorded outcomes / empty frontier) falls
+     * back to text-similarity matching inside `findMatchingFrontierAware`
+     * (`playbook.ts`), so enabling it never deadlocks or throws.
+     */
+    frontierRouting: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Whether failed trajectories may be injected as in-context EXEMPLARS
+     * (the experience-retrieval channel surfaced to the agent at solve time).
+     *
+     * This does NOT control whether failures are stored or learned from:
+     * failures always still feed reflexion episodes, playbook anti-patterns,
+     * causal edges, and error-pattern analysis. It only governs the imitation
+     * channel. Injecting raw failed trajectories as exemplars can anchor an
+     * agent to bad approaches — especially on imitation-heavy / procedural tasks
+     * (embodied, web nav) where the agent copies action sequences. Set to
+     * `false` for success-biased exemplar injection (the agent only sees
+     * trajectories that worked). Default `true` preserves prior behavior.
+     */
+    injectFailedExperiences: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * On init, seed the (file-backed) MetaPlaybookBank from the committed
+     * `META_PLAYBOOK_SEEDS` — meta-level guidance that steers the
+     * analysis/extraction/maintenance agents. Idempotent: only seeds an empty
+     * bank, so learned refinements are never overwritten. Default `true`
+     * (cold-start default; set `false` for seed-free ablations).
+     */
+    seedMetaPlaybooks: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * On init, seed MetaMemory with the committed `META_STRATEGY_SEEDS` routing
+     * priors so the router's meta-adjustment path is not inert on a cold store.
+     * Idempotent: only seeds when no strategies exist, so learned strategies and
+     * their evidence (EMA success rate) are never overwritten. Default `true`.
+     */
+    seedMetaStrategies: z.ZodDefault<z.ZodBoolean>;
+    /** Playbook serving/retrieval configuration. */
+    playbookRetrieval: z.ZodDefault<z.ZodObject<{
+        /**
+         * Playbook retrieval implementation.
+         * - legacy: cognitive-core's existing PlaybookLibrary matcher.
+         * - skill-tree-hybrid: convert playbooks to skill-tree Skills and score with
+         *   skill-tree's body-indexed hybrid scorer.
+         */
+        mode: z.ZodDefault<z.ZodEnum<["legacy", "skill-tree-hybrid"]>>;
+        /**
+         * Minimum retrieval score required before a playbook is injected, for LEXICAL
+         * (text-similarity) scoring. Lexical scores are sparse (~0.1 even for relevant
+         * matches), so this floor cannot separate signal from noise — embedding mode
+         * (`minScoreSemantic`) is what makes a meaningful floor possible. Serving
+         * relevance floor, separate from playbook confidence.
+         */
+        minScore: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Relevance floor when SEMANTIC (embedding-cosine) scoring is active (an
+         * EmbeddingProvider attached via `setEmbeddingProvider`). Cosine scores are
+         * denser than lexical, so a real floor (default 0.35 — below the ~0.5 "high
+         * similarity" bar so relevant matches survive) rejects noise WITHOUT omitting
+         * relevant playbooks, unlike a raised lexical floor.
+         */
+        minScoreSemantic: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Multiplier applied to the active floor on the GLOBAL (cross-domain) fallback
+         * retrieval — when a task's own domain has no playbooks and retrieval reaches
+         * across all domains, require a higher score (default 1.5×) so out-of-family
+         * playbooks need a strong match. Prevents cross-family negative transfer (see
+         * docs/runs/skillflow-playbook-ablation-3families-bedrock-haiku.md).
+         */
+        crossDomainFloorMultiplier: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Fusion strategy for skill-tree-hybrid mode. RRF only changes ordering when
+         * a dense embedder is attached; BM25-only scoring remains available.
+         */
+        fusion: z.ZodDefault<z.ZodEnum<["weighted", "rrf"]>>;
+        /**
+         * How an injected playbook is rendered into the prompt (roadmap §4.3 / Exp 4):
+         * - `full`: the whole playbook (strategy + all tactics/steps). Default.
+         * - `sectioned`: strategy + only the tactics/steps whose text shares cues with
+         *   the task. Lower token cost and less context interference for broad
+         *   playbooks where only a subskill applies. Deterministic (no LLM); a no-op
+         *   for already-atomic playbooks whose every tactic matches.
+         * (`refined`, an LLM task-specific rewrite, is a separate serve-time path and
+         * not selectable here yet.)
+         */
+        incorporation: z.ZodDefault<z.ZodEnum<["full", "sectioned"]>>;
+    }, "strip", z.ZodTypeAny, {
+        mode: "legacy" | "skill-tree-hybrid";
+        minScore: number;
+        minScoreSemantic: number;
+        crossDomainFloorMultiplier: number;
+        fusion: "weighted" | "rrf";
+        incorporation: "full" | "sectioned";
+    }, {
+        mode?: "legacy" | "skill-tree-hybrid" | undefined;
+        minScore?: number | undefined;
+        minScoreSemantic?: number | undefined;
+        crossDomainFloorMultiplier?: number | undefined;
+        fusion?: "weighted" | "rrf" | undefined;
+        incorporation?: "full" | "sectioned" | undefined;
+    }>>;
+    /** Optional post-retrieval playbook applicability gate. */
+    playbookApplicability: z.ZodDefault<z.ZodObject<{
+        /**
+         * Opt-in serving gate that decides whether a retrieved playbook is specific
+         * enough to inject.
+         */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Floor for matches that lack trigger/situation cues. */
+        minSpecificityScore: z.ZodDefault<z.ZodNumber>;
+        /** Stronger floor for cross-domain matches without trigger/situation cues. */
+        crossDomainMinScore: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        minSpecificityScore: number;
+        crossDomainMinScore: number;
+    }, {
+        enabled?: boolean | undefined;
+        minSpecificityScore?: number | undefined;
+        crossDomainMinScore?: number | undefined;
+    }>>;
+    /** Procedural-memory filesystem migration settings. */
+    proceduralMemory: z.ZodDefault<z.ZodObject<{
+        /**
+         * Stable procedural-memory authority. `filesystem` (the default) makes
+         * `.atlas/playbooks/<slug>/SKILL.md` canonical for stable playbook content;
+         * SQLite remains the runtime cache and operational ledger (operational state
+         * mirrored to `.ccore/state.json` so the DB rebuilds from files). `sqlite`
+         * preserves the legacy behavior where SQLite rows are the source of truth —
+         * used by migration tooling and the SQLite-only-drift / migration tests,
+         * which opt back in via `source: "sqlite"` explicitly.
+         */
+        source: z.ZodDefault<z.ZodEnum<["sqlite", "filesystem"]>>;
+        /** Canonical procedural-memory directory, relative to storage.baseDir. */
+        dir: z.ZodDefault<z.ZodString>;
+        /** Fail startup on file-first warnings instead of continuing best-effort. */
+        strictStartup: z.ZodDefault<z.ZodBoolean>;
+        /** Future destructive cleanup switch; defaults off for hard migration safety. */
+        pruneSqliteOnly: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Reindex-on-edit cascade (§6.2). When on, a debounced file watcher over the
+         * canonical `playbooks/` tree picks up external `SKILL.md` edits (hand edits,
+         * `git pull`) live via a durable queue — no reboot needed. Off by default:
+         * short-lived eval/CLI runs don't need it (startup reindex covers them), and
+         * only long-lived servers benefit. Requires `source: "filesystem"`.
+         */
+        watch: z.ZodDefault<z.ZodBoolean>;
+        /** Coalescing window (ms) for a burst of file events before the cascade drains. */
+        watchDebounceMs: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Poll for changes instead of native OS events. Needed on filesystems where
+         * native watching doesn't fire (NFS, Docker bind mounts, some CI). Off by
+         * default (native fsevents/inotify are cheaper).
+         */
+        watchUsePolling: z.ZodDefault<z.ZodBoolean>;
+        /** Poll interval (ms) when `watchUsePolling` is on. */
+        watchPollIntervalMs: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Legacy Phase 3 bridge. Prefer `source: "filesystem"` for hard-authority
+         * migration; this remains for callers that only want mirroring.
+         */
+        structuralDualWrite: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            dir: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            dir: string;
+        }, {
+            enabled?: boolean | undefined;
+            dir?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        source: "sqlite" | "filesystem";
+        dir: string;
+        strictStartup: boolean;
+        pruneSqliteOnly: boolean;
+        watch: boolean;
+        watchDebounceMs: number;
+        watchUsePolling: boolean;
+        watchPollIntervalMs: number;
+        structuralDualWrite: {
+            enabled: boolean;
+            dir: string;
+        };
+    }, {
+        source?: "sqlite" | "filesystem" | undefined;
+        dir?: string | undefined;
+        strictStartup?: boolean | undefined;
+        pruneSqliteOnly?: boolean | undefined;
+        watch?: boolean | undefined;
+        watchDebounceMs?: number | undefined;
+        watchUsePolling?: boolean | undefined;
+        watchPollIntervalMs?: number | undefined;
+        structuralDualWrite?: {
+            enabled?: boolean | undefined;
+            dir?: string | undefined;
+        } | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     maxExperiences: number;
     maxStrategies: number;
@@ -163,6 +573,37 @@ export declare const MemoryConfigSchema: z.ZodObject<{
         autoPrune: boolean;
         preserveDomainCoverage: boolean;
     };
+    frontierRouting: boolean;
+    injectFailedExperiences: boolean;
+    seedMetaPlaybooks: boolean;
+    seedMetaStrategies: boolean;
+    playbookRetrieval: {
+        mode: "legacy" | "skill-tree-hybrid";
+        minScore: number;
+        minScoreSemantic: number;
+        crossDomainFloorMultiplier: number;
+        fusion: "weighted" | "rrf";
+        incorporation: "full" | "sectioned";
+    };
+    playbookApplicability: {
+        enabled: boolean;
+        minSpecificityScore: number;
+        crossDomainMinScore: number;
+    };
+    proceduralMemory: {
+        source: "sqlite" | "filesystem";
+        dir: string;
+        strictStartup: boolean;
+        pruneSqliteOnly: boolean;
+        watch: boolean;
+        watchDebounceMs: number;
+        watchUsePolling: boolean;
+        watchPollIntervalMs: number;
+        structuralDualWrite: {
+            enabled: boolean;
+            dir: string;
+        };
+    };
 }, {
     maxExperiences?: number | undefined;
     maxStrategies?: number | undefined;
@@ -178,6 +619,37 @@ export declare const MemoryConfigSchema: z.ZodObject<{
         autoPrune?: boolean | undefined;
         preserveDomainCoverage?: boolean | undefined;
     } | undefined;
+    frontierRouting?: boolean | undefined;
+    injectFailedExperiences?: boolean | undefined;
+    seedMetaPlaybooks?: boolean | undefined;
+    seedMetaStrategies?: boolean | undefined;
+    playbookRetrieval?: {
+        mode?: "legacy" | "skill-tree-hybrid" | undefined;
+        minScore?: number | undefined;
+        minScoreSemantic?: number | undefined;
+        crossDomainFloorMultiplier?: number | undefined;
+        fusion?: "weighted" | "rrf" | undefined;
+        incorporation?: "full" | "sectioned" | undefined;
+    } | undefined;
+    playbookApplicability?: {
+        enabled?: boolean | undefined;
+        minSpecificityScore?: number | undefined;
+        crossDomainMinScore?: number | undefined;
+    } | undefined;
+    proceduralMemory?: {
+        source?: "sqlite" | "filesystem" | undefined;
+        dir?: string | undefined;
+        strictStartup?: boolean | undefined;
+        pruneSqliteOnly?: boolean | undefined;
+        watch?: boolean | undefined;
+        watchDebounceMs?: number | undefined;
+        watchUsePolling?: boolean | undefined;
+        watchPollIntervalMs?: number | undefined;
+        structuralDualWrite?: {
+            enabled?: boolean | undefined;
+            dir?: string | undefined;
+        } | undefined;
+    } | undefined;
 }>;
 export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;
 /**
@@ -306,9 +778,18 @@ export declare const RefinementConfigSchema: z.ZodObject<{
     useAgentEvaluation: z.ZodDefault<z.ZodBoolean>;
     /** Agent type to use for evaluation */
     evaluatorAgentType: z.ZodDefault<z.ZodString>;
-    /** Confidence threshold below which to trigger refinement */
+    /**
+     * Confidence threshold below which to trigger refinement.
+     * Raised from 0.6 so refinement is reachable on normal routes — most
+     * routing decisions land below 0.85 confidence and should remain eligible
+     * for verifier-driven refinement.
+     */
     confidenceThreshold: z.ZodDefault<z.ZodNumber>;
-    /** Routing strategies that should trigger refinement */
+    /**
+     * Routing strategies that should trigger refinement.
+     * Broadened to all four strategies (G1): a task can mis-execute on any
+     * route, including `direct`/`adapt`, so none are excluded by default.
+     */
     triggerOnStrategies: z.ZodDefault<z.ZodArray<z.ZodEnum<["explore", "fallback", "direct", "adapt"]>, "many">>;
 }, "strip", z.ZodTypeAny, {
     maxIterations: number;
@@ -336,14 +817,29 @@ export declare const SkillPromotionConfigSchema: z.ZodObject<{
     minSuccessCount: z.ZodDefault<z.ZodNumber>;
     /** Minimum success rate to promote */
     minSuccessRate: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Eval-gate tier promotion (G5). When ON, a playbook must pass an
+     * eval gate IN ADDITION to the threshold criteria before it is
+     * promoted to a served tier.
+     *
+     * Default ON (maintainer's call): the default gate is Pareto-frontier
+     * dominance, which is headless-safe — it reuses already-built, no-LLM
+     * machinery and treats a playbook with no frontier history (first-ever
+     * / freshly-extracted) as non-dominated, so default-on gating never
+     * deadlocks. When a `PromotionJudge` (or `ReplayJudge`) is registered
+     * on the `SkillLibrary`, the stronger judge-based gate is used instead.
+     */
+    evalGate: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     minSuccessRate: number;
     minConfidence: number;
     minSuccessCount: number;
+    evalGate: boolean;
 }, {
     minSuccessRate?: number | undefined;
     minConfidence?: number | undefined;
     minSuccessCount?: number | undefined;
+    evalGate?: boolean | undefined;
 }>;
 export type SkillPromotionConfig = z.infer<typeof SkillPromotionConfigSchema>;
 /**
@@ -376,17 +872,25 @@ export declare const SkillContextConfigSchema: z.ZodObject<{
     includeRefinements: z.ZodDefault<z.ZodBoolean>;
     /** Include code examples in skill context */
     includeExamples: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * G4: include a worked-trajectory exemplar (few-shot demonstration) in skill
+     * context when a playbook carries one. Default ON — a surfaced skill should
+     * carry the demonstration, not just rules ("demonstration > rules").
+     */
+    includeExemplar: z.ZodDefault<z.ZodBoolean>;
     /** Cache refresh interval in milliseconds (default: 5 minutes) */
     cacheRefreshInterval: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     maxTokensForSkills: number;
     includeRefinements: boolean;
     includeExamples: boolean;
+    includeExemplar: boolean;
     cacheRefreshInterval: number;
 }, {
     maxTokensForSkills?: number | undefined;
     includeRefinements?: boolean | undefined;
     includeExamples?: boolean | undefined;
+    includeExemplar?: boolean | undefined;
     cacheRefreshInterval?: number | undefined;
 }>;
 export type SkillContextConfig = z.infer<typeof SkillContextConfigSchema>;
@@ -418,14 +922,29 @@ export declare const SkillLibraryConfigSchema: z.ZodObject<{
         minSuccessCount: z.ZodDefault<z.ZodNumber>;
         /** Minimum success rate to promote */
         minSuccessRate: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Eval-gate tier promotion (G5). When ON, a playbook must pass an
+         * eval gate IN ADDITION to the threshold criteria before it is
+         * promoted to a served tier.
+         *
+         * Default ON (maintainer's call): the default gate is Pareto-frontier
+         * dominance, which is headless-safe — it reuses already-built, no-LLM
+         * machinery and treats a playbook with no frontier history (first-ever
+         * / freshly-extracted) as non-dominated, so default-on gating never
+         * deadlocks. When a `PromotionJudge` (or `ReplayJudge`) is registered
+         * on the `SkillLibrary`, the stronger judge-based gate is used instead.
+         */
+        evalGate: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         minSuccessRate: number;
         minConfidence: number;
         minSuccessCount: number;
+        evalGate: boolean;
     }, {
         minSuccessRate?: number | undefined;
         minConfidence?: number | undefined;
         minSuccessCount?: number | undefined;
+        evalGate?: boolean | undefined;
     }>>;
     /** Capacity limits */
     limits: z.ZodDefault<z.ZodObject<{
@@ -452,17 +971,25 @@ export declare const SkillLibraryConfigSchema: z.ZodObject<{
         includeRefinements: z.ZodDefault<z.ZodBoolean>;
         /** Include code examples in skill context */
         includeExamples: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * G4: include a worked-trajectory exemplar (few-shot demonstration) in skill
+         * context when a playbook carries one. Default ON — a surfaced skill should
+         * carry the demonstration, not just rules ("demonstration > rules").
+         */
+        includeExemplar: z.ZodDefault<z.ZodBoolean>;
         /** Cache refresh interval in milliseconds (default: 5 minutes) */
         cacheRefreshInterval: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         maxTokensForSkills: number;
         includeRefinements: boolean;
         includeExamples: boolean;
+        includeExemplar: boolean;
         cacheRefreshInterval: number;
     }, {
         maxTokensForSkills?: number | undefined;
         includeRefinements?: boolean | undefined;
         includeExamples?: boolean | undefined;
+        includeExemplar?: boolean | undefined;
         cacheRefreshInterval?: number | undefined;
     }>>;
     /** Demotion criteria */
@@ -478,17 +1005,83 @@ export declare const SkillLibraryConfigSchema: z.ZodObject<{
         failureThreshold?: number | undefined;
         minConfidenceToRetain?: number | undefined;
     }>>;
+    /** Contextual playbook retrieval for tiered skill surfacing. */
+    retrieval: z.ZodDefault<z.ZodObject<{
+        /**
+         * Playbook retrieval implementation.
+         * - legacy: cognitive-core's existing PlaybookLibrary matcher.
+         * - skill-tree-hybrid: convert playbooks to skill-tree Skills and score with
+         *   skill-tree's body-indexed hybrid scorer.
+         */
+        mode: z.ZodDefault<z.ZodEnum<["legacy", "skill-tree-hybrid"]>>;
+        /**
+         * Minimum retrieval score required before a playbook is injected, for LEXICAL
+         * (text-similarity) scoring. Lexical scores are sparse (~0.1 even for relevant
+         * matches), so this floor cannot separate signal from noise — embedding mode
+         * (`minScoreSemantic`) is what makes a meaningful floor possible. Serving
+         * relevance floor, separate from playbook confidence.
+         */
+        minScore: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Relevance floor when SEMANTIC (embedding-cosine) scoring is active (an
+         * EmbeddingProvider attached via `setEmbeddingProvider`). Cosine scores are
+         * denser than lexical, so a real floor (default 0.35 — below the ~0.5 "high
+         * similarity" bar so relevant matches survive) rejects noise WITHOUT omitting
+         * relevant playbooks, unlike a raised lexical floor.
+         */
+        minScoreSemantic: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Multiplier applied to the active floor on the GLOBAL (cross-domain) fallback
+         * retrieval — when a task's own domain has no playbooks and retrieval reaches
+         * across all domains, require a higher score (default 1.5×) so out-of-family
+         * playbooks need a strong match. Prevents cross-family negative transfer (see
+         * docs/runs/skillflow-playbook-ablation-3families-bedrock-haiku.md).
+         */
+        crossDomainFloorMultiplier: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Fusion strategy for skill-tree-hybrid mode. RRF only changes ordering when
+         * a dense embedder is attached; BM25-only scoring remains available.
+         */
+        fusion: z.ZodDefault<z.ZodEnum<["weighted", "rrf"]>>;
+        /**
+         * How an injected playbook is rendered into the prompt (roadmap §4.3 / Exp 4):
+         * - `full`: the whole playbook (strategy + all tactics/steps). Default.
+         * - `sectioned`: strategy + only the tactics/steps whose text shares cues with
+         *   the task. Lower token cost and less context interference for broad
+         *   playbooks where only a subskill applies. Deterministic (no LLM); a no-op
+         *   for already-atomic playbooks whose every tactic matches.
+         * (`refined`, an LLM task-specific rewrite, is a separate serve-time path and
+         * not selectable here yet.)
+         */
+        incorporation: z.ZodDefault<z.ZodEnum<["full", "sectioned"]>>;
+    }, "strip", z.ZodTypeAny, {
+        mode: "legacy" | "skill-tree-hybrid";
+        minScore: number;
+        minScoreSemantic: number;
+        crossDomainFloorMultiplier: number;
+        fusion: "weighted" | "rrf";
+        incorporation: "full" | "sectioned";
+    }, {
+        mode?: "legacy" | "skill-tree-hybrid" | undefined;
+        minScore?: number | undefined;
+        minScoreSemantic?: number | undefined;
+        crossDomainFloorMultiplier?: number | undefined;
+        fusion?: "weighted" | "rrf" | undefined;
+        incorporation?: "full" | "sectioned" | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     context: {
         maxTokensForSkills: number;
         includeRefinements: boolean;
         includeExamples: boolean;
+        includeExemplar: boolean;
         cacheRefreshInterval: number;
     };
     promotion: {
         minSuccessRate: number;
         minConfidence: number;
         minSuccessCount: number;
+        evalGate: boolean;
     };
     limits: {
         maxCoreSkills: number;
@@ -499,17 +1092,27 @@ export declare const SkillLibraryConfigSchema: z.ZodObject<{
         failureThreshold: number;
         minConfidenceToRetain: number;
     };
+    retrieval: {
+        mode: "legacy" | "skill-tree-hybrid";
+        minScore: number;
+        minScoreSemantic: number;
+        crossDomainFloorMultiplier: number;
+        fusion: "weighted" | "rrf";
+        incorporation: "full" | "sectioned";
+    };
 }, {
     context?: {
         maxTokensForSkills?: number | undefined;
         includeRefinements?: boolean | undefined;
         includeExamples?: boolean | undefined;
+        includeExemplar?: boolean | undefined;
         cacheRefreshInterval?: number | undefined;
     } | undefined;
     promotion?: {
         minSuccessRate?: number | undefined;
         minConfidence?: number | undefined;
         minSuccessCount?: number | undefined;
+        evalGate?: boolean | undefined;
     } | undefined;
     limits?: {
         maxCoreSkills?: number | undefined;
@@ -520,6 +1123,14 @@ export declare const SkillLibraryConfigSchema: z.ZodObject<{
         failureThreshold?: number | undefined;
         minConfidenceToRetain?: number | undefined;
     } | undefined;
+    retrieval?: {
+        mode?: "legacy" | "skill-tree-hybrid" | undefined;
+        minScore?: number | undefined;
+        minScoreSemantic?: number | undefined;
+        crossDomainFloorMultiplier?: number | undefined;
+        fusion?: "weighted" | "rrf" | undefined;
+        incorporation?: "full" | "sectioned" | undefined;
+    } | undefined;
 }>;
 export type SkillLibraryConfig = z.infer<typeof SkillLibraryConfigSchema>;
 /**
@@ -536,11 +1147,14 @@ export declare const AgenticTaskRunnerConfigSchema: z.ZodObject<{
     staleWorkspaceMaxAgeMs: z.ZodDefault<z.ZodNumber>;
     /** Base directory for workspaces (defaults to os.tmpdir()) */
     workspaceBaseDir: z.ZodOptional<z.ZodString>;
+    /** Always run the workspace agent for playbook extraction when a runner exists. */
+    forceAgenticPlaybookExtraction: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     cleanupWorkspaces: boolean;
     keepFailedWorkspaces: boolean;
     maxConcurrentAgents: number;
     staleWorkspaceMaxAgeMs: number;
+    forceAgenticPlaybookExtraction: boolean;
     workspaceBaseDir?: string | undefined;
 }, {
     cleanupWorkspaces?: boolean | undefined;
@@ -548,6 +1162,7 @@ export declare const AgenticTaskRunnerConfigSchema: z.ZodObject<{
     maxConcurrentAgents?: number | undefined;
     staleWorkspaceMaxAgeMs?: number | undefined;
     workspaceBaseDir?: string | undefined;
+    forceAgenticPlaybookExtraction?: boolean | undefined;
 }>;
 export type AgenticTaskRunnerConfig = z.infer<typeof AgenticTaskRunnerConfigSchema>;
 /**
@@ -590,127 +1205,6 @@ export declare const MCPServerConfigSchema: z.ZodObject<{
     enableDomainFiltering?: boolean | undefined;
 }>;
 export type MCPServerConfig = z.infer<typeof MCPServerConfigSchema>;
-/**
- * Compression configuration for team trajectory ingestion
- */
-export declare const CompressionConfigSchema: z.ZodObject<{
-    /** Maximum tokens per agent after compression */
-    maxTokensPerAgent: z.ZodDefault<z.ZodNumber>;
-    /** Preserve interaction boundary steps at full fidelity */
-    preserveInteractionBoundaries: z.ZodDefault<z.ZodBoolean>;
-    /** Minimum consecutive non-key steps before folding */
-    foldThreshold: z.ZodDefault<z.ZodNumber>;
-    /** Maximum ratio of steps to mark as critical */
-    maxCriticalRatio: z.ZodDefault<z.ZodNumber>;
-    /** Score threshold for critical steps */
-    criticalStepThreshold: z.ZodDefault<z.ZodNumber>;
-    /** Score threshold for critical interactions */
-    criticalInteractionThreshold: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    maxTokensPerAgent: number;
-    preserveInteractionBoundaries: boolean;
-    foldThreshold: number;
-    maxCriticalRatio: number;
-    criticalStepThreshold: number;
-    criticalInteractionThreshold: number;
-}, {
-    maxTokensPerAgent?: number | undefined;
-    preserveInteractionBoundaries?: boolean | undefined;
-    foldThreshold?: number | undefined;
-    maxCriticalRatio?: number | undefined;
-    criticalStepThreshold?: number | undefined;
-    criticalInteractionThreshold?: number | undefined;
-}>;
-export type CompressionConfig = z.infer<typeof CompressionConfigSchema>;
-/**
- * Team-aware learning configuration
- */
-export declare const TeamLearningConfigSchema: z.ZodObject<{
-    /** Enable team-aware learning */
-    enabled: z.ZodDefault<z.ZodBoolean>;
-    /** Minimum team trajectories before batch learning */
-    minTeamTrajectories: z.ZodDefault<z.ZodNumber>;
-    /** Similarity threshold for team playbook deduplication */
-    deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
-    /** Weight of structural metrics in analysis (0 = ignore, 1 = metrics only) */
-    metricsWeight: z.ZodDefault<z.ZodNumber>;
-    /** Maximum team experiences to store */
-    maxTeamExperiences: z.ZodDefault<z.ZodNumber>;
-    /** Maximum team playbooks to store */
-    maxTeamPlaybooks: z.ZodDefault<z.ZodNumber>;
-    /** Maximum role playbooks to store */
-    maxRolePlaybooks: z.ZodDefault<z.ZodNumber>;
-    /** Analysis agent timeout in milliseconds */
-    analysisTimeout: z.ZodDefault<z.ZodNumber>;
-    /** Extraction agent timeout in milliseconds */
-    extractionTimeout: z.ZodDefault<z.ZodNumber>;
-    /** Compression settings for trajectory ingestion */
-    compression: z.ZodDefault<z.ZodObject<{
-        /** Maximum tokens per agent after compression */
-        maxTokensPerAgent: z.ZodDefault<z.ZodNumber>;
-        /** Preserve interaction boundary steps at full fidelity */
-        preserveInteractionBoundaries: z.ZodDefault<z.ZodBoolean>;
-        /** Minimum consecutive non-key steps before folding */
-        foldThreshold: z.ZodDefault<z.ZodNumber>;
-        /** Maximum ratio of steps to mark as critical */
-        maxCriticalRatio: z.ZodDefault<z.ZodNumber>;
-        /** Score threshold for critical steps */
-        criticalStepThreshold: z.ZodDefault<z.ZodNumber>;
-        /** Score threshold for critical interactions */
-        criticalInteractionThreshold: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        maxTokensPerAgent: number;
-        preserveInteractionBoundaries: boolean;
-        foldThreshold: number;
-        maxCriticalRatio: number;
-        criticalStepThreshold: number;
-        criticalInteractionThreshold: number;
-    }, {
-        maxTokensPerAgent?: number | undefined;
-        preserveInteractionBoundaries?: boolean | undefined;
-        foldThreshold?: number | undefined;
-        maxCriticalRatio?: number | undefined;
-        criticalStepThreshold?: number | undefined;
-        criticalInteractionThreshold?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    enabled: boolean;
-    deduplicationThreshold: number;
-    minTeamTrajectories: number;
-    metricsWeight: number;
-    maxTeamExperiences: number;
-    maxTeamPlaybooks: number;
-    maxRolePlaybooks: number;
-    analysisTimeout: number;
-    extractionTimeout: number;
-    compression: {
-        maxTokensPerAgent: number;
-        preserveInteractionBoundaries: boolean;
-        foldThreshold: number;
-        maxCriticalRatio: number;
-        criticalStepThreshold: number;
-        criticalInteractionThreshold: number;
-    };
-}, {
-    enabled?: boolean | undefined;
-    deduplicationThreshold?: number | undefined;
-    minTeamTrajectories?: number | undefined;
-    metricsWeight?: number | undefined;
-    maxTeamExperiences?: number | undefined;
-    maxTeamPlaybooks?: number | undefined;
-    maxRolePlaybooks?: number | undefined;
-    analysisTimeout?: number | undefined;
-    extractionTimeout?: number | undefined;
-    compression?: {
-        maxTokensPerAgent?: number | undefined;
-        preserveInteractionBoundaries?: boolean | undefined;
-        foldThreshold?: number | undefined;
-        maxCriticalRatio?: number | undefined;
-        criticalStepThreshold?: number | undefined;
-        criticalInteractionThreshold?: number | undefined;
-    } | undefined;
-}>;
-export type TeamLearningConfig = z.infer<typeof TeamLearningConfigSchema>;
 /**
  * Knowledge Bank confidence model configuration
  */
@@ -747,38 +1241,6 @@ export declare const ConfidenceConfigSchema: z.ZodObject<{
     decayGracePeriodDays?: number | undefined;
 }>;
 export type ConfidenceConfig = z.infer<typeof ConfidenceConfigSchema>;
-/**
- * Knowledge Bank graph overlay configuration
- */
-export declare const GraphConfigSchema: z.ZodObject<{
-    /** Which graph layers to enable */
-    enabledLayers: z.ZodDefault<z.ZodArray<z.ZodEnum<["semantic", "temporal", "causal", "entity"]>, "many">>;
-    /** Whether to auto-infer temporal edges from timestamps */
-    inferTemporalEdges: z.ZodDefault<z.ZodBoolean>;
-    /** Whether to auto-infer causal edges from failure-recovery patterns */
-    inferCausalEdges: z.ZodDefault<z.ZodBoolean>;
-    /** Whether to auto-infer entity edges from shared entity tags */
-    inferEntityEdges: z.ZodDefault<z.ZodBoolean>;
-    /** Split layer files by domain when node count exceeds this */
-    domainSplitThreshold: z.ZodDefault<z.ZodNumber>;
-    /** Promote to SQLite when total edge count exceeds this */
-    sqlitePromotionThreshold: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
-    inferTemporalEdges: boolean;
-    inferCausalEdges: boolean;
-    inferEntityEdges: boolean;
-    domainSplitThreshold: number;
-    sqlitePromotionThreshold: number;
-}, {
-    enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
-    inferTemporalEdges?: boolean | undefined;
-    inferCausalEdges?: boolean | undefined;
-    inferEntityEdges?: boolean | undefined;
-    domainSplitThreshold?: number | undefined;
-    sqlitePromotionThreshold?: number | undefined;
-}>;
-export type GraphConfigType = z.infer<typeof GraphConfigSchema>;
 /**
  * Knowledge Bank defragmentation configuration
  */
@@ -787,6 +1249,20 @@ export declare const DefragConfigSchema: z.ZodObject<{
     minInboxItems: z.ZodDefault<z.ZodNumber>;
     /** Whether to auto-consolidate observations into entities */
     autoConsolidate: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * How consolidation builds entity notes:
+     * - `off`: skip consolidation entirely (atomic facts only).
+     * - `index`: entity notes are lightweight records — canonical name + links to
+     *   the atomic fact notes mentioning the entity, NO duplicated fact bodies.
+     *   Used as a retrieval boost anchor (see getRelevantKnowledge). Default.
+     * - `content`: legacy behavior — concatenate truncated fact bodies into the
+     *   entity note (retained for back-compat).
+     *
+     * `autoConsolidate: false` forces `off` regardless of this value.
+     * Optional at the type level for back-compat with hand-built configs; the
+     * KnowledgeDefragmenter treats `undefined` as `index`.
+     */
+    consolidationMode: z.ZodOptional<z.ZodEnum<["off", "index", "content"]>>;
     /** Minimum observations about an entity before consolidation */
     consolidationThreshold: z.ZodDefault<z.ZodNumber>;
     /** Whether to auto-regenerate domain summaries */
@@ -795,6 +1271,20 @@ export declare const DefragConfigSchema: z.ZodObject<{
     llmSummaryGeneration: z.ZodDefault<z.ZodBoolean>;
     /** Whether to auto-resolve simple contradictions */
     autoResolveContradictions: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Run the pairwise contradiction-detection sweep during defrag. This is O(n²)
+     * within a domain, so for large single-domain stores (e.g. a long conversation
+     * where every fact shares one domain) it is expensive and low-value. Optional;
+     * the KnowledgeDefragmenter treats `undefined` as enabled (back-compat). Set
+     * false to skip. See DESIGN-memory-extraction-add-only.md (WS1c).
+     */
+    contradictionScan: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Hard cap on observations-per-domain considered by the contradiction sweep;
+     * beyond this the sweep is skipped for that domain to bound cost. `undefined`
+     * → default cap (see KnowledgeDefragmenter).
+     */
+    contradictionScanMaxNotes: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     minInboxItems: number;
     autoConsolidate: boolean;
@@ -802,13 +1292,19 @@ export declare const DefragConfigSchema: z.ZodObject<{
     autoRegenerateSummaries: boolean;
     llmSummaryGeneration: boolean;
     autoResolveContradictions: boolean;
+    consolidationMode?: "content" | "off" | "index" | undefined;
+    contradictionScan?: boolean | undefined;
+    contradictionScanMaxNotes?: number | undefined;
 }, {
     minInboxItems?: number | undefined;
     autoConsolidate?: boolean | undefined;
+    consolidationMode?: "content" | "off" | "index" | undefined;
     consolidationThreshold?: number | undefined;
     autoRegenerateSummaries?: boolean | undefined;
     llmSummaryGeneration?: boolean | undefined;
     autoResolveContradictions?: boolean | undefined;
+    contradictionScan?: boolean | undefined;
+    contradictionScanMaxNotes?: number | undefined;
 }>;
 export type DefragConfig = z.infer<typeof DefragConfigSchema>;
 /**
@@ -847,6 +1343,13 @@ export declare const KnowledgeSurfacingConfigSchema: z.ZodObject<{
     includeEvidence: z.ZodDefault<z.ZodBoolean>;
     /** Include graph links in surfaced notes */
     includeLinks: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Additive score boost applied to atomic fact notes that are linked from an
+     * entity record matching the query (index-mode consolidation). Entity records
+     * themselves are NOT injected as content — they act purely as ranking anchors.
+     * Optional; getRelevantKnowledge treats `undefined` as 0.15.
+     */
+    entityBoostWeight: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     includeDomainSummaries: boolean;
     includeEntityNotes: boolean;
@@ -854,6 +1357,7 @@ export declare const KnowledgeSurfacingConfigSchema: z.ZodObject<{
     maxTokensForKnowledge: number;
     includeEvidence: boolean;
     includeLinks: boolean;
+    entityBoostWeight?: number | undefined;
 }, {
     includeDomainSummaries?: boolean | undefined;
     includeEntityNotes?: boolean | undefined;
@@ -861,6 +1365,7 @@ export declare const KnowledgeSurfacingConfigSchema: z.ZodObject<{
     maxTokensForKnowledge?: number | undefined;
     includeEvidence?: boolean | undefined;
     includeLinks?: boolean | undefined;
+    entityBoostWeight?: number | undefined;
 }>;
 export type KnowledgeSurfacingConfig = z.infer<typeof KnowledgeSurfacingConfigSchema>;
 /**
@@ -894,6 +1399,20 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         minInboxItems: z.ZodDefault<z.ZodNumber>;
         /** Whether to auto-consolidate observations into entities */
         autoConsolidate: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * How consolidation builds entity notes:
+         * - `off`: skip consolidation entirely (atomic facts only).
+         * - `index`: entity notes are lightweight records — canonical name + links to
+         *   the atomic fact notes mentioning the entity, NO duplicated fact bodies.
+         *   Used as a retrieval boost anchor (see getRelevantKnowledge). Default.
+         * - `content`: legacy behavior — concatenate truncated fact bodies into the
+         *   entity note (retained for back-compat).
+         *
+         * `autoConsolidate: false` forces `off` regardless of this value.
+         * Optional at the type level for back-compat with hand-built configs; the
+         * KnowledgeDefragmenter treats `undefined` as `index`.
+         */
+        consolidationMode: z.ZodOptional<z.ZodEnum<["off", "index", "content"]>>;
         /** Minimum observations about an entity before consolidation */
         consolidationThreshold: z.ZodDefault<z.ZodNumber>;
         /** Whether to auto-regenerate domain summaries */
@@ -902,6 +1421,20 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         llmSummaryGeneration: z.ZodDefault<z.ZodBoolean>;
         /** Whether to auto-resolve simple contradictions */
         autoResolveContradictions: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Run the pairwise contradiction-detection sweep during defrag. This is O(n²)
+         * within a domain, so for large single-domain stores (e.g. a long conversation
+         * where every fact shares one domain) it is expensive and low-value. Optional;
+         * the KnowledgeDefragmenter treats `undefined` as enabled (back-compat). Set
+         * false to skip. See DESIGN-memory-extraction-add-only.md (WS1c).
+         */
+        contradictionScan: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Hard cap on observations-per-domain considered by the contradiction sweep;
+         * beyond this the sweep is skipped for that domain to bound cost. `undefined`
+         * → default cap (see KnowledgeDefragmenter).
+         */
+        contradictionScanMaxNotes: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         minInboxItems: number;
         autoConsolidate: boolean;
@@ -909,13 +1442,19 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         autoRegenerateSummaries: boolean;
         llmSummaryGeneration: boolean;
         autoResolveContradictions: boolean;
+        consolidationMode?: "content" | "off" | "index" | undefined;
+        contradictionScan?: boolean | undefined;
+        contradictionScanMaxNotes?: number | undefined;
     }, {
         minInboxItems?: number | undefined;
         autoConsolidate?: boolean | undefined;
+        consolidationMode?: "content" | "off" | "index" | undefined;
         consolidationThreshold?: number | undefined;
         autoRegenerateSummaries?: boolean | undefined;
         llmSummaryGeneration?: boolean | undefined;
         autoResolveContradictions?: boolean | undefined;
+        contradictionScan?: boolean | undefined;
+        contradictionScanMaxNotes?: number | undefined;
     }>>;
     /** Confidence model config */
     confidence: z.ZodDefault<z.ZodObject<{
@@ -950,35 +1489,6 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         staleThreshold?: number | undefined;
         decayGracePeriodDays?: number | undefined;
     }>>;
-    /** Graph overlay config */
-    graph: z.ZodDefault<z.ZodObject<{
-        /** Which graph layers to enable */
-        enabledLayers: z.ZodDefault<z.ZodArray<z.ZodEnum<["semantic", "temporal", "causal", "entity"]>, "many">>;
-        /** Whether to auto-infer temporal edges from timestamps */
-        inferTemporalEdges: z.ZodDefault<z.ZodBoolean>;
-        /** Whether to auto-infer causal edges from failure-recovery patterns */
-        inferCausalEdges: z.ZodDefault<z.ZodBoolean>;
-        /** Whether to auto-infer entity edges from shared entity tags */
-        inferEntityEdges: z.ZodDefault<z.ZodBoolean>;
-        /** Split layer files by domain when node count exceeds this */
-        domainSplitThreshold: z.ZodDefault<z.ZodNumber>;
-        /** Promote to SQLite when total edge count exceeds this */
-        sqlitePromotionThreshold: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
-        inferTemporalEdges: boolean;
-        inferCausalEdges: boolean;
-        inferEntityEdges: boolean;
-        domainSplitThreshold: number;
-        sqlitePromotionThreshold: number;
-    }, {
-        enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
-        inferTemporalEdges?: boolean | undefined;
-        inferCausalEdges?: boolean | undefined;
-        inferEntityEdges?: boolean | undefined;
-        domainSplitThreshold?: number | undefined;
-        sqlitePromotionThreshold?: number | undefined;
-    }>>;
     /** Surfacing config (independent from SkillLibrary) */
     surfacing: z.ZodDefault<z.ZodObject<{
         /** Include domain summaries in task context */
@@ -993,6 +1503,13 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         includeEvidence: z.ZodDefault<z.ZodBoolean>;
         /** Include graph links in surfaced notes */
         includeLinks: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Additive score boost applied to atomic fact notes that are linked from an
+         * entity record matching the query (index-mode consolidation). Entity records
+         * themselves are NOT injected as content — they act purely as ranking anchors.
+         * Optional; getRelevantKnowledge treats `undefined` as 0.15.
+         */
+        entityBoostWeight: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         includeDomainSummaries: boolean;
         includeEntityNotes: boolean;
@@ -1000,6 +1517,7 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         maxTokensForKnowledge: number;
         includeEvidence: boolean;
         includeLinks: boolean;
+        entityBoostWeight?: number | undefined;
     }, {
         includeDomainSummaries?: boolean | undefined;
         includeEntityNotes?: boolean | undefined;
@@ -1007,6 +1525,7 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         maxTokensForKnowledge?: number | undefined;
         includeEvidence?: boolean | undefined;
         includeLinks?: boolean | undefined;
+        entityBoostWeight?: number | undefined;
     }>>;
     /** Whether to manage minimem-specific features (sync, versioning) */
     minimemAware: z.ZodDefault<z.ZodBoolean>;
@@ -1023,14 +1542,6 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         decayGracePeriodDays: number;
     };
     enabled: boolean;
-    graph: {
-        enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
-        inferTemporalEdges: boolean;
-        inferCausalEdges: boolean;
-        inferEntityEdges: boolean;
-        domainSplitThreshold: number;
-        sqlitePromotionThreshold: number;
-    };
     memoryDir: string;
     extraction: {
         enabled: boolean;
@@ -1044,6 +1555,9 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         autoRegenerateSummaries: boolean;
         llmSummaryGeneration: boolean;
         autoResolveContradictions: boolean;
+        consolidationMode?: "content" | "off" | "index" | undefined;
+        contradictionScan?: boolean | undefined;
+        contradictionScanMaxNotes?: number | undefined;
     };
     surfacing: {
         includeDomainSummaries: boolean;
@@ -1052,6 +1566,7 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         maxTokensForKnowledge: number;
         includeEvidence: boolean;
         includeLinks: boolean;
+        entityBoostWeight?: number | undefined;
     };
     minimemAware: boolean;
     coherenceChecking: boolean;
@@ -1066,14 +1581,6 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         decayGracePeriodDays?: number | undefined;
     } | undefined;
     enabled?: boolean | undefined;
-    graph?: {
-        enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
-        inferTemporalEdges?: boolean | undefined;
-        inferCausalEdges?: boolean | undefined;
-        inferEntityEdges?: boolean | undefined;
-        domainSplitThreshold?: number | undefined;
-        sqlitePromotionThreshold?: number | undefined;
-    } | undefined;
     memoryDir?: string | undefined;
     extraction?: {
         enabled?: boolean | undefined;
@@ -1083,10 +1590,13 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
     defrag?: {
         minInboxItems?: number | undefined;
         autoConsolidate?: boolean | undefined;
+        consolidationMode?: "content" | "off" | "index" | undefined;
         consolidationThreshold?: number | undefined;
         autoRegenerateSummaries?: boolean | undefined;
         llmSummaryGeneration?: boolean | undefined;
         autoResolveContradictions?: boolean | undefined;
+        contradictionScan?: boolean | undefined;
+        contradictionScanMaxNotes?: number | undefined;
     } | undefined;
     surfacing?: {
         includeDomainSummaries?: boolean | undefined;
@@ -1095,6 +1605,7 @@ export declare const KnowledgeBankConfigSchema: z.ZodObject<{
         maxTokensForKnowledge?: number | undefined;
         includeEvidence?: boolean | undefined;
         includeLinks?: boolean | undefined;
+        entityBoostWeight?: number | undefined;
     } | undefined;
     minimemAware?: boolean | undefined;
     coherenceChecking?: boolean | undefined;
@@ -1135,17 +1646,72 @@ export type SessionBankConfig = z.infer<typeof SessionBankConfigSchema>;
 /**
  * Skill-tree storage configuration
  */
+export declare const SharedSkillBankConfigSchema: z.ZodObject<{
+    /**
+     * Mirror published (graduated) playbooks into a shared skill-tree
+     * filesystem bank so consumers outside this Atlas instance (openswarm's
+     * SkillProvider, Claude Code skill loaders, peer tools) can read them
+     * without an openhive materialization bridge. Off by default: writing to a
+     * machine-global bank is an explicit opt-in (CLI `--shared-bank` /
+     * `COGCORE_SHARED_SKILL_BANK`).
+     */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Bank base path (skill-tree `storage.basePath`; skills land under
+     * `<path>/.skilltree/skills/<id>/SKILL.md`). Defaults to the ecosystem's
+     * conventional shared bank `~/.skill-tree` when omitted.
+     */
+    path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    path?: string | undefined;
+}, {
+    path?: string | undefined;
+    enabled?: boolean | undefined;
+}>;
 export declare const SkillTreeConfigSchema: z.ZodObject<{
     /** Enable automatic skill-tree publishing via SqliteStorageAdapter */
     enabled: z.ZodDefault<z.ZodBoolean>;
     /** Path to the SQLite database for skill storage (relative to storage.baseDir) */
     dbPath: z.ZodDefault<z.ZodString>;
+    /** Optional mirror of published skills into a shared filesystem bank. */
+    sharedBank: z.ZodDefault<z.ZodObject<{
+        /**
+         * Mirror published (graduated) playbooks into a shared skill-tree
+         * filesystem bank so consumers outside this Atlas instance (openswarm's
+         * SkillProvider, Claude Code skill loaders, peer tools) can read them
+         * without an openhive materialization bridge. Off by default: writing to a
+         * machine-global bank is an explicit opt-in (CLI `--shared-bank` /
+         * `COGCORE_SHARED_SKILL_BANK`).
+         */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Bank base path (skill-tree `storage.basePath`; skills land under
+         * `<path>/.skilltree/skills/<id>/SKILL.md`). Defaults to the ecosystem's
+         * conventional shared bank `~/.skill-tree` when omitted.
+         */
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        path?: string | undefined;
+    }, {
+        path?: string | undefined;
+        enabled?: boolean | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     enabled: boolean;
     dbPath: string;
+    sharedBank: {
+        enabled: boolean;
+        path?: string | undefined;
+    };
 }, {
     enabled?: boolean | undefined;
     dbPath?: string | undefined;
+    sharedBank?: {
+        path?: string | undefined;
+        enabled?: boolean | undefined;
+    } | undefined;
 }>;
 /**
  * Curated playbook cache configuration (for git sources)
@@ -1167,7 +1733,13 @@ export type CuratedCacheConfig = z.infer<typeof CuratedCacheConfigSchema>;
  * Curated playbook configuration
  */
 export declare const CuratedPlaybooksConfigSchema: z.ZodObject<{
-    /** Load the bundled compound-engineering seed pack on init */
+    /**
+     * Load the bundled seed packs (compound-engineering + agent-ops) on init.
+     * Cold-start semantics: bundled packs only seed an EMPTY playbook library
+     * (mirrors the meta-playbook seed idempotency), so a warm store is never
+     * retro-seeded on upgrade. `recreateOnInit` bypasses the empty check.
+     * Default `true`; evals that must stay seed-free set this to `false`.
+     */
     loadBundledSeedPack: z.ZodDefault<z.ZodBoolean>;
     /** Additional directories to load curated playbooks from (backward compat) */
     additionalDirs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -1225,34 +1797,413 @@ export type SkillTreeConfig = z.infer<typeof SkillTreeConfigSchema>;
  * without removing them from the codebase.
  */
 export declare const FeaturesConfigSchema: z.ZodObject<{
-    /** Enable instant (hot-path) learning on every trajectory (InstantLoop) */
-    instantLoop: z.ZodDefault<z.ZodBoolean>;
     /** Enable reflexion episode generation and storage */
     reflexion: z.ZodDefault<z.ZodBoolean>;
     /** Enable coherence checking on knowledge note insertion */
     coherenceChecking: z.ZodDefault<z.ZodBoolean>;
-    /** Enable experience clustering via ReasoningBank in batch pipeline */
-    reasoningBank: z.ZodDefault<z.ZodBoolean>;
-    /** Enable causal edge extraction in instant loop */
-    causalExtraction: z.ZodDefault<z.ZodBoolean>;
     /** Enable temporal compression (Hot/Warm/Cold/Evict) in batch pipeline */
     temporalCompression: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Dual-write every processed trajectory to the durable `dream_queue` table
+     * (Phase A of the dreaming refactor). Write-only substrate: nothing drains it
+     * yet, so this does not change learning behavior. Default on so the queue is
+     * populated and ready for the decoupled `dream()` consumer (Phase B).
+     */
+    dreamQueue: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Roll each dream-time effectiveness annotation into a per-(scope, family,
+     * solver) lift cell (`lift_cells` table, scope 'production') — the
+     * treatment-effect companion to the eval difficulty registry. Write-only
+     * (no core consumer; read by `cogcore eval lift-report`), one cheap upsert
+     * per annotated trajectory, dream-time only. Default on.
+     */
+    liftTracking: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Enable Pareto-frontier merge proposing in the maintenance loop.
+     * On by default, but self-gating: it only runs once a ReplayJudge is
+     * available (bound via `setLearningProvider` for an LLM judge, or
+     * `enableLiveReplayGating` for a live judge). With no judge it no-ops, so
+     * headless / provider-less setups are unaffected.
+     */
+    mergeProposing: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Enable single-parent reflective playbook mutation in the maintenance
+     * loop. On by default, but self-gating: it only runs once BOTH an LLM
+     * provider (the generator, via `setLearningProvider`) and a ReplayJudge
+     * are available. With neither it no-ops.
+     */
+    reflectiveMutation: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Force lexical retrieval (Jaccard+trigram textSimilarity) even when an
+     * embedding provider is attached. Default false: when a provider is set,
+     * retrieval scores by vector cosine (semantic). Set true to ablate
+     * semantic vs. lexical — corresponds to E5 ablation arm `lexical-retrieval`.
+     */
+    lexicalRetrieval: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Enable write-time curation (PR-D2): near-dup merge on add(), helpfulness
+     * counters, prune pass in maintenance, helpfulness-weighted injection re-rank.
+     * Default true. Set false to restore append-only behavior (ablation arm
+     * `append-only`).
+     */
+    curation: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Surface applicability conditions (situations + antiPatterns) at injection
+     * time so the agent sees "Apply when:" / "Do NOT apply when:" alongside the
+     * strategy and tactics.  Default true — this is the fix.  Set false to
+     * reproduce old behavior (ablation arm: no-applicability-injection).
+     */
+    injectApplicability: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Use embedding cosine similarity for anti-pattern exclusion at retrieval
+     * time when an embedding provider is attached.  Default true.  When false,
+     * falls back to the legacy lexical textSimilarity > 0.7 guard.
+     */
+    semanticAntiPatterns: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * F6: Update playbook helpful/harmful counters via INJECTION-PRESENCE +
+     * TASK OUTCOME (relevance-weighted), rather than lexical usage detection.
+     *
+     * When true (default), for each task solve with injected playbooks, each
+     * playbook's successCount/failureCount is incremented by its relevance
+     * share (score_i / sum(score_j)) times the task outcome.  This fixes the
+     * curation loop for DISTILLED playbooks whose abstract tactics never
+     * lexically match concrete actions, so wasUsed was always false and counters
+     * never updated.
+     *
+     * When false, falls back to the old wasUsed-gated recordSuccess/recordFailure
+     * path (lexical usage detection; ablation arm).
+     *
+     * Default true (this is the fix).
+     */
+    injectionPresenceCredit: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * ADDITIVE LEARNING (default ON as of 2026-07-06). When ON, procedural-memory
+     * consolidation REFINES/REUSES existing playbooks instead of minting a unique
+     * `distilled-<uuid>` per trajectory:
+     *   FIX 1 — at dream distill time, a freshly distilled playbook that is
+     *     sufficiently similar (see `learning.additiveMergeThreshold`) to an
+     *     existing one (this-batch OR library) is merged into it (append
+     *     createdFrom, fold guidance/anti-patterns, accumulate counters, bump
+     *     version) rather than added as a new row.
+     *   FIX 2 — each solve records a frontier/live outcome for the playbooks
+     *     that were actually INJECTED (served set), so reused playbooks
+     *     accumulate frontier rows aligned with hybrid retrieval — not just the
+     *     legacy 0.3 lexical instant-loop match — feeding a non-sparse mutation
+     *     gate.
+     * Set `false` (eval `--no-additive`) to restore the legacy "proliferating"
+     * behavior (a new unique `distilled-<uuid>` per trajectory) for A/B arms.
+     */
+    additiveConsolidation: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * F5: Emit a USE-TIME relevance-gating instruction alongside injected
+     * candidate playbooks, telling the agent to self-filter against the
+     * "Apply when:" / "Do NOT apply when:" conditions before using any
+     * candidate.  Only emitted when there is ≥1 candidate playbook AND
+     * injectApplicability is on.
+     *
+     * Default true.  Set false to reproduce old behavior (ablation arm:
+     * no-relevance-gating).
+     */
+    relevanceGating: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     coherenceChecking: boolean;
-    instantLoop: boolean;
     reflexion: boolean;
-    reasoningBank: boolean;
-    causalExtraction: boolean;
     temporalCompression: boolean;
+    dreamQueue: boolean;
+    liftTracking: boolean;
+    mergeProposing: boolean;
+    reflectiveMutation: boolean;
+    lexicalRetrieval: boolean;
+    curation: boolean;
+    injectApplicability: boolean;
+    semanticAntiPatterns: boolean;
+    injectionPresenceCredit: boolean;
+    additiveConsolidation: boolean;
+    relevanceGating: boolean;
 }, {
     coherenceChecking?: boolean | undefined;
-    instantLoop?: boolean | undefined;
     reflexion?: boolean | undefined;
-    reasoningBank?: boolean | undefined;
-    causalExtraction?: boolean | undefined;
     temporalCompression?: boolean | undefined;
+    dreamQueue?: boolean | undefined;
+    liftTracking?: boolean | undefined;
+    mergeProposing?: boolean | undefined;
+    reflectiveMutation?: boolean | undefined;
+    lexicalRetrieval?: boolean | undefined;
+    curation?: boolean | undefined;
+    injectApplicability?: boolean | undefined;
+    semanticAntiPatterns?: boolean | undefined;
+    injectionPresenceCredit?: boolean | undefined;
+    additiveConsolidation?: boolean | undefined;
+    relevanceGating?: boolean | undefined;
 }>;
 export type FeaturesConfig = z.infer<typeof FeaturesConfigSchema>;
+/**
+ * Dreaming / consolidation configuration.
+ *
+ * Controls when and how accumulated trajectories are consolidated. Learning is
+ * always decoupled: consolidation happens only via `dream()` — explicitly, on a
+ * schedule, or at close.
+ */
+export declare const DreamSchedulerConfigSchema: z.ZodObject<{
+    /** Arm an in-process idle timer that dreams after `idleMs` of no activity. */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Idle debounce before an auto-dream fires (ms). */
+    idleMs: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    idleMs: number;
+}, {
+    enabled?: boolean | undefined;
+    idleMs?: number | undefined;
+}>;
+export declare const DreamConfigSchema: z.ZodObject<{
+    /** After each solve/process call, run a dream synchronously (eval determinism). */
+    consolidateInline: z.ZodDefault<z.ZodBoolean>;
+    /** Pending-row count at/above which the coordinator considers a dream due. */
+    countThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Oldest-pending age at/above which a dream is considered overdue (ms). */
+    maxStalenessMs: z.ZodDefault<z.ZodNumber>;
+    /** Max rows claimed per internal batch within a single dream. */
+    maxRowsPerDream: z.ZodDefault<z.ZodNumber>;
+    /** Max internal batches a single dream will drain before stopping. */
+    maxBatchesPerDream: z.ZodDefault<z.ZodNumber>;
+    /** Row lease TTL while a dream holds claimed rows (ms). */
+    leaseTtlMs: z.ZodDefault<z.ZodNumber>;
+    /** Attempts before a repeatedly-failing row is parked as `failed`. */
+    maxAttempts: z.ZodDefault<z.ZodNumber>;
+    /** In-process idle scheduler. */
+    scheduler: z.ZodDefault<z.ZodObject<{
+        /** Arm an in-process idle timer that dreams after `idleMs` of no activity. */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Idle debounce before an auto-dream fires (ms). */
+        idleMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        idleMs: number;
+    }, {
+        enabled?: boolean | undefined;
+        idleMs?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    consolidateInline: boolean;
+    countThreshold: number;
+    maxStalenessMs: number;
+    maxRowsPerDream: number;
+    maxBatchesPerDream: number;
+    leaseTtlMs: number;
+    maxAttempts: number;
+    scheduler: {
+        enabled: boolean;
+        idleMs: number;
+    };
+}, {
+    consolidateInline?: boolean | undefined;
+    countThreshold?: number | undefined;
+    maxStalenessMs?: number | undefined;
+    maxRowsPerDream?: number | undefined;
+    maxBatchesPerDream?: number | undefined;
+    leaseTtlMs?: number | undefined;
+    maxAttempts?: number | undefined;
+    scheduler?: {
+        enabled?: boolean | undefined;
+        idleMs?: number | undefined;
+    } | undefined;
+}>;
+export type DreamConfig = z.infer<typeof DreamConfigSchema>;
+/**
+ * Validation control plane for mechanism/eval runs.
+ *
+ * This is intentionally separate from production feature flags. Validation
+ * arms need to isolate retrieval, serving, write, and maintenance behavior
+ * without silently changing the default runtime.
+ */
+export declare const ValidationRetrievalChannelSchema: z.ZodEnum<["experiences", "knowledge", "playbooks", "metaPlaybooks", "shortTerm"]>;
+export type ValidationRetrievalChannel = z.infer<typeof ValidationRetrievalChannelSchema>;
+export declare const ValidationWriteChannelSchema: z.ZodEnum<["experience", "knowledgeNote", "playbook", "metaPlaybook", "reflexion", "causal", "frontier", "diagnosticOnly"]>;
+export type ValidationWriteChannel = z.infer<typeof ValidationWriteChannelSchema>;
+export declare const ValidationMutationModeSchema: z.ZodEnum<["frozen", "active", "candidate"]>;
+export type ValidationMutationMode = z.infer<typeof ValidationMutationModeSchema>;
+export declare const ValidationMaintenanceMaskSchema: z.ZodObject<{
+    /** Write-time curation and prune maintenance. */
+    curation: z.ZodDefault<z.ZodBoolean>;
+    /** Pareto/replay-gated two-parent merge proposals. */
+    mergeProposing: z.ZodDefault<z.ZodBoolean>;
+    /** Single-parent reflective mutation proposals. */
+    reflectiveMutation: z.ZodDefault<z.ZodBoolean>;
+    /** Dream/batch extraction may create new learned artifacts. */
+    extraction: z.ZodDefault<z.ZodBoolean>;
+    /** Scheduler-driven maintenance/dream runs. */
+    scheduling: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    extraction: boolean;
+    mergeProposing: boolean;
+    reflectiveMutation: boolean;
+    curation: boolean;
+    scheduling: boolean;
+}, {
+    extraction?: boolean | undefined;
+    mergeProposing?: boolean | undefined;
+    reflectiveMutation?: boolean | undefined;
+    curation?: boolean | undefined;
+    scheduling?: boolean | undefined;
+}>;
+export type ValidationMaintenanceMask = z.infer<typeof ValidationMaintenanceMaskSchema>;
+export declare const ValidationChannelMasksSchema: z.ZodObject<{
+    retrieval: z.ZodDefault<z.ZodArray<z.ZodEnum<["experiences", "knowledge", "playbooks", "metaPlaybooks", "shortTerm"]>, "many">>;
+    serving: z.ZodDefault<z.ZodArray<z.ZodEnum<["experiences", "knowledge", "playbooks", "metaPlaybooks", "shortTerm"]>, "many">>;
+    write: z.ZodDefault<z.ZodArray<z.ZodEnum<["experience", "knowledgeNote", "playbook", "metaPlaybook", "reflexion", "causal", "frontier", "diagnosticOnly"]>, "many">>;
+    maintenance: z.ZodDefault<z.ZodObject<{
+        /** Write-time curation and prune maintenance. */
+        curation: z.ZodDefault<z.ZodBoolean>;
+        /** Pareto/replay-gated two-parent merge proposals. */
+        mergeProposing: z.ZodDefault<z.ZodBoolean>;
+        /** Single-parent reflective mutation proposals. */
+        reflectiveMutation: z.ZodDefault<z.ZodBoolean>;
+        /** Dream/batch extraction may create new learned artifacts. */
+        extraction: z.ZodDefault<z.ZodBoolean>;
+        /** Scheduler-driven maintenance/dream runs. */
+        scheduling: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        extraction: boolean;
+        mergeProposing: boolean;
+        reflectiveMutation: boolean;
+        curation: boolean;
+        scheduling: boolean;
+    }, {
+        extraction?: boolean | undefined;
+        mergeProposing?: boolean | undefined;
+        reflectiveMutation?: boolean | undefined;
+        curation?: boolean | undefined;
+        scheduling?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    retrieval: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+    serving: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+    write: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[];
+    maintenance: {
+        extraction: boolean;
+        mergeProposing: boolean;
+        reflectiveMutation: boolean;
+        curation: boolean;
+        scheduling: boolean;
+    };
+}, {
+    retrieval?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+    serving?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+    write?: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[] | undefined;
+    maintenance?: {
+        extraction?: boolean | undefined;
+        mergeProposing?: boolean | undefined;
+        reflectiveMutation?: boolean | undefined;
+        curation?: boolean | undefined;
+        scheduling?: boolean | undefined;
+    } | undefined;
+}>;
+export type ValidationChannelMasks = z.infer<typeof ValidationChannelMasksSchema>;
+export declare const ValidationConfigSchema: z.ZodObject<{
+    /** Enable validation-specific isolation controls. Production default is off. */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * active: existing direct-commit behavior.
+     * frozen: no mutation/merge/curation writes during validation.
+     * candidate: proposals are redirected to non-serving candidates (future work).
+     */
+    mutationMode: z.ZodDefault<z.ZodEnum<["frozen", "active", "candidate"]>>;
+    channelMasks: z.ZodDefault<z.ZodObject<{
+        retrieval: z.ZodDefault<z.ZodArray<z.ZodEnum<["experiences", "knowledge", "playbooks", "metaPlaybooks", "shortTerm"]>, "many">>;
+        serving: z.ZodDefault<z.ZodArray<z.ZodEnum<["experiences", "knowledge", "playbooks", "metaPlaybooks", "shortTerm"]>, "many">>;
+        write: z.ZodDefault<z.ZodArray<z.ZodEnum<["experience", "knowledgeNote", "playbook", "metaPlaybook", "reflexion", "causal", "frontier", "diagnosticOnly"]>, "many">>;
+        maintenance: z.ZodDefault<z.ZodObject<{
+            /** Write-time curation and prune maintenance. */
+            curation: z.ZodDefault<z.ZodBoolean>;
+            /** Pareto/replay-gated two-parent merge proposals. */
+            mergeProposing: z.ZodDefault<z.ZodBoolean>;
+            /** Single-parent reflective mutation proposals. */
+            reflectiveMutation: z.ZodDefault<z.ZodBoolean>;
+            /** Dream/batch extraction may create new learned artifacts. */
+            extraction: z.ZodDefault<z.ZodBoolean>;
+            /** Scheduler-driven maintenance/dream runs. */
+            scheduling: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            extraction: boolean;
+            mergeProposing: boolean;
+            reflectiveMutation: boolean;
+            curation: boolean;
+            scheduling: boolean;
+        }, {
+            extraction?: boolean | undefined;
+            mergeProposing?: boolean | undefined;
+            reflectiveMutation?: boolean | undefined;
+            curation?: boolean | undefined;
+            scheduling?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        retrieval: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+        serving: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+        write: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[];
+        maintenance: {
+            extraction: boolean;
+            mergeProposing: boolean;
+            reflectiveMutation: boolean;
+            curation: boolean;
+            scheduling: boolean;
+        };
+    }, {
+        retrieval?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+        serving?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+        write?: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[] | undefined;
+        maintenance?: {
+            extraction?: boolean | undefined;
+            mergeProposing?: boolean | undefined;
+            reflectiveMutation?: boolean | undefined;
+            curation?: boolean | undefined;
+            scheduling?: boolean | undefined;
+        } | undefined;
+    }>>;
+    /**
+     * Permit cold-start seeding (bundled playbook pack, meta-playbook seeds,
+     * meta-strategy priors) under validation. Default false: validation runs
+     * start from an explicitly-controlled memory state. The seed-lift A/B
+     * (Phase 1 of the seed co-optimization loop) sets this true on the seeded
+     * arm so the committed seeds are the *measured variable* rather than an
+     * uncontrolled confound.
+     */
+    allowSeeds: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    mutationMode: "frozen" | "active" | "candidate";
+    channelMasks: {
+        retrieval: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+        serving: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+        write: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[];
+        maintenance: {
+            extraction: boolean;
+            mergeProposing: boolean;
+            reflectiveMutation: boolean;
+            curation: boolean;
+            scheduling: boolean;
+        };
+    };
+    allowSeeds: boolean;
+}, {
+    enabled?: boolean | undefined;
+    mutationMode?: "frozen" | "active" | "candidate" | undefined;
+    channelMasks?: {
+        retrieval?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+        serving?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+        write?: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[] | undefined;
+        maintenance?: {
+            extraction?: boolean | undefined;
+            mergeProposing?: boolean | undefined;
+            reflectiveMutation?: boolean | undefined;
+            curation?: boolean | undefined;
+            scheduling?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+    allowSeeds?: boolean | undefined;
+}>;
+export type ValidationConfig = z.infer<typeof ValidationConfigSchema>;
 /**
  * Main Atlas configuration
  */
@@ -1263,6 +2214,19 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         creditStrategy: z.ZodDefault<z.ZodEnum<["simple", "llm", "counterfactual"]>>;
         /** How to extract patterns */
         patternExtractor: z.ZodDefault<z.ZodEnum<["llm", "text", "both"]>>;
+        /**
+         * G2: When `patternExtractor` (or `creditStrategy`) requests an LLM-backed
+         * path but no agent backend is wired (no `taskRunner`; e.g. `createAtlas`
+         * with no backend or CLI ingest), extraction/analysis degrades to the
+         * heuristic implementation. That degradation is always made LOUD (a
+         * once-per-run warning). When `strictExtraction` is ON, the degradation
+         * instead THROWS so misconfiguration is caught up front.
+         *
+         * Default OFF (warn, don't throw) so headless ingest still functions —
+         * autonomous LLM extraction genuinely requires a backend, so headless
+         * runs must be allowed to fall back to the heuristic extractor.
+         */
+        strictExtraction: z.ZodDefault<z.ZodBoolean>;
         /** Minimum trajectories before batch learning */
         minTrajectories: z.ZodDefault<z.ZodNumber>;
         /** Minimum hours since last batch learning */
@@ -1273,22 +2237,40 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
         /** Maximum experiences to keep during pruning (default: 1000) */
         maxExperiences: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Additive-consolidation similarity threshold (0..1). Only consulted when
+         * `features.additiveConsolidation` is ON. A freshly distilled playbook is
+         * MERGED into an existing one instead of minting a new `distilled-<uuid>`
+         * when their embeddings-optional similarity (cosine when both embeddings
+         * exist, else lexical textSimilarity over strategy + situations) meets this
+         * threshold AND they share a domain. Default 0.55 — deliberately below the
+         * 0.9 write-time dedup threshold (which almost never fires for distinct
+         * distilled titles) so genuine same-family repeats actually compound, while
+         * the domain-overlap hard gate + this floor guard against cross-family
+         * over-merge. Lower → more aggressive merging (evidence compounds faster but
+         * risk of conflating distinct lessons); higher → closer to proliferation.
+         */
+        additiveMergeThreshold: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         creditStrategy: "llm" | "simple" | "counterfactual";
-        patternExtractor: "llm" | "both" | "text";
+        patternExtractor: "llm" | "text" | "both";
+        strictExtraction: boolean;
         minTrajectories: number;
         deduplicationThreshold: number;
         maxExperiences: number;
+        additiveMergeThreshold: number;
         minHoursSinceLast?: number | undefined;
         minSuccessRate?: number | undefined;
     }, {
         creditStrategy?: "llm" | "simple" | "counterfactual" | undefined;
-        patternExtractor?: "llm" | "both" | "text" | undefined;
+        patternExtractor?: "llm" | "text" | "both" | undefined;
+        strictExtraction?: boolean | undefined;
         minTrajectories?: number | undefined;
         minHoursSinceLast?: number | undefined;
         minSuccessRate?: number | undefined;
         deduplicationThreshold?: number | undefined;
         maxExperiences?: number | undefined;
+        additiveMergeThreshold?: number | undefined;
     }>>;
     /** Router configuration */
     router: z.ZodDefault<z.ZodObject<{
@@ -1298,14 +2280,32 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         useDomainRouting: z.ZodDefault<z.ZodBoolean>;
         /** Default search strategy */
         defaultStrategy: z.ZodDefault<z.ZodString>;
+        /**
+         * Difficulty-aware routing (G6). When ON, the router computes a general,
+         * domain-agnostic task-difficulty signal (`computeTaskDifficulty`) and:
+         *   - routes HARD tasks to the expensive refinement/exemplar strategy with a
+         *     deliberately LOWER `routing.confidence` (below `refinement
+         *     .confidenceThreshold`, default 0.85) so they auto-enter the G1
+         *     refinement loop;
+         *   - routes EASY tasks to the cheap/direct path with higher confidence so
+         *     they stay above the threshold and skip refinement;
+         *   - sets the multi-objective `prefer` axis from difficulty (hard → quality,
+         *     trivial → cheap) so the Pareto frontier query is actually exercised.
+         *
+         * Default ON (maintainer's call): degrades gracefully (no throw) when the
+         * frontier is cold or memory is empty.
+         */
+        difficultyAwareRouting: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         similarityThreshold: number;
         useDomainRouting: boolean;
         defaultStrategy: string;
+        difficultyAwareRouting: boolean;
     }, {
         similarityThreshold?: number | undefined;
         useDomainRouting?: boolean | undefined;
         defaultStrategy?: string | undefined;
+        difficultyAwareRouting?: boolean | undefined;
     }>>;
     /** Memory configuration */
     memory: z.ZodDefault<z.ZodObject<{
@@ -1352,6 +2352,206 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             autoPrune?: boolean | undefined;
             preserveDomainCoverage?: boolean | undefined;
         }>>;
+        /**
+         * Use the Pareto frontier to select playbooks when a signature has
+         * recorded outcomes, falling back to text-similarity matching otherwise.
+         *
+         * Default ON (G6, maintainer's call): the frontier path is headless-safe —
+         * a cold store (signature with no recorded outcomes / empty frontier) falls
+         * back to text-similarity matching inside `findMatchingFrontierAware`
+         * (`playbook.ts`), so enabling it never deadlocks or throws.
+         */
+        frontierRouting: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Whether failed trajectories may be injected as in-context EXEMPLARS
+         * (the experience-retrieval channel surfaced to the agent at solve time).
+         *
+         * This does NOT control whether failures are stored or learned from:
+         * failures always still feed reflexion episodes, playbook anti-patterns,
+         * causal edges, and error-pattern analysis. It only governs the imitation
+         * channel. Injecting raw failed trajectories as exemplars can anchor an
+         * agent to bad approaches — especially on imitation-heavy / procedural tasks
+         * (embodied, web nav) where the agent copies action sequences. Set to
+         * `false` for success-biased exemplar injection (the agent only sees
+         * trajectories that worked). Default `true` preserves prior behavior.
+         */
+        injectFailedExperiences: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * On init, seed the (file-backed) MetaPlaybookBank from the committed
+         * `META_PLAYBOOK_SEEDS` — meta-level guidance that steers the
+         * analysis/extraction/maintenance agents. Idempotent: only seeds an empty
+         * bank, so learned refinements are never overwritten. Default `true`
+         * (cold-start default; set `false` for seed-free ablations).
+         */
+        seedMetaPlaybooks: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * On init, seed MetaMemory with the committed `META_STRATEGY_SEEDS` routing
+         * priors so the router's meta-adjustment path is not inert on a cold store.
+         * Idempotent: only seeds when no strategies exist, so learned strategies and
+         * their evidence (EMA success rate) are never overwritten. Default `true`.
+         */
+        seedMetaStrategies: z.ZodDefault<z.ZodBoolean>;
+        /** Playbook serving/retrieval configuration. */
+        playbookRetrieval: z.ZodDefault<z.ZodObject<{
+            /**
+             * Playbook retrieval implementation.
+             * - legacy: cognitive-core's existing PlaybookLibrary matcher.
+             * - skill-tree-hybrid: convert playbooks to skill-tree Skills and score with
+             *   skill-tree's body-indexed hybrid scorer.
+             */
+            mode: z.ZodDefault<z.ZodEnum<["legacy", "skill-tree-hybrid"]>>;
+            /**
+             * Minimum retrieval score required before a playbook is injected, for LEXICAL
+             * (text-similarity) scoring. Lexical scores are sparse (~0.1 even for relevant
+             * matches), so this floor cannot separate signal from noise — embedding mode
+             * (`minScoreSemantic`) is what makes a meaningful floor possible. Serving
+             * relevance floor, separate from playbook confidence.
+             */
+            minScore: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Relevance floor when SEMANTIC (embedding-cosine) scoring is active (an
+             * EmbeddingProvider attached via `setEmbeddingProvider`). Cosine scores are
+             * denser than lexical, so a real floor (default 0.35 — below the ~0.5 "high
+             * similarity" bar so relevant matches survive) rejects noise WITHOUT omitting
+             * relevant playbooks, unlike a raised lexical floor.
+             */
+            minScoreSemantic: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Multiplier applied to the active floor on the GLOBAL (cross-domain) fallback
+             * retrieval — when a task's own domain has no playbooks and retrieval reaches
+             * across all domains, require a higher score (default 1.5×) so out-of-family
+             * playbooks need a strong match. Prevents cross-family negative transfer (see
+             * docs/runs/skillflow-playbook-ablation-3families-bedrock-haiku.md).
+             */
+            crossDomainFloorMultiplier: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Fusion strategy for skill-tree-hybrid mode. RRF only changes ordering when
+             * a dense embedder is attached; BM25-only scoring remains available.
+             */
+            fusion: z.ZodDefault<z.ZodEnum<["weighted", "rrf"]>>;
+            /**
+             * How an injected playbook is rendered into the prompt (roadmap §4.3 / Exp 4):
+             * - `full`: the whole playbook (strategy + all tactics/steps). Default.
+             * - `sectioned`: strategy + only the tactics/steps whose text shares cues with
+             *   the task. Lower token cost and less context interference for broad
+             *   playbooks where only a subskill applies. Deterministic (no LLM); a no-op
+             *   for already-atomic playbooks whose every tactic matches.
+             * (`refined`, an LLM task-specific rewrite, is a separate serve-time path and
+             * not selectable here yet.)
+             */
+            incorporation: z.ZodDefault<z.ZodEnum<["full", "sectioned"]>>;
+        }, "strip", z.ZodTypeAny, {
+            mode: "legacy" | "skill-tree-hybrid";
+            minScore: number;
+            minScoreSemantic: number;
+            crossDomainFloorMultiplier: number;
+            fusion: "weighted" | "rrf";
+            incorporation: "full" | "sectioned";
+        }, {
+            mode?: "legacy" | "skill-tree-hybrid" | undefined;
+            minScore?: number | undefined;
+            minScoreSemantic?: number | undefined;
+            crossDomainFloorMultiplier?: number | undefined;
+            fusion?: "weighted" | "rrf" | undefined;
+            incorporation?: "full" | "sectioned" | undefined;
+        }>>;
+        /** Optional post-retrieval playbook applicability gate. */
+        playbookApplicability: z.ZodDefault<z.ZodObject<{
+            /**
+             * Opt-in serving gate that decides whether a retrieved playbook is specific
+             * enough to inject.
+             */
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /** Floor for matches that lack trigger/situation cues. */
+            minSpecificityScore: z.ZodDefault<z.ZodNumber>;
+            /** Stronger floor for cross-domain matches without trigger/situation cues. */
+            crossDomainMinScore: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            minSpecificityScore: number;
+            crossDomainMinScore: number;
+        }, {
+            enabled?: boolean | undefined;
+            minSpecificityScore?: number | undefined;
+            crossDomainMinScore?: number | undefined;
+        }>>;
+        /** Procedural-memory filesystem migration settings. */
+        proceduralMemory: z.ZodDefault<z.ZodObject<{
+            /**
+             * Stable procedural-memory authority. `filesystem` (the default) makes
+             * `.atlas/playbooks/<slug>/SKILL.md` canonical for stable playbook content;
+             * SQLite remains the runtime cache and operational ledger (operational state
+             * mirrored to `.ccore/state.json` so the DB rebuilds from files). `sqlite`
+             * preserves the legacy behavior where SQLite rows are the source of truth —
+             * used by migration tooling and the SQLite-only-drift / migration tests,
+             * which opt back in via `source: "sqlite"` explicitly.
+             */
+            source: z.ZodDefault<z.ZodEnum<["sqlite", "filesystem"]>>;
+            /** Canonical procedural-memory directory, relative to storage.baseDir. */
+            dir: z.ZodDefault<z.ZodString>;
+            /** Fail startup on file-first warnings instead of continuing best-effort. */
+            strictStartup: z.ZodDefault<z.ZodBoolean>;
+            /** Future destructive cleanup switch; defaults off for hard migration safety. */
+            pruneSqliteOnly: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Reindex-on-edit cascade (§6.2). When on, a debounced file watcher over the
+             * canonical `playbooks/` tree picks up external `SKILL.md` edits (hand edits,
+             * `git pull`) live via a durable queue — no reboot needed. Off by default:
+             * short-lived eval/CLI runs don't need it (startup reindex covers them), and
+             * only long-lived servers benefit. Requires `source: "filesystem"`.
+             */
+            watch: z.ZodDefault<z.ZodBoolean>;
+            /** Coalescing window (ms) for a burst of file events before the cascade drains. */
+            watchDebounceMs: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Poll for changes instead of native OS events. Needed on filesystems where
+             * native watching doesn't fire (NFS, Docker bind mounts, some CI). Off by
+             * default (native fsevents/inotify are cheaper).
+             */
+            watchUsePolling: z.ZodDefault<z.ZodBoolean>;
+            /** Poll interval (ms) when `watchUsePolling` is on. */
+            watchPollIntervalMs: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Legacy Phase 3 bridge. Prefer `source: "filesystem"` for hard-authority
+             * migration; this remains for callers that only want mirroring.
+             */
+            structuralDualWrite: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                dir: z.ZodDefault<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                enabled: boolean;
+                dir: string;
+            }, {
+                enabled?: boolean | undefined;
+                dir?: string | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            source: "sqlite" | "filesystem";
+            dir: string;
+            strictStartup: boolean;
+            pruneSqliteOnly: boolean;
+            watch: boolean;
+            watchDebounceMs: number;
+            watchUsePolling: boolean;
+            watchPollIntervalMs: number;
+            structuralDualWrite: {
+                enabled: boolean;
+                dir: string;
+            };
+        }, {
+            source?: "sqlite" | "filesystem" | undefined;
+            dir?: string | undefined;
+            strictStartup?: boolean | undefined;
+            pruneSqliteOnly?: boolean | undefined;
+            watch?: boolean | undefined;
+            watchDebounceMs?: number | undefined;
+            watchUsePolling?: boolean | undefined;
+            watchPollIntervalMs?: number | undefined;
+            structuralDualWrite?: {
+                enabled?: boolean | undefined;
+                dir?: string | undefined;
+            } | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         maxExperiences: number;
         maxStrategies: number;
@@ -1367,6 +2567,37 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             autoPrune: boolean;
             preserveDomainCoverage: boolean;
         };
+        frontierRouting: boolean;
+        injectFailedExperiences: boolean;
+        seedMetaPlaybooks: boolean;
+        seedMetaStrategies: boolean;
+        playbookRetrieval: {
+            mode: "legacy" | "skill-tree-hybrid";
+            minScore: number;
+            minScoreSemantic: number;
+            crossDomainFloorMultiplier: number;
+            fusion: "weighted" | "rrf";
+            incorporation: "full" | "sectioned";
+        };
+        playbookApplicability: {
+            enabled: boolean;
+            minSpecificityScore: number;
+            crossDomainMinScore: number;
+        };
+        proceduralMemory: {
+            source: "sqlite" | "filesystem";
+            dir: string;
+            strictStartup: boolean;
+            pruneSqliteOnly: boolean;
+            watch: boolean;
+            watchDebounceMs: number;
+            watchUsePolling: boolean;
+            watchPollIntervalMs: number;
+            structuralDualWrite: {
+                enabled: boolean;
+                dir: string;
+            };
+        };
     }, {
         maxExperiences?: number | undefined;
         maxStrategies?: number | undefined;
@@ -1382,6 +2613,37 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             autoPrune?: boolean | undefined;
             preserveDomainCoverage?: boolean | undefined;
         } | undefined;
+        frontierRouting?: boolean | undefined;
+        injectFailedExperiences?: boolean | undefined;
+        seedMetaPlaybooks?: boolean | undefined;
+        seedMetaStrategies?: boolean | undefined;
+        playbookRetrieval?: {
+            mode?: "legacy" | "skill-tree-hybrid" | undefined;
+            minScore?: number | undefined;
+            minScoreSemantic?: number | undefined;
+            crossDomainFloorMultiplier?: number | undefined;
+            fusion?: "weighted" | "rrf" | undefined;
+            incorporation?: "full" | "sectioned" | undefined;
+        } | undefined;
+        playbookApplicability?: {
+            enabled?: boolean | undefined;
+            minSpecificityScore?: number | undefined;
+            crossDomainMinScore?: number | undefined;
+        } | undefined;
+        proceduralMemory?: {
+            source?: "sqlite" | "filesystem" | undefined;
+            dir?: string | undefined;
+            strictStartup?: boolean | undefined;
+            pruneSqliteOnly?: boolean | undefined;
+            watch?: boolean | undefined;
+            watchDebounceMs?: number | undefined;
+            watchUsePolling?: boolean | undefined;
+            watchPollIntervalMs?: number | undefined;
+            structuralDualWrite?: {
+                enabled?: boolean | undefined;
+                dir?: string | undefined;
+            } | undefined;
+        } | undefined;
     }>>;
     /** Storage configuration */
     storage: z.ZodDefault<z.ZodObject<{
@@ -1468,9 +2730,18 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         useAgentEvaluation: z.ZodDefault<z.ZodBoolean>;
         /** Agent type to use for evaluation */
         evaluatorAgentType: z.ZodDefault<z.ZodString>;
-        /** Confidence threshold below which to trigger refinement */
+        /**
+         * Confidence threshold below which to trigger refinement.
+         * Raised from 0.6 so refinement is reachable on normal routes — most
+         * routing decisions land below 0.85 confidence and should remain eligible
+         * for verifier-driven refinement.
+         */
         confidenceThreshold: z.ZodDefault<z.ZodNumber>;
-        /** Routing strategies that should trigger refinement */
+        /**
+         * Routing strategies that should trigger refinement.
+         * Broadened to all four strategies (G1): a task can mis-execute on any
+         * route, including `direct`/`adapt`, so none are excluded by default.
+         */
         triggerOnStrategies: z.ZodDefault<z.ZodArray<z.ZodEnum<["explore", "fallback", "direct", "adapt"]>, "many">>;
     }, "strip", z.ZodTypeAny, {
         maxIterations: number;
@@ -1497,14 +2768,29 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             minSuccessCount: z.ZodDefault<z.ZodNumber>;
             /** Minimum success rate to promote */
             minSuccessRate: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Eval-gate tier promotion (G5). When ON, a playbook must pass an
+             * eval gate IN ADDITION to the threshold criteria before it is
+             * promoted to a served tier.
+             *
+             * Default ON (maintainer's call): the default gate is Pareto-frontier
+             * dominance, which is headless-safe — it reuses already-built, no-LLM
+             * machinery and treats a playbook with no frontier history (first-ever
+             * / freshly-extracted) as non-dominated, so default-on gating never
+             * deadlocks. When a `PromotionJudge` (or `ReplayJudge`) is registered
+             * on the `SkillLibrary`, the stronger judge-based gate is used instead.
+             */
+            evalGate: z.ZodDefault<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             minSuccessRate: number;
             minConfidence: number;
             minSuccessCount: number;
+            evalGate: boolean;
         }, {
             minSuccessRate?: number | undefined;
             minConfidence?: number | undefined;
             minSuccessCount?: number | undefined;
+            evalGate?: boolean | undefined;
         }>>;
         /** Capacity limits */
         limits: z.ZodDefault<z.ZodObject<{
@@ -1531,17 +2817,25 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             includeRefinements: z.ZodDefault<z.ZodBoolean>;
             /** Include code examples in skill context */
             includeExamples: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * G4: include a worked-trajectory exemplar (few-shot demonstration) in skill
+             * context when a playbook carries one. Default ON — a surfaced skill should
+             * carry the demonstration, not just rules ("demonstration > rules").
+             */
+            includeExemplar: z.ZodDefault<z.ZodBoolean>;
             /** Cache refresh interval in milliseconds (default: 5 minutes) */
             cacheRefreshInterval: z.ZodDefault<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             maxTokensForSkills: number;
             includeRefinements: boolean;
             includeExamples: boolean;
+            includeExemplar: boolean;
             cacheRefreshInterval: number;
         }, {
             maxTokensForSkills?: number | undefined;
             includeRefinements?: boolean | undefined;
             includeExamples?: boolean | undefined;
+            includeExemplar?: boolean | undefined;
             cacheRefreshInterval?: number | undefined;
         }>>;
         /** Demotion criteria */
@@ -1557,17 +2851,83 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             failureThreshold?: number | undefined;
             minConfidenceToRetain?: number | undefined;
         }>>;
+        /** Contextual playbook retrieval for tiered skill surfacing. */
+        retrieval: z.ZodDefault<z.ZodObject<{
+            /**
+             * Playbook retrieval implementation.
+             * - legacy: cognitive-core's existing PlaybookLibrary matcher.
+             * - skill-tree-hybrid: convert playbooks to skill-tree Skills and score with
+             *   skill-tree's body-indexed hybrid scorer.
+             */
+            mode: z.ZodDefault<z.ZodEnum<["legacy", "skill-tree-hybrid"]>>;
+            /**
+             * Minimum retrieval score required before a playbook is injected, for LEXICAL
+             * (text-similarity) scoring. Lexical scores are sparse (~0.1 even for relevant
+             * matches), so this floor cannot separate signal from noise — embedding mode
+             * (`minScoreSemantic`) is what makes a meaningful floor possible. Serving
+             * relevance floor, separate from playbook confidence.
+             */
+            minScore: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Relevance floor when SEMANTIC (embedding-cosine) scoring is active (an
+             * EmbeddingProvider attached via `setEmbeddingProvider`). Cosine scores are
+             * denser than lexical, so a real floor (default 0.35 — below the ~0.5 "high
+             * similarity" bar so relevant matches survive) rejects noise WITHOUT omitting
+             * relevant playbooks, unlike a raised lexical floor.
+             */
+            minScoreSemantic: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Multiplier applied to the active floor on the GLOBAL (cross-domain) fallback
+             * retrieval — when a task's own domain has no playbooks and retrieval reaches
+             * across all domains, require a higher score (default 1.5×) so out-of-family
+             * playbooks need a strong match. Prevents cross-family negative transfer (see
+             * docs/runs/skillflow-playbook-ablation-3families-bedrock-haiku.md).
+             */
+            crossDomainFloorMultiplier: z.ZodDefault<z.ZodNumber>;
+            /**
+             * Fusion strategy for skill-tree-hybrid mode. RRF only changes ordering when
+             * a dense embedder is attached; BM25-only scoring remains available.
+             */
+            fusion: z.ZodDefault<z.ZodEnum<["weighted", "rrf"]>>;
+            /**
+             * How an injected playbook is rendered into the prompt (roadmap §4.3 / Exp 4):
+             * - `full`: the whole playbook (strategy + all tactics/steps). Default.
+             * - `sectioned`: strategy + only the tactics/steps whose text shares cues with
+             *   the task. Lower token cost and less context interference for broad
+             *   playbooks where only a subskill applies. Deterministic (no LLM); a no-op
+             *   for already-atomic playbooks whose every tactic matches.
+             * (`refined`, an LLM task-specific rewrite, is a separate serve-time path and
+             * not selectable here yet.)
+             */
+            incorporation: z.ZodDefault<z.ZodEnum<["full", "sectioned"]>>;
+        }, "strip", z.ZodTypeAny, {
+            mode: "legacy" | "skill-tree-hybrid";
+            minScore: number;
+            minScoreSemantic: number;
+            crossDomainFloorMultiplier: number;
+            fusion: "weighted" | "rrf";
+            incorporation: "full" | "sectioned";
+        }, {
+            mode?: "legacy" | "skill-tree-hybrid" | undefined;
+            minScore?: number | undefined;
+            minScoreSemantic?: number | undefined;
+            crossDomainFloorMultiplier?: number | undefined;
+            fusion?: "weighted" | "rrf" | undefined;
+            incorporation?: "full" | "sectioned" | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         context: {
             maxTokensForSkills: number;
             includeRefinements: boolean;
             includeExamples: boolean;
+            includeExemplar: boolean;
             cacheRefreshInterval: number;
         };
         promotion: {
             minSuccessRate: number;
             minConfidence: number;
             minSuccessCount: number;
+            evalGate: boolean;
         };
         limits: {
             maxCoreSkills: number;
@@ -1578,17 +2938,27 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             failureThreshold: number;
             minConfidenceToRetain: number;
         };
+        retrieval: {
+            mode: "legacy" | "skill-tree-hybrid";
+            minScore: number;
+            minScoreSemantic: number;
+            crossDomainFloorMultiplier: number;
+            fusion: "weighted" | "rrf";
+            incorporation: "full" | "sectioned";
+        };
     }, {
         context?: {
             maxTokensForSkills?: number | undefined;
             includeRefinements?: boolean | undefined;
             includeExamples?: boolean | undefined;
+            includeExemplar?: boolean | undefined;
             cacheRefreshInterval?: number | undefined;
         } | undefined;
         promotion?: {
             minSuccessRate?: number | undefined;
             minConfidence?: number | undefined;
             minSuccessCount?: number | undefined;
+            evalGate?: boolean | undefined;
         } | undefined;
         limits?: {
             maxCoreSkills?: number | undefined;
@@ -1599,6 +2969,14 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             failureThreshold?: number | undefined;
             minConfidenceToRetain?: number | undefined;
         } | undefined;
+        retrieval?: {
+            mode?: "legacy" | "skill-tree-hybrid" | undefined;
+            minScore?: number | undefined;
+            minScoreSemantic?: number | undefined;
+            crossDomainFloorMultiplier?: number | undefined;
+            fusion?: "weighted" | "rrf" | undefined;
+            incorporation?: "full" | "sectioned" | undefined;
+        } | undefined;
     }>>;
     /** MCP Server configuration */
     mcp: z.ZodDefault<z.ZodObject<{
@@ -1649,11 +3027,14 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         staleWorkspaceMaxAgeMs: z.ZodDefault<z.ZodNumber>;
         /** Base directory for workspaces (defaults to os.tmpdir()) */
         workspaceBaseDir: z.ZodOptional<z.ZodString>;
+        /** Always run the workspace agent for playbook extraction when a runner exists. */
+        forceAgenticPlaybookExtraction: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         cleanupWorkspaces: boolean;
         keepFailedWorkspaces: boolean;
         maxConcurrentAgents: number;
         staleWorkspaceMaxAgeMs: number;
+        forceAgenticPlaybookExtraction: boolean;
         workspaceBaseDir?: string | undefined;
     }, {
         cleanupWorkspaces?: boolean | undefined;
@@ -1661,6 +3042,7 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         maxConcurrentAgents?: number | undefined;
         staleWorkspaceMaxAgeMs?: number | undefined;
         workspaceBaseDir?: string | undefined;
+        forceAgenticPlaybookExtraction?: boolean | undefined;
     }>>;
     /** Compute provider configuration */
     compute: z.ZodDefault<z.ZodObject<{
@@ -1679,92 +3061,6 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         defaultLocation?: "local" | "remote" | "any" | undefined;
         allowFallback?: boolean | undefined;
     }>>;
-    /** Team-aware learning configuration */
-    teamLearning: z.ZodDefault<z.ZodObject<{
-        /** Enable team-aware learning */
-        enabled: z.ZodDefault<z.ZodBoolean>;
-        /** Minimum team trajectories before batch learning */
-        minTeamTrajectories: z.ZodDefault<z.ZodNumber>;
-        /** Similarity threshold for team playbook deduplication */
-        deduplicationThreshold: z.ZodDefault<z.ZodNumber>;
-        /** Weight of structural metrics in analysis (0 = ignore, 1 = metrics only) */
-        metricsWeight: z.ZodDefault<z.ZodNumber>;
-        /** Maximum team experiences to store */
-        maxTeamExperiences: z.ZodDefault<z.ZodNumber>;
-        /** Maximum team playbooks to store */
-        maxTeamPlaybooks: z.ZodDefault<z.ZodNumber>;
-        /** Maximum role playbooks to store */
-        maxRolePlaybooks: z.ZodDefault<z.ZodNumber>;
-        /** Analysis agent timeout in milliseconds */
-        analysisTimeout: z.ZodDefault<z.ZodNumber>;
-        /** Extraction agent timeout in milliseconds */
-        extractionTimeout: z.ZodDefault<z.ZodNumber>;
-        /** Compression settings for trajectory ingestion */
-        compression: z.ZodDefault<z.ZodObject<{
-            /** Maximum tokens per agent after compression */
-            maxTokensPerAgent: z.ZodDefault<z.ZodNumber>;
-            /** Preserve interaction boundary steps at full fidelity */
-            preserveInteractionBoundaries: z.ZodDefault<z.ZodBoolean>;
-            /** Minimum consecutive non-key steps before folding */
-            foldThreshold: z.ZodDefault<z.ZodNumber>;
-            /** Maximum ratio of steps to mark as critical */
-            maxCriticalRatio: z.ZodDefault<z.ZodNumber>;
-            /** Score threshold for critical steps */
-            criticalStepThreshold: z.ZodDefault<z.ZodNumber>;
-            /** Score threshold for critical interactions */
-            criticalInteractionThreshold: z.ZodDefault<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            maxTokensPerAgent: number;
-            preserveInteractionBoundaries: boolean;
-            foldThreshold: number;
-            maxCriticalRatio: number;
-            criticalStepThreshold: number;
-            criticalInteractionThreshold: number;
-        }, {
-            maxTokensPerAgent?: number | undefined;
-            preserveInteractionBoundaries?: boolean | undefined;
-            foldThreshold?: number | undefined;
-            maxCriticalRatio?: number | undefined;
-            criticalStepThreshold?: number | undefined;
-            criticalInteractionThreshold?: number | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        enabled: boolean;
-        deduplicationThreshold: number;
-        minTeamTrajectories: number;
-        metricsWeight: number;
-        maxTeamExperiences: number;
-        maxTeamPlaybooks: number;
-        maxRolePlaybooks: number;
-        analysisTimeout: number;
-        extractionTimeout: number;
-        compression: {
-            maxTokensPerAgent: number;
-            preserveInteractionBoundaries: boolean;
-            foldThreshold: number;
-            maxCriticalRatio: number;
-            criticalStepThreshold: number;
-            criticalInteractionThreshold: number;
-        };
-    }, {
-        enabled?: boolean | undefined;
-        deduplicationThreshold?: number | undefined;
-        minTeamTrajectories?: number | undefined;
-        metricsWeight?: number | undefined;
-        maxTeamExperiences?: number | undefined;
-        maxTeamPlaybooks?: number | undefined;
-        maxRolePlaybooks?: number | undefined;
-        analysisTimeout?: number | undefined;
-        extractionTimeout?: number | undefined;
-        compression?: {
-            maxTokensPerAgent?: number | undefined;
-            preserveInteractionBoundaries?: boolean | undefined;
-            foldThreshold?: number | undefined;
-            maxCriticalRatio?: number | undefined;
-            criticalStepThreshold?: number | undefined;
-            criticalInteractionThreshold?: number | undefined;
-        } | undefined;
-    }>>;
     /** Knowledge bank configuration */
     knowledgeBank: z.ZodDefault<z.ZodObject<{
         /** Enable knowledge bank */
@@ -1794,6 +3090,20 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             minInboxItems: z.ZodDefault<z.ZodNumber>;
             /** Whether to auto-consolidate observations into entities */
             autoConsolidate: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * How consolidation builds entity notes:
+             * - `off`: skip consolidation entirely (atomic facts only).
+             * - `index`: entity notes are lightweight records — canonical name + links to
+             *   the atomic fact notes mentioning the entity, NO duplicated fact bodies.
+             *   Used as a retrieval boost anchor (see getRelevantKnowledge). Default.
+             * - `content`: legacy behavior — concatenate truncated fact bodies into the
+             *   entity note (retained for back-compat).
+             *
+             * `autoConsolidate: false` forces `off` regardless of this value.
+             * Optional at the type level for back-compat with hand-built configs; the
+             * KnowledgeDefragmenter treats `undefined` as `index`.
+             */
+            consolidationMode: z.ZodOptional<z.ZodEnum<["off", "index", "content"]>>;
             /** Minimum observations about an entity before consolidation */
             consolidationThreshold: z.ZodDefault<z.ZodNumber>;
             /** Whether to auto-regenerate domain summaries */
@@ -1802,6 +3112,20 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             llmSummaryGeneration: z.ZodDefault<z.ZodBoolean>;
             /** Whether to auto-resolve simple contradictions */
             autoResolveContradictions: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Run the pairwise contradiction-detection sweep during defrag. This is O(n²)
+             * within a domain, so for large single-domain stores (e.g. a long conversation
+             * where every fact shares one domain) it is expensive and low-value. Optional;
+             * the KnowledgeDefragmenter treats `undefined` as enabled (back-compat). Set
+             * false to skip. See DESIGN-memory-extraction-add-only.md (WS1c).
+             */
+            contradictionScan: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * Hard cap on observations-per-domain considered by the contradiction sweep;
+             * beyond this the sweep is skipped for that domain to bound cost. `undefined`
+             * → default cap (see KnowledgeDefragmenter).
+             */
+            contradictionScanMaxNotes: z.ZodOptional<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             minInboxItems: number;
             autoConsolidate: boolean;
@@ -1809,13 +3133,19 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             autoRegenerateSummaries: boolean;
             llmSummaryGeneration: boolean;
             autoResolveContradictions: boolean;
+            consolidationMode?: "content" | "off" | "index" | undefined;
+            contradictionScan?: boolean | undefined;
+            contradictionScanMaxNotes?: number | undefined;
         }, {
             minInboxItems?: number | undefined;
             autoConsolidate?: boolean | undefined;
+            consolidationMode?: "content" | "off" | "index" | undefined;
             consolidationThreshold?: number | undefined;
             autoRegenerateSummaries?: boolean | undefined;
             llmSummaryGeneration?: boolean | undefined;
             autoResolveContradictions?: boolean | undefined;
+            contradictionScan?: boolean | undefined;
+            contradictionScanMaxNotes?: number | undefined;
         }>>;
         /** Confidence model config */
         confidence: z.ZodDefault<z.ZodObject<{
@@ -1850,35 +3180,6 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             staleThreshold?: number | undefined;
             decayGracePeriodDays?: number | undefined;
         }>>;
-        /** Graph overlay config */
-        graph: z.ZodDefault<z.ZodObject<{
-            /** Which graph layers to enable */
-            enabledLayers: z.ZodDefault<z.ZodArray<z.ZodEnum<["semantic", "temporal", "causal", "entity"]>, "many">>;
-            /** Whether to auto-infer temporal edges from timestamps */
-            inferTemporalEdges: z.ZodDefault<z.ZodBoolean>;
-            /** Whether to auto-infer causal edges from failure-recovery patterns */
-            inferCausalEdges: z.ZodDefault<z.ZodBoolean>;
-            /** Whether to auto-infer entity edges from shared entity tags */
-            inferEntityEdges: z.ZodDefault<z.ZodBoolean>;
-            /** Split layer files by domain when node count exceeds this */
-            domainSplitThreshold: z.ZodDefault<z.ZodNumber>;
-            /** Promote to SQLite when total edge count exceeds this */
-            sqlitePromotionThreshold: z.ZodDefault<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
-            inferTemporalEdges: boolean;
-            inferCausalEdges: boolean;
-            inferEntityEdges: boolean;
-            domainSplitThreshold: number;
-            sqlitePromotionThreshold: number;
-        }, {
-            enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
-            inferTemporalEdges?: boolean | undefined;
-            inferCausalEdges?: boolean | undefined;
-            inferEntityEdges?: boolean | undefined;
-            domainSplitThreshold?: number | undefined;
-            sqlitePromotionThreshold?: number | undefined;
-        }>>;
         /** Surfacing config (independent from SkillLibrary) */
         surfacing: z.ZodDefault<z.ZodObject<{
             /** Include domain summaries in task context */
@@ -1893,6 +3194,13 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             includeEvidence: z.ZodDefault<z.ZodBoolean>;
             /** Include graph links in surfaced notes */
             includeLinks: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Additive score boost applied to atomic fact notes that are linked from an
+             * entity record matching the query (index-mode consolidation). Entity records
+             * themselves are NOT injected as content — they act purely as ranking anchors.
+             * Optional; getRelevantKnowledge treats `undefined` as 0.15.
+             */
+            entityBoostWeight: z.ZodOptional<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             includeDomainSummaries: boolean;
             includeEntityNotes: boolean;
@@ -1900,6 +3208,7 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             maxTokensForKnowledge: number;
             includeEvidence: boolean;
             includeLinks: boolean;
+            entityBoostWeight?: number | undefined;
         }, {
             includeDomainSummaries?: boolean | undefined;
             includeEntityNotes?: boolean | undefined;
@@ -1907,6 +3216,7 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             maxTokensForKnowledge?: number | undefined;
             includeEvidence?: boolean | undefined;
             includeLinks?: boolean | undefined;
+            entityBoostWeight?: number | undefined;
         }>>;
         /** Whether to manage minimem-specific features (sync, versioning) */
         minimemAware: z.ZodDefault<z.ZodBoolean>;
@@ -1923,14 +3233,6 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             decayGracePeriodDays: number;
         };
         enabled: boolean;
-        graph: {
-            enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
-            inferTemporalEdges: boolean;
-            inferCausalEdges: boolean;
-            inferEntityEdges: boolean;
-            domainSplitThreshold: number;
-            sqlitePromotionThreshold: number;
-        };
         memoryDir: string;
         extraction: {
             enabled: boolean;
@@ -1944,6 +3246,9 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             autoRegenerateSummaries: boolean;
             llmSummaryGeneration: boolean;
             autoResolveContradictions: boolean;
+            consolidationMode?: "content" | "off" | "index" | undefined;
+            contradictionScan?: boolean | undefined;
+            contradictionScanMaxNotes?: number | undefined;
         };
         surfacing: {
             includeDomainSummaries: boolean;
@@ -1952,6 +3257,7 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             maxTokensForKnowledge: number;
             includeEvidence: boolean;
             includeLinks: boolean;
+            entityBoostWeight?: number | undefined;
         };
         minimemAware: boolean;
         coherenceChecking: boolean;
@@ -1966,14 +3272,6 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             decayGracePeriodDays?: number | undefined;
         } | undefined;
         enabled?: boolean | undefined;
-        graph?: {
-            enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
-            inferTemporalEdges?: boolean | undefined;
-            inferCausalEdges?: boolean | undefined;
-            inferEntityEdges?: boolean | undefined;
-            domainSplitThreshold?: number | undefined;
-            sqlitePromotionThreshold?: number | undefined;
-        } | undefined;
         memoryDir?: string | undefined;
         extraction?: {
             enabled?: boolean | undefined;
@@ -1983,10 +3281,13 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         defrag?: {
             minInboxItems?: number | undefined;
             autoConsolidate?: boolean | undefined;
+            consolidationMode?: "content" | "off" | "index" | undefined;
             consolidationThreshold?: number | undefined;
             autoRegenerateSummaries?: boolean | undefined;
             llmSummaryGeneration?: boolean | undefined;
             autoResolveContradictions?: boolean | undefined;
+            contradictionScan?: boolean | undefined;
+            contradictionScanMaxNotes?: number | undefined;
         } | undefined;
         surfacing?: {
             includeDomainSummaries?: boolean | undefined;
@@ -1995,6 +3296,7 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             maxTokensForKnowledge?: number | undefined;
             includeEvidence?: boolean | undefined;
             includeLinks?: boolean | undefined;
+            entityBoostWeight?: number | undefined;
         } | undefined;
         minimemAware?: boolean | undefined;
         coherenceChecking?: boolean | undefined;
@@ -2005,16 +3307,54 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         /** Path to the SQLite database for skill storage (relative to storage.baseDir) */
         dbPath: z.ZodDefault<z.ZodString>;
+        /** Optional mirror of published skills into a shared filesystem bank. */
+        sharedBank: z.ZodDefault<z.ZodObject<{
+            /**
+             * Mirror published (graduated) playbooks into a shared skill-tree
+             * filesystem bank so consumers outside this Atlas instance (openswarm's
+             * SkillProvider, Claude Code skill loaders, peer tools) can read them
+             * without an openhive materialization bridge. Off by default: writing to a
+             * machine-global bank is an explicit opt-in (CLI `--shared-bank` /
+             * `COGCORE_SHARED_SKILL_BANK`).
+             */
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /**
+             * Bank base path (skill-tree `storage.basePath`; skills land under
+             * `<path>/.skilltree/skills/<id>/SKILL.md`). Defaults to the ecosystem's
+             * conventional shared bank `~/.skill-tree` when omitted.
+             */
+            path: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            path?: string | undefined;
+        }, {
+            path?: string | undefined;
+            enabled?: boolean | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
         dbPath: string;
+        sharedBank: {
+            enabled: boolean;
+            path?: string | undefined;
+        };
     }, {
         enabled?: boolean | undefined;
         dbPath?: string | undefined;
+        sharedBank?: {
+            path?: string | undefined;
+            enabled?: boolean | undefined;
+        } | undefined;
     }>>;
     /** Curated playbook seeding configuration */
     curatedPlaybooks: z.ZodDefault<z.ZodObject<{
-        /** Load the bundled compound-engineering seed pack on init */
+        /**
+         * Load the bundled seed packs (compound-engineering + agent-ops) on init.
+         * Cold-start semantics: bundled packs only seed an EMPTY playbook library
+         * (mirrors the meta-playbook seed idempotency), so a warm store is never
+         * retro-seeded on upgrade. `recreateOnInit` bypasses the empty check.
+         * Default `true`; evals that must stay seed-free set this to `false`.
+         */
         loadBundledSeedPack: z.ZodDefault<z.ZodBoolean>;
         /** Additional directories to load curated playbooks from (backward compat) */
         additionalDirs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -2094,34 +3434,321 @@ export declare const AtlasConfigSchema: z.ZodObject<{
     }>>;
     /** Feature toggles for ruvector-inspired subsystems */
     features: z.ZodDefault<z.ZodObject<{
-        /** Enable instant (hot-path) learning on every trajectory (InstantLoop) */
-        instantLoop: z.ZodDefault<z.ZodBoolean>;
         /** Enable reflexion episode generation and storage */
         reflexion: z.ZodDefault<z.ZodBoolean>;
         /** Enable coherence checking on knowledge note insertion */
         coherenceChecking: z.ZodDefault<z.ZodBoolean>;
-        /** Enable experience clustering via ReasoningBank in batch pipeline */
-        reasoningBank: z.ZodDefault<z.ZodBoolean>;
-        /** Enable causal edge extraction in instant loop */
-        causalExtraction: z.ZodDefault<z.ZodBoolean>;
         /** Enable temporal compression (Hot/Warm/Cold/Evict) in batch pipeline */
         temporalCompression: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Dual-write every processed trajectory to the durable `dream_queue` table
+         * (Phase A of the dreaming refactor). Write-only substrate: nothing drains it
+         * yet, so this does not change learning behavior. Default on so the queue is
+         * populated and ready for the decoupled `dream()` consumer (Phase B).
+         */
+        dreamQueue: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Roll each dream-time effectiveness annotation into a per-(scope, family,
+         * solver) lift cell (`lift_cells` table, scope 'production') — the
+         * treatment-effect companion to the eval difficulty registry. Write-only
+         * (no core consumer; read by `cogcore eval lift-report`), one cheap upsert
+         * per annotated trajectory, dream-time only. Default on.
+         */
+        liftTracking: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Enable Pareto-frontier merge proposing in the maintenance loop.
+         * On by default, but self-gating: it only runs once a ReplayJudge is
+         * available (bound via `setLearningProvider` for an LLM judge, or
+         * `enableLiveReplayGating` for a live judge). With no judge it no-ops, so
+         * headless / provider-less setups are unaffected.
+         */
+        mergeProposing: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Enable single-parent reflective playbook mutation in the maintenance
+         * loop. On by default, but self-gating: it only runs once BOTH an LLM
+         * provider (the generator, via `setLearningProvider`) and a ReplayJudge
+         * are available. With neither it no-ops.
+         */
+        reflectiveMutation: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Force lexical retrieval (Jaccard+trigram textSimilarity) even when an
+         * embedding provider is attached. Default false: when a provider is set,
+         * retrieval scores by vector cosine (semantic). Set true to ablate
+         * semantic vs. lexical — corresponds to E5 ablation arm `lexical-retrieval`.
+         */
+        lexicalRetrieval: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Enable write-time curation (PR-D2): near-dup merge on add(), helpfulness
+         * counters, prune pass in maintenance, helpfulness-weighted injection re-rank.
+         * Default true. Set false to restore append-only behavior (ablation arm
+         * `append-only`).
+         */
+        curation: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Surface applicability conditions (situations + antiPatterns) at injection
+         * time so the agent sees "Apply when:" / "Do NOT apply when:" alongside the
+         * strategy and tactics.  Default true — this is the fix.  Set false to
+         * reproduce old behavior (ablation arm: no-applicability-injection).
+         */
+        injectApplicability: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Use embedding cosine similarity for anti-pattern exclusion at retrieval
+         * time when an embedding provider is attached.  Default true.  When false,
+         * falls back to the legacy lexical textSimilarity > 0.7 guard.
+         */
+        semanticAntiPatterns: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * F6: Update playbook helpful/harmful counters via INJECTION-PRESENCE +
+         * TASK OUTCOME (relevance-weighted), rather than lexical usage detection.
+         *
+         * When true (default), for each task solve with injected playbooks, each
+         * playbook's successCount/failureCount is incremented by its relevance
+         * share (score_i / sum(score_j)) times the task outcome.  This fixes the
+         * curation loop for DISTILLED playbooks whose abstract tactics never
+         * lexically match concrete actions, so wasUsed was always false and counters
+         * never updated.
+         *
+         * When false, falls back to the old wasUsed-gated recordSuccess/recordFailure
+         * path (lexical usage detection; ablation arm).
+         *
+         * Default true (this is the fix).
+         */
+        injectionPresenceCredit: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * ADDITIVE LEARNING (default ON as of 2026-07-06). When ON, procedural-memory
+         * consolidation REFINES/REUSES existing playbooks instead of minting a unique
+         * `distilled-<uuid>` per trajectory:
+         *   FIX 1 — at dream distill time, a freshly distilled playbook that is
+         *     sufficiently similar (see `learning.additiveMergeThreshold`) to an
+         *     existing one (this-batch OR library) is merged into it (append
+         *     createdFrom, fold guidance/anti-patterns, accumulate counters, bump
+         *     version) rather than added as a new row.
+         *   FIX 2 — each solve records a frontier/live outcome for the playbooks
+         *     that were actually INJECTED (served set), so reused playbooks
+         *     accumulate frontier rows aligned with hybrid retrieval — not just the
+         *     legacy 0.3 lexical instant-loop match — feeding a non-sparse mutation
+         *     gate.
+         * Set `false` (eval `--no-additive`) to restore the legacy "proliferating"
+         * behavior (a new unique `distilled-<uuid>` per trajectory) for A/B arms.
+         */
+        additiveConsolidation: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * F5: Emit a USE-TIME relevance-gating instruction alongside injected
+         * candidate playbooks, telling the agent to self-filter against the
+         * "Apply when:" / "Do NOT apply when:" conditions before using any
+         * candidate.  Only emitted when there is ≥1 candidate playbook AND
+         * injectApplicability is on.
+         *
+         * Default true.  Set false to reproduce old behavior (ablation arm:
+         * no-relevance-gating).
+         */
+        relevanceGating: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         coherenceChecking: boolean;
-        instantLoop: boolean;
         reflexion: boolean;
-        reasoningBank: boolean;
-        causalExtraction: boolean;
         temporalCompression: boolean;
+        dreamQueue: boolean;
+        liftTracking: boolean;
+        mergeProposing: boolean;
+        reflectiveMutation: boolean;
+        lexicalRetrieval: boolean;
+        curation: boolean;
+        injectApplicability: boolean;
+        semanticAntiPatterns: boolean;
+        injectionPresenceCredit: boolean;
+        additiveConsolidation: boolean;
+        relevanceGating: boolean;
     }, {
         coherenceChecking?: boolean | undefined;
-        instantLoop?: boolean | undefined;
         reflexion?: boolean | undefined;
-        reasoningBank?: boolean | undefined;
-        causalExtraction?: boolean | undefined;
         temporalCompression?: boolean | undefined;
+        dreamQueue?: boolean | undefined;
+        liftTracking?: boolean | undefined;
+        mergeProposing?: boolean | undefined;
+        reflectiveMutation?: boolean | undefined;
+        lexicalRetrieval?: boolean | undefined;
+        curation?: boolean | undefined;
+        injectApplicability?: boolean | undefined;
+        semanticAntiPatterns?: boolean | undefined;
+        injectionPresenceCredit?: boolean | undefined;
+        additiveConsolidation?: boolean | undefined;
+        relevanceGating?: boolean | undefined;
+    }>>;
+    /** Dreaming / consolidation configuration */
+    dream: z.ZodDefault<z.ZodObject<{
+        /** After each solve/process call, run a dream synchronously (eval determinism). */
+        consolidateInline: z.ZodDefault<z.ZodBoolean>;
+        /** Pending-row count at/above which the coordinator considers a dream due. */
+        countThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Oldest-pending age at/above which a dream is considered overdue (ms). */
+        maxStalenessMs: z.ZodDefault<z.ZodNumber>;
+        /** Max rows claimed per internal batch within a single dream. */
+        maxRowsPerDream: z.ZodDefault<z.ZodNumber>;
+        /** Max internal batches a single dream will drain before stopping. */
+        maxBatchesPerDream: z.ZodDefault<z.ZodNumber>;
+        /** Row lease TTL while a dream holds claimed rows (ms). */
+        leaseTtlMs: z.ZodDefault<z.ZodNumber>;
+        /** Attempts before a repeatedly-failing row is parked as `failed`. */
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        /** In-process idle scheduler. */
+        scheduler: z.ZodDefault<z.ZodObject<{
+            /** Arm an in-process idle timer that dreams after `idleMs` of no activity. */
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /** Idle debounce before an auto-dream fires (ms). */
+            idleMs: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            idleMs: number;
+        }, {
+            enabled?: boolean | undefined;
+            idleMs?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        consolidateInline: boolean;
+        countThreshold: number;
+        maxStalenessMs: number;
+        maxRowsPerDream: number;
+        maxBatchesPerDream: number;
+        leaseTtlMs: number;
+        maxAttempts: number;
+        scheduler: {
+            enabled: boolean;
+            idleMs: number;
+        };
+    }, {
+        consolidateInline?: boolean | undefined;
+        countThreshold?: number | undefined;
+        maxStalenessMs?: number | undefined;
+        maxRowsPerDream?: number | undefined;
+        maxBatchesPerDream?: number | undefined;
+        leaseTtlMs?: number | undefined;
+        maxAttempts?: number | undefined;
+        scheduler?: {
+            enabled?: boolean | undefined;
+            idleMs?: number | undefined;
+        } | undefined;
+    }>>;
+    /** Validation-only mechanism isolation controls. */
+    validation: z.ZodDefault<z.ZodObject<{
+        /** Enable validation-specific isolation controls. Production default is off. */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * active: existing direct-commit behavior.
+         * frozen: no mutation/merge/curation writes during validation.
+         * candidate: proposals are redirected to non-serving candidates (future work).
+         */
+        mutationMode: z.ZodDefault<z.ZodEnum<["frozen", "active", "candidate"]>>;
+        channelMasks: z.ZodDefault<z.ZodObject<{
+            retrieval: z.ZodDefault<z.ZodArray<z.ZodEnum<["experiences", "knowledge", "playbooks", "metaPlaybooks", "shortTerm"]>, "many">>;
+            serving: z.ZodDefault<z.ZodArray<z.ZodEnum<["experiences", "knowledge", "playbooks", "metaPlaybooks", "shortTerm"]>, "many">>;
+            write: z.ZodDefault<z.ZodArray<z.ZodEnum<["experience", "knowledgeNote", "playbook", "metaPlaybook", "reflexion", "causal", "frontier", "diagnosticOnly"]>, "many">>;
+            maintenance: z.ZodDefault<z.ZodObject<{
+                /** Write-time curation and prune maintenance. */
+                curation: z.ZodDefault<z.ZodBoolean>;
+                /** Pareto/replay-gated two-parent merge proposals. */
+                mergeProposing: z.ZodDefault<z.ZodBoolean>;
+                /** Single-parent reflective mutation proposals. */
+                reflectiveMutation: z.ZodDefault<z.ZodBoolean>;
+                /** Dream/batch extraction may create new learned artifacts. */
+                extraction: z.ZodDefault<z.ZodBoolean>;
+                /** Scheduler-driven maintenance/dream runs. */
+                scheduling: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                extraction: boolean;
+                mergeProposing: boolean;
+                reflectiveMutation: boolean;
+                curation: boolean;
+                scheduling: boolean;
+            }, {
+                extraction?: boolean | undefined;
+                mergeProposing?: boolean | undefined;
+                reflectiveMutation?: boolean | undefined;
+                curation?: boolean | undefined;
+                scheduling?: boolean | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            retrieval: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+            serving: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+            write: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[];
+            maintenance: {
+                extraction: boolean;
+                mergeProposing: boolean;
+                reflectiveMutation: boolean;
+                curation: boolean;
+                scheduling: boolean;
+            };
+        }, {
+            retrieval?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+            serving?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+            write?: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[] | undefined;
+            maintenance?: {
+                extraction?: boolean | undefined;
+                mergeProposing?: boolean | undefined;
+                reflectiveMutation?: boolean | undefined;
+                curation?: boolean | undefined;
+                scheduling?: boolean | undefined;
+            } | undefined;
+        }>>;
+        /**
+         * Permit cold-start seeding (bundled playbook pack, meta-playbook seeds,
+         * meta-strategy priors) under validation. Default false: validation runs
+         * start from an explicitly-controlled memory state. The seed-lift A/B
+         * (Phase 1 of the seed co-optimization loop) sets this true on the seeded
+         * arm so the committed seeds are the *measured variable* rather than an
+         * uncontrolled confound.
+         */
+        allowSeeds: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        mutationMode: "frozen" | "active" | "candidate";
+        channelMasks: {
+            retrieval: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+            serving: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+            write: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[];
+            maintenance: {
+                extraction: boolean;
+                mergeProposing: boolean;
+                reflectiveMutation: boolean;
+                curation: boolean;
+                scheduling: boolean;
+            };
+        };
+        allowSeeds: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        mutationMode?: "frozen" | "active" | "candidate" | undefined;
+        channelMasks?: {
+            retrieval?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+            serving?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+            write?: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[] | undefined;
+            maintenance?: {
+                extraction?: boolean | undefined;
+                mergeProposing?: boolean | undefined;
+                reflectiveMutation?: boolean | undefined;
+                curation?: boolean | undefined;
+                scheduling?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        allowSeeds?: boolean | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
+    validation: {
+        enabled: boolean;
+        mutationMode: "frozen" | "active" | "candidate";
+        channelMasks: {
+            retrieval: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+            serving: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[];
+            write: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[];
+            maintenance: {
+                extraction: boolean;
+                mergeProposing: boolean;
+                reflectiveMutation: boolean;
+                curation: boolean;
+                scheduling: boolean;
+            };
+        };
+        allowSeeds: boolean;
+    };
     refinement: {
         maxIterations: number;
         acceptableScore: number;
@@ -2160,13 +3787,46 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             autoPrune: boolean;
             preserveDomainCoverage: boolean;
         };
+        frontierRouting: boolean;
+        injectFailedExperiences: boolean;
+        seedMetaPlaybooks: boolean;
+        seedMetaStrategies: boolean;
+        playbookRetrieval: {
+            mode: "legacy" | "skill-tree-hybrid";
+            minScore: number;
+            minScoreSemantic: number;
+            crossDomainFloorMultiplier: number;
+            fusion: "weighted" | "rrf";
+            incorporation: "full" | "sectioned";
+        };
+        playbookApplicability: {
+            enabled: boolean;
+            minSpecificityScore: number;
+            crossDomainMinScore: number;
+        };
+        proceduralMemory: {
+            source: "sqlite" | "filesystem";
+            dir: string;
+            strictStartup: boolean;
+            pruneSqliteOnly: boolean;
+            watch: boolean;
+            watchDebounceMs: number;
+            watchUsePolling: boolean;
+            watchPollIntervalMs: number;
+            structuralDualWrite: {
+                enabled: boolean;
+                dir: string;
+            };
+        };
     };
     learning: {
         creditStrategy: "llm" | "simple" | "counterfactual";
-        patternExtractor: "llm" | "both" | "text";
+        patternExtractor: "llm" | "text" | "both";
+        strictExtraction: boolean;
         minTrajectories: number;
         deduplicationThreshold: number;
         maxExperiences: number;
+        additiveMergeThreshold: number;
         minHoursSinceLast?: number | undefined;
         minSuccessRate?: number | undefined;
     };
@@ -2174,6 +3834,7 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         similarityThreshold: number;
         useDomainRouting: boolean;
         defaultStrategy: string;
+        difficultyAwareRouting: boolean;
     };
     storage: {
         baseDir: string;
@@ -2186,12 +3847,14 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             maxTokensForSkills: number;
             includeRefinements: boolean;
             includeExamples: boolean;
+            includeExemplar: boolean;
             cacheRefreshInterval: number;
         };
         promotion: {
             minSuccessRate: number;
             minConfidence: number;
             minSuccessCount: number;
+            evalGate: boolean;
         };
         limits: {
             maxCoreSkills: number;
@@ -2202,6 +3865,14 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             failureThreshold: number;
             minConfidenceToRetain: number;
         };
+        retrieval: {
+            mode: "legacy" | "skill-tree-hybrid";
+            minScore: number;
+            minScoreSemantic: number;
+            crossDomainFloorMultiplier: number;
+            fusion: "weighted" | "rrf";
+            incorporation: "full" | "sectioned";
+        };
     };
     mcp: {
         enabled: boolean;
@@ -2218,6 +3889,7 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         keepFailedWorkspaces: boolean;
         maxConcurrentAgents: number;
         staleWorkspaceMaxAgeMs: number;
+        forceAgenticPlaybookExtraction: boolean;
         workspaceBaseDir?: string | undefined;
     };
     compute: {
@@ -2225,25 +3897,6 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         defaultLocation: "local" | "remote" | "any";
         allowFallback: boolean;
     };
-    teamLearning: {
-        enabled: boolean;
-        deduplicationThreshold: number;
-        minTeamTrajectories: number;
-        metricsWeight: number;
-        maxTeamExperiences: number;
-        maxTeamPlaybooks: number;
-        maxRolePlaybooks: number;
-        analysisTimeout: number;
-        extractionTimeout: number;
-        compression: {
-            maxTokensPerAgent: number;
-            preserveInteractionBoundaries: boolean;
-            foldThreshold: number;
-            maxCriticalRatio: number;
-            criticalStepThreshold: number;
-            criticalInteractionThreshold: number;
-        };
-    };
     knowledgeBank: {
         confidence: {
             extractedInitial: number;
@@ -2255,14 +3908,6 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             decayGracePeriodDays: number;
         };
         enabled: boolean;
-        graph: {
-            enabledLayers: ("semantic" | "temporal" | "causal" | "entity")[];
-            inferTemporalEdges: boolean;
-            inferCausalEdges: boolean;
-            inferEntityEdges: boolean;
-            domainSplitThreshold: number;
-            sqlitePromotionThreshold: number;
-        };
         memoryDir: string;
         extraction: {
             enabled: boolean;
@@ -2276,6 +3921,9 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             autoRegenerateSummaries: boolean;
             llmSummaryGeneration: boolean;
             autoResolveContradictions: boolean;
+            consolidationMode?: "content" | "off" | "index" | undefined;
+            contradictionScan?: boolean | undefined;
+            contradictionScanMaxNotes?: number | undefined;
         };
         surfacing: {
             includeDomainSummaries: boolean;
@@ -2284,6 +3932,7 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             maxTokensForKnowledge: number;
             includeEvidence: boolean;
             includeLinks: boolean;
+            entityBoostWeight?: number | undefined;
         };
         minimemAware: boolean;
         coherenceChecking: boolean;
@@ -2291,6 +3940,10 @@ export declare const AtlasConfigSchema: z.ZodObject<{
     skillTree: {
         enabled: boolean;
         dbPath: string;
+        sharedBank: {
+            enabled: boolean;
+            path?: string | undefined;
+        };
     };
     curatedPlaybooks: {
         loadBundledSeedPack: boolean;
@@ -2312,13 +3965,51 @@ export declare const AtlasConfigSchema: z.ZodObject<{
     };
     features: {
         coherenceChecking: boolean;
-        instantLoop: boolean;
         reflexion: boolean;
-        reasoningBank: boolean;
-        causalExtraction: boolean;
         temporalCompression: boolean;
+        dreamQueue: boolean;
+        liftTracking: boolean;
+        mergeProposing: boolean;
+        reflectiveMutation: boolean;
+        lexicalRetrieval: boolean;
+        curation: boolean;
+        injectApplicability: boolean;
+        semanticAntiPatterns: boolean;
+        injectionPresenceCredit: boolean;
+        additiveConsolidation: boolean;
+        relevanceGating: boolean;
+    };
+    dream: {
+        consolidateInline: boolean;
+        countThreshold: number;
+        maxStalenessMs: number;
+        maxRowsPerDream: number;
+        maxBatchesPerDream: number;
+        leaseTtlMs: number;
+        maxAttempts: number;
+        scheduler: {
+            enabled: boolean;
+            idleMs: number;
+        };
     };
 }, {
+    validation?: {
+        enabled?: boolean | undefined;
+        mutationMode?: "frozen" | "active" | "candidate" | undefined;
+        channelMasks?: {
+            retrieval?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+            serving?: ("playbooks" | "experiences" | "knowledge" | "metaPlaybooks" | "shortTerm")[] | undefined;
+            write?: ("causal" | "reflexion" | "experience" | "knowledgeNote" | "playbook" | "metaPlaybook" | "frontier" | "diagnosticOnly")[] | undefined;
+            maintenance?: {
+                extraction?: boolean | undefined;
+                mergeProposing?: boolean | undefined;
+                reflectiveMutation?: boolean | undefined;
+                curation?: boolean | undefined;
+                scheduling?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        allowSeeds?: boolean | undefined;
+    } | undefined;
     refinement?: {
         maxIterations?: number | undefined;
         acceptableScore?: number | undefined;
@@ -2357,20 +4048,54 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             autoPrune?: boolean | undefined;
             preserveDomainCoverage?: boolean | undefined;
         } | undefined;
+        frontierRouting?: boolean | undefined;
+        injectFailedExperiences?: boolean | undefined;
+        seedMetaPlaybooks?: boolean | undefined;
+        seedMetaStrategies?: boolean | undefined;
+        playbookRetrieval?: {
+            mode?: "legacy" | "skill-tree-hybrid" | undefined;
+            minScore?: number | undefined;
+            minScoreSemantic?: number | undefined;
+            crossDomainFloorMultiplier?: number | undefined;
+            fusion?: "weighted" | "rrf" | undefined;
+            incorporation?: "full" | "sectioned" | undefined;
+        } | undefined;
+        playbookApplicability?: {
+            enabled?: boolean | undefined;
+            minSpecificityScore?: number | undefined;
+            crossDomainMinScore?: number | undefined;
+        } | undefined;
+        proceduralMemory?: {
+            source?: "sqlite" | "filesystem" | undefined;
+            dir?: string | undefined;
+            strictStartup?: boolean | undefined;
+            pruneSqliteOnly?: boolean | undefined;
+            watch?: boolean | undefined;
+            watchDebounceMs?: number | undefined;
+            watchUsePolling?: boolean | undefined;
+            watchPollIntervalMs?: number | undefined;
+            structuralDualWrite?: {
+                enabled?: boolean | undefined;
+                dir?: string | undefined;
+            } | undefined;
+        } | undefined;
     } | undefined;
     learning?: {
         creditStrategy?: "llm" | "simple" | "counterfactual" | undefined;
-        patternExtractor?: "llm" | "both" | "text" | undefined;
+        patternExtractor?: "llm" | "text" | "both" | undefined;
+        strictExtraction?: boolean | undefined;
         minTrajectories?: number | undefined;
         minHoursSinceLast?: number | undefined;
         minSuccessRate?: number | undefined;
         deduplicationThreshold?: number | undefined;
         maxExperiences?: number | undefined;
+        additiveMergeThreshold?: number | undefined;
     } | undefined;
     router?: {
         similarityThreshold?: number | undefined;
         useDomainRouting?: boolean | undefined;
         defaultStrategy?: string | undefined;
+        difficultyAwareRouting?: boolean | undefined;
     } | undefined;
     storage?: {
         baseDir?: string | undefined;
@@ -2383,12 +4108,14 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             maxTokensForSkills?: number | undefined;
             includeRefinements?: boolean | undefined;
             includeExamples?: boolean | undefined;
+            includeExemplar?: boolean | undefined;
             cacheRefreshInterval?: number | undefined;
         } | undefined;
         promotion?: {
             minSuccessRate?: number | undefined;
             minConfidence?: number | undefined;
             minSuccessCount?: number | undefined;
+            evalGate?: boolean | undefined;
         } | undefined;
         limits?: {
             maxCoreSkills?: number | undefined;
@@ -2399,6 +4126,14 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             failureThreshold?: number | undefined;
             minConfidenceToRetain?: number | undefined;
         } | undefined;
+        retrieval?: {
+            mode?: "legacy" | "skill-tree-hybrid" | undefined;
+            minScore?: number | undefined;
+            minScoreSemantic?: number | undefined;
+            crossDomainFloorMultiplier?: number | undefined;
+            fusion?: "weighted" | "rrf" | undefined;
+            incorporation?: "full" | "sectioned" | undefined;
+        } | undefined;
     } | undefined;
     mcp?: {
         enabled?: boolean | undefined;
@@ -2416,31 +4151,13 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         maxConcurrentAgents?: number | undefined;
         staleWorkspaceMaxAgeMs?: number | undefined;
         workspaceBaseDir?: string | undefined;
+        forceAgenticPlaybookExtraction?: boolean | undefined;
     } | undefined;
     compute?: {
         defaultCostTier?: "free" | "low" | "medium" | "high" | undefined;
         defaultLocation?: "local" | "remote" | "any" | undefined;
         allowFallback?: boolean | undefined;
     } | undefined;
-    teamLearning?: {
-        enabled?: boolean | undefined;
-        deduplicationThreshold?: number | undefined;
-        minTeamTrajectories?: number | undefined;
-        metricsWeight?: number | undefined;
-        maxTeamExperiences?: number | undefined;
-        maxTeamPlaybooks?: number | undefined;
-        maxRolePlaybooks?: number | undefined;
-        analysisTimeout?: number | undefined;
-        extractionTimeout?: number | undefined;
-        compression?: {
-            maxTokensPerAgent?: number | undefined;
-            preserveInteractionBoundaries?: boolean | undefined;
-            foldThreshold?: number | undefined;
-            maxCriticalRatio?: number | undefined;
-            criticalStepThreshold?: number | undefined;
-            criticalInteractionThreshold?: number | undefined;
-        } | undefined;
-    } | undefined;
     knowledgeBank?: {
         confidence?: {
             extractedInitial?: number | undefined;
@@ -2452,14 +4169,6 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             decayGracePeriodDays?: number | undefined;
         } | undefined;
         enabled?: boolean | undefined;
-        graph?: {
-            enabledLayers?: ("semantic" | "temporal" | "causal" | "entity")[] | undefined;
-            inferTemporalEdges?: boolean | undefined;
-            inferCausalEdges?: boolean | undefined;
-            inferEntityEdges?: boolean | undefined;
-            domainSplitThreshold?: number | undefined;
-            sqlitePromotionThreshold?: number | undefined;
-        } | undefined;
         memoryDir?: string | undefined;
         extraction?: {
             enabled?: boolean | undefined;
@@ -2469,10 +4178,13 @@ export declare const AtlasConfigSchema: z.ZodObject<{
         defrag?: {
             minInboxItems?: number | undefined;
             autoConsolidate?: boolean | undefined;
+            consolidationMode?: "content" | "off" | "index" | undefined;
             consolidationThreshold?: number | undefined;
             autoRegenerateSummaries?: boolean | undefined;
             llmSummaryGeneration?: boolean | undefined;
             autoResolveContradictions?: boolean | undefined;
+            contradictionScan?: boolean | undefined;
+            contradictionScanMaxNotes?: number | undefined;
         } | undefined;
         surfacing?: {
             includeDomainSummaries?: boolean | undefined;
@@ -2481,6 +4193,7 @@ export declare const AtlasConfigSchema: z.ZodObject<{
             maxTokensForKnowledge?: number | undefined;
             includeEvidence?: boolean | undefined;
             includeLinks?: boolean | undefined;
+            entityBoostWeight?: number | undefined;
         } | undefined;
         minimemAware?: boolean | undefined;
         coherenceChecking?: boolean | undefined;
@@ -2488,6 +4201,10 @@ export declare const AtlasConfigSchema: z.ZodObject<{
     skillTree?: {
         enabled?: boolean | undefined;
         dbPath?: string | undefined;
+        sharedBank?: {
+            path?: string | undefined;
+            enabled?: boolean | undefined;
+        } | undefined;
     } | undefined;
     curatedPlaybooks?: {
         loadBundledSeedPack?: boolean | undefined;
@@ -2509,11 +4226,32 @@ export declare const AtlasConfigSchema: z.ZodObject<{
     } | undefined;
     features?: {
         coherenceChecking?: boolean | undefined;
-        instantLoop?: boolean | undefined;
         reflexion?: boolean | undefined;
-        reasoningBank?: boolean | undefined;
-        causalExtraction?: boolean | undefined;
         temporalCompression?: boolean | undefined;
+        dreamQueue?: boolean | undefined;
+        liftTracking?: boolean | undefined;
+        mergeProposing?: boolean | undefined;
+        reflectiveMutation?: boolean | undefined;
+        lexicalRetrieval?: boolean | undefined;
+        curation?: boolean | undefined;
+        injectApplicability?: boolean | undefined;
+        semanticAntiPatterns?: boolean | undefined;
+        injectionPresenceCredit?: boolean | undefined;
+        additiveConsolidation?: boolean | undefined;
+        relevanceGating?: boolean | undefined;
+    } | undefined;
+    dream?: {
+        consolidateInline?: boolean | undefined;
+        countThreshold?: number | undefined;
+        maxStalenessMs?: number | undefined;
+        maxRowsPerDream?: number | undefined;
+        maxBatchesPerDream?: number | undefined;
+        leaseTtlMs?: number | undefined;
+        maxAttempts?: number | undefined;
+        scheduler?: {
+            enabled?: boolean | undefined;
+            idleMs?: number | undefined;
+        } | undefined;
     } | undefined;
 }>;
 export type AtlasConfig = z.infer<typeof AtlasConfigSchema>;
@@ -2521,6 +4259,21 @@ export type AtlasConfig = z.infer<typeof AtlasConfigSchema>;
  * Create default configuration
  */
 export declare function createDefaultConfig(overrides?: Partial<AtlasConfig>): AtlasConfig;
+export declare function createValidationConfig(overrides?: Partial<ValidationConfig>): ValidationConfig;
+/**
+ * Apply validation controls to the runtime-facing config.
+ *
+ * This does not enable validation on its own. When validation is enabled, the
+ * maintenance mask gates the corresponding runtime feature flags. Frozen
+ * mutation mode additionally disables direct mutation/merge/curation paths.
+ *
+ * Validation also disables ALL cold-start seeding (bundled packs,
+ * meta-playbooks, routing priors) unless `validation.allowSeeds` is set:
+ * validation runs must start from an explicitly-controlled memory state, so
+ * any warmth is injected by the harness's own levers, never implicitly by
+ * defaults. `allowSeeds: true` is the explicit lever for seed-lift A/Bs.
+ */
+export declare function applyValidationControls(config: AtlasConfig): AtlasConfig;
 /**
  * Merge configurations
  */