cognitive-core 0.2.5 → 0.3.1

package/dist/types/config.js

@@ -15,6 +15,19 @@ export const LearningConfigSchema = z.object({
     creditStrategy: CreditStrategySchema.default('simple'),
     /** How to extract patterns */
     patternExtractor: PatternExtractorSchema.default('llm'),
+    /**
+     * 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.boolean().default(false),
     /** Minimum trajectories before batch learning */
     minTrajectories: z.number().default(10),
     /** Minimum hours since last batch learning */
@@ -25,6 +38,20 @@ export const LearningConfigSchema = z.object({
     deduplicationThreshold: z.number().min(0).max(1).default(0.9),
     /** Maximum experiences to keep during pruning (default: 1000) */
     maxExperiences: z.number().default(1000),
+    /**
+     * 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.number().min(0).max(1).default(0.55),
 });
 /**
  * Task routing configuration
@@ -36,6 +63,22 @@ export const RouterConfigSchema = z.object({
     useDomainRouting: z.boolean().default(true),
     /** Default search strategy */
     defaultStrategy: z.string().default('direct'),
+    /**
+     * 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.boolean().default(true),
 });
 /**
  * Memory capacity limits for automatic pruning
@@ -59,6 +102,112 @@ export const MemoryCapacityConfigSchema = z.object({
 /**
  * Memory retrieval configuration
  */
+export const PlaybookRetrievalConfigSchema = z.object({
+    /**
+     * 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.enum(['legacy', 'skill-tree-hybrid']).default('legacy'),
+    /**
+     * 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.number().min(0).max(1).default(0.1),
+    /**
+     * 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.number().min(0).max(1).default(0.35),
+    /**
+     * 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.number().min(1).default(1.5),
+    /**
+     * Fusion strategy for skill-tree-hybrid mode. RRF only changes ordering when
+     * a dense embedder is attached; BM25-only scoring remains available.
+     */
+    fusion: z.enum(['weighted', 'rrf']).default('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.enum(['full', 'sectioned']).default('full'),
+});
+export const PlaybookApplicabilityConfigSchema = z.object({
+    /**
+     * Opt-in serving gate that decides whether a retrieved playbook is specific
+     * enough to inject.
+     */
+    enabled: z.boolean().default(false),
+    /** Floor for matches that lack trigger/situation cues. */
+    minSpecificityScore: z.number().min(0).max(1).default(0.45),
+    /** Stronger floor for cross-domain matches without trigger/situation cues. */
+    crossDomainMinScore: z.number().min(0).max(1).default(0.55),
+});
+export const ProceduralMemoryConfigSchema = z.object({
+    /**
+     * 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.enum(['sqlite', 'filesystem']).default('filesystem'),
+    /** Canonical procedural-memory directory, relative to storage.baseDir. */
+    dir: z.string().default('playbooks'),
+    /** Fail startup on file-first warnings instead of continuing best-effort. */
+    strictStartup: z.boolean().default(false),
+    /** Future destructive cleanup switch; defaults off for hard migration safety. */
+    pruneSqliteOnly: z.boolean().default(false),
+    /**
+     * 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.boolean().default(false),
+    /** Coalescing window (ms) for a burst of file events before the cascade drains. */
+    watchDebounceMs: z.number().int().positive().default(150),
+    /**
+     * 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.boolean().default(false),
+    /** Poll interval (ms) when `watchUsePolling` is on. */
+    watchPollIntervalMs: z.number().int().positive().default(100),
+    /**
+     * Legacy Phase 3 bridge. Prefer `source: "filesystem"` for hard-authority
+     * migration; this remains for callers that only want mirroring.
+     */
+    structuralDualWrite: z
+        .object({
+        enabled: z.boolean().default(false),
+        dir: z.string().default('playbooks'),
+    })
+        .default({}),
+});
 export const MemoryConfigSchema = z.object({
     /** Maximum experiences to retrieve */
     maxExperiences: z.number().default(4), // ReMem paper default
@@ -72,6 +221,51 @@ export const MemoryConfigSchema = z.object({
     maxContextTokens: z.number().default(4000),
     /** Capacity limits for storage */
     capacity: MemoryCapacityConfigSchema.default({}),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+    /** Playbook serving/retrieval configuration. */
+    playbookRetrieval: PlaybookRetrievalConfigSchema.default({}),
+    /** Optional post-retrieval playbook applicability gate. */
+    playbookApplicability: PlaybookApplicabilityConfigSchema.default({}),
+    /** Procedural-memory filesystem migration settings. */
+    proceduralMemory: ProceduralMemoryConfigSchema.default({}),
 });
 /**
  * Storage configuration
@@ -89,12 +283,7 @@ export const StorageConfigSchema = z.object({
 /**
  * Embedding provider type
  */
-export const EmbeddingProviderTypeSchema = z.enum([
-    'openai',
-    'voyage',
-    'local',
-    'none',
-]);
+export const EmbeddingProviderTypeSchema = z.enum(['openai', 'voyage', 'local', 'none']);
 /**
  * Embedding configuration
  */
@@ -147,19 +336,28 @@ export const ComputeProviderConfigSchema = z.object({
  */
 export const RefinementConfigSchema = z.object({
     /** Maximum refinement iterations */
-    maxIterations: z.number().min(1).max(10).default(3),
+    maxIterations: z.number().min(0).max(10).default(3),
     /** Minimum quality score to accept without refinement */
     acceptableScore: z.number().min(0).max(1).default(0.7),
     /** Whether to use ACP agent for evaluation */
     useAgentEvaluation: z.boolean().default(true),
     /** Agent type to use for evaluation */
     evaluatorAgentType: z.string().default('evaluator'),
-    /** Confidence threshold below which to trigger refinement */
-    confidenceThreshold: z.number().min(0).max(1).default(0.6),
-    /** Routing strategies that should 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.number().min(0).max(1).default(0.85),
+    /**
+     * 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
         .array(z.enum(['explore', 'fallback', 'direct', 'adapt']))
-        .default(['explore', 'fallback']),
+        .default(['explore', 'fallback', 'direct', 'adapt']),
 });
 /**
  * Skill Library promotion criteria
@@ -171,6 +369,19 @@ export const SkillPromotionConfigSchema = z.object({
     minSuccessCount: z.number().default(5),
     /** Minimum success rate to promote */
     minSuccessRate: z.number().min(0).max(1).default(0.8),
+    /**
+     * 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.boolean().default(true),
 });
 /**
  * Skill Library capacity limits
@@ -193,6 +404,12 @@ export const SkillContextConfigSchema = z.object({
     includeRefinements: z.boolean().default(true),
     /** Include code examples in skill context */
     includeExamples: z.boolean().default(false),
+    /**
+     * 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.boolean().default(true),
     /** Cache refresh interval in milliseconds (default: 5 minutes) */
     cacheRefreshInterval: z.number().default(5 * 60 * 1000),
 });
@@ -217,6 +434,8 @@ export const SkillLibraryConfigSchema = z.object({
     context: SkillContextConfigSchema.default({}),
     /** Demotion criteria */
     demotion: SkillDemotionConfigSchema.default({}),
+    /** Contextual playbook retrieval for tiered skill surfacing. */
+    retrieval: PlaybookRetrievalConfigSchema.default({}),
 });
 /**
  * Agentic Task Runner configuration
@@ -232,6 +451,8 @@ export const AgenticTaskRunnerConfigSchema = z.object({
     staleWorkspaceMaxAgeMs: z.number().default(3600_000),
     /** Base directory for workspaces (defaults to os.tmpdir()) */
     workspaceBaseDir: z.string().optional(),
+    /** Always run the workspace agent for playbook extraction when a runner exists. */
+    forceAgenticPlaybookExtraction: z.boolean().default(true),
 });
 /**
  * MCP Server configuration
@@ -254,48 +475,6 @@ export const MCPServerConfigSchema = z.object({
     /** Enable filtering by domain */
     enableDomainFiltering: z.boolean().default(true),
 });
-/**
- * Compression configuration for team trajectory ingestion
- */
-export const CompressionConfigSchema = z.object({
-    /** Maximum tokens per agent after compression */
-    maxTokensPerAgent: z.number().default(5000),
-    /** Preserve interaction boundary steps at full fidelity */
-    preserveInteractionBoundaries: z.boolean().default(true),
-    /** Minimum consecutive non-key steps before folding */
-    foldThreshold: z.number().default(5),
-    /** Maximum ratio of steps to mark as critical */
-    maxCriticalRatio: z.number().default(0.25),
-    /** Score threshold for critical steps */
-    criticalStepThreshold: z.number().default(0.3),
-    /** Score threshold for critical interactions */
-    criticalInteractionThreshold: z.number().default(0.3),
-});
-/**
- * Team-aware learning configuration
- */
-export const TeamLearningConfigSchema = z.object({
-    /** Enable team-aware learning */
-    enabled: z.boolean().default(false),
-    /** Minimum team trajectories before batch learning */
-    minTeamTrajectories: z.number().default(5),
-    /** Similarity threshold for team playbook deduplication */
-    deduplicationThreshold: z.number().min(0).max(1).default(0.85),
-    /** Weight of structural metrics in analysis (0 = ignore, 1 = metrics only) */
-    metricsWeight: z.number().min(0).max(1).default(0.3),
-    /** Maximum team experiences to store */
-    maxTeamExperiences: z.number().default(200),
-    /** Maximum team playbooks to store */
-    maxTeamPlaybooks: z.number().default(50),
-    /** Maximum role playbooks to store */
-    maxRolePlaybooks: z.number().default(100),
-    /** Analysis agent timeout in milliseconds */
-    analysisTimeout: z.number().default(300_000),
-    /** Extraction agent timeout in milliseconds */
-    extractionTimeout: z.number().default(600_000),
-    /** Compression settings for trajectory ingestion */
-    compression: CompressionConfigSchema.default({}),
-});
 /**
  * Knowledge Bank confidence model configuration
  */
@@ -315,25 +494,6 @@ export const ConfidenceConfigSchema = z.object({
     /** Days without validation before decay begins */
     decayGracePeriodDays: z.number().default(90),
 });
-/**
- * Knowledge Bank graph overlay configuration
- */
-export const GraphConfigSchema = z.object({
-    /** Which graph layers to enable */
-    enabledLayers: z
-        .array(z.enum(['semantic', 'temporal', 'causal', 'entity']))
-        .default(['semantic']),
-    /** Whether to auto-infer temporal edges from timestamps */
-    inferTemporalEdges: z.boolean().default(true),
-    /** Whether to auto-infer causal edges from failure-recovery patterns */
-    inferCausalEdges: z.boolean().default(true),
-    /** Whether to auto-infer entity edges from shared entity tags */
-    inferEntityEdges: z.boolean().default(true),
-    /** Split layer files by domain when node count exceeds this */
-    domainSplitThreshold: z.number().default(500),
-    /** Promote to SQLite when total edge count exceeds this */
-    sqlitePromotionThreshold: z.number().default(10000),
-});
 /**
  * Knowledge Bank defragmentation configuration
  */
@@ -342,6 +502,20 @@ export const DefragConfigSchema = z.object({
     minInboxItems: z.number().default(5),
     /** Whether to auto-consolidate observations into entities */
     autoConsolidate: z.boolean().default(true),
+    /**
+     * 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.enum(['off', 'index', 'content']).optional(),
     /** Minimum observations about an entity before consolidation */
     consolidationThreshold: z.number().default(3),
     /** Whether to auto-regenerate domain summaries */
@@ -350,6 +524,20 @@ export const DefragConfigSchema = z.object({
     llmSummaryGeneration: z.boolean().default(false),
     /** Whether to auto-resolve simple contradictions */
     autoResolveContradictions: z.boolean().default(false),
+    /**
+     * 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.boolean().optional(),
+    /**
+     * 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.number().optional(),
 });
 /**
  * Knowledge Bank extraction configuration
@@ -378,6 +566,13 @@ export const KnowledgeSurfacingConfigSchema = z.object({
     includeEvidence: z.boolean().default(false),
     /** Include graph links in surfaced notes */
     includeLinks: z.boolean().default(false),
+    /**
+     * 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.number().optional(),
 });
 /**
  * Knowledge Bank configuration
@@ -393,8 +588,6 @@ export const KnowledgeBankConfigSchema = z.object({
     defrag: DefragConfigSchema.default({}),
     /** Confidence model config */
     confidence: ConfidenceConfigSchema.default({}),
-    /** Graph overlay config */
-    graph: GraphConfigSchema.default({}),
     /** Surfacing config (independent from SkillLibrary) */
     surfacing: KnowledgeSurfacingConfigSchema.default({}),
     /** Whether to manage minimem-specific features (sync, versioning) */
@@ -422,11 +615,30 @@ export const SessionBankConfigSchema = z.object({
 /**
  * Skill-tree storage configuration
  */
+export const SharedSkillBankConfigSchema = z.object({
+    /**
+     * 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.boolean().default(false),
+    /**
+     * 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.string().optional(),
+});
 export const SkillTreeConfigSchema = z.object({
     /** Enable automatic skill-tree publishing via SqliteStorageAdapter */
     enabled: z.boolean().default(true),
     /** Path to the SQLite database for skill storage (relative to storage.baseDir) */
     dbPath: z.string().default('skills.db'),
+    /** Optional mirror of published skills into a shared filesystem bank. */
+    sharedBank: SharedSkillBankConfigSchema.default({}),
 });
 /**
  * Curated playbook cache configuration (for git sources)
@@ -441,8 +653,14 @@ export const CuratedCacheConfigSchema = z.object({
  * Curated playbook configuration
  */
 export const CuratedPlaybooksConfigSchema = z.object({
-    /** Load the bundled compound-engineering seed pack on init */
-    loadBundledSeedPack: z.boolean().default(false),
+    /**
+     * 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.boolean().default(true),
     /** Additional directories to load curated playbooks from (backward compat) */
     additionalDirs: z.array(z.string()).default([]),
     /**
@@ -468,18 +686,230 @@ export const CuratedPlaybooksConfigSchema = z.object({
  * without removing them from the codebase.
  */
 export const FeaturesConfigSchema = z.object({
-    /** Enable instant (hot-path) learning on every trajectory (InstantLoop) */
-    instantLoop: z.boolean().default(true),
+    // NOTE: there is no `instantLoop` flag. The InstantLoop is the core hot-path
+    // write (it stores experiences and feeds the energy evaluator that triggers
+    // batch learning) — it is not an optional enrichment and is always on.
+    // (A dead, never-read `instantLoop` flag was removed; the "does experience
+    // memory help?" measurement is covered by the eval's experience-channel
+    // ablation, which strips injection without corrupting storage/energy signals.)
     /** Enable reflexion episode generation and storage */
     reflexion: z.boolean().default(true),
     /** Enable coherence checking on knowledge note insertion */
     coherenceChecking: z.boolean().default(true),
-    /** Enable experience clustering via ReasoningBank in batch pipeline */
-    reasoningBank: z.boolean().default(true),
-    /** Enable causal edge extraction in instant loop */
-    causalExtraction: z.boolean().default(true),
     /** Enable temporal compression (Hot/Warm/Cold/Evict) in batch pipeline */
     temporalCompression: z.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(false),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+    /**
+     * 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.boolean().default(true),
+});
+/**
+ * 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 const DreamSchedulerConfigSchema = z.object({
+    /** Arm an in-process idle timer that dreams after `idleMs` of no activity. */
+    enabled: z.boolean().default(false),
+    /** Idle debounce before an auto-dream fires (ms). */
+    idleMs: z.number().int().positive().default(30_000),
+});
+export const DreamConfigSchema = z.object({
+    /** After each solve/process call, run a dream synchronously (eval determinism). */
+    consolidateInline: z.boolean().default(false),
+    /** Pending-row count at/above which the coordinator considers a dream due. */
+    countThreshold: z.number().int().positive().default(10),
+    /** Oldest-pending age at/above which a dream is considered overdue (ms). */
+    maxStalenessMs: z.number().int().positive().default(3_600_000),
+    /** Max rows claimed per internal batch within a single dream. */
+    maxRowsPerDream: z.number().int().positive().default(200),
+    /** Max internal batches a single dream will drain before stopping. */
+    maxBatchesPerDream: z.number().int().positive().default(50),
+    /** Row lease TTL while a dream holds claimed rows (ms). */
+    leaseTtlMs: z.number().int().positive().default(900_000),
+    /** Attempts before a repeatedly-failing row is parked as `failed`. */
+    maxAttempts: z.number().int().positive().default(3),
+    /** In-process idle scheduler. */
+    scheduler: DreamSchedulerConfigSchema.default({}),
+});
+/**
+ * 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 const ValidationRetrievalChannelSchema = z.enum([
+    'experiences',
+    'knowledge',
+    'playbooks',
+    'metaPlaybooks',
+    'shortTerm',
+]);
+export const ValidationWriteChannelSchema = z.enum([
+    'experience',
+    'knowledgeNote',
+    'playbook',
+    'metaPlaybook',
+    'reflexion',
+    'causal',
+    'frontier',
+    'diagnosticOnly',
+]);
+export const ValidationMutationModeSchema = z.enum(['frozen', 'active', 'candidate']);
+export const ValidationMaintenanceMaskSchema = z.object({
+    /** Write-time curation and prune maintenance. */
+    curation: z.boolean().default(true),
+    /** Pareto/replay-gated two-parent merge proposals. */
+    mergeProposing: z.boolean().default(true),
+    /** Single-parent reflective mutation proposals. */
+    reflectiveMutation: z.boolean().default(true),
+    /** Dream/batch extraction may create new learned artifacts. */
+    extraction: z.boolean().default(true),
+    /** Scheduler-driven maintenance/dream runs. */
+    scheduling: z.boolean().default(true),
+});
+export const ValidationChannelMasksSchema = z.object({
+    retrieval: z
+        .array(ValidationRetrievalChannelSchema)
+        .default(['experiences', 'knowledge', 'playbooks', 'metaPlaybooks', 'shortTerm']),
+    serving: z
+        .array(ValidationRetrievalChannelSchema)
+        .default(['experiences', 'knowledge', 'playbooks', 'metaPlaybooks', 'shortTerm']),
+    write: z
+        .array(ValidationWriteChannelSchema)
+        .default([
+        'experience',
+        'knowledgeNote',
+        'playbook',
+        'metaPlaybook',
+        'reflexion',
+        'causal',
+        'frontier',
+        'diagnosticOnly',
+    ]),
+    maintenance: ValidationMaintenanceMaskSchema.default({}),
+});
+export const ValidationConfigSchema = z.object({
+    /** Enable validation-specific isolation controls. Production default is off. */
+    enabled: z.boolean().default(false),
+    /**
+     * active: existing direct-commit behavior.
+     * frozen: no mutation/merge/curation writes during validation.
+     * candidate: proposals are redirected to non-serving candidates (future work).
+     */
+    mutationMode: ValidationMutationModeSchema.default('frozen'),
+    channelMasks: ValidationChannelMasksSchema.default({}),
+    /**
+     * 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.boolean().default(false),
 });
 /**
  * Main Atlas configuration
@@ -507,8 +937,6 @@ export const AtlasConfigSchema = z.object({
     agenticTasks: AgenticTaskRunnerConfigSchema.default({}),
     /** Compute provider configuration */
     compute: ComputeProviderConfigSchema.default({}),
-    /** Team-aware learning configuration */
-    teamLearning: TeamLearningConfigSchema.default({}),
     /** Knowledge bank configuration */
     knowledgeBank: KnowledgeBankConfigSchema.default({}),
     /** Skill-tree storage configuration */
@@ -519,6 +947,10 @@ export const AtlasConfigSchema = z.object({
     sessionBank: SessionBankConfigSchema.default({}),
     /** Feature toggles for ruvector-inspired subsystems */
     features: FeaturesConfigSchema.default({}),
+    /** Dreaming / consolidation configuration */
+    dream: DreamConfigSchema.default({}),
+    /** Validation-only mechanism isolation controls. */
+    validation: ValidationConfigSchema.default({}),
 });
 /**
  * Create default configuration
@@ -526,6 +958,50 @@ export const AtlasConfigSchema = z.object({
 export function createDefaultConfig(overrides) {
     return AtlasConfigSchema.parse(overrides ?? {});
 }
+export function createValidationConfig(overrides) {
+    return ValidationConfigSchema.parse(overrides ?? {});
+}
+/**
+ * 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 function applyValidationControls(config) {
+    if (!config.validation.enabled)
+        return config;
+    const maintenance = config.validation.channelMasks.maintenance;
+    const features = {
+        ...config.features,
+        curation: config.features.curation && maintenance.curation,
+        mergeProposing: config.features.mergeProposing && maintenance.mergeProposing,
+        reflectiveMutation: config.features.reflectiveMutation && maintenance.reflectiveMutation,
+        dreamQueue: config.features.dreamQueue && maintenance.scheduling && maintenance.extraction,
+    };
+    if (config.validation.mutationMode === 'frozen') {
+        features.curation = false;
+        features.mergeProposing = false;
+        features.reflectiveMutation = false;
+        features.dreamQueue = false;
+        features.reflexion = false;
+    }
+    if (config.validation.allowSeeds) {
+        return { ...config, features };
+    }
+    return {
+        ...config,
+        features,
+        curatedPlaybooks: { ...config.curatedPlaybooks, loadBundledSeedPack: false },
+        memory: { ...config.memory, seedMetaPlaybooks: false, seedMetaStrategies: false },
+    };
+}
 /**
  * Merge configurations
  */
@@ -533,18 +1009,37 @@ export function mergeConfig(base, overrides) {
     return AtlasConfigSchema.parse({
         learning: { ...base.learning, ...overrides.learning },
         router: { ...base.router, ...overrides.router },
-        memory: { ...base.memory, ...overrides.memory },
+        memory: {
+            ...base.memory,
+            ...overrides.memory,
+            capacity: { ...base.memory.capacity, ...overrides.memory?.capacity },
+            playbookRetrieval: {
+                ...base.memory.playbookRetrieval,
+                ...overrides.memory?.playbookRetrieval,
+            },
+        },
         storage: { ...base.storage, ...overrides.storage },
         embedding: { ...base.embedding, ...overrides.embedding },
         execution: { ...base.execution, ...overrides.execution },
         refinement: { ...base.refinement, ...overrides.refinement },
-        skillLibrary: { ...base.skillLibrary, ...overrides.skillLibrary },
+        skillLibrary: {
+            ...base.skillLibrary,
+            ...overrides.skillLibrary,
+            promotion: { ...base.skillLibrary.promotion, ...overrides.skillLibrary?.promotion },
+            limits: { ...base.skillLibrary.limits, ...overrides.skillLibrary?.limits },
+            context: { ...base.skillLibrary.context, ...overrides.skillLibrary?.context },
+            demotion: { ...base.skillLibrary.demotion, ...overrides.skillLibrary?.demotion },
+            retrieval: { ...base.skillLibrary.retrieval, ...overrides.skillLibrary?.retrieval },
+        },
         mcp: { ...base.mcp, ...overrides.mcp },
         agenticTasks: { ...base.agenticTasks, ...overrides.agenticTasks },
         compute: { ...base.compute, ...overrides.compute },
-        teamLearning: { ...base.teamLearning, ...overrides.teamLearning },
         knowledgeBank: { ...base.knowledgeBank, ...overrides.knowledgeBank },
-        skillTree: { ...base.skillTree, ...overrides.skillTree },
+        skillTree: {
+            ...base.skillTree,
+            ...overrides.skillTree,
+            sharedBank: { ...base.skillTree.sharedBank, ...overrides.skillTree?.sharedBank },
+        },
         curatedPlaybooks: {
             ...base.curatedPlaybooks,
             ...overrides.curatedPlaybooks,
@@ -552,6 +1047,23 @@ export function mergeConfig(base, overrides) {
         },
         sessionBank: { ...base.sessionBank, ...overrides.sessionBank },
         features: { ...base.features, ...overrides.features },
+        dream: {
+            ...base.dream,
+            ...overrides.dream,
+            scheduler: { ...base.dream.scheduler, ...overrides.dream?.scheduler },
+        },
+        validation: {
+            ...base.validation,
+            ...overrides.validation,
+            channelMasks: {
+                ...base.validation.channelMasks,
+                ...overrides.validation?.channelMasks,
+                maintenance: {
+                    ...base.validation.channelMasks.maintenance,
+                    ...overrides.validation?.channelMasks?.maintenance,
+                },
+            },
+        },
     });
 }
 //# sourceMappingURL=config.js.map