byterover-cli 3.6.1 → 3.7.1

package/dist/server/infra/context-tree/runtime-signal-store.d.ts

@@ -0,0 +1,46 @@
+/**
+ * IKeyStorage-backed implementation of {@link IRuntimeSignalStore}.
+ *
+ * Uses composite keys `["signals", ...pathSegments]`. Atomicity within a
+ * single process comes from `IKeyStorage.update`'s per-key RWLock; the
+ * interface docs cover the cross-process caveat.
+ */
+import type { IKeyStorage } from '../../../agent/core/interfaces/i-key-storage.js';
+import type { ILogger } from '../../../agent/core/interfaces/i-logger.js';
+import type { IRuntimeSignalStore, RuntimeSignalsUpdater } from '../../core/interfaces/storage/i-runtime-signal-store.js';
+import { type RuntimeSignals } from '../../core/domain/knowledge/runtime-signals-schema.js';
+export declare class RuntimeSignalStore implements IRuntimeSignalStore {
+    private readonly keyStorage;
+    private readonly logger;
+    constructor(keyStorage: IKeyStorage, logger: ILogger);
+    batchUpdate(updates: Map<string, RuntimeSignalsUpdater>): Promise<void>;
+    delete(relPath: string): Promise<void>;
+    get(relPath: string): Promise<RuntimeSignals>;
+    getMany(relPaths: readonly string[]): Promise<Map<string, RuntimeSignals>>;
+    list(): Promise<Map<string, RuntimeSignals>>;
+    set(relPath: string, signals: RuntimeSignals): Promise<void>;
+    update(relPath: string, updater: RuntimeSignalsUpdater): Promise<RuntimeSignals>;
+    /**
+     * Reconstruct the relative path from a `["signals", ...segments]` key.
+     * Returns null for keys that do not belong to this store (defensive against
+     * the remote chance of namespace collisions during listing).
+     */
+    private relPathFromKey;
+    /**
+     * Encode a relative path into a composite storage key.
+     *
+     * FileKeyStorage rejects `/` inside segments, so each path component
+     * becomes its own segment. Empty components (from leading, trailing, or
+     * consecutive slashes) are dropped so the encoding is insensitive to
+     * path normalization variants.
+     */
+    private signalKey;
+    /**
+     * Coerce an unknown stored value into a valid RuntimeSignals record.
+     *
+     * Missing (`undefined`) yields defaults silently — the common fresh-path
+     * case. Corrupt stored data logs a warning and also falls back to
+     * defaults so callers never have to handle read errors inline.
+     */
+    private validateOrDefault;
+}

package/dist/server/infra/context-tree/runtime-signal-store.js

@@ -0,0 +1,118 @@
+/**
+ * IKeyStorage-backed implementation of {@link IRuntimeSignalStore}.
+ *
+ * Uses composite keys `["signals", ...pathSegments]`. Atomicity within a
+ * single process comes from `IKeyStorage.update`'s per-key RWLock; the
+ * interface docs cover the cross-process caveat.
+ */
+import { createDefaultRuntimeSignals, RuntimeSignalsSchema, } from '../../core/domain/knowledge/runtime-signals-schema.js';
+const SIGNALS_PREFIX = 'signals';
+// The store does not enforce the importance ↔ maturity hysteresis —
+// callers bumping importance must recompute maturity via `determineTier`
+// in the same updater. Invariant upheld at every write site; see
+// interface-level docs for the rationale. Orphan-entry cleanup is tracked
+// in features/runtime-signals/backlog.md (`pruneOrphans`).
+export class RuntimeSignalStore {
+    keyStorage;
+    logger;
+    constructor(keyStorage, logger) {
+        this.keyStorage = keyStorage;
+        this.logger = logger;
+    }
+    async batchUpdate(updates) {
+        // Different relPaths do not share a per-key lock, so parallel updates
+        // scale naturally. Each individual update remains atomic because
+        // IKeyStorage.update is atomic per key (within one process).
+        await Promise.all([...updates.entries()].map(([relPath, updater]) => this.update(relPath, updater)));
+    }
+    async delete(relPath) {
+        await this.keyStorage.delete(this.signalKey(relPath));
+    }
+    async get(relPath) {
+        const raw = await this.keyStorage.get(this.signalKey(relPath));
+        return this.validateOrDefault(raw, relPath);
+    }
+    async getMany(relPaths) {
+        // Only include paths that have a stored record. Callers distinguish
+        // missing via `.has(path)`; ergonomic default-on-miss via
+        // `map.get(path) ?? createDefaultRuntimeSignals()`.
+        const entries = await Promise.all(relPaths.map(async (relPath) => {
+            const raw = await this.keyStorage.get(this.signalKey(relPath));
+            if (raw === undefined)
+                return null;
+            const parsed = RuntimeSignalsSchema.safeParse(raw);
+            if (parsed.success) {
+                return [relPath, parsed.data];
+            }
+            this.logger.warn(`RuntimeSignalStore: discarding corrupt entry for ${relPath}: ${parsed.error.message}`);
+            return null;
+        }));
+        return new Map(entries.filter((entry) => entry !== null));
+    }
+    async list() {
+        const entries = await this.keyStorage.listWithValues([SIGNALS_PREFIX]);
+        const result = new Map();
+        for (const entry of entries) {
+            const relPath = this.relPathFromKey(entry.key);
+            if (relPath === null)
+                continue;
+            result.set(relPath, this.validateOrDefault(entry.value, relPath));
+        }
+        return result;
+    }
+    async set(relPath, signals) {
+        const validated = RuntimeSignalsSchema.parse(signals);
+        await this.keyStorage.set(this.signalKey(relPath), validated);
+    }
+    async update(relPath, updater) {
+        return this.keyStorage.update(this.signalKey(relPath), (current) => {
+            // `current` is typed as RuntimeSignals but the underlying value may be
+            // anything the disk held (missing, partial, corrupt). validateOrDefault
+            // coerces it into a valid record before the updater runs.
+            const base = this.validateOrDefault(current, relPath);
+            const merged = updater(base);
+            // Re-validate updater output so a buggy caller cannot land invalid
+            // data (e.g. importance out of range) on disk.
+            return RuntimeSignalsSchema.parse(merged);
+        });
+    }
+    /**
+     * Reconstruct the relative path from a `["signals", ...segments]` key.
+     * Returns null for keys that do not belong to this store (defensive against
+     * the remote chance of namespace collisions during listing).
+     */
+    relPathFromKey(key) {
+        if (key.length < 2 || key[0] !== SIGNALS_PREFIX)
+            return null;
+        return key.slice(1).join('/');
+    }
+    /**
+     * Encode a relative path into a composite storage key.
+     *
+     * FileKeyStorage rejects `/` inside segments, so each path component
+     * becomes its own segment. Empty components (from leading, trailing, or
+     * consecutive slashes) are dropped so the encoding is insensitive to
+     * path normalization variants.
+     */
+    signalKey(relPath) {
+        const segments = relPath.split('/').filter((s) => s.length > 0);
+        return [SIGNALS_PREFIX, ...segments];
+    }
+    /**
+     * Coerce an unknown stored value into a valid RuntimeSignals record.
+     *
+     * Missing (`undefined`) yields defaults silently — the common fresh-path
+     * case. Corrupt stored data logs a warning and also falls back to
+     * defaults so callers never have to handle read errors inline.
+     */
+    validateOrDefault(raw, relPath) {
+        if (raw === undefined) {
+            return createDefaultRuntimeSignals();
+        }
+        const parsed = RuntimeSignalsSchema.safeParse(raw);
+        if (parsed.success)
+            return parsed.data;
+        this.logger.warn(`RuntimeSignalStore: discarding corrupt entry for ${relPath}: ${parsed.error.message}`);
+        return createDefaultRuntimeSignals();
+    }
+}

package/dist/server/infra/daemon/agent-process.js

@@ -27,6 +27,7 @@ import { CipherAgent } from '../../../agent/infra/agent/index.js';
 import { FileSystemService } from '../../../agent/infra/file-system/file-system-service.js';
 import { FolderPackService } from '../../../agent/infra/folder-pack/folder-pack-service.js';
 import { SessionMetadataStore } from '../../../agent/infra/session/session-metadata-store.js';
+import { FileKeyStorage } from '../../../agent/infra/storage/file-key-storage.js';
 import { createSearchKnowledgeService } from '../../../agent/infra/tools/implementations/search-knowledge-service.js';
 import { AuthEvents } from '../../../shared/transport/events/auth-events.js';
 import { decodeSearchContent } from '../../../shared/transport/search-content.js';
@@ -36,6 +37,7 @@ import { serializeTaskError, TaskError, TaskErrorCode } from '../../core/domain/
 import { loadSources } from '../../core/domain/source/source-schema.js';
 import { TransportAgentEventNames, TransportDaemonEventNames, TransportStateEventNames, TransportTaskEventNames, } from '../../core/domain/transport/schemas.js';
 import { FileContextTreeArchiveService } from '../context-tree/file-context-tree-archive-service.js';
+import { RuntimeSignalStore } from '../context-tree/runtime-signal-store.js';
 import { DreamLockService } from '../dream/dream-lock-service.js';
 import { DreamLogStore } from '../dream/dream-log-store.js';
 import { DreamStateService } from '../dream/dream-state-service.js';
@@ -300,7 +302,25 @@ async function start() {
         workingDirectory: projectPath,
     });
     await fileSystemService.initialize();
-    const searchService = createSearchKnowledgeService(fileSystemService, { baseDirectory: projectPath });
+    // Runtime-signal sidecar for this daemon. FileKeyStorage is file-backed
+    // under configResult.storagePath, so the daemon and any other process for
+    // the same project write to the same on-disk store. `brv search`, curate,
+    // and archive in this daemon all mirror scoring writes through it.
+    const daemonKeyStorage = new FileKeyStorage({
+        storageDir: configResult.storagePath,
+    });
+    await daemonKeyStorage.initialize();
+    const daemonLogger = {
+        debug: (msg) => agentLog(msg),
+        error: (msg) => agentLog(msg),
+        info: (msg) => agentLog(msg),
+        warn: (msg) => agentLog(msg),
+    };
+    const daemonRuntimeSignalStore = new RuntimeSignalStore(daemonKeyStorage, daemonLogger);
+    const searchService = createSearchKnowledgeService(fileSystemService, {
+        baseDirectory: projectPath,
+        runtimeSignalStore: daemonRuntimeSignalStore,
+    });
     // 7. Create executors and listen for task:execute from pool
     const curateExecutor = new CurateExecutor();
     const folderPackService = new FolderPackService(fileSystemService);
@@ -316,7 +336,7 @@ async function start() {
     transport.on(TransportTaskEventNames.EXECUTE, (task) => {
         agentLog(`task:execute received taskId=${task.taskId} type=${task.type} activeTaskCount=${activeTaskCount + 1}`);
         // eslint-disable-next-line no-void
-        void executeTask(task, curateExecutor, folderPackExecutor, queryExecutor, searchExecutor, searchService, configResult.storagePath);
+        void executeTask(task, curateExecutor, folderPackExecutor, queryExecutor, searchExecutor, searchService, configResult.storagePath, daemonRuntimeSignalStore);
     });
     // 8. Register with transport server (for TransportHandlers tracking)
     await transport.requestWithAck('agent:register', { projectPath });
@@ -324,7 +344,7 @@ async function start() {
     process.send?.({ clientId, type: 'ready' });
     agentLog('Ready — listening for tasks');
 }
-async function executeTask(task, curateExecutor, folderPackExecutor, queryExecutor, searchExecutor, searchKnowledgeService, storagePath) {
+async function executeTask(task, curateExecutor, folderPackExecutor, queryExecutor, searchExecutor, searchKnowledgeService, storagePath, runtimeSignalStore) {
     const { clientCwd, clientId, content, files, folderPath, force, taskId, trigger, type, worktreeRoot } = task;
     if (!transport || !agent)
         return;
@@ -438,12 +458,13 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
                         break;
                     }
                     const dreamExecutor = new DreamExecutor({
-                        archiveService: new FileContextTreeArchiveService(),
+                        archiveService: new FileContextTreeArchiveService(runtimeSignalStore),
                         curateLogStore: new FileCurateLogStore({ baseDir: storagePath }),
                         dreamLockService,
                         dreamLogStore: new DreamLogStore({ baseDir: brvDir }),
                         dreamStateService,
                         reviewBackupStore: new FileReviewBackupStore(brvDir),
+                        runtimeSignalStore,
                         searchService: searchKnowledgeService,
                     });
                     const dreamResult = await dreamExecutor.executeWithAgent(agent, {

package/dist/server/infra/dream/operations/consolidate.d.ts

@@ -11,6 +11,7 @@
  * Never throws — returns partial results on errors.
  */
 import type { ICipherAgent } from '../../../../agent/core/interfaces/i-cipher-agent.js';
+import type { ILogger } from '../../../../agent/core/interfaces/i-logger.js';
 import type { DreamOperation } from '../dream-log-schema.js';
 import type { DreamState } from '../dream-state-schema.js';
 export type ConsolidateDeps = {
@@ -27,9 +28,25 @@ export type ConsolidateDeps = {
         update(updater: (state: DreamState) => DreamState): Promise<DreamState>;
         write(state: DreamState): Promise<void>;
     };
+    /**
+     * Optional logger. When provided, per-file sidecar failures during the
+     * CROSS_REFERENCE review gate emit a warn so silent swallows are visible.
+     */
+    logger?: ILogger;
     reviewBackupStore?: {
         save(relativePath: string, content: string): Promise<void>;
     };
+    /**
+     * Optional. When present, the CROSS_REFERENCE review-gate consults the
+     * sidecar to check whether any input file has `maturity === 'core'`. Absent
+     * store or missing entries mean no file qualifies as core — review is
+     * skipped, matching the pre-migration behaviour for paths without scoring.
+     */
+    runtimeSignalStore?: {
+        get(relPath: string): Promise<{
+            maturity: 'core' | 'draft' | 'validated';
+        }>;
+    };
     searchService: {
         search(query: string, options?: {
             limit?: number;

package/dist/server/infra/dream/operations/consolidate.js

@@ -14,7 +14,7 @@ import { dump as yamlDump, load as yamlLoad } from 'js-yaml';
 import { randomUUID } from 'node:crypto';
 import { access, mkdir, readdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { parseFrontmatterScoring } from '../../../core/domain/knowledge/markdown-writer.js';
+import { warnSidecarFailure } from '../../../core/domain/knowledge/sidecar-logging.js';
 import { ConsolidateResponseSchema } from '../dream-response-schemas.js';
 import { parseDreamResponse } from '../parse-dream-response.js';
 /**
@@ -148,7 +148,13 @@ async function processDomain(domain, files, deps, hints = []) {
         for (const action of parsed.actions) {
             try {
                 // eslint-disable-next-line no-await-in-loop
-                const op = await executeAction(action, contextTreeDir, fileContents, deps.reviewBackupStore);
+                const op = await executeAction(action, {
+                    contextTreeDir,
+                    fileContents,
+                    logger: deps.logger,
+                    reviewBackupStore: deps.reviewBackupStore,
+                    runtimeSignalStore: deps.runtimeSignalStore,
+                });
                 if (op)
                     results.push(op);
             }
@@ -338,23 +344,24 @@ function buildPrompt(changedFiles, relatedFiles, filesPayload, pendingMergeHints
     lines.push('', 'File contents:', fileBlocks, '', 'For each pair/group of related files, classify the relationship and recommend an action:', '- MERGE: Files are redundant/overlapping → combine into one, specify outputFile and mergedContent', '- TEMPORAL_UPDATE: File has contradictory/outdated info → rewrite with temporal narrative, specify updatedContent', '- CROSS_REFERENCE: Files are complementary → add cross-references (no content changes needed)', '- SKIP: Files are genuinely unrelated → no action needed', '', 'Respond with JSON matching this schema:', '```', '{ "actions": [{ "type": "MERGE"|"TEMPORAL_UPDATE"|"CROSS_REFERENCE"|"SKIP", "files": ["path1", ...], "reason": "...", "confidence?": 0.0-1.0, "mergedContent?": "...", "outputFile?": "...", "updatedContent?": "..." }] }', '```', '', 'Rules:', '- Default to MERGE when files share >50% of content or cover the same topic. SKIP only when files are genuinely on unrelated topics.', '- Returning all SKIP when duplicates exist is a failure, not caution.', '- For MERGE, choose the richer/more complete file as outputFile. The mergedContent should preserve all unique details from both sources.', '- For TEMPORAL_UPDATE, preserve all facts and add temporal context. Include confidence (0-1) indicating certainty that the update is correct.', '- For CROSS_REFERENCE, just list the files — the system will add frontmatter links.', '- Preserve all diagrams, tables, code examples, and structured data verbatim.');
     return lines.join('\n');
 }
-async function executeAction(action, contextTreeDir, fileContents, reviewBackupStore) {
+async function executeAction(action, ctx) {
     switch (action.type) {
         case 'CROSS_REFERENCE': {
-            return executeCrossReference(action, contextTreeDir, fileContents, reviewBackupStore);
+            return executeCrossReference(action, ctx);
         }
         case 'MERGE': {
-            return executeMerge(action, contextTreeDir, fileContents, reviewBackupStore);
+            return executeMerge(action, ctx);
         }
         case 'SKIP': {
             return undefined;
         }
         case 'TEMPORAL_UPDATE': {
-            return executeTemporalUpdate(action, contextTreeDir, fileContents, reviewBackupStore);
+            return executeTemporalUpdate(action, ctx);
         }
     }
 }
-async function executeMerge(action, contextTreeDir, fileContents, reviewBackupStore) {
+async function executeMerge(action, ctx) {
+    const { contextTreeDir, fileContents, reviewBackupStore, runtimeSignalStore } = ctx;
     const outputFile = action.outputFile ?? action.files[0];
     if (!action.mergedContent) {
         throw new Error(`MERGE action missing mergedContent for ${outputFile}`);
@@ -386,7 +393,7 @@ async function executeMerge(action, contextTreeDir, fileContents, reviewBackupSt
     const toDelete = action.files.filter((f) => f !== outputFile);
     await Promise.all(toDelete.map((f) => unlink(join(contextTreeDir, f)).catch(() => { })));
     // Determine needsReview
-    const needsReview = determineNeedsReview('MERGE', action.files, fileContents);
+    const needsReview = await determineNeedsReview('MERGE', action.files, { runtimeSignalStore });
     return {
         action: 'MERGE',
         inputFiles: action.files,
@@ -397,7 +404,8 @@ async function executeMerge(action, contextTreeDir, fileContents, reviewBackupSt
         type: 'CONSOLIDATE',
     };
 }
-async function executeTemporalUpdate(action, contextTreeDir, fileContents, reviewBackupStore) {
+async function executeTemporalUpdate(action, ctx) {
+    const { contextTreeDir, fileContents, reviewBackupStore, runtimeSignalStore } = ctx;
     const targetFile = action.files[0];
     if (!action.updatedContent) {
         throw new Error(`TEMPORAL_UPDATE action missing updatedContent for ${targetFile}`);
@@ -409,7 +417,10 @@ async function executeTemporalUpdate(action, contextTreeDir, fileContents, revie
     if (original !== undefined) {
         previousTexts[targetFile] = original;
     }
-    const needsReview = determineNeedsReview('TEMPORAL_UPDATE', action.files, fileContents, action.confidence);
+    const needsReview = await determineNeedsReview('TEMPORAL_UPDATE', action.files, {
+        confidence: action.confidence,
+        runtimeSignalStore,
+    });
     // Create review backup only when the operation needs human review
     if (reviewBackupStore && original !== undefined && needsReview) {
         try {
@@ -432,7 +443,8 @@ async function executeTemporalUpdate(action, contextTreeDir, fileContents, revie
         type: 'CONSOLIDATE',
     };
 }
-async function executeCrossReference(action, contextTreeDir, fileContents, reviewBackupStore) {
+async function executeCrossReference(action, ctx) {
+    const { contextTreeDir, fileContents, logger, reviewBackupStore, runtimeSignalStore } = ctx;
     const previousTexts = {};
     for (const file of action.files) {
         const content = fileContents.get(file);
@@ -440,7 +452,7 @@ async function executeCrossReference(action, contextTreeDir, fileContents, revie
             previousTexts[file] = content;
         }
     }
-    const needsReview = determineNeedsReview('CROSS_REFERENCE', action.files, fileContents);
+    const needsReview = await determineNeedsReview('CROSS_REFERENCE', action.files, { logger, runtimeSignalStore });
     if (needsReview && reviewBackupStore) {
         await Promise.all(Object.entries(previousTexts).map(([file, content]) => reviewBackupStore.save(file, content).catch(() => { })));
     }
@@ -494,21 +506,30 @@ async function addRelatedLinks(filePath, relatedPaths) {
     const yaml = yamlDump({ related: relatedPaths }, { flowLevel: 1, lineWidth: -1, sortKeys: true }).trimEnd();
     await atomicWrite(filePath, `---\n${yaml}\n---\n${content}`);
 }
-function determineNeedsReview(actionType, files, fileContents, confidence) {
+async function determineNeedsReview(actionType, files, opts) {
     // MERGE always needs review
     if (actionType === 'MERGE')
         return true;
     // TEMPORAL_UPDATE: needs review when confidence is low or absent
     if (actionType === 'TEMPORAL_UPDATE')
-        return (confidence ?? 0) < 0.7;
-    // CROSS_REFERENCE: only if any file has core maturity
+        return (opts.confidence ?? 0) < 0.7;
+    // CROSS_REFERENCE: only if any file has core maturity in the sidecar.
+    // Without a store, no file can qualify as core — review is skipped, which
+    // matches the pre-migration default when no scoring was present.
+    const { logger, runtimeSignalStore } = opts;
+    if (!runtimeSignalStore)
+        return false;
     for (const file of files) {
-        const content = fileContents.get(file);
-        if (content) {
-            const scoring = parseFrontmatterScoring(content);
-            if (scoring?.maturity === 'core')
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            const signals = await runtimeSignalStore.get(file);
+            if (signals.maturity === 'core')
                 return true;
         }
+        catch (error) {
+            // Ignore per-file sidecar failures — continue checking remaining files.
+            warnSidecarFailure(logger, 'consolidate', 'get', `${file} (CROSS_REFERENCE gate)`, error);
+        }
     }
     return false;
 }

package/dist/server/infra/dream/operations/prune.d.ts

@@ -12,6 +12,7 @@
  * Never throws — returns empty array on errors.
  */
 import type { ICipherAgent } from '../../../../agent/core/interfaces/i-cipher-agent.js';
+import type { ILogger } from '../../../../agent/core/interfaces/i-logger.js';
 import type { DreamOperation } from '../dream-log-schema.js';
 import type { DreamState } from '../dream-state-schema.js';
 export type PruneDeps = {
@@ -31,10 +32,27 @@ export type PruneDeps = {
         update(updater: (state: DreamState) => DreamState): Promise<DreamState>;
         write(state: DreamState): Promise<void>;
     };
+    /**
+     * Optional logger. When provided, sidecar failures in the candidate scan
+     * emit a warn so the fail-open degradation is visible.
+     */
+    logger?: ILogger;
     projectRoot: string;
     reviewBackupStore?: {
         save(relativePath: string, content: string): Promise<void>;
     };
+    /**
+     * Runtime-signal sidecar. Source of truth for `importance` and `maturity`
+     * used in prune's candidacy decisions. Absent store or missing-per-path
+     * entries are treated as defaults (importance 50, maturity 'draft') —
+     * matches the plan's "paths without entries use defaults" principle.
+     */
+    runtimeSignalStore?: {
+        list(): Promise<Map<string, {
+            importance: number;
+            maturity: 'core' | 'draft' | 'validated';
+        }>>;
+    };
     signal?: AbortSignal;
     taskId: string;
 };

package/dist/server/infra/dream/operations/prune.js

@@ -13,6 +13,8 @@
  */
 import { readdir, readFile, stat, utimes } from 'node:fs/promises';
 import { join } from 'node:path';
+import { DEFAULT_IMPORTANCE, DEFAULT_MATURITY } from '../../../core/domain/knowledge/runtime-signals-schema.js';
+import { warnSidecarFailure } from '../../../core/domain/knowledge/sidecar-logging.js';
 import { isExcludedFromSync } from '../../context-tree/derived-artifact.js';
 import { toUnixPath } from '../../context-tree/path-utils.js';
 import { PruneResponseSchema } from '../dream-response-schemas.js';
@@ -48,10 +50,25 @@ export async function prune(deps) {
 async function findCandidates(deps) {
     const candidateMap = new Map();
     const now = Date.now();
+    // Source of truth for importance/maturity is the sidecar. Preload once per
+    // scan so per-path lookups are O(1) map reads instead of repeated regex
+    // passes over markdown content. On sidecar failure the map is empty and
+    // every path falls back to defaults (importance 50, maturity 'draft').
+    let signalsByPath;
+    try {
+        signalsByPath = deps.runtimeSignalStore ? await deps.runtimeSignalStore.list() : new Map();
+    }
+    catch (error) {
+        warnSidecarFailure(deps.logger, 'prune', 'list', 'findCandidates', error);
+        signalsByPath = new Map();
+    }
     // Signal A: archive service importance decay
     try {
         const importancePaths = await deps.archiveService.findArchiveCandidates(deps.projectRoot);
-        const infoResults = await Promise.all(importancePaths.map(async (path) => ({ info: await readCandidateInfo(deps.contextTreeDir, path, now), path })));
+        const infoResults = await Promise.all(importancePaths.map(async (path) => ({
+            info: await readCandidateInfo(deps.contextTreeDir, path, now, signalsByPath),
+            path,
+        })));
         for (const { info, path } of infoResults) {
             if (info && info.maturity !== 'core') {
                 candidateMap.set(path, { ...info, signal: 'importance' });
@@ -63,7 +80,7 @@ async function findCandidates(deps) {
     }
     // Signal B: mtime staleness
     try {
-        const stalePaths = await findStaleFiles(deps.contextTreeDir, now);
+        const stalePaths = await findStaleFiles(deps.contextTreeDir, now, signalsByPath);
         for (const { info, path } of stalePaths) {
             if (candidateMap.has(path)) {
                 // Already found by Signal A — mark as both
@@ -84,16 +101,16 @@ async function findCandidates(deps) {
     candidates.sort((a, b) => b.daysSinceModified - a.daysSinceModified);
     return candidates.slice(0, MAX_CANDIDATES);
 }
-async function readCandidateInfo(contextTreeDir, relativePath, now) {
+async function readCandidateInfo(contextTreeDir, relativePath, now, signalsByPath) {
     try {
         const fullPath = join(contextTreeDir, relativePath);
-        const content = await readFile(fullPath, 'utf8');
         const fileStat = await stat(fullPath);
         const daysSinceModified = (now - fileStat.mtimeMs) / MS_PER_DAY;
+        const signals = signalsByPath.get(relativePath);
         return {
             daysSinceModified,
-            importance: extractImportance(content),
-            maturity: extractMaturity(content),
+            importance: signals?.importance ?? DEFAULT_IMPORTANCE,
+            maturity: signals?.maturity ?? DEFAULT_MATURITY,
             path: relativePath,
             signal: 'importance',
         };
@@ -102,13 +119,16 @@ async function readCandidateInfo(contextTreeDir, relativePath, now) {
         return undefined;
     }
 }
-async function findStaleFiles(contextTreeDir, now) {
+async function findStaleFiles(contextTreeDir, now, signalsByPath) {
     const results = [];
     await walkMdFiles(contextTreeDir, async (relativePath, fullPath) => {
         try {
-            const content = await readFile(fullPath, 'utf8');
-            const maturity = extractMaturity(content);
-            // core files NEVER pruned
+            const signals = signalsByPath.get(relativePath);
+            const maturity = signals?.maturity ?? DEFAULT_MATURITY;
+            // core files NEVER pruned. Absent sidecar entry means maturity defaults
+            // to 'draft', so core protection depends on the sidecar being populated.
+            // That is intentional: post-migration, a file is only 'core' when the
+            // maturity tier has been earned via repeated access / curate updates.
             if (maturity === 'core')
                 return;
             const threshold = maturity === 'validated' ? VALIDATED_STALE_DAYS : DRAFT_STALE_DAYS;
@@ -118,7 +138,7 @@ async function findStaleFiles(contextTreeDir, now) {
                 results.push({
                     info: {
                         daysSinceModified,
-                        importance: extractImportance(content),
+                        importance: signals?.importance ?? DEFAULT_IMPORTANCE,
                         maturity,
                         path: relativePath,
                         signal: 'mtime',
@@ -351,12 +371,3 @@ async function writePendingMerge(decision, deps) {
         };
     });
 }
-// ── Frontmatter helpers ────────────────────────────────────────────────────
-function extractMaturity(content) {
-    const match = /^maturity:\s*['"]?(core|draft|validated)['"]?/m.exec(content);
-    return match?.[1] ?? 'draft';
-}
-function extractImportance(content) {
-    const match = /^importance:\s*(\d+(?:\.\d+)?)/m.exec(content);
-    return match ? Number.parseFloat(match[1]) : 50;
-}

package/dist/server/infra/dream/operations/synthesize.d.ts

@@ -11,10 +11,23 @@
  * Never throws — returns empty array on errors.
  */
 import type { ICipherAgent } from '../../../../agent/core/interfaces/i-cipher-agent.js';
+import type { ILogger } from '../../../../agent/core/interfaces/i-logger.js';
+import type { IRuntimeSignalStore } from '../../../core/interfaces/storage/i-runtime-signal-store.js';
 import type { DreamOperation } from '../dream-log-schema.js';
 export type SynthesizeDeps = {
     agent: ICipherAgent;
     contextTreeDir: string;
+    /**
+     * Optional logger. When provided, sidecar seed failures emit a warn
+     * so the fail-open degradation is observable rather than silent.
+     */
+    logger?: ILogger;
+    /**
+     * Optional sidecar store for runtime ranking signals. When provided,
+     * newly created synthesis files are seeded with default signals so
+     * ranking data lives in the sidecar rather than in markdown frontmatter.
+     */
+    runtimeSignalStore?: IRuntimeSignalStore;
     searchService: {
         search(query: string, options?: {
             limit?: number;

package/dist/server/infra/dream/operations/synthesize.js

@@ -14,6 +14,8 @@ import { dump as yamlDump, load as yamlLoad } from 'js-yaml';
 import { randomUUID } from 'node:crypto';
 import { access, mkdir, readdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
+import { createDefaultRuntimeSignals } from '../../../core/domain/knowledge/runtime-signals-schema.js';
+import { warnSidecarFailure } from '../../../core/domain/knowledge/sidecar-logging.js';
 import { isDescendantOf } from '../../../utils/path-utils.js';
 import { SynthesizeResponseSchema } from '../dream-response-schemas.js';
 import { parseDreamResponse } from '../parse-dream-response.js';
@@ -66,7 +68,7 @@ export async function synthesize(deps) {
         for (const candidate of novel) {
             try {
                 // eslint-disable-next-line no-await-in-loop
-                const op = await writeSynthesisFile(candidate, contextTreeDir);
+                const op = await writeSynthesisFile(candidate, contextTreeDir, deps.runtimeSignalStore, deps.logger);
                 if (op)
                     results.push(op);
             }
@@ -181,7 +183,7 @@ async function isDuplicateCandidate(candidate, existingSyntheses, searchService)
         return false; // Search failure → assume novel
     }
 }
-async function writeSynthesisFile(candidate, contextTreeDir) {
+async function writeSynthesisFile(candidate, contextTreeDir, runtimeSignalStore, logger) {
     const slug = slugify(candidate.title);
     const relativePath = `${candidate.placement}/${slug}.md`;
     const absPath = resolve(contextTreeDir, relativePath);
@@ -201,7 +203,6 @@ async function writeSynthesisFile(candidate, contextTreeDir) {
     /* eslint-disable camelcase */
     const frontmatter = {
         confidence: candidate.confidence,
-        maturity: 'draft',
         sources,
         synthesized_at: new Date().toISOString(),
         type: 'synthesis',
@@ -220,6 +221,17 @@ async function writeSynthesisFile(candidate, contextTreeDir) {
     ].join('\n');
     const content = `---\n${yaml}\n---\n\n${body}`;
     await atomicWrite(absPath, content);
+    // Seed the sidecar with default signals so ranking data lives in the
+    // sidecar rather than in markdown frontmatter. Best-effort — a sidecar
+    // failure must never prevent the synthesis file from being created.
+    if (runtimeSignalStore) {
+        try {
+            await runtimeSignalStore.set(relativePath, createDefaultRuntimeSignals());
+        }
+        catch (error) {
+            warnSidecarFailure(logger, 'synthesize', 'seed', relativePath, error);
+        }
+    }
     return {
         action: 'CREATE',
         confidence: candidate.confidence,