@prodero/curator 0.0.0-stage → 0.1.0

package/dist/core/applicability.js

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+import { tokens } from './matching.js';
+import { isPathScope, pathApplies, pathScopeRelevant } from './path-scope.js';
+export const TASK_KINDS = ['implementation', 'testing', 'migration', 'deployment', 'documentation', 'review', 'debugging'];
+const names = z.array(z.string().trim().min(1).max(160)).min(1).max(16);
+const paths = z.array(z.string().trim().min(1).max(300)).min(1).max(16).refine(a => a.every(p => !/[\0\r\n]/.test(p) && !p.startsWith('/') && !p.includes('\\') && !p.split('/').includes('..') && !p.includes('//') && p !== '.' && !p.replace(/\/\*\*$/, '').includes('*')), 'Use repository-relative paths with optional terminal /**');
+export const applicabilitySchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('legacy') }).strict(),
+    z.object({ kind: z.literal('project') }).strict(),
+    z.object({ kind: z.literal('unresolved') }).strict(),
+    z.object({ kind: z.literal('scoped'), paths: paths.optional(), subsystems: names.optional(), taskKinds: z.array(z.enum(TASK_KINDS)).min(1).max(7).optional() }).strict(),
+]);
+export const taskContextInputSchema = z.object({ paths: paths.optional(), subsystems: names.optional(), taskKinds: z.array(z.enum(TASK_KINDS)).min(1).max(7).optional(), explicitTopics: names.optional() }).strict();
+const uniq = (v) => [...new Set(v)].sort();
+const lower = (s) => s.toLowerCase().trim();
+const cleanPath = (s) => s.replace(/\/\*\*$/, '').replace(/^\.\//, '').replace(/\/$/, '');
+export function validateApplicability(value, policy) {
+    const a = applicabilitySchema.parse(value);
+    if (policy === 'required' && a.kind === 'unresolved')
+        throw new Error('Required knowledge needs an explicit applicability boundary');
+    if (a.kind === 'scoped' && !a.paths?.length && !a.subsystems?.length && !a.taskKinds?.length)
+        throw new Error('Scoped applicability needs at least one restriction');
+    return a;
+}
+export function applicabilityOf(r) { return r.applicability ?? { kind: 'legacy' }; }
+export function scopeProjection(a) {
+    if (a.kind === 'project')
+        return { scope: 'global', scopeRef: null };
+    if (a.kind === 'unresolved')
+        return { scope: 'task', scopeRef: 'unresolved' };
+    if (a.kind === 'legacy')
+        throw new Error('Legacy applicability retains its original scope');
+    if (a.paths?.length)
+        return { scope: 'module', scopeRef: cleanPath(a.paths[0]), scopeKind: 'path' };
+    if (a.subsystems?.length)
+        return { scope: 'module', scopeRef: a.subsystems[0], scopeKind: 'topic' };
+    return { scope: 'task', scopeRef: a.taskKinds.join(' ') };
+}
+export function withApplicability(r, a) {
+    a = validateApplicability(a, r.contextPolicy);
+    return { ...r, ...(a.kind === 'legacy' ? {} : { scopeKind: undefined, ...scopeProjection(a) }), applicability: a };
+}
+export function applicabilityKey(r) {
+    const a = applicabilityOf(r);
+    return a.kind === 'legacy' ? (r.scope === 'global' ? JSON.stringify({ kind: 'project' }) : JSON.stringify(['legacy', r.scope, r.scopeRef, r.scopeKind ?? null])) : JSON.stringify(a.kind !== 'scoped' ? a : { kind: a.kind, paths: a.paths ? uniq(a.paths.map(cleanPath)) : [], subsystems: a.subsystems ? uniq(a.subsystems.map(lower)) : [], taskKinds: a.taskKinds ? uniq(a.taskKinds) : [] });
+}
+export const sameApplicability = (a, b) => applicabilityKey(a) === applicabilityKey(b);
+/** Subset proof only; incomparable boundaries are not guessed equivalent. */
+export function narrowsApplicability(before, after) {
+    if (sameApplicability(before, after))
+        return true;
+    const b = applicabilityOf(before), a = applicabilityOf(after);
+    if (a.kind === 'legacy')
+        return false;
+    if (b.kind === 'project' || b.kind === 'unresolved')
+        return a.kind === 'scoped';
+    if (b.kind === 'legacy')
+        return before.scope === 'global' && a.kind === 'scoped';
+    if (a.kind !== 'scoped')
+        return false;
+    return (!b.paths || !!a.paths && a.paths.every(p => b.paths.some(q => pathApplies(cleanPath(q), cleanPath(p))))) &&
+        (!b.subsystems || !!a.subsystems && a.subsystems.every(s => b.subsystems.map(lower).includes(lower(s)))) &&
+        (!b.taskKinds || !!a.taskKinds && a.taskKinds.every(k => b.taskKinds.includes(k)));
+}
+const kindPatterns = { implementation: /\b(?:implement|implementation|develop|update|fix|add|refactor)\b/i, testing: /\b(?:test|tests|testing|unit|spec|harness)\b|тест/i, migration: /\bmigrat\w*\b|миграц/i, deployment: /\b(?:deploy\w*|release|rollout)\b|депло/i, documentation: /\b(?:readme|documentation|docs|document)\b|документ/i, review: /\b(?:review|audit)\b|аудит|ревью/i, debugging: /\b(?:debug\w*|investigate|diagnos\w*|troubleshoot)\b|диагност|расслед/i };
+export function buildTaskContext(taskText = '', input = {}, knownSubsystems = [], knownPaths = []) {
+    input = taskContextInputSchema.parse(input);
+    const signals = [];
+    const add = (dimension, value, source, basis) => signals.push({ dimension, value, source, ...(basis ? { basis } : {}) });
+    for (const [dimension, values] of Object.entries(input))
+        for (const v of values ?? [])
+            add(dimension === 'explicitTopics' ? 'subsystems' : dimension, v, 'argument');
+    const mentions = [...taskText.matchAll(/`([^`]+)`|"([^"\n]+)"|(?:^|\s)([\w@.-]+\/[\w@./*-]+|[\w.-]+\.(?:md|ts|tsx|js|php|py|json|sql|html|css)\b)/g)].map(m => m[1] ?? m[2] ?? m[3]);
+    for (const p of mentions)
+        if (paths.safeParse([p]).success)
+            add('paths', cleanPath(p), 'task-text');
+    for (const kind of TASK_KINDS)
+        if (kindPatterns[kind].test(taskText))
+            add('taskKinds', kind, 'task-text');
+    for (const p of knownPaths)
+        if (cleanPath(taskText.trim()) === cleanPath(p))
+            add('paths', cleanPath(p), 'task-text');
+    const queryTokens = tokens(taskText);
+    for (const name of knownSubsystems)
+        if ([...tokens(name)].length && [...tokens(name)].every(t => queryTokens.has(t)))
+            add('subsystems', name, 'task-text', 'vocabulary');
+    // Technical identifiers are usable narrow topics without a hardcoded project dictionary.
+    for (const m of taskText.matchAll(/\b(?:[A-Z][a-z]+(?:[A-Z][A-Za-z0-9]*)+|[A-Z]{2,}|[a-z]+_[a-z_]+)\b/g))
+        if (!['README', 'SQL', 'API', 'UI'].includes(m[0]))
+            add('subsystems', m[0], 'task-text', 'identifier');
+    const values = (dimension) => uniq(signals.filter(s => s.dimension === dimension).map(s => s.value));
+    if (signals.some(s => s.dimension === 'taskKinds' && s.value === 'documentation') && !/\b(?:implement|implementation|code|refactor)\b/i.test(taskText)) {
+        for (let i = signals.length - 1; i >= 0; i--)
+            if (signals[i].source === 'task-text' && signals[i].dimension === 'taskKinds' && signals[i].value === 'implementation')
+                signals.splice(i, 1);
+    }
+    const kinds = values('taskKinds');
+    const subsystems = values('subsystems');
+    return { taskText, paths: values('paths'), subsystems, taskKinds: kinds, signals, documentationOnly: kinds.includes('documentation') && !kinds.some(k => ['testing', 'deployment', 'migration', 'debugging'].includes(k)) && !subsystems.length };
+}
+export function evaluateApplicability(record, context, use = 'required') {
+    const a = applicabilityOf(record), yes = (why) => ({ state: 'applicable', reasons: [why], matched: 1 });
+    if (a.kind === 'project')
+        return yes('Applies throughout this project');
+    if (a.kind === 'unresolved')
+        return { state: 'unknown', reasons: ['Knowledge has no resolved work boundary'], matched: 0 };
+    if (a.kind === 'legacy') {
+        // Exact pre-v3 rules, including different historical Required/Relevant filtering.
+        if (record.scope === 'global')
+            return yes('Legacy global scope preserved');
+        if (isPathScope(record))
+            return { state: pathScopeRelevant(context.taskText, record) ? 'applicable' : 'not_applicable', reasons: ['Legacy path matching preserved'], matched: 0 };
+        if (use === 'relevant')
+            return yes('Legacy topic relevance retrieval preserved');
+        const query = lower(context.taskText).replace(/^\.\//, '').replace(/\/$/, ''), ref = lower(record.scopeRef ?? '').replace(/^\.\//, '').replace(/\/$/, '');
+        const matched = !!query && !!ref && (query === ref || query.startsWith(ref + '/') || record.scope === 'task' && [...tokens(query)].some(t => tokens(ref).has(t)));
+        return { state: matched ? 'applicable' : 'not_applicable', reasons: ['Legacy scoped Required matching preserved'], matched: Number(matched) };
+    }
+    const results = [];
+    if (a.paths) {
+        const match = a.paths.some(p => context.paths.some(q => pathApplies(cleanPath(p), cleanPath(q))));
+        results.push({ state: match ? 'applicable' : context.paths.length ? 'not_applicable' : 'unknown', reason: match ? 'Repository path matched' : context.paths.length ? 'Paths are outside the configured boundary' : `Task has no resolved path; needs ${a.paths.join(' or ')}` });
+    }
+    if (a.subsystems) {
+        const otherResolved = context.signals.some(s => s.dimension === 'subsystems' && (s.source === 'argument' || s.basis === 'vocabulary'));
+        const match = a.subsystems.some(s => context.subsystems.some(q => lower(s) === lower(q)));
+        results.push({ state: match ? 'applicable' : otherResolved || context.documentationOnly ? 'not_applicable' : 'unknown', reason: match ? `Subsystem matched: ${a.subsystems.filter(s => context.subsystems.some(q => lower(q) === lower(s))).join(', ')}` : otherResolved || context.documentationOnly ? 'Task focus does not match the subsystem' : `Task has no resolved subsystem; needs ${a.subsystems.join(' or ')}` });
+    }
+    if (a.taskKinds) {
+        const match = a.taskKinds.some(k => context.taskKinds.includes(k));
+        results.push({ state: match ? 'applicable' : context.taskKinds.length ? 'not_applicable' : 'unknown', reason: match ? `Task kind matched: ${a.taskKinds.filter(k => context.taskKinds.includes(k)).join(', ')}` : context.taskKinds.length ? 'Task kind is outside the configured boundary' : `Task kind is unresolved; needs ${a.taskKinds.join(' or ')}` });
+    }
+    return { state: results.some(r => r.state === 'not_applicable') ? 'not_applicable' : results.some(r => r.state === 'unknown') ? 'unknown' : 'applicable', reasons: results.map(r => r.reason), matched: results.filter(r => r.state === 'applicable').length };
+}
+export function inferApplicability(content, context) {
+    const own = buildTaskContext(content);
+    const c = own.paths.length || own.subsystems.length ? own : context ?? own;
+    const a = { kind: 'scoped', ...(c.paths.length ? { paths: c.paths.slice(0, 16) } : {}), ...(c.subsystems.length ? { subsystems: c.subsystems.slice(0, 16) } : {}), ...(c.taskKinds.length ? { taskKinds: c.taskKinds } : {}) };
+    // No invented mandatory/global claim: unlocated ordinary knowledge stays task-bound.
+    return a.paths || a.subsystems || a.taskKinds ? a : { kind: 'unresolved' };
+}
+export { applicabilityLabel } from "./applicability-label.js";
+//# sourceMappingURL=applicability.js.map

package/dist/core/bootstrap.js

@@ -0,0 +1,129 @@
+import { applicabilityKey, buildTaskContext, evaluateApplicability, applicabilityLabel } from "./applicability.js";
+import { loadMemoryCatalog } from "./memory-index.js";
+import { TOKEN_COUNT_METHOD } from "./telemetry.js";
+export const MAX_BOOTSTRAP_INSTRUCTIONS = 12;
+export const DEFAULT_BOOTSTRAP_BUDGET_TOKENS = 1_000;
+const PRIORITY_SCORE = { critical: 80, important: 40, normal: 20, contextual: 10 };
+function normalizedScope(value) {
+    const scope = value?.trim().toLowerCase().replace(/^\.\//, "").replace(/\/$/, "");
+    return scope || null;
+}
+export function instructionApplies(item, scope) {
+    return item.contextPolicy === 'required' && evaluateApplicability(item, buildTaskContext(scope, {}, item.applicability?.kind === 'scoped' ? item.applicability.subsystems : [], item.applicability?.kind === 'scoped' ? item.applicability.paths : [])).state === 'applicable';
+}
+function orderInstructions(a, b) {
+    const aSpecific = a.scope === "global" ? 0 : 1;
+    const bSpecific = b.scope === "global" ? 0 : 1;
+    return Number(b.priority === "critical") - Number(a.priority === "critical")
+        || bSpecific - aSpecific
+        || PRIORITY_SCORE[b.priority] - PRIORITY_SCORE[a.priority]
+        || a.title.localeCompare(b.title)
+        || a.id.localeCompare(b.id);
+}
+function instructionView(item, summary) {
+    return {
+        id: item.id,
+        title: item.title,
+        content: item.content,
+        applicability: item.applicability,
+        appliesTo: applicabilityLabel(item),
+        scope: item.scope,
+        scopeRef: item.scopeRef,
+        priority: item.priority,
+        status: item.status === "disputed" ? "disputed" : "active",
+        layer: summary.layer,
+        kind: "instruction",
+        contextPolicy: "required",
+        authority: item.authority,
+        enforcement: "required",
+        estimatedTokens: summary.estimatedTokens,
+    };
+}
+export function conflictWarnings(candidates) {
+    const byId = new Map(candidates.map((item) => [item.id, item]));
+    const pairs = new Map();
+    const addPair = (left, right) => {
+        if (left.id === right.id)
+            return;
+        const [first, second] = [left, right].sort((a, b) => a.id.localeCompare(b.id));
+        pairs.set(`${first.id}:${second.id}`, [first, second]);
+    };
+    for (const item of candidates) {
+        for (const relation of item.relations) {
+            if (relation.type === "contradicts" && byId.has(relation.target))
+                addPair(item, byId.get(relation.target));
+        }
+        if (item.status === "disputed") {
+            for (const related of item.related)
+                if (byId.get(related)?.status === "disputed")
+                    addPair(item, byId.get(related));
+        }
+    }
+    const boundaries = new Map();
+    for (const item of candidates) {
+        const key = `${applicabilityKey(item)}:${item.normalizedTitle}`;
+        const group = boundaries.get(key) ?? [];
+        group.push(item);
+        boundaries.set(key, group);
+    }
+    for (const group of boundaries.values()) {
+        for (let left = 0; left < group.length; left += 1)
+            for (let right = left + 1; right < group.length; right += 1) {
+                if (group[left].normalizedContent !== group[right].normalizedContent)
+                    addPair(group[left], group[right]);
+            }
+    }
+    const paired = new Set([...pairs.values()].flatMap(([left, right]) => [left.id, right.id]));
+    const warnings = [...pairs.values()]
+        .sort(([a], [b]) => a.id.localeCompare(b.id))
+        .map(([left, right]) => `Conflicting required instructions: ${left.title} (${left.id}) vs ${right.title} (${right.id}).`);
+    for (const item of candidates.filter((candidate) => candidate.status === "disputed" && !paired.has(candidate.id)).sort(orderInstructions)) {
+        warnings.push(`Disputed required instruction requires review: ${item.title} (${item.id}).`);
+    }
+    return warnings;
+}
+export async function getBootstrapContext(root, scope) {
+    const catalog = await loadMemoryCatalog(root);
+    const shadowed = new Set(catalog.summaries.filter((item) => item.status === "active" || item.status === "disputed").flatMap((item) => item.supersedes));
+    const candidates = catalog.summaries
+        .filter((item) => (item.status === "active" || item.status === "disputed") && !shadowed.has(item.id) && instructionApplies(item, scope))
+        .sort(orderInstructions);
+    const warnings = conflictWarnings(candidates);
+    const selected = [];
+    let selectedTokens = 0;
+    for (const item of candidates) {
+        if (selected.length >= MAX_BOOTSTRAP_INSTRUCTIONS || selectedTokens + item.estimatedTokens > DEFAULT_BOOTSTRAP_BUDGET_TOKENS)
+            continue;
+        selected.push(item);
+        selectedTokens += item.estimatedTokens;
+    }
+    const selectedIds = new Set(selected.map((item) => item.id));
+    const omitted = candidates.filter((item) => !selectedIds.has(item.id));
+    const omittedCritical = omitted.filter(item => item.priority === "critical").length;
+    if (omittedCritical)
+        warnings.push(`${omittedCritical} critical required instruction(s) were not loaded because Bootstrap Context is bounded to ${MAX_BOOTSTRAP_INSTRUCTIONS} items and ${DEFAULT_BOOTSTRAP_BUDGET_TOKENS} estimated tokens.`);
+    const instructions = await Promise.all(selected.map(async (item) => instructionView(await catalog.load(item.id), item)));
+    return {
+        version: 1,
+        projectRoot: root,
+        scope: normalizedScope(scope),
+        loaded: true,
+        instructions,
+        warnings,
+        metrics: { scopedRequiredPolicies: catalog.summaries.filter(i => i.contextPolicy === "required" && ["active", "disputed"].includes(i.status) && !shadowed.has(i.id) && !instructionApplies(i)).length, candidateInstructions: candidates.length, loadedInstructions: instructions.length, omittedInstructions: omitted.length, estimatedTokens: selectedTokens, tokenCountMethod: TOKEN_COUNT_METHOD, estimated: true },
+        limits: { maxInstructions: MAX_BOOTSTRAP_INSTRUCTIONS, budgetTokens: DEFAULT_BOOTSTRAP_BUDGET_TOKENS },
+    };
+}
+export function emptyBootstrapContext(root, scope) {
+    return {
+        version: 1,
+        projectRoot: root,
+        scope: normalizedScope(scope),
+        loaded: false,
+        instructions: [],
+        warnings: [],
+        metrics: { candidateInstructions: 0, loadedInstructions: 0, omittedInstructions: 0, estimatedTokens: 0, tokenCountMethod: TOKEN_COUNT_METHOD, estimated: true },
+        limits: { maxInstructions: MAX_BOOTSTRAP_INSTRUCTIONS, budgetTokens: DEFAULT_BOOTSTRAP_BUDGET_TOKENS },
+    };
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/core/consolidation.js

@@ -0,0 +1,315 @@
+import { parseObservationAnnotations as annotations } from "./format.js";
+import { validateApplicability, withApplicability, sameApplicability } from "./applicability.js";
+import { inferredKnowledge } from './knowledge-authority.js';
+import { inheritKnowledgePolicy } from "./knowledge-policy.js";
+import { SyncEvidenceCollector, pressureRecord } from "./memory-pressure.js";
+import { deterministicClassification, reconciliationSignal } from "./reconciliation.js";
+import { assertCompatibleProject } from "./storage.js";
+import { assertNoSecrets } from "./secrets.js";
+import { exactKnowledge, semanticRisk, evidenceSentences } from "./semantic-safety.js";
+import { createSkillCandidate } from "./skills.js";
+import { sortableId } from "./ids.js";
+import { tokens } from "./matching.js";
+import { loadMemoryCatalog, MAX_RELATED_MEMORY_CANDIDATES } from "./memory-index.js";
+import { renderKnowledge, parseKnowledge } from "./memory.js";
+import { safeProjectPath, fileHash } from "./sync-transaction.js";
+import { estimateTokens, knowledgeText } from "./telemetry.js";
+const SECTION_DEFAULTS = {
+    Decisions: { category: "decision", priority: "important", scope: "global" },
+    Lessons: { category: "lesson", priority: "normal", scope: "task" },
+    Discoveries: { category: "state", priority: "normal", scope: "task" },
+    "Project State Changes": { category: "state", priority: "normal", scope: "global" },
+    "Global Instruction Candidates": { category: "instruction", priority: "important", scope: "global" },
+    "Skill Candidates": { category: "instruction", priority: "contextual", scope: "task" },
+};
+function similarity(a, b) {
+    const left = tokens(a);
+    const right = tokens(b);
+    if (!left.size || !right.size)
+        return { jaccard: 0, coverage: 0 };
+    const intersection = [...left].filter((token) => right.has(token)).length;
+    return { jaccard: intersection / (left.size + right.size - intersection), coverage: intersection / Math.min(left.size, right.size) };
+}
+function asScope(value, fallback) { return value === "module" || value === "task" || value === "global" ? value : fallback; }
+function asPriority(value, fallback) { return value === "critical" || value === "important" || value === "normal" || value === "contextual" ? value : fallback; }
+function asCategory(value, fallback) {
+    return value === "principle" || value === "invariant" || value === "decision" || value === "constraint" || value === "lesson" || value === "state" || value === "instruction" ? value : fallback;
+}
+function titleFrom(content) {
+    const clean = content.replace(/[`*_]/g, "").replace(/\s+/g, " ").trim();
+    const sentence = clean.match(/^(.{1,100}?[.!?])(?:\s|$)/)?.[1] ?? clean;
+    return sentence.length > 100 ? `${sentence.slice(0, 97).trim()}…` : sentence;
+}
+export function sessionCandidates(session) {
+    assertNoSecrets(session);
+    const candidates = [];
+    for (const [section, items] of Object.entries(session.sections)) {
+        const defaults = SECTION_DEFAULTS[section];
+        if (!defaults)
+            continue;
+        items.forEach((raw, index) => {
+            const parsed = annotations(raw);
+            if (!parsed.content)
+                return;
+            const explicitFromText = [...parsed.content.matchAll(/\b(?:replaces|supersedes)\s+(mem_[a-zA-Z0-9_]+)/gi)].map((match) => match[1]);
+            let triggers = [];
+            try {
+                const value = JSON.parse(parsed.metadata.triggers ?? "[]");
+                if (Array.isArray(value))
+                    triggers = value.filter((v) => typeof v === "string");
+            }
+            catch { /* Legacy observations have no structured triggers. */ }
+            let relations = [];
+            try {
+                const value = JSON.parse(parsed.metadata.relations ?? "[]");
+                if (Array.isArray(value))
+                    relations = value.filter((v) => Boolean(v && typeof v === "object" && typeof v.type === "string" && typeof v.target === "string"));
+            }
+            catch { /* Legacy observations have no structured relationships. */ }
+            candidates.push({
+                ...(parsed.metadata.applicability ? { applicability: validateApplicability(JSON.parse(parsed.metadata.applicability)) } : {}),
+                instructionCandidate: section === "Global Instruction Candidates",
+                skill: section === "Skill Candidates",
+                description: parsed.metadata.description,
+                triggers,
+                proposedReason: parsed.metadata.proposed_reason,
+                scope: asScope(parsed.metadata.scope, defaults.scope),
+                scopeRef: parsed.metadata.scope_ref ?? null,
+                ...(parsed.metadata.scope_kind ? { scopeKind: parsed.metadata.scope_kind } : {}),
+                category: asCategory(parsed.metadata.category, defaults.category),
+                priority: asPriority(parsed.metadata.priority, defaults.priority),
+                title: parsed.metadata.title ?? titleFrom(parsed.content),
+                content: parsed.content,
+                sessionId: session.id,
+                derivedFrom: `${session.id}#${parsed.metadata.id ?? `${section.replace(/\s+/g, "-").toLowerCase()}-${index + 1}`}`,
+                supersedes: unique([...(parsed.metadata.supersedes?.split(",").map((value) => value.trim()).filter(Boolean) ?? []), ...explicitFromText]),
+                relations,
+            });
+        });
+    }
+    return candidates.map(c => c.applicability && !c.skill && !c.instructionCandidate ? withApplicability(c, c.applicability) : c);
+}
+function unique(values) { return [...new Set(values)].sort(); }
+function uniqueRelations(values) {
+    return [...new Map(values.map((relation) => [`${relation.type}:${relation.target}`, relation])).values()]
+        .sort((a, b) => a.type.localeCompare(b.type) || a.target.localeCompare(b.target));
+}
+function explicitSuperseded(candidate, active) {
+    return active.filter((item) => candidate.supersedes.includes(item.id) || new RegExp(`\\b(?:replaces|supersedes)\\s+${item.id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i").test(candidate.content));
+}
+/** Core-owned signals; similarity and merge guards are never conflict verdicts. */
+export function candidateReviewSignals(candidate, related) {
+    const signals = [];
+    if (candidate.instructionCandidate)
+        signals.push({ kind: 'instruction-candidate', detail: 'Proposed instruction; not an active required policy.', severity: 'info', requiresReview: true });
+    if (candidate.skill)
+        signals.push({ kind: 'skill-candidate', detail: 'Proposed skill; activation requires separate review.', severity: 'info', requiresReview: true });
+    for (const old of related) {
+        const category = deterministicClassification(candidate, old);
+        // Retrieval can include loose neighbors; keep unrelated observations quiet.
+        if (category === 'unresolved' && similarity(candidate.content, old.content).coverage < 0.3)
+            continue;
+        signals.push(reconciliationSignal(category, old));
+    }
+    return signals;
+}
+function mergeEligible(candidate, old) {
+    if (semanticRisk(candidate.content, old.content))
+        return false;
+    const incoming = evidenceSentences(candidate.content);
+    const existing = evidenceSentences(old.content);
+    // Only an unchanged sentence prefix plus complementary complete sentences is safe without reasoning.
+    const smaller = incoming.length < existing.length ? incoming : existing;
+    const larger = incoming.length < existing.length ? existing : incoming;
+    return smaller.length > 0 && smaller.every((sentence, index) => sentence === larger[index])
+        && estimateTokens(`${old.title}\n${old.content}\n${candidate.content}`) <= 2_000;
+}
+function segments(value) {
+    return value.split(/(?:\r?\n){2,}|(?<=[.!?])\s+(?=[\p{Lu}\p{N}`])/u).map((part) => part.trim()).filter(Boolean);
+}
+function compactContribution(existing, incoming) {
+    const kept = segments(existing);
+    const seen = new Set(kept.map(exactKnowledge));
+    const added = [];
+    let removed = 0;
+    for (const segment of segments(incoming)) {
+        const key = exactKnowledge(segment);
+        if (!key || seen.has(key)) {
+            removed += 1;
+            continue;
+        }
+        seen.add(key);
+        kept.push(segment);
+        added.push(segment);
+    }
+    return { content: kept.join("\n\n"), added: added.join("\n\n"), removed };
+}
+async function deterministicConsolidate(root, sessions, now = new Date(), processedSources = new Set()) {
+    const candidates = sessions.flatMap(sessionCandidates).filter((candidate) => !processedSources.has(candidate.derivedFrom));
+    const catalog = await loadMemoryCatalog(root);
+    const writes = new Map();
+    const pressure = new SyncEvidenceCollector();
+    const changedRecords = new Map();
+    const stageKnowledge = async (item) => {
+        const relative = `local/memory/${item.id}.md`;
+        const after = renderKnowledge(item);
+        parseKnowledge(after, `${item.id}.md`);
+        const existing = writes.get(relative);
+        const before = existing ? existing.before : catalog.originalHashes.get(item.id) ?? await fileHash(await safeProjectPath(root, relative));
+        writes.set(relative, { path: relative, before, after });
+        catalog.stage(item, "local");
+        changedRecords.set(item.id, pressureRecord({ ...item, layer: "local", estimatedTokens: estimateTokens(knowledgeText(item)), relations: item.relations ?? [] }));
+    };
+    const result = {
+        candidates: 0, created: [], createdSkills: [], skillCandidateTokensAdded: 0, updated: [], consolidated: [], superseded: [], duplicates: [], conflicts: [], conflictCount: 0,
+        memoryFilesScanned: catalog.filesScanned, memoryBodiesIndexed: catalog.bodiesIndexed, memoryBodiesLoaded: 0, relatedCandidatesSelectedMax: 0,
+        observationsProcessed: 0, rawSessionTokens: 0, rawKnowledgeTokens: 0, rawSkillCandidateTokens: 0, canonicalTokensAdded: 0,
+        compactedSegments: 0, conservativeMergesSkipped: 0,
+    };
+    result.candidates = candidates.length;
+    result.observationsProcessed = candidates.length;
+    result.rawKnowledgeTokens = candidates.filter((candidate) => !candidate.skill).reduce((total, candidate) => total + estimateTokens(candidate.content), 0);
+    result.rawSkillCandidateTokens = candidates.filter((candidate) => candidate.skill).reduce((total, candidate) => total + estimateTokens(candidate.content), 0);
+    result.rawSessionTokens = candidates.reduce((total, candidate) => total + estimateTokens(candidate.content), 0);
+    for (const candidate of candidates) {
+        if (candidate.instructionCandidate) {
+            (result.instructionCandidates ??= []).push({ ...candidate, id: `candidate_${result.instructionCandidates?.length ?? 0}`, kind: "instruction_candidate", sources: [candidate.derivedFrom], evidence: [{ source: candidate.derivedFrom, quote: candidate.content }] });
+            continue;
+        }
+        if (candidate.skill) {
+            const saved = await createSkillCandidate(root, {
+                title: candidate.title,
+                description: candidate.description ?? candidate.content.replace(/\s+/g, " ").slice(0, 300),
+                content: candidate.content,
+                scope: candidate.scopeRef ?? "project",
+                triggers: candidate.triggers,
+            }, { sessionId: candidate.sessionId, derivedFrom: candidate.derivedFrom, proposedReason: candidate.proposedReason }, now, writes);
+            if (saved.created) {
+                result.createdSkills.push(saved.skill.id);
+                result.skillCandidateTokensAdded += estimateTokens(saved.skill.content);
+            }
+            continue;
+        }
+        const selected = catalog.selectRelated({
+            scope: candidate.scope,
+            scopeRef: candidate.scopeRef,
+            scopeKind: candidate.scopeKind,
+            applicability: candidate.applicability ?? { kind: "legacy" },
+            category: candidate.category,
+            title: candidate.title,
+            content: candidate.content,
+            explicitIds: candidate.supersedes,
+        }, MAX_RELATED_MEMORY_CANDIDATES);
+        // An explicit replacement must survive the complete write path. Never silently
+        // drop a missing/historical target and save an unrelated active record instead.
+        const unavailable = candidate.supersedes.filter(id => !selected.some(item => item.id === id));
+        if (unavailable.length)
+            throw new Error(`Explicit supersedes target is missing or no longer current: ${unavailable.join(", ")}. Session remains pending; use current memory IDs.`);
+        result.relatedCandidatesSelectedMax = Math.max(result.relatedCandidatesSelectedMax, selected.length);
+        const active = await Promise.all(selected.map((entry) => catalog.load(entry.id)));
+        for (const signal of candidateReviewSignals(candidate, active)) {
+            const target = selected.find(item => item.id === signal.memory?.id);
+            if (target)
+                pressure.observe(candidate.derivedFrom, pressureRecord(target), signal.kind);
+        }
+        const localIds = new Set(selected.filter((entry) => entry.layer === "local").map((entry) => entry.id));
+        const exact = active.find((item) => item.scope === candidate.scope && item.scopeRef === candidate.scopeRef && item.scopeKind === candidate.scopeKind && item.category === candidate.category && sameApplicability(item, candidate) && exactKnowledge(item.content) === exactKnowledge(candidate.content));
+        if (exact && !candidate.supersedes.length) {
+            if (localIds.has(exact.id)) {
+                exact.sourceSessions = unique([...exact.sourceSessions, candidate.sessionId]);
+                exact.derivedFrom = unique([...exact.derivedFrom, candidate.derivedFrom]);
+                exact.relations = uniqueRelations([...(exact.relations ?? []), ...candidate.relations]);
+                exact.updatedAt = now.toISOString();
+                await stageKnowledge(exact);
+                result.updated.push(exact.id);
+            }
+            result.duplicates.push(exact.id);
+            continue;
+        }
+        const supersededTargets = explicitSuperseded(candidate, active);
+        const replaced = supersededTargets.filter((item) => localIds.has(item.id));
+        const id = sortableId("mem", now);
+        const item = {
+            id,
+            scope: candidate.scope,
+            scopeRef: candidate.scopeRef,
+            scopeKind: candidate.scopeKind,
+            applicability: candidate.applicability ?? { kind: "legacy" },
+            version: 3,
+            category: candidate.category,
+            priority: candidate.priority,
+            status: "active",
+            title: candidate.title,
+            content: candidate.content,
+            createdAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+            sourceSessions: [candidate.sessionId],
+            derivedFrom: [candidate.derivedFrom],
+            supersedes: unique(supersededTargets.flatMap((old) => [old.id, ...old.supersedes])),
+            related: [],
+            relations: uniqueRelations(candidate.relations),
+        };
+        Object.assign(item, withApplicability(inferredKnowledge(item), item.applicability));
+        inheritKnowledgePolicy(item, supersededTargets);
+        if (supersededTargets.length) {
+            for (const old of replaced) {
+                old.status = "superseded";
+                old.updatedAt = now.toISOString();
+                old.related = unique([...old.related, id]);
+                await stageKnowledge(old);
+                result.superseded.push(old.id);
+                result.updated.push(old.id);
+            }
+        }
+        else {
+            const sameBoundary = active.filter((old) => localIds.has(old.id) && old.scope === candidate.scope && old.scopeRef === candidate.scopeRef && old.scopeKind === candidate.scopeKind && old.category === candidate.category && sameApplicability(old, candidate));
+            const overlapping = sameBoundary.find((old) => mergeEligible(candidate, old));
+            if (overlapping) {
+                const compacted = compactContribution(overlapping.content, candidate.content);
+                overlapping.content = compacted.content;
+                result.compactedSegments += compacted.removed;
+                result.canonicalTokensAdded += estimateTokens(compacted.added);
+                overlapping.sourceSessions = unique([...overlapping.sourceSessions, candidate.sessionId]);
+                overlapping.derivedFrom = unique([...overlapping.derivedFrom, candidate.derivedFrom]);
+                overlapping.relations = uniqueRelations([...(overlapping.relations ?? []), ...candidate.relations]);
+                overlapping.updatedAt = now.toISOString();
+                await stageKnowledge(overlapping);
+                result.updated.push(overlapping.id);
+                if (compacted.added)
+                    result.consolidated.push(overlapping.id);
+                else
+                    result.duplicates.push(overlapping.id);
+                continue;
+            }
+            if (sameBoundary.some((old) => {
+                const score = similarity(`${candidate.title} ${candidate.content}`, `${old.title} ${old.content}`);
+                return score.jaccard >= 0.35 || score.coverage >= 0.5;
+            }))
+                result.conservativeMergesSkipped += 1;
+            // Similarity and protected-token changes only limit safe merging. Without
+            // semantic evidence, keep both records active for later reconciliation.
+        }
+        await stageKnowledge(item);
+        result.created.push(id);
+        result.canonicalTokensAdded += estimateTokens(knowledgeText(item));
+    }
+    result.created = unique(result.created);
+    result.updated = unique(result.updated);
+    result.consolidated = unique(result.consolidated);
+    result.superseded = unique(result.superseded);
+    result.duplicates = unique(result.duplicates);
+    result.conflicts = unique(result.conflicts);
+    result.memoryBodiesLoaded = catalog.bodiesLoaded;
+    result.writes = [...writes.values()];
+    result.memoryPressure = pressure.finish([...changedRecords.values()], result);
+    return result;
+}
+export const deterministicConsolidator = {
+    name: "deterministic-v1",
+    consolidate: deterministicConsolidate,
+};
+export async function consolidateSessions(root, sessions, now = new Date(), consolidator = deterministicConsolidator, processedSources = new Set()) {
+    await assertCompatibleProject(root);
+    return consolidator.consolidate(root, sessions, now, processedSources);
+}
+//# sourceMappingURL=consolidation.js.map

package/dist/core/constants.js

@@ -0,0 +1,21 @@
+import { readFileSync } from "node:fs";
+const packageIdentity = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+const releaseIdentity = JSON.parse(readFileSync(new URL("../../prodero.release.json", import.meta.url), "utf8"));
+if (releaseIdentity.formatVersion !== 1 || !Number.isInteger(releaseIdentity.schemaVersion) || releaseIdentity.schemaVersion < 1 || !Number.isInteger(releaseIdentity.knowledgeSchemaVersion) || releaseIdentity.knowledgeSchemaVersion < 1)
+    throw new Error("Invalid prodero.release.json");
+export const PRODERO_VERSION = packageIdentity.version;
+export const PRODERO_SCHEMA_VERSION = releaseIdentity.schemaVersion;
+export const PRODERO_KNOWLEDGE_SCHEMA_VERSION = releaseIdentity.knowledgeSchemaVersion;
+export const PRODERO_PACKAGE_NAME = packageIdentity.name;
+export const PRODERO_DIRECTORY = ".prodero";
+export const MANAGED_START = "<!-- prodero:start -->";
+export const MANAGED_END = "<!-- prodero:end -->";
+export const PROJECT_DIRECTORIES = [
+    "memory",
+    "sessions",
+    "skills",
+    "checkpoints",
+    "local/memory",
+    ".cache",
+];
+//# sourceMappingURL=constants.js.map