byterover-cli 3.6.1 → 3.7.1

package/dist/server/constants.js

@@ -95,13 +95,32 @@ export const OVERVIEW_EXTENSION = '.overview.md';
 export const MANIFEST_FILE = '_manifest.json';
 export const ARCHIVE_IMPORTANCE_THRESHOLD = 35;
 export const DEFAULT_GHOST_CUE_MAX_TOKENS = 220;
-/** Patterns the context-tree .gitignore must contain (derived artifacts only). */
+/** Patterns the context-tree .gitignore must contain. */
 export const CONTEXT_TREE_GITIGNORE_PATTERNS = [
+    // Derived artifacts
     '.gitignore',
     '.snapshot.json',
     '_manifest.json',
     '_index.md',
     '*.abstract.md',
     '*.overview.md',
+    // macOS
+    '.DS_Store',
+    '._*',
+    // Windows
+    'Thumbs.db',
+    'ehthumbs.db',
+    'Desktop.ini',
+    // Linux
+    '.directory',
+    '.fuse_hidden*',
+    '.nfs*',
+    // Editor swap / backup / temp
+    '*.swp',
+    '*.swo',
+    '*~',
+    '.#*',
+    '*.bak',
+    '*.tmp',
 ];
 export const CONTEXT_TREE_GITIGNORE_HEADER = '# Derived artifacts — do not track';

package/dist/server/core/domain/knowledge/markdown-writer.d.ts

@@ -30,16 +30,14 @@ export interface Fact {
     value?: string;
 }
 /**
- * Scoring metadata for knowledge lifecycle management (FinMem-inspired).
- * Stored in YAML frontmatter alongside existing fields.
+ * Content timestamps kept in markdown frontmatter. `createdAt` is the
+ * immutable creation time; `updatedAt` reflects the last content
+ * modification. Runtime ranking signals (importance, recency, maturity,
+ * accessCount, updateCount) live in the sidecar — see
+ * `features/runtime-signals/plan.md`.
  */
-export interface FrontmatterScoring {
-    accessCount?: number;
+export interface ContextTimestamps {
     createdAt?: string;
-    importance?: number;
-    maturity?: 'core' | 'draft' | 'validated';
-    recency?: number;
-    updateCount?: number;
     updatedAt?: string;
 }
 export interface ContextData {
@@ -50,48 +48,20 @@ export interface ContextData {
     rawConcept?: RawConcept;
     reason?: string;
     relations?: string[];
-    scoring?: FrontmatterScoring;
     snippets: string[];
     summary?: string;
     tags: string[];
+    timestamps?: ContextTimestamps;
 }
-interface Frontmatter {
-    accessCount?: number;
-    createdAt?: string;
-    importance?: number;
-    keywords: string[];
-    maturity?: 'core' | 'draft' | 'validated';
-    recency?: number;
-    related: string[];
-    summary?: string;
-    tags: string[];
-    title?: string;
-    updateCount?: number;
-    updatedAt?: string;
-}
-/**
- * Parse content extracting relations from either frontmatter or legacy @ format.
- * Returns parsed frontmatter metadata and the body content for further parsing.
- */
-/**
- * Extract scoring metadata from parsed frontmatter.
- * Returns defaults for missing fields.
- */
-export declare function extractScoring(fm: Frontmatter): FrontmatterScoring;
-/**
- * Parse frontmatter from raw markdown content and return scoring metadata.
- * Exported for use by search-knowledge-service to extract scoring without
- * going through the full parseContent path.
- */
-export declare function parseFrontmatterScoring(content: string): FrontmatterScoring | undefined;
 /**
- * Replace scoring fields in existing markdown content without touching the body.
- * If no frontmatter exists, returns the original content unchanged.
+ * Extract the createdAt timestamp from a raw markdown file's frontmatter.
+ * Used by callers (e.g. curate UPDATE) that need to preserve the immutable
+ * creation time across a write without round-tripping through the full
+ * parsed-content shape.
  */
-export declare function updateScoringInContent(content: string, scoring: FrontmatterScoring): string;
+export declare function parseCreatedAt(content: string): string | undefined;
 export declare const MarkdownWriter: {
     generateContext(data: ContextData): string;
     mergeContexts(sourceContent: string, targetContent: string, reason?: string, summary?: string): string;
     parseContent(content: string, name?: string): ContextData;
 };
-export {};

package/dist/server/core/domain/knowledge/markdown-writer.js

@@ -1,11 +1,14 @@
 import { dump as yamlDump, load as yamlLoad } from 'js-yaml';
-import { determineTier, mergeScoring as mergeScoringFn } from './memory-scoring.js';
 import { normalizeRelationPath, parseRelations } from './relation-parser.js';
 /**
  * Generate YAML frontmatter block from context data.
- * Only includes fields that have values.
+ *
+ * Emits only semantic fields and content timestamps. Runtime ranking
+ * signals (importance, recency, maturity, accessCount, updateCount) are
+ * not written — they live in the sidecar store since commit 5 of the
+ * runtime-signals migration.
  */
-function generateFrontmatter(title, relations, tags = [], keywords = [], scoring, summary) {
+function generateFrontmatter(title, relations, tags = [], keywords = [], timestamps, summary) {
     const normalizedRelations = (relations || []).map(rel => normalizeRelationPath(rel));
     const fm = {};
     if (title) {
@@ -19,29 +22,11 @@ function generateFrontmatter(title, relations, tags = [], keywords = [], scoring
         fm.related = normalizedRelations;
     }
     fm.keywords = keywords;
-    // Scoring fields — only emit when present (backward compatible)
-    if (scoring) {
-        if (scoring.importance !== undefined) {
-            fm.importance = Math.round(scoring.importance * 100) / 100;
-        }
-        if (scoring.recency !== undefined) {
-            fm.recency = Math.round(scoring.recency * 1000) / 1000;
-        }
-        if (scoring.maturity) {
-            fm.maturity = scoring.maturity;
-        }
-        if (scoring.accessCount !== undefined && scoring.accessCount > 0) {
-            fm.accessCount = scoring.accessCount;
-        }
-        if (scoring.updateCount !== undefined && scoring.updateCount > 0) {
-            fm.updateCount = scoring.updateCount;
-        }
-        if (scoring.createdAt) {
-            fm.createdAt = scoring.createdAt;
-        }
-        if (scoring.updatedAt) {
-            fm.updatedAt = scoring.updatedAt;
-        }
+    if (timestamps?.createdAt) {
+        fm.createdAt = timestamps.createdAt;
+    }
+    if (timestamps?.updatedAt) {
+        fm.updatedAt = timestamps.updatedAt;
     }
     // Always generate frontmatter since tags and keywords are required
     const yamlContent = yamlDump(fm, { flowLevel: 1, lineWidth: -1, sortKeys: false }).trimEnd();
@@ -80,28 +65,17 @@ function parseFrontmatter(content) {
         if (typeof parsed.summary === 'string') {
             frontmatter.summary = parsed.summary;
         }
-        // Scoring fields (backward compatible — absent in old files)
-        if (typeof parsed.importance === 'number') {
-            frontmatter.importance = parsed.importance;
-        }
-        if (typeof parsed.recency === 'number') {
-            frontmatter.recency = parsed.recency;
-        }
-        if (typeof parsed.accessCount === 'number') {
-            frontmatter.accessCount = parsed.accessCount;
-        }
-        if (typeof parsed.updateCount === 'number') {
-            frontmatter.updateCount = parsed.updateCount;
-        }
+        // Content timestamps (createdAt is immutable, updatedAt tracks real
+        // content modification). Pre-migration files may also carry legacy
+        // scoring fields (importance, recency, maturity, accessCount,
+        // updateCount) — those are silently ignored here; the runtime signals
+        // they represented now live in the sidecar.
         if (typeof parsed.createdAt === 'string') {
             frontmatter.createdAt = parsed.createdAt;
         }
         if (typeof parsed.updatedAt === 'string') {
             frontmatter.updatedAt = parsed.updatedAt;
         }
-        if (parsed.maturity === 'draft' || parsed.maturity === 'validated' || parsed.maturity === 'core') {
-            frontmatter.maturity = parsed.maturity;
-        }
         return { body, frontmatter };
     }
     catch {
@@ -500,59 +474,29 @@ function mergeFacts(source, target) {
     return merged.length > 0 ? merged : undefined;
 }
 /**
- * Parse content extracting relations from either frontmatter or legacy @ format.
- * Returns parsed frontmatter metadata and the body content for further parsing.
- */
-/**
- * Extract scoring metadata from parsed frontmatter.
- * Returns defaults for missing fields.
- */
-export function extractScoring(fm) {
-    return {
-        accessCount: fm.accessCount ?? 0,
-        createdAt: fm.createdAt,
-        importance: fm.importance ?? 50,
-        maturity: fm.maturity ?? 'draft',
-        recency: fm.recency ?? 1,
-        updateCount: fm.updateCount ?? 0,
-        updatedAt: fm.updatedAt,
-    };
-}
-/**
- * Parse frontmatter from raw markdown content and return scoring metadata.
- * Exported for use by search-knowledge-service to extract scoring without
- * going through the full parseContent path.
- */
-export function parseFrontmatterScoring(content) {
-    const parsed = parseFrontmatter(content);
-    if (!parsed) {
-        return undefined;
-    }
-    return extractScoring(parsed.frontmatter);
-}
-/**
- * Replace scoring fields in existing markdown content without touching the body.
- * If no frontmatter exists, returns the original content unchanged.
+ * Extract the createdAt timestamp from a raw markdown file's frontmatter.
+ * Used by callers (e.g. curate UPDATE) that need to preserve the immutable
+ * creation time across a write without round-tripping through the full
+ * parsed-content shape.
  */
-export function updateScoringInContent(content, scoring) {
-    const parsed = parseFrontmatter(content);
-    if (!parsed) {
-        return content;
-    }
-    const { body, frontmatter } = parsed;
-    const updatedFrontmatter = generateFrontmatter(frontmatter.title ?? '', frontmatter.related, frontmatter.tags, frontmatter.keywords, scoring, frontmatter.summary);
-    return updatedFrontmatter + body;
+export function parseCreatedAt(content) {
+    return parseFrontmatter(content)?.frontmatter.createdAt;
 }
 function parseContentWithFrontmatter(content) {
     const parsed = parseFrontmatter(content);
     if (parsed) {
+        const timestamps = {};
+        if (parsed.frontmatter.createdAt)
+            timestamps.createdAt = parsed.frontmatter.createdAt;
+        if (parsed.frontmatter.updatedAt)
+            timestamps.updatedAt = parsed.frontmatter.updatedAt;
         return {
             body: parsed.body,
             keywords: parsed.frontmatter.keywords,
             relations: parsed.frontmatter.related,
-            scoring: extractScoring(parsed.frontmatter),
             summary: parsed.frontmatter.summary,
             tags: parsed.frontmatter.tags,
+            timestamps: Object.keys(timestamps).length > 0 ? timestamps : undefined,
             title: parsed.frontmatter.title,
         };
     }
@@ -568,7 +512,7 @@ export const MarkdownWriter = {
     generateContext(data) {
         const snippets = (data.snippets || []).filter(s => s && s.trim());
         const relations = data.relations || [];
-        const frontmatter = generateFrontmatter(data.name, relations, data.tags, data.keywords, data.scoring, data.summary);
+        const frontmatter = generateFrontmatter(data.name, relations, data.tags, data.keywords, data.timestamps, data.summary);
         const reasonSection = generateReasonSection(data.reason);
         const rawConceptSection = generateRawConceptSection(data.rawConcept);
         const narrativeSection = generateNarrativeSection(data.narrative);
@@ -602,14 +546,10 @@ export const MarkdownWriter = {
         const mergedKeywords = [...new Set([...sourceParsed.keywords, ...targetParsed.keywords])];
         // reason: explicit override wins, then source (newer), then target (older)
         const mergedReason = reason ?? parseReasonSection(sourceParsed.body) ?? parseReasonSection(targetParsed.body);
-        // Merge scoring metadata (FinMem-inspired lifecycle)
-        const defaultScoring = { importance: 50, maturity: 'draft', recency: 1 };
-        let mergedScoringData;
-        if (sourceParsed.scoring || targetParsed.scoring) {
-            const merged = mergeScoringFn(sourceParsed.scoring ?? defaultScoring, targetParsed.scoring ?? defaultScoring);
-            const recalculatedTier = determineTier(merged.importance ?? 50, (merged.maturity ?? 'draft'));
-            mergedScoringData = { ...merged, maturity: recalculatedTier };
-        }
+        // Merge timestamps: preserve the earliest createdAt and stamp a fresh
+        // updatedAt. Scoring signals (importance/recency/maturity/counts) are
+        // merged at the sidecar layer by the merge caller — not here.
+        const mergedTimestamps = mergeTimestamps(sourceParsed.timestamps, targetParsed.timestamps);
         const sourceRawConcept = parseRawConceptSection(sourceParsed.body);
         const targetRawConcept = parseRawConceptSection(targetParsed.body);
         const mergedRawConcept = mergeRawConcepts(sourceRawConcept, targetRawConcept);
@@ -637,14 +577,14 @@ export const MarkdownWriter = {
             rawConcept: mergedRawConcept,
             reason: mergedReason,
             relations: mergedRelations,
-            scoring: mergedScoringData,
             snippets: mergedSnippets,
             summary: summary ?? sourceParsed.summary ?? targetParsed.summary,
             tags: mergedTags,
+            timestamps: mergedTimestamps,
         });
     },
     parseContent(content, name = '') {
-        const { body, keywords, relations, scoring, summary, tags, title } = parseContentWithFrontmatter(content);
+        const { body, keywords, relations, summary, tags, timestamps, title } = parseContentWithFrontmatter(content);
         return {
             facts: parseFactsSection(body),
             keywords,
@@ -653,10 +593,29 @@ export const MarkdownWriter = {
             rawConcept: parseRawConceptSection(body),
             reason: parseReasonSection(body),
             relations,
-            scoring,
             snippets: extractSnippetsFromContent(body),
             summary,
             tags,
+            timestamps,
         };
     },
 };
+/**
+ * Merge two timestamp records: earliest createdAt, fresh updatedAt.
+ *
+ * Always stamps a fresh `updatedAt` — merge is a content modification, so
+ * the output always carries an updated timestamp regardless of input shape.
+ * `createdAt` only appears in the output when at least one input had it.
+ */
+function mergeTimestamps(a, b) {
+    const out = { updatedAt: new Date().toISOString() };
+    const aCreated = a?.createdAt;
+    const bCreated = b?.createdAt;
+    if (aCreated && bCreated) {
+        out.createdAt = new Date(aCreated).getTime() <= new Date(bCreated).getTime() ? aCreated : bCreated;
+    }
+    else if (aCreated ?? bCreated) {
+        out.createdAt = aCreated ?? bCreated;
+    }
+    return out;
+}

package/dist/server/core/domain/knowledge/memory-scoring.d.ts

@@ -9,7 +9,7 @@
  *
  * All functions are stateless and side-effect free.
  */
-import type { FrontmatterScoring } from './markdown-writer.js';
+import type { RuntimeSignals } from './runtime-signals-schema.js';
 /** Days for recency half-life (~21 days to halve) */
 export declare const DECAY_RECENCY_FACTOR = 30;
 /** Per-day importance multiplier (~78% after 50 days of non-use) */
@@ -41,23 +41,21 @@ export declare const TIER_BOOST: Record<string, number>;
  * then applies a tier-based boost.
  *
  * @param bm25Normalized - Normalized BM25 score in [0, 1)
- * @param importance - Importance score in [0, 100]
- * @param recency - Recency score in [0, 1]
- * @param maturity - Maturity tier ('draft' | 'validated' | 'core')
+ * @param signals - RuntimeSignals snapshot (importance, recency, maturity)
  * @returns Compound score (typically in [0, ~1.15])
  */
-export declare function compoundScore(bm25Normalized: number, importance: number, recency: number, maturity: string): number;
+export declare function compoundScore(bm25Normalized: number, signals: RuntimeSignals): number;
 /**
- * Apply time-based exponential decay to scoring fields.
+ * Apply time-based exponential decay to a signals snapshot.
  *
  * Recency decays as exp(-days / DECAY_RECENCY_FACTOR).
  * Importance decays as importance * DECAY_IMPORTANCE_FACTOR^days.
  *
- * @param scoring - Current scoring state
+ * @param signals - Current RuntimeSignals snapshot
  * @param daysSinceLastUpdate - Days since the file was last updated
- * @returns New scoring with decayed values (original not mutated)
+ * @returns New signals with decayed values (original not mutated)
  */
-export declare function applyDecay(scoring: FrontmatterScoring, daysSinceLastUpdate: number): FrontmatterScoring;
+export declare function applyDecay(signals: RuntimeSignals, daysSinceLastUpdate: number): RuntimeSignals;
 /**
  * Determine the maturity tier based on importance score.
  *
@@ -72,47 +70,30 @@ export declare function applyDecay(scoring: FrontmatterScoring, daysSinceLastUpd
  * @returns The determined tier
  */
 export declare function determineTier(importance: number, currentTier: 'core' | 'draft' | 'validated'): 'core' | 'draft' | 'validated';
-/**
- * Record a search access hit on a knowledge file.
- *
- * Increments access count and adds an importance bonus.
- *
- * @param scoring - Current scoring state
- * @returns Updated scoring (original not mutated)
- */
-export declare function recordAccessHit(scoring: FrontmatterScoring): FrontmatterScoring;
 /**
  * Record multiple accumulated access hits at once.
  *
- * @param scoring - Current scoring state
- * @param hitCount - Number of hits to record
- * @returns Updated scoring (original not mutated)
+ * Increments accessCount by `hitCount` and importance by
+ * `ACCESS_IMPORTANCE_BONUS * hitCount` (capped at 100). Caller is
+ * responsible for recomputing maturity via `determineTier` if the
+ * importance delta may cross a hysteresis threshold.
  */
-export declare function recordAccessHits(scoring: FrontmatterScoring, hitCount: number): FrontmatterScoring;
+export declare function recordAccessHits(signals: RuntimeSignals, hitCount: number): RuntimeSignals;
 /**
  * Record a curate update on a knowledge file.
  *
- * Increments update count, adds an importance bonus, resets recency to 1.0,
- * and updates the timestamp.
- *
- * @param scoring - Current scoring state
- * @returns Updated scoring (original not mutated)
- */
-export declare function recordCurateUpdate(scoring: FrontmatterScoring): FrontmatterScoring;
-/**
- * Return default scoring values for a new or unscored knowledge file.
+ * Increments updateCount, adds an importance bonus, resets recency to 1.0.
+ * Caller is responsible for recomputing maturity via `determineTier`.
  */
-export declare function applyDefaultScoring(): FrontmatterScoring;
+export declare function recordCurateUpdate(signals: RuntimeSignals): RuntimeSignals;
 /**
- * Merge two scoring states during a MERGE operation.
+ * Merge two runtime-signal snapshots during a MERGE operation.
  *
  * Strategy:
  * - importance: max of both
  * - recency: max of both
  * - accessCount: sum
  * - updateCount: sum + 1 (for the merge itself)
- * - maturity: higher tier
- * - createdAt: earlier date
- * - updatedAt: current time
+ * - maturity: higher tier (caller may refine via `determineTier`)
  */
-export declare function mergeScoring(source: FrontmatterScoring, target: FrontmatterScoring): FrontmatterScoring;
+export declare function mergeScoring(source: RuntimeSignals, target: RuntimeSignals): RuntimeSignals;

package/dist/server/core/domain/knowledge/memory-scoring.js

@@ -50,36 +50,33 @@ export const TIER_BOOST = {
  * then applies a tier-based boost.
  *
  * @param bm25Normalized - Normalized BM25 score in [0, 1)
- * @param importance - Importance score in [0, 100]
- * @param recency - Recency score in [0, 1]
- * @param maturity - Maturity tier ('draft' | 'validated' | 'core')
+ * @param signals - RuntimeSignals snapshot (importance, recency, maturity)
  * @returns Compound score (typically in [0, ~1.15])
  */
-export function compoundScore(bm25Normalized, importance, recency, maturity) {
-    const normalizedImportance = Math.min(importance, 100) / 100;
-    const base = W_RELEVANCE * bm25Normalized + W_IMPORTANCE * normalizedImportance + W_RECENCY * recency;
-    const boost = TIER_BOOST[maturity] ?? TIER_BOOST.draft;
+export function compoundScore(bm25Normalized, signals) {
+    const normalizedImportance = Math.min(signals.importance, 100) / 100;
+    const base = W_RELEVANCE * bm25Normalized + W_IMPORTANCE * normalizedImportance + W_RECENCY * signals.recency;
+    const boost = TIER_BOOST[signals.maturity] ?? TIER_BOOST.draft;
     return base * boost;
 }
 /**
- * Apply time-based exponential decay to scoring fields.
+ * Apply time-based exponential decay to a signals snapshot.
  *
  * Recency decays as exp(-days / DECAY_RECENCY_FACTOR).
  * Importance decays as importance * DECAY_IMPORTANCE_FACTOR^days.
  *
- * @param scoring - Current scoring state
+ * @param signals - Current RuntimeSignals snapshot
  * @param daysSinceLastUpdate - Days since the file was last updated
- * @returns New scoring with decayed values (original not mutated)
+ * @returns New signals with decayed values (original not mutated)
  */
-export function applyDecay(scoring, daysSinceLastUpdate) {
+export function applyDecay(signals, daysSinceLastUpdate) {
     if (daysSinceLastUpdate <= 0) {
-        return scoring;
+        return signals;
     }
-    const currentImportance = scoring.importance ?? 50;
     const newRecency = Math.exp(-daysSinceLastUpdate / DECAY_RECENCY_FACTOR);
-    const newImportance = currentImportance * DECAY_IMPORTANCE_FACTOR ** daysSinceLastUpdate;
+    const newImportance = signals.importance * DECAY_IMPORTANCE_FACTOR ** daysSinceLastUpdate;
     return {
-        ...scoring,
+        ...signals,
         importance: Math.max(0, newImportance),
         recency: newRecency,
     };
@@ -114,104 +111,58 @@ export function determineTier(importance, currentTier) {
     }
     return currentTier;
 }
-/**
- * Record a search access hit on a knowledge file.
- *
- * Increments access count and adds an importance bonus.
- *
- * @param scoring - Current scoring state
- * @returns Updated scoring (original not mutated)
- */
-export function recordAccessHit(scoring) {
-    const newAccessCount = (scoring.accessCount ?? 0) + 1;
-    const newImportance = Math.min(100, (scoring.importance ?? 50) + ACCESS_IMPORTANCE_BONUS);
-    return {
-        ...scoring,
-        accessCount: newAccessCount,
-        importance: newImportance,
-    };
-}
 /**
  * Record multiple accumulated access hits at once.
  *
- * @param scoring - Current scoring state
- * @param hitCount - Number of hits to record
- * @returns Updated scoring (original not mutated)
+ * Increments accessCount by `hitCount` and importance by
+ * `ACCESS_IMPORTANCE_BONUS * hitCount` (capped at 100). Caller is
+ * responsible for recomputing maturity via `determineTier` if the
+ * importance delta may cross a hysteresis threshold.
  */
-export function recordAccessHits(scoring, hitCount) {
+export function recordAccessHits(signals, hitCount) {
     if (hitCount <= 0) {
-        return scoring;
+        return signals;
     }
-    const newAccessCount = (scoring.accessCount ?? 0) + hitCount;
-    const newImportance = Math.min(100, (scoring.importance ?? 50) + ACCESS_IMPORTANCE_BONUS * hitCount);
     return {
-        ...scoring,
-        accessCount: newAccessCount,
-        importance: newImportance,
+        ...signals,
+        accessCount: signals.accessCount + hitCount,
+        importance: Math.min(100, signals.importance + ACCESS_IMPORTANCE_BONUS * hitCount),
     };
 }
 /**
  * Record a curate update on a knowledge file.
  *
- * Increments update count, adds an importance bonus, resets recency to 1.0,
- * and updates the timestamp.
- *
- * @param scoring - Current scoring state
- * @returns Updated scoring (original not mutated)
- */
-export function recordCurateUpdate(scoring) {
-    const newUpdateCount = (scoring.updateCount ?? 0) + 1;
-    const newImportance = Math.min(100, (scoring.importance ?? 50) + UPDATE_IMPORTANCE_BONUS);
-    const now = new Date().toISOString();
-    return {
-        ...scoring,
-        importance: newImportance,
-        recency: 1,
-        updateCount: newUpdateCount,
-        updatedAt: now,
-    };
-}
-/**
- * Return default scoring values for a new or unscored knowledge file.
+ * Increments updateCount, adds an importance bonus, resets recency to 1.0.
+ * Caller is responsible for recomputing maturity via `determineTier`.
  */
-export function applyDefaultScoring() {
-    const now = new Date().toISOString();
+export function recordCurateUpdate(signals) {
     return {
-        accessCount: 0,
-        createdAt: now,
-        importance: 50,
-        maturity: 'draft',
+        ...signals,
+        importance: Math.min(100, signals.importance + UPDATE_IMPORTANCE_BONUS),
         recency: 1,
-        updateCount: 0,
-        updatedAt: now,
+        updateCount: signals.updateCount + 1,
     };
 }
 /**
- * Merge two scoring states during a MERGE operation.
+ * Merge two runtime-signal snapshots during a MERGE operation.
  *
  * Strategy:
  * - importance: max of both
  * - recency: max of both
  * - accessCount: sum
  * - updateCount: sum + 1 (for the merge itself)
- * - maturity: higher tier
- * - createdAt: earlier date
- * - updatedAt: current time
+ * - maturity: higher tier (caller may refine via `determineTier`)
  */
 export function mergeScoring(source, target) {
     const tierRank = { core: 3, draft: 1, validated: 2 };
-    const sourceRank = tierRank[source.maturity ?? 'draft'] ?? 1;
-    const targetRank = tierRank[target.maturity ?? 'draft'] ?? 1;
-    const higherTier = sourceRank >= targetRank ? (source.maturity ?? 'draft') : (target.maturity ?? 'draft');
-    const sourceCreated = source.createdAt ? new Date(source.createdAt).getTime() : Date.now();
-    const targetCreated = target.createdAt ? new Date(target.createdAt).getTime() : Date.now();
+    const sourceRank = tierRank[source.maturity] ?? 1;
+    const targetRank = tierRank[target.maturity] ?? 1;
+    const higherTier = sourceRank >= targetRank ? source.maturity : target.maturity;
     return {
-        accessCount: (source.accessCount ?? 0) + (target.accessCount ?? 0),
-        createdAt: sourceCreated <= targetCreated ? source.createdAt : target.createdAt,
-        importance: Math.max(source.importance ?? 50, target.importance ?? 50),
+        accessCount: source.accessCount + target.accessCount,
+        importance: Math.max(source.importance, target.importance),
         maturity: higherTier,
-        recency: Math.max(source.recency ?? 1, target.recency ?? 1),
-        updateCount: (source.updateCount ?? 0) + (target.updateCount ?? 0) + 1,
-        updatedAt: new Date().toISOString(),
+        recency: Math.max(source.recency, target.recency),
+        updateCount: source.updateCount + target.updateCount + 1,
     };
 }