byterover-cli 3.7.0 → 3.7.1

package/dist/agent/core/interfaces/cipher-services.d.ts

@@ -1,3 +1,4 @@
+import type { IRuntimeSignalStore } from '../../../server/core/interfaces/storage/i-runtime-signal-store.js';
 import type { AgentEventBus, SessionEventBus } from '../../infra/events/event-emitter.js';
 import type { FileSystemService } from '../../infra/file-system/file-system-service.js';
 import type { CompactionService } from '../../infra/llm/context/compaction/compaction-service.js';
@@ -51,6 +52,12 @@ export interface CipherAgentServices {
     messageStorageService: MessageStorageService;
     policyEngine: IPolicyEngine;
     processService: ProcessService;
+    /**
+     * Sidecar store for per-machine ranking signals kept out of the shared
+     * context-tree markdown (importance, recency, maturity, accessCount,
+     * updateCount). Reachable here for future wiring; no consumer uses it yet.
+     */
+    runtimeSignalStore: IRuntimeSignalStore;
     sandboxService: ISandboxService;
     systemPromptManager: SystemPromptManager;
     toolManager: ToolManager;

package/dist/agent/infra/agent/cipher-agent.js

@@ -978,8 +978,10 @@ export class CipherAgent extends BaseAgent {
                 services.abstractQueue.setGenerator(retryableFreshGenerator);
             });
         }
-        // Rebuild sandbox CurateService with the queue — reuses existing hot-swap path
-        const newCurateService = createCurateService(services.workingDirectory, services.abstractQueue);
+        // Rebuild sandbox CurateService with the queue — reuses existing hot-swap path.
+        // runtimeSignalStore is threaded so agent-driven curate ADD/UPDATE seed +
+        // bump the sidecar (matches the tool-registry wiring at construction time).
+        const newCurateService = createCurateService(services.workingDirectory, services.abstractQueue, services.runtimeSignalStore);
         services.sandboxService.setCurateService?.(newCurateService);
         // Atomically rebuild CURATE + INGEST_RESOURCE tools so both enqueue abstracts
         services.toolProvider.replaceTools([ToolName.CURATE, ToolName.INGEST_RESOURCE], { abstractQueue: services.abstractQueue, contentGenerator: retryableCurateGenerator });

package/dist/agent/infra/agent/service-initializer.js

@@ -12,6 +12,7 @@
  */
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { RuntimeSignalStore } from '../../../server/infra/context-tree/runtime-signal-store.js';
 import { createBlobStorage } from '../blob/blob-storage-factory.js';
 import { EnvironmentContextBuilder } from '../environment/environment-context-builder.js';
 import { SessionEventBus } from '../events/event-emitter.js';
@@ -139,7 +140,22 @@ export async function createCipherAgentServices(config, agentEventBus) {
     // Priority 16 — right after context tree structure, before memories
     const mapSelectionContributor = new MapSelectionContributor('mapSelection', 16);
     systemPromptManager.registerContributor(mapSelectionContributor);
-    // 6b. Swarm coordinator — try to load config and build providers.
+    // 6b. Storage layer — initialised before the swarm block so the swarm
+    // SearchKnowledgeService receives `runtimeSignalStore` at construction
+    // time. Post-commit-5 the markdown fallback is gone, so a swarm search
+    // without the sidecar would silently drop every access-hit bump.
+    const keyStorage = new FileKeyStorage({
+        storageDir: storageBasePath,
+    });
+    await keyStorage.initialize();
+    const messageStorage = new MessageStorageService(keyStorage);
+    const messageStorageService = messageStorage;
+    const historyStorage = new GranularHistoryStorage(messageStorage);
+    // Sidecar store for per-machine ranking signals (importance, recency,
+    // maturity, accessCount, updateCount). Kept out of the context-tree
+    // markdown so query-time bumps don't dirty version-controlled files.
+    const runtimeSignalStore = new RuntimeSignalStore(keyStorage, logger);
+    // 6c. Swarm coordinator — try to load config and build providers.
     // Missing config → fail-open (no swarm). Invalid config → warn but continue.
     let swarmCoordinator;
     try {
@@ -158,7 +174,11 @@ export async function createCipherAgentServices(config, agentEventBus) {
             logger.warn(`Swarm provider issue: ${error.provider}: ${error.message}`);
         }
         const swarmProviders = buildProvidersFromConfig(swarmConfig, {
-            searchService: createSearchKnowledgeService(fileSystemService),
+            searchService: createSearchKnowledgeService(fileSystemService, {
+                baseDirectory: workingDirectory,
+                logger,
+                runtimeSignalStore,
+            }),
         });
         if (swarmProviders.length > 0) {
             swarmCoordinator = new SwarmCoordinator(swarmProviders, swarmConfig);
@@ -182,7 +202,7 @@ export async function createCipherAgentServices(config, agentEventBus) {
     }
     // 7. Abstract generation queue (generator injected later via rebindCurateTools)
     const abstractQueue = new AbstractGenerationQueue(workingDirectory);
-    // 8. Tool provider (depends on FileSystemService, ProcessService, MemoryManager, SystemPromptManager)
+    // 9. Tool provider (depends on FileSystemService, ProcessService, MemoryManager, SystemPromptManager)
     const verbose = config.llm.verbose ?? false;
     const descriptionLoader = new ToolDescriptionLoader();
     const toolProvider = new ToolProvider({
@@ -192,28 +212,21 @@ export async function createCipherAgentServices(config, agentEventBus) {
         getToolProvider: () => toolProvider,
         memoryManager,
         processService,
+        runtimeSignalStore,
         sandboxService,
         swarmCoordinator,
     }, systemPromptManager, descriptionLoader);
     await toolProvider.initialize();
-    // 9. Policy engine with default rules for autonomous execution
+    // 10. Policy engine with default rules for autonomous execution
     const policyEngine = new PolicyEngine({ defaultDecision: 'ALLOW' });
     policyEngine.addRules(DEFAULT_POLICY_RULES);
-    // 10. Tool scheduler (orchestrates policy check → execution)
+    // 11. Tool scheduler (orchestrates policy check → execution)
     const toolScheduler = new CoreToolScheduler(toolProvider, policyEngine, undefined, {
         verbose,
     });
-    // 11. Tool manager (with scheduler for policy-based execution)
+    // 12. Tool manager (with scheduler for policy-based execution)
     const toolManager = new ToolManager(toolProvider, toolScheduler);
     await toolManager.initialize();
-    // 11. History storage - granular file-based storage
-    const keyStorage = new FileKeyStorage({
-        storageDir: storageBasePath,
-    });
-    await keyStorage.initialize();
-    const messageStorage = new MessageStorageService(keyStorage);
-    const messageStorageService = messageStorage;
-    const historyStorage = new GranularHistoryStorage(messageStorage);
     // CompactionService for context overflow management
     const tokenizer = new GeminiTokenizer(config.model ?? 'gemini-3-flash-preview');
     const compactionService = new CompactionService(messageStorage, tokenizer, {
@@ -239,6 +252,7 @@ export async function createCipherAgentServices(config, agentEventBus) {
         messageStorageService,
         policyEngine,
         processService,
+        runtimeSignalStore,
         sandboxService,
         systemPromptManager,
         toolManager,

package/dist/agent/infra/sandbox/curate-service.d.ts

@@ -2,6 +2,7 @@
  * Curate service implementation for sandbox integration.
  * Wraps the curate-tool logic for use in the sandbox's tools.* SDK.
  */
+import type { IRuntimeSignalStore } from '../../../server/core/interfaces/storage/i-runtime-signal-store.js';
 import type { CurateOperation, CurateOptions, CurateResult, DetectDomainsInput, DetectDomainsResult, ICurateService } from '../../core/interfaces/i-curate-service.js';
 import type { AbstractGenerationQueue } from '../map/abstract-queue.js';
 /**
@@ -10,8 +11,9 @@ import type { AbstractGenerationQueue } from '../map/abstract-queue.js';
  */
 export declare class CurateService implements ICurateService {
     private readonly abstractQueue?;
+    private readonly runtimeSignalStore?;
     private readonly workingDirectory;
-    constructor(workingDirectory?: string, abstractQueue?: AbstractGenerationQueue | undefined);
+    constructor(workingDirectory?: string, abstractQueue?: AbstractGenerationQueue | undefined, runtimeSignalStore?: IRuntimeSignalStore | undefined);
     /**
      * Execute curate operations on knowledge topics.
      *
@@ -35,4 +37,4 @@ export declare class CurateService implements ICurateService {
  * @param workingDirectory - Working directory for resolving relative paths
  * @returns CurateService instance
  */
-export declare function createCurateService(workingDirectory?: string, abstractQueue?: AbstractGenerationQueue): ICurateService;
+export declare function createCurateService(workingDirectory?: string, abstractQueue?: AbstractGenerationQueue, runtimeSignalStore?: IRuntimeSignalStore): ICurateService;

package/dist/agent/infra/sandbox/curate-service.js

@@ -74,9 +74,11 @@ function validateOperations(operations) {
  */
 export class CurateService {
     abstractQueue;
+    runtimeSignalStore;
     workingDirectory;
-    constructor(workingDirectory, abstractQueue) {
+    constructor(workingDirectory, abstractQueue, runtimeSignalStore) {
         this.abstractQueue = abstractQueue;
+        this.runtimeSignalStore = runtimeSignalStore;
         this.workingDirectory = workingDirectory ?? process.cwd();
     }
     /**
@@ -120,7 +122,7 @@ export class CurateService {
             };
         }
         // Call the underlying executeCurate function from curate-tool
-        const result = await executeCurate({ basePath, operations }, undefined, this.abstractQueue);
+        const result = await executeCurate({ basePath, operations }, undefined, this.abstractQueue, this.runtimeSignalStore);
         return result;
     }
     /**
@@ -159,6 +161,6 @@ export class CurateService {
  * @param workingDirectory - Working directory for resolving relative paths
  * @returns CurateService instance
  */
-export function createCurateService(workingDirectory, abstractQueue) {
-    return new CurateService(workingDirectory, abstractQueue);
+export function createCurateService(workingDirectory, abstractQueue, runtimeSignalStore) {
+    return new CurateService(workingDirectory, abstractQueue, runtimeSignalStore);
 }

package/dist/agent/infra/tools/implementations/curate-tool.d.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
+import type { IRuntimeSignalStore } from '../../../../server/core/interfaces/storage/i-runtime-signal-store.js';
 import type { Tool, ToolExecutionContext } from '../../../core/domain/tools/types.js';
+import type { ILogger } from '../../../core/interfaces/i-logger.js';
 import type { AbstractGenerationQueue } from '../../map/abstract-queue.js';
 /**
  * Operation types for curating knowledge topics.
@@ -574,6 +576,6 @@ export interface CurateOutput {
  * Execute curate operations on knowledge topics.
  * Exported for use by CurateService in sandbox.
  */
-export declare function executeCurate(input: unknown, _context?: ToolExecutionContext, abstractQueue?: AbstractGenerationQueue): Promise<CurateOutput>;
-export declare function createCurateTool(workingDirectory?: string, abstractQueue?: AbstractGenerationQueue): Tool;
+export declare function executeCurate(input: unknown, _context?: ToolExecutionContext, abstractQueue?: AbstractGenerationQueue, runtimeSignalStore?: IRuntimeSignalStore, logger?: ILogger): Promise<CurateOutput>;
+export declare function createCurateTool(workingDirectory?: string, abstractQueue?: AbstractGenerationQueue, runtimeSignalStore?: IRuntimeSignalStore, logger?: ILogger): Tool;
 export {};

package/dist/agent/infra/tools/implementations/curate-tool.js

@@ -2,12 +2,90 @@ import { basename, dirname, join, relative, resolve } from 'node:path';
 import { z } from 'zod';
 import { REVIEW_BACKUPS_DIR } from '../../../../server/constants.js';
 import { DirectoryManager } from '../../../../server/core/domain/knowledge/directory-manager.js';
-import { MarkdownWriter, parseFrontmatterScoring } from '../../../../server/core/domain/knowledge/markdown-writer.js';
-import { applyDefaultScoring, determineTier, recordCurateUpdate, } from '../../../../server/core/domain/knowledge/memory-scoring.js';
+import { MarkdownWriter, parseCreatedAt } from '../../../../server/core/domain/knowledge/markdown-writer.js';
+import { determineTier, mergeScoring, recordCurateUpdate, } from '../../../../server/core/domain/knowledge/memory-scoring.js';
+import { createDefaultRuntimeSignals, } from '../../../../server/core/domain/knowledge/runtime-signals-schema.js';
+import { warnSidecarFailure } from '../../../../server/core/domain/knowledge/sidecar-logging.js';
 import { toSnakeCase } from '../../../../server/utils/file-helpers.js';
 import { deriveImpactFromLoss, detectStructuralLoss } from '../../../core/domain/knowledge/conflict-detector.js';
 import { resolveStructuralLoss } from '../../../core/domain/knowledge/conflict-resolver.js';
 import { ToolName } from '../../../core/domain/tools/constants.js';
+/**
+ * Derive the sidecar relPath (forward-slash, relative to the context tree
+ * root) from an absolute context-file path and the operation basePath.
+ */
+function relPathFromContextPath(contextPath, basePath) {
+    return relative(basePath, contextPath).split('\\').join('/');
+}
+/**
+ * Preserve the original `createdAt` from the existing markdown frontmatter on
+ * UPDATE. `createdAt` is immutable content metadata, not a runtime signal, so
+ * it stays in the markdown source-of-truth. Falls back to a fresh timestamp
+ * when the existing file has no `createdAt` (old files or those that never
+ * had it).
+ */
+function existingCreatedAt(existingContent) {
+    if (!existingContent)
+        return new Date().toISOString();
+    return parseCreatedAt(existingContent) ?? new Date().toISOString();
+}
+const CURATE_SITE = 'curate-tool';
+/**
+ * Seed the sidecar with default signals for a newly-added file.
+ * Best-effort: sidecar write failures never break the markdown operation.
+ */
+async function seedSidecarDefaults(store, relPath, logger) {
+    if (!store)
+        return;
+    try {
+        await store.set(relPath, createDefaultRuntimeSignals());
+    }
+    catch (error) {
+        warnSidecarFailure(logger, CURATE_SITE, 'seed', relPath, error);
+    }
+}
+/**
+ * Mirror a curate UPDATE into the sidecar.
+ *
+ * Applies `recordCurateUpdate`-equivalent bumps (importance +5, recency=1,
+ * updateCount+1) and recomputes `maturity` via `determineTier` inside the
+ * atomic updater so same-path contention does not lose writes.
+ * `updatedAt` is intentionally NOT mirrored — it is a content timestamp
+ * that stays in markdown frontmatter.
+ */
+async function mirrorCurateUpdate(store, relPath, logger) {
+    if (!store)
+        return;
+    try {
+        await store.update(relPath, (current) => {
+            const bumped = recordCurateUpdate(current);
+            return {
+                ...current,
+                importance: bumped.importance,
+                maturity: determineTier(bumped.importance, current.maturity),
+                recency: bumped.recency,
+                updateCount: bumped.updateCount,
+            };
+        });
+    }
+    catch (error) {
+        warnSidecarFailure(logger, CURATE_SITE, 'update', relPath, error);
+    }
+}
+/**
+ * Remove a path's sidecar entry after its markdown file was deleted or moved
+ * (DELETE, MERGE source, archive). Best-effort.
+ */
+async function dropSidecar(store, relPath, logger) {
+    if (!store)
+        return;
+    try {
+        await store.delete(relPath);
+    }
+    catch (error) {
+        warnSidecarFailure(logger, CURATE_SITE, 'drop', relPath, error);
+    }
+}
 /**
  * Operation types for curating knowledge topics.
  * Inspired by ACE Curator patterns.
@@ -453,7 +531,7 @@ function buildFullPath(basePath, knowledgePath) {
 /**
  * Execute ADD operation - create new domain/topic/subtopic with {title}.md
  */
-async function executeAdd(basePath, operation, onAfterWrite) {
+async function executeAdd(basePath, operation, onAfterWrite, runtimeSignalStore, logger) {
     const { confidence, content, domainContext, impact, path, reason, subtopicContext, summary, title, topicContext } = operation;
     const reviewMeta = deriveReviewMetadata('ADD', confidence, impact);
     if (!title) {
@@ -513,15 +591,18 @@ async function executeAdd(basePath, operation, onAfterWrite) {
             rawConcept: filteredContent.rawConcept,
             reason,
             relations: filteredContent.relations,
-            scoring: applyDefaultScoring(),
             snippets: filteredContent.snippets ?? [],
             summary,
             tags: filteredContent.tags,
+            timestamps: { createdAt: new Date().toISOString(), updatedAt: new Date().toISOString() },
         });
         const filename = `${toSnakeCase(title)}.md`;
         const contextPath = join(finalPath, filename);
         await DirectoryManager.writeFileAtomic(contextPath, contextContent);
         onAfterWrite?.(contextPath, contextContent);
+        // Dual-write: seed the sidecar with default signals for the new file.
+        // Mirrors the default scoring applied to markdown frontmatter above.
+        await seedSidecarDefaults(runtimeSignalStore, relPathFromContextPath(contextPath, basePath), logger);
         await ensureContextMd(basePath, parsed, topicContext, subtopicContext, onAfterWrite);
         return {
             ...reviewMeta,
@@ -555,7 +636,7 @@ function maxImpact(a, b) {
 /**
  * Execute UPDATE operation - modify existing {title}.md
  */
-async function executeUpdate(basePath, operation, onAfterWrite) {
+async function executeUpdate(basePath, operation, onAfterWrite, runtimeSignalStore, logger) {
     const { confidence, content, domainContext, impact, path, reason, subtopicContext, summary, title, topicContext } = operation;
     // Used for early-exit validation failures (before structural loss can be assessed)
     const baseReviewMeta = deriveReviewMetadata('UPDATE', confidence, impact);
@@ -606,12 +687,15 @@ async function executeUpdate(basePath, operation, onAfterWrite) {
             };
         }
         await createDomainContextIfMissing(basePath, parsed.domain, domainContext, onAfterWrite);
-        // Read existing file to preserve scoring metadata and detect structural loss
+        // Read existing file to detect structural loss
         const existingContent = await DirectoryManager.readFile(contextPath);
-        const existingScoring = existingContent ? parseFrontmatterScoring(existingContent) : undefined;
-        const updatedScoring = existingScoring ? recordCurateUpdate(existingScoring) : applyDefaultScoring();
-        const newTier = determineTier(updatedScoring.importance ?? 50, (updatedScoring.maturity ?? 'draft'));
-        const finalScoring = { ...updatedScoring, maturity: newTier };
+        // Markdown only carries content timestamps post-commit-5. The sidecar
+        // handles all scoring (importance / recency / maturity / counts) via
+        // `mirrorCurateUpdate` below, inside an atomic read-modify-write.
+        const timestamps = {
+            createdAt: existingCreatedAt(existingContent),
+            updatedAt: new Date().toISOString(),
+        };
         // Filter out non-existent files from rawConcept.files
         const filteredContent = await filterValidFiles(content);
         // Extract previous summary from existing file's frontmatter (for review UI)
@@ -640,12 +724,16 @@ async function executeUpdate(basePath, operation, onAfterWrite) {
         const contextContent = MarkdownWriter.generateContext({
             ...resolvedContextData,
             reason,
-            scoring: finalScoring,
             summary,
+            timestamps,
         });
         await backupBeforeWrite(contextPath, basePath);
         await DirectoryManager.writeFileAtomic(contextPath, contextContent);
         onAfterWrite?.(contextPath, contextContent);
+        // Dual-write: mirror the curate-update bumps (importance +5, recency=1,
+        // updateCount+1, maturity retiered) into the sidecar. `updatedAt` stays
+        // in markdown only — it is a content timestamp, not a runtime signal.
+        await mirrorCurateUpdate(runtimeSignalStore, relPathFromContextPath(contextPath, basePath), logger);
         await ensureContextMd(basePath, parsed, topicContext, subtopicContext, onAfterWrite);
         return {
             ...reviewMeta,
@@ -674,7 +762,7 @@ async function executeUpdate(basePath, operation, onAfterWrite) {
  * Execute UPSERT operation - automatically creates or updates based on file existence
  * This is the recommended operation type as it eliminates the need for pre-checks.
  */
-async function executeUpsert(basePath, operation, onAfterWrite) {
+async function executeUpsert(basePath, operation, onAfterWrite, runtimeSignalStore, logger) {
     const { path, reason, title } = operation;
     const reviewMeta = deriveReviewMetadata('UPSERT', operation.confidence, operation.impact);
     if (!title) {
@@ -716,7 +804,7 @@ async function executeUpsert(basePath, operation, onAfterWrite) {
         const exists = await DirectoryManager.fileExists(contextPath);
         if (exists) {
             // File exists - delegate to UPDATE logic
-            const result = await executeUpdate(basePath, { ...operation, type: 'UPDATE' }, onAfterWrite);
+            const result = await executeUpdate(basePath, { ...operation, type: 'UPDATE' }, onAfterWrite, runtimeSignalStore, logger);
             // Return with UPSERT type but indicate it was an update
             return {
                 ...result,
@@ -725,7 +813,7 @@ async function executeUpsert(basePath, operation, onAfterWrite) {
             };
         }
         // File doesn't exist - delegate to ADD logic
-        const result = await executeAdd(basePath, { ...operation, type: 'ADD' }, onAfterWrite);
+        const result = await executeAdd(basePath, { ...operation, type: 'ADD' }, onAfterWrite, runtimeSignalStore, logger);
         // Return with UPSERT type but indicate it was an add
         return {
             ...result,
@@ -747,7 +835,7 @@ async function executeUpsert(basePath, operation, onAfterWrite) {
 /**
  * Execute MERGE operation - combine source file into target file, delete source file
  */
-async function executeMerge(basePath, operation, onAfterWrite) {
+async function executeMerge(basePath, operation, onAfterWrite, runtimeSignalStore, logger) {
     const { confidence, domainContext, impact, mergeTarget, mergeTargetTitle, path, reason, subtopicContext, summary, title, topicContext, } = operation;
     const reviewMeta = deriveReviewMetadata('MERGE', confidence, impact);
     if (!title) {
@@ -831,11 +919,58 @@ async function executeMerge(basePath, operation, onAfterWrite) {
         // Backup both files before merge modifies target and deletes source
         await backupBeforeWrite(targetContextPath, basePath);
         await backupBeforeWrite(sourceContextPath, basePath);
+        // Capture source sidecar signals BEFORE any destructive operation so a
+        // mid-flow crash cannot leave the target unmerged with an orphaned
+        // source entry. The sidecar merge happens after the markdown writes
+        // succeed, using the captured snapshot.
+        const sourceRelPath = relPathFromContextPath(sourceContextPath, basePath);
+        const targetRelPath = relPathFromContextPath(targetContextPath, basePath);
+        const sourceSignalsSnapshot = runtimeSignalStore
+            ? await runtimeSignalStore.get(sourceRelPath)
+            : null;
         const mergedContent = MarkdownWriter.mergeContexts(sourceContent, targetContent, reason, summary);
         await DirectoryManager.writeFileAtomic(targetContextPath, mergedContent);
         onAfterWrite?.(targetContextPath, mergedContent);
         await DirectoryManager.deleteFile(sourceContextPath);
         await deleteDerivedSiblings(sourceContextPath);
+        // Dual-write: merge sidecar signals using `mergeScoring` (the canonical
+        // merge policy). Runs inside `update`'s atomic callback so a concurrent
+        // access-hit flush on the target cannot lose bumps.
+        //
+        // The target-update and source-delete are wrapped in separate try/catch
+        // blocks so an operator can tell which half failed. If update succeeds
+        // but delete throws the source sidecar entry becomes an orphan (source
+        // markdown is already gone, nothing will ever overwrite it). Tracked by
+        // pruneOrphans in the backlog.
+        if (runtimeSignalStore && sourceSignalsSnapshot) {
+            let targetUpdated = false;
+            try {
+                await runtimeSignalStore.update(targetRelPath, (current) => {
+                    const merged = mergeScoring(sourceSignalsSnapshot, current);
+                    return {
+                        accessCount: merged.accessCount,
+                        importance: merged.importance,
+                        maturity: determineTier(merged.importance, merged.maturity),
+                        recency: merged.recency,
+                        updateCount: merged.updateCount,
+                    };
+                });
+                targetUpdated = true;
+            }
+            catch (error) {
+                // Best-effort — markdown merge already succeeded.
+                warnSidecarFailure(logger, CURATE_SITE, 'merge-update', `${sourceRelPath} -> ${targetRelPath}`, error);
+            }
+            if (targetUpdated) {
+                try {
+                    await runtimeSignalStore.delete(sourceRelPath);
+                }
+                catch (error) {
+                    // Source sidecar is now a permanent orphan until pruneOrphans runs.
+                    warnSidecarFailure(logger, CURATE_SITE, 'merge-delete', sourceRelPath, error);
+                }
+            }
+        }
         await ensureContextMd(basePath, sourceParsed, topicContext, subtopicContext, onAfterWrite);
         await ensureContextMd(basePath, targetParsed, topicContext, subtopicContext, onAfterWrite);
         return {
@@ -866,7 +1001,7 @@ async function executeMerge(basePath, operation, onAfterWrite) {
  * Execute DELETE operation - remove specific file or entire folder
  * If title is provided, deletes specific file; if omitted, deletes entire folder
  */
-async function executeDelete(basePath, operation) {
+async function executeDelete(basePath, operation, runtimeSignalStore, logger) {
     const { path, reason, title } = operation;
     const reviewMeta = deriveReviewMetadata('DELETE', operation.confidence, operation.impact);
     try {
@@ -900,6 +1035,9 @@ async function executeDelete(basePath, operation) {
             await backupBeforeWrite(filePath, basePath);
             await DirectoryManager.deleteFile(filePath);
             await deleteDerivedSiblings(filePath);
+            // Dual-write: drop the deleted file's sidecar entry so it does not
+            // become an orphan.
+            await dropSidecar(runtimeSignalStore, relPathFromContextPath(filePath, basePath), logger);
             return {
                 ...reviewMeta,
                 filePath,
@@ -947,6 +1085,12 @@ async function executeDelete(basePath, operation) {
         }
         await Promise.all(mdFiles.map((f) => backupBeforeWrite(f, basePath)));
         await DirectoryManager.deleteTopicRecursive(fullPath);
+        // Dual-write: drop sidecar entries for every markdown file that was
+        // deleted. Without this, folder deletes leak orphan signal entries.
+        // Best-effort — the markdown delete has already succeeded.
+        if (runtimeSignalStore) {
+            await Promise.all(mdFiles.map((f) => dropSidecar(runtimeSignalStore, relPathFromContextPath(f, basePath), logger)));
+        }
         return {
             ...reviewMeta,
             additionalFilePaths: mdFiles,
@@ -974,7 +1118,7 @@ async function executeDelete(basePath, operation) {
  * Execute curate operations on knowledge topics.
  * Exported for use by CurateService in sandbox.
  */
-export async function executeCurate(input, _context, abstractQueue) {
+export async function executeCurate(input, _context, abstractQueue, runtimeSignalStore, logger) {
     const parseResult = CurateInputSchema.safeParse(input);
     if (!parseResult.success) {
         return {
@@ -1016,31 +1160,31 @@ export async function executeCurate(input, _context, abstractQueue) {
         let result;
         switch (operation.type) {
             case 'ADD': {
-                result = await executeAdd(basePath, operation, onAfterWrite);
+                result = await executeAdd(basePath, operation, onAfterWrite, runtimeSignalStore, logger);
                 if (result.status === 'success')
                     summary.added++;
                 break;
             }
             case 'DELETE': {
-                result = await executeDelete(basePath, operation);
+                result = await executeDelete(basePath, operation, runtimeSignalStore, logger);
                 if (result.status === 'success')
                     summary.deleted++;
                 break;
             }
             case 'MERGE': {
-                result = await executeMerge(basePath, operation, onAfterWrite);
+                result = await executeMerge(basePath, operation, onAfterWrite, runtimeSignalStore, logger);
                 if (result.status === 'success')
                     summary.merged++;
                 break;
             }
             case 'UPDATE': {
-                result = await executeUpdate(basePath, operation, onAfterWrite);
+                result = await executeUpdate(basePath, operation, onAfterWrite, runtimeSignalStore, logger);
                 if (result.status === 'success')
                     summary.updated++;
                 break;
             }
             case 'UPSERT': {
-                result = await executeUpsert(basePath, operation, onAfterWrite);
+                result = await executeUpsert(basePath, operation, onAfterWrite, runtimeSignalStore, logger);
                 // UPSERT counts as either added or updated based on what happened
                 if (result.status === 'success') {
                     if (result.message?.includes('created new')) {
@@ -1075,7 +1219,7 @@ export async function executeCurate(input, _context, abstractQueue) {
     /* eslint-enable no-await-in-loop */
     return { applied, summary };
 }
-export function createCurateTool(workingDirectory, abstractQueue) {
+export function createCurateTool(workingDirectory, abstractQueue, runtimeSignalStore, logger) {
     return {
         description: `Curate knowledge topics with atomic operations. This tool manages the knowledge structure using four operation types and supports a two-part context model: Raw Concept + Narrative.
 
@@ -1275,10 +1419,10 @@ export function createCurateTool(workingDirectory, abstractQueue) {
                 const parseResult = CurateInputSchema.safeParse(input);
                 if (parseResult.success) {
                     parseResult.data.basePath = resolve(workingDirectory, parseResult.data.basePath);
-                    return executeCurate(parseResult.data, context, abstractQueue);
+                    return executeCurate(parseResult.data, context, abstractQueue, runtimeSignalStore, logger);
                 }
             }
-            return executeCurate(input, context, abstractQueue);
+            return executeCurate(input, context, abstractQueue, runtimeSignalStore, logger);
         },
         id: ToolName.CURATE,
         inputSchema: CurateInputSchema,

package/dist/agent/infra/tools/implementations/expand-knowledge-tool.d.ts

@@ -1,9 +1,11 @@
+import type { IRuntimeSignalStore } from '../../../../server/core/interfaces/storage/i-runtime-signal-store.js';
 import type { Tool } from '../../../core/domain/tools/types.js';
 /**
  * Configuration for expand knowledge tool.
  */
 export interface ExpandKnowledgeToolConfig {
     baseDirectory?: string;
+    runtimeSignalStore?: IRuntimeSignalStore;
 }
 /**
  * Creates the expand knowledge tool.

package/dist/agent/infra/tools/implementations/expand-knowledge-tool.js

@@ -36,7 +36,7 @@ const ExpandKnowledgeInputSchema = z
  * @returns Configured expand knowledge tool
  */
 export function createExpandKnowledgeTool(config = {}) {
-    const archiveService = new FileContextTreeArchiveService();
+    const archiveService = new FileContextTreeArchiveService(config.runtimeSignalStore);
     return {
         description: 'Retrieve full content from archived knowledge entries or L1 overview files. ' +
             'Use stubPath when search results include an archive_stub that you need to drill into. ' +

package/dist/agent/infra/tools/implementations/memory-symbol-tree.d.ts

@@ -1,4 +1,3 @@
-import type { FrontmatterScoring } from '../../../../server/core/domain/knowledge/markdown-writer.js';
 /**
  * Symbol kinds in the memory hierarchy, ordered by depth.
  * Mirrors Serena's SymbolKind pattern for code symbols.
@@ -48,12 +47,6 @@ export interface SummaryDocLike {
     excerpt?: string;
     /** Path to the _index.md file, e.g. "domain/topic/_index.md" */
     path: string;
-    /** Frontmatter scoring parsed from _index.md — used to apply hotness/importance to propagated hits */
-    scoring?: {
-        importance?: number;
-        maturity?: string;
-        recency?: number;
-    };
     tokenCount: number;
 }
 /**
@@ -97,7 +90,6 @@ interface DocumentLike {
     content: string;
     id: string;
     path: string;
-    scoring: FrontmatterScoring;
     title: string;
 }
 /**

package/dist/agent/infra/tools/implementations/memory-symbol-tree.js

@@ -46,14 +46,6 @@ function determineKind(segments) {
         }
     }
 }
-function extractMetadataFromScoring(scoring) {
-    return {
-        importance: scoring.importance ?? 50,
-        keywords: [],
-        maturity: scoring.maturity ?? 'draft',
-        tags: [],
-    };
-}
 /**
  * Get or create a folder symbol (Domain/Topic/Subtopic) at the given path.
  * Creates intermediate nodes as needed.
@@ -133,12 +125,8 @@ export function buildSymbolTree(documentMap, summaryMap) {
         const segments = doc.path.split('/');
         const folderPath = segments.slice(0, -1).join('/');
         const folderNode = symbolMap.get(folderPath);
-        if (folderNode) {
-            folderNode.metadata = {
-                ...folderNode.metadata,
-                ...extractMetadataFromScoring(doc.scoring),
-            };
-        }
+        // Post-commit-5: ranking signals (importance, maturity) are read from the
+        // sidecar at query time; the symbol tree only carries structural metadata.
         // Also register the context.md path itself for direct lookups
         symbolMap.set(doc.path, folderNode ?? getOrCreateFolderNode(symbolMap, root, folderPath, segments.slice(0, -1)));
     }
@@ -150,7 +138,7 @@ export function buildSymbolTree(documentMap, summaryMap) {
         const contextNode = {
             children: [],
             kind: MemorySymbolKind.Context,
-            metadata: extractMetadataFromScoring(doc.scoring),
+            metadata: { ...DEFAULT_METADATA },
             name: doc.title || segments.at(-1).replace(/\.md$/, ''),
             parent: parentNode,
             path: doc.path,