@prodero/curator 0.0.0-stage → 0.2.0

package/dist/core/knowledge-analysis.js

@@ -0,0 +1,46 @@
+/** Evidence-first proposals only. Classification never establishes authority. */
+import { inferApplicability, buildTaskContext } from './applicability.js';
+export const KNOWLEDGE_ANALYSIS_VERSION = 'evidence-3';
+const transient = /\b(?:currently (?:fails?|blocked|broken)|temporary workaround|remains? blocked|planned work owns|discovery.*fails?)\b/i;
+/** Keep exact text slices: no paraphrasing, dropped clauses or lexical authority. */
+export function analyzeKnowledgeText(title, content) {
+    const boundaries = [...content.matchAll(/^(?:Decision|Impact|Constraint|Correction|Guard Pattern|Workflow Note|Test-Quality Note|State|Lesson|Principle|Invariant):\s*$/gmi)];
+    const chunks = boundaries.length > 1 ? boundaries.map((m, i) => ({ start: i === 0 ? 0 : m.index, end: boundaries[i + 1]?.index ?? content.length, label: m[0].trim().slice(0, -1).toLowerCase() })) : [{ start: 0, end: content.length, label: boundaries[0]?.[0].trim().slice(0, -1).toLowerCase() ?? '' }];
+    // Impact stays with its decision; split only lifecycle/category boundaries.
+    const groups = [];
+    for (const c of chunks) {
+        if ((c.label === 'impact' || c.label === 'constraint' && /\b(?:must|should|never|always|required|only|cannot|do not)\b/i.test(content.slice(groups.at(-1)?.start ?? 0, c.start))) && groups.length && !transient.test(content.slice(c.start, c.end)))
+            groups.at(-1).end = c.end;
+        else
+            groups.push({ ...c });
+    }
+    const wholeContext = buildTaskContext(`${title}\n${content}`);
+    const titleContext = buildTaskContext(title);
+    const domain = titleContext.subsystems.length ? titleContext.subsystems : wholeContext.subsystems;
+    return groups.filter(c => content.slice(c.start, c.end).trim()).map((c, i) => {
+        const body = content.slice(c.start, c.end).trim();
+        const historical = transient.test(body);
+        const normative = /\b(?:must|should|never|always|required|only|cannot|do not|prohibit)\b/i.test(body);
+        const category = historical ? 'state' : c.label === 'principle' ? 'principle' : c.label === 'invariant' ? 'invariant' : c.label === 'constraint' || c.label === 'guard pattern' ? 'constraint' : c.label === 'lesson' || c.label === 'correction' ? 'lesson' : c.label === 'decision' ? (normative ? 'instruction' : 'decision') : c.label === 'workflow note' || /^(?:Run |Use |Always |Never |Do not )/.test(body) ? 'instruction' : /\b(?:invariant|transactional invariant)\b/i.test(body) ? 'invariant' : /\b(?:must not|cannot|never persist|prohibit)\b/i.test(body) ? 'constraint' : /\b(?:uses?|chosen|canonical|decided|adopted)\b/i.test(body) ? 'decision' : 'state';
+        let applicability = inferApplicability(body);
+        // Named domain is stronger than incidental code identifiers. Preserve concrete paths
+        // when no domain is established; avoid AND-ing incidental paths with a subsystem.
+        // Titles are authored source metadata, not a built-in domain dictionary.
+        // A single explicit identifier may name the work boundary; ambiguous titles
+        // remain unresolved rather than inventing a preferred subsystem.
+        const named = [...new Set(domain.filter(n => !['AI', 'PHP', 'CLI', 'HTTP', 'HTML', 'JSON', 'DB', 'SQL'].includes(n)))];
+        if (named.length === 1)
+            applicability = { kind: 'scoped', subsystems: named, ...(/\b(?:tests?|testing|harness)\b/i.test(title) ? { taskKinds: ['testing'] } : {}) };
+        if (named.length > 1)
+            applicability = { kind: 'unresolved' };
+        const evidence = [`Source characters ${c.start}–${c.end}`, ...(c.label ? [`Explicit source field: ${c.label}`] : []), ...(historical ? ['Time-sensitive wording; retained as historical state'] : [])];
+        if (applicability.kind === 'scoped')
+            evidence.push(`Explicit work signals: ${JSON.stringify(applicability)}`);
+        return { title: groups.length === 1 ? title : `${title.slice(0, 155)} · ${c.label || `part ${i + 1}`}`, content: body, category, applicability, evidence, start: c.start, end: c.end, transient: historical };
+    });
+}
+export function importPreviewSummary(items) {
+    const selected = items.filter(i => i.include !== false);
+    return { records: selected.length, categories: Object.fromEntries([...new Set(selected.map(i => i.category))].sort().map(c => [c, selected.filter(i => i.category === c).length])), required: 0, relevant: selected.length, projectWide: selected.filter(i => i.applicability?.kind === 'project').length, scoped: selected.filter(i => i.applicability?.kind === 'scoped').length, unresolved: selected.filter(i => !i.applicability || i.applicability.kind === 'unresolved').length };
+}
+//# sourceMappingURL=knowledge-analysis.js.map

package/dist/core/knowledge-authority.js

@@ -0,0 +1,143 @@
+import { sameApplicability, applicabilityKey, narrowsApplicability, applicabilityOf, withApplicability } from "./applicability.js";
+import { AsyncLocalStorage } from 'node:async_hooks';
+import path from 'node:path';
+import { knowledgePolicy } from './knowledge-policy.js';
+import { evidenceSentences } from './semantic-safety.js';
+const authorityContext = new AsyncLocalStorage();
+const shape = (i) => JSON.stringify([i.category, i.scope, i.scopeRef, i.scopeKind, i.priority, i.content, applicabilityKey(i)]);
+/** Internal application capability, not an MCP input or persisted permission.
+ * Entry points bind either host-attested intent or the explicit chat-rule command;
+ * the latter is model-mediated and retains distinct provenance.
+ * Scope is invocation-local; neither serialized evidence nor authority is a capability. */
+export async function withTrustedKnowledgeIntent(root, proposed, proof, operation) {
+    if (!proof.evidence.trim())
+        throw new Error('Trusted policy intent requires an auditable source reference');
+    const grant = { active: true, root: path.resolve(root), proposed: structuredClone(proposed), evidence: proof.evidence, authority: proof.authority, before: proof.before ? JSON.stringify(proof.before) : undefined };
+    try {
+        return await authorityContext.run(grant, operation);
+    }
+    finally {
+        grant.active = false;
+    }
+}
+export const protectedKnowledge = (i) => i.contextPolicy === 'required' || i.priority === 'critical' || ['explicit_user', 'reviewed'].includes(i.authority ?? '');
+const sameScope = (a, b) => sameApplicability(a, b);
+/** Conservative proof: whole clauses, including order, must survive exactly. No
+ * semantic equivalence is inferred from an LLM assertion or bag of words. */
+export const sameProtection = (a, b) => a.category === b.category && sameScope(a, b) && a.priority === b.priority && a.contextPolicy === b.contextPolicy && a.authority === b.authority && JSON.stringify(evidenceSentences(a.content)) === JSON.stringify(evidenceSentences(b.content));
+const samePolicyBoundary = (a, b) => a.category === b.category && sameScope(a, b) && a.priority === b.priority && a.contextPolicy === b.contextPolicy && a.authority === b.authority;
+function clausesCovered(before, after) {
+    const output = evidenceSentences(after);
+    let cursor = 0;
+    return evidenceSentences(before).every(clause => { const index = output.indexOf(clause, cursor); cursor = index + 1; return index >= 0; });
+}
+export const coversProtection = (before, after) => samePolicyBoundary(before, after) && clausesCovered(before.content, after.content);
+function equivalentSources(proposed, sources) {
+    if (!sources.length || !sources.every(s => samePolicyBoundary(s, proposed)))
+        return false;
+    const clauses = new Set(sources.flatMap(s => evidenceSentences(s.content))), out = new Set(evidenceSentences(proposed.content));
+    return clauses.size === out.size && [...clauses].every(c => out.has(c)) && sources.every(s => clausesCovered(s.content, proposed.content));
+}
+export function inferredKnowledge(item, origin = 'inferred') {
+    return { ...item, ...knowledgePolicy({ ...item, version: item.version === 3 ? 3 : 2, contextPolicy: 'relevant', authority: origin }) };
+}
+/** The single semantic authorization boundary, shared by every canonical transaction. */
+export function evaluateKnowledgeTransition(root, proposed, before, options = {}) {
+    try {
+        knowledgePolicy(proposed);
+    }
+    catch {
+        return { decision: 'forbidden', item: before ?? proposed, reasons: ['invalid-policy-combination'], blocking: true };
+    }
+    if (reviewedBatchAllows(root, proposed, before))
+        return { decision: "allowed", item: proposed, reasons: ["trusted-current-operation"], blocking: false };
+    const grant = authorityContext.getStore();
+    if (grant?.active && grant.proposed.status === proposed.status && grant.root === path.resolve(root) && shape(grant.proposed) === shape(proposed) && (!grant.before || grant.before === JSON.stringify(before) || (!before && options.sources?.some(s => JSON.stringify(s) === grant.before)))) {
+        const item = { ...proposed, ...knowledgePolicy({ ...proposed, version: proposed.version === 3 ? 3 : 2, contextPolicy: grant.proposed.contextPolicy, authority: grant.authority }), evidence: [...(proposed.evidence ?? []), { kind: 'user_instruction', ref: grant.evidence }] };
+        return { decision: 'allowed', item, reasons: ['trusted-current-operation'], blocking: false };
+    }
+    if (!before) {
+        // Publication and equivalent replacement retain existing policy, never gain it.
+        const source = options.sources?.find(s => sameProtection(s, proposed));
+        if ((source && source.status === proposed.status) || (proposed.status === 'active' && equivalentSources(proposed, (options.sources ?? []).filter(s => s.status === 'active'))))
+            return { decision: 'allowed', item: proposed, reasons: ['existing-policy-preserved'], blocking: false };
+        const item = inferredKnowledge(proposed, proposed.authority === 'imported' ? 'imported' : 'inferred');
+        if (item.priority === 'critical')
+            item.priority = 'important';
+        const sources = options.sources ?? [];
+        // Never union incomparable source boundaries. A useful inferred fork can
+        // keep the first source boundary; uncovered originals remain active.
+        if (sources.length && !sources.some(s => sameScope(item, s))) {
+            item.scope = sources[0].scope;
+            item.scopeRef = sources[0].scopeRef;
+            item.scopeKind = sources[0].scopeKind;
+            Object.assign(item, withApplicability(item, applicabilityOf(sources[0])));
+        }
+        const changed = item.contextPolicy !== proposed.contextPolicy || item.authority !== proposed.authority || item.priority !== proposed.priority || !sameScope(item, proposed);
+        return { decision: changed ? (options.exact ? 'review_required' : 'allowed_with_safe_fallback') : 'allowed', item, reasons: changed ? ['unverified-promotion-saved-as-relevant'] : [], blocking: changed && !!options.exact };
+    }
+    const reasons = [];
+    if (options.replacementRequested && before.status !== proposed.status && !options.retirementCovered)
+        reasons.push("replacement-does-not-cover-source");
+    if (before.contextPolicy !== proposed.contextPolicy)
+        reasons.push('delivery-policy-change');
+    if (before.authority !== proposed.authority)
+        reasons.push('authority-change');
+    if (proposed.priority === 'critical' && before.priority !== 'critical')
+        reasons.push('criticality-increase');
+    if (protectedKnowledge(before)) {
+        if (!sameScope(before, proposed))
+            reasons.push('protected-applicability-change');
+        if (before.priority !== proposed.priority)
+            reasons.push('protected-priority-change');
+        if ((before.category !== proposed.category || JSON.stringify(evidenceSentences(before.content)) !== JSON.stringify(evidenceSentences(proposed.content))) && !equivalentSources(proposed, options.sources ?? [before]))
+            reasons.push('protected-meaning-change');
+        if ((proposed.relations ?? []).some(r => ['superseded_by', 'consolidated_into', 'contradicts'].includes(r.type) && !(before.relations ?? []).some(old => old.type === r.type && old.target === r.target)))
+            reasons.push('protected-topology-change');
+        if (before.status !== proposed.status && !options.retirementCovered)
+            reasons.push('protected-retirement');
+    }
+    // Ordinary inference may refine relevant knowledge but cannot broaden its scope.
+    if (!sameScope(before, proposed) && !(before.contextPolicy === 'relevant' && before.authority === 'inferred' && proposed.derivedFrom.length > 0 && narrowsApplicability(before, proposed)))
+        reasons.push('applicability-change');
+    if (!reasons.length)
+        return { decision: 'allowed', item: proposed, reasons: [], blocking: false };
+    return { decision: options.exact ? 'review_required' : 'review_recommended', item: structuredClone(before), reasons: [...new Set(reasons)], blocking: !!options.exact };
+}
+export class KnowledgePolicyReviewRequired extends Error {
+    transition;
+    code = 'POLICY_REVIEW_REQUIRED';
+    constructor(transition) {
+        super('POLICY_REVIEW_REQUIRED: The requested rule change needs trusted user intent or an exact policy review. Existing knowledge was preserved.');
+        this.transition = transition;
+    }
+}
+/** Optional diagnostics, not an approval queue and never a Prepare blocker. */
+export function summarizePolicyDecisions(decisions) {
+    return { blocking: decisions.some(d => d.blocking), recommendations: decisions.filter(d => d.decision === 'review_recommended').length,
+        safeFallbacks: decisions.filter(d => d.decision === 'allowed_with_safe_fallback').length, reasons: [...new Set(decisions.flatMap(d => d.reasons))], interactivePrompts: 0 };
+}
+const batchReviewContext = new AsyncLocalStorage();
+export async function withTrustedKnowledgeBatch(root, entries, evidence, operation) {
+    if (!evidence.trim() || !entries.length)
+        throw new Error('Exact trusted batch review required');
+    const grant = { active: true, root: path.resolve(root), entries: structuredClone(entries), evidence };
+    try {
+        return await batchReviewContext.run(grant, operation);
+    }
+    finally {
+        grant.active = false;
+    }
+}
+function reviewedBatchAllows(root, proposed, before) {
+    const g = batchReviewContext.getStore();
+    // Canonical normalization eliminates presentation aliases, not semantic metadata.
+    const canonical = (i) => JSON.stringify(Object.fromEntries(Object.entries(i).filter(([k, v]) => v !== undefined && !['kind', 'enforcement'].includes(k)).sort(([a], [b]) => a.localeCompare(b))));
+    return !!g?.active && g.root === path.resolve(root) && g.entries.some(e => canonical(e.after) === canonical(proposed) && (!e.before ? !before : !!before && canonical(e.before) === canonical(before)));
+}
+/** Diagnostic reference only; never grants permission when replayed from history. */
+export function trustedKnowledgeBatchEvidence(root) {
+    const grant = batchReviewContext.getStore();
+    return grant?.active && grant.root === path.resolve(root) ? grant.evidence : null;
+}
+//# sourceMappingURL=knowledge-authority.js.map

package/dist/core/knowledge-curation.js

@@ -0,0 +1,316 @@
+import { copyStorageTree, ensureStorageDirectory, ensureDataDirectory } from "./storage.js";
+import { PRIVATE_FILE_MODE } from "../filesystem/permissions.js";
+import { validateRevision, revisionHash } from './curation-revision.js';
+import { renderReviewProjection } from './curation-review-state.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadMemoryCatalog } from './memory-index.js';
+import { readConfig, checkedDataPath, sha256, listCheckpoints } from './storage.js';
+import { parseKnowledge, renderKnowledge } from './memory.js';
+import { KNOWLEDGE_ANALYSIS_VERSION } from './knowledge-analysis.js';
+import { assertSafeCurationData, collectCurationEvidence, evidenceFor } from './curation-evidence.js';
+import { refineCurationClauses } from './curation-clauses.js';
+const CURATION_ENGINE = KNOWLEDGE_ANALYSIS_VERSION + '/clauses-2';
+import { withApplicability, sameApplicability, narrowsApplicability, applicabilityLabel } from './applicability.js';
+import { evaluateKnowledgeTransition, KnowledgePolicyReviewRequired, trustedKnowledgeBatchEvidence } from './knowledge-authority.js';
+import { withSyncLock, ownsSyncLock, recoverSyncTransaction, commitSyncTransaction } from './sync-transaction.js';
+import { buildIndex } from './index.js';
+import { prepareContext } from './context.js';
+import { sortableId } from './ids.js';
+import { estimateTokens, knowledgeText } from './telemetry.js';
+const digest = (value) => sha256(JSON.stringify(value));
+const seal = (plan) => ({ ...plan, planId: digest(plan) });
+const active = (items) => items.filter(i => i.status === 'active');
+function stats(items) { const a = active([...new Map(items.map(i => [i.id, i])).values()]), required = a.filter(i => i.contextPolicy === 'required'); return { records: a.length, required: required.length, projectWideRequired: required.filter(i => i.applicability?.kind === 'project' || i.applicability?.kind === 'legacy' && i.scope === 'global').length, scopedRequired: required.filter(i => i.applicability?.kind === 'scoped').length, relevant: a.filter(i => i.contextPolicy === 'relevant').length, unresolved: a.filter(i => i.applicability?.kind === 'unresolved').length, requiredTokens: required.reduce((n, i) => n + estimateTokens(knowledgeText(i)), 0) }; }
+export function corpusSummary(proposals) { return { consolidated: new Set(proposals.flatMap(p => p.outputs.filter(o => o.id.startsWith('mem_curate_shared_')).map(o => o.id))).size, before: stats(proposals.map(p => p.before)), proposed: stats(proposals.flatMap(p => p.attention.length ? p.before : p.outputs)), decomposed: proposals.filter(p => p.outputs.length > 1 && !p.attention.length).length, attention: proposals.filter(p => p.attention.length).length, unchanged: proposals.filter(p => !p.changes.length || p.attention.length).length, safe: proposals.filter(p => p.changes.length && !p.attention.length).length }; }
+/** Pure read phase: cache rebuilds stay in memory, no plan/history persistence. */
+export async function planKnowledgeCuration(root, options = {}) {
+    const config = await readConfig(root);
+    if (!config || config.knowledgeSchemaVersion !== 3)
+        throw new Error('Update knowledge format before curation');
+    const catalog = await loadMemoryCatalog(root, { persistCache: false });
+    const all = await Promise.all(catalog.summaries.filter(s => !options.memorySyncSources || options.memorySyncSources.includes(s.id)).map(s => catalog.load(s.id)));
+    if (options.memorySyncSources) {
+        const ids = [...new Set(options.memorySyncSources)].sort();
+        if (!ids.length || ids.length > 24 || ids.length !== options.memorySyncSources.length)
+            throw new Error('Invalid Sync analysis scope');
+        const proposals = ids.map(id => {
+            const before = all.find(i => i.id === id && ['active', 'disputed'].includes(i.status)), summary = catalog.summaries.find(s => s.id === id);
+            if (!before || !summary)
+                throw new Error('Sync analysis source changed');
+            return { id, sourceId: id, revision: catalog.originalHashes.get(id), path: summary.relativePath, before, outputs: [before], group: 'Memory', changes: [], evidence: [], attention: [], confidence: 'high', mapping: [{ start: 0, end: before.content.length, outputId: id }], consolidationSources: ids };
+        });
+        const canonicalRoot = await fs.realpath(root);
+        const plan = seal({ version: 1, engine: CURATION_ENGINE, project: canonicalRoot, knowledgeSchema: 3, memorySyncSources: ids, fingerprint: digest(ids.map(id => [id, catalog.originalHashes.get(id)])), proposals, summary: corpusSummary(proposals), accountedSources: ids.length, evidenceRoot: canonicalRoot, evidenceTruncated: false });
+        validateCurationPlan(plan);
+        return plan;
+    }
+    const inventory = await collectCurationEvidence(options.evidenceRoot ?? root);
+    const proposals = [];
+    for (const before of all.filter(i => i.authority === 'legacy_inherited' && !i.derivedFrom.some(ref => ref.startsWith('curation-source:')) && i.contextPolicy === 'required' && ['active', 'disputed'].includes(i.status))) {
+        const summary = catalog.summaries.find(s => s.id === before.id);
+        const parts = refineCurationClauses(before.title, before.content);
+        const projectEvidence = evidenceFor(before.content, inventory);
+        const structured = /^Decision:/m.test(before.content);
+        const attention = [];
+        const conflicts = (before.relations ?? []).filter(r => r.type === 'contradicts');
+        if (before.status === 'disputed' || conflicts.length)
+            attention.push(`Existing conflict: ${conflicts.map(r => r.target).join(', ') || 'disputed lifecycle state'}`);
+        if (parts.some(p => p.transient))
+            attention.push('Contains potentially stale historical state; verify current validity before changing protection.');
+        const outputs = parts.map((p, n) => {
+            // Parent policy is a ceiling: only a source-supported normative core inherits it.
+            const policy = before.contextPolicy === 'required' && p.normative ? 'required' : 'relevant';
+            const category = policy === 'required' ? 'instruction' : p.category;
+            const app = before.applicability && before.applicability.kind !== 'legacy' && before.applicability.kind !== 'unresolved' ? before.applicability : !structured || p.applicability.kind === 'unresolved' ? (before.applicability ?? { kind: 'legacy' }) : p.applicability;
+            return withApplicability({ ...before, id: parts.length === 1 ? before.id : `mem_curate_${digest([before.id, catalog.originalHashes.get(before.id), n]).slice(0, 24)}`, category, contextPolicy: policy, authority: 'legacy_inherited', title: p.title, content: p.content, derivedFrom: [...before.derivedFrom, ...(p.segments ?? [{ start: p.start, end: p.end }]).map(m => `curation-source:${before.id}@${catalog.originalHashes.get(before.id)}#${m.start}-${m.end}`)], related: [...new Set([...before.related, ...(parts.length > 1 ? [before.id] : [])])] }, app);
+        });
+        // Contradiction metadata is evidence of unresolved policy, never permission to demote it.
+        if (before.status === 'disputed' || conflicts.length)
+            outputs.splice(0, outputs.length, structuredClone(before));
+        if (structured && parts.some(p => p.applicability.kind === 'unresolved'))
+            attention.push('Applicability remains unresolved; review the intended project boundary.');
+        if (outputs.some(o => !sameApplicability(before, o) && !narrowsApplicability(before, o)))
+            attention.push('Proposed applicability is not provably narrower; keep the source until reviewed.');
+        const changes = [];
+        if (outputs.length > 1)
+            changes.push('decomposition');
+        if (outputs.some(i => !sameApplicability(before, i)))
+            changes.push('applicability-narrowing');
+        if (outputs.some(i => i.contextPolicy !== before.contextPolicy))
+            changes.push('policy-change');
+        if (outputs.some(i => i.category !== before.category))
+            changes.push('category-change');
+        if (!changes.length)
+            outputs.splice(0, outputs.length, structuredClone(before));
+        if (changes.length && outputs.some(i => i.contextPolicy === 'required' && (i.applicability?.kind === 'legacy' && i.scope === 'global')))
+            attention.push('Required project-wide boundary remains uncertain.');
+        const group = outputs.flatMap(i => i.applicability?.kind === 'scoped' ? i.applicability.subsystems ?? i.applicability.paths ?? i.applicability.taskKinds ?? [] : [])[0] ?? 'Project-wide';
+        if (outputs.some(o => o.applicability?.kind === 'scoped' && o.applicability.subsystems?.some(n => /^(?:DB|SQL|JSON|HTML|PHP|AI)$/.test(n) || /(?:Harness|Helper)$/.test(n))))
+            attention.push('Applicability currently names a generic technology or helper rather than a resolved subsystem; review its real work boundary.');
+        const hadAttention = attention.length > 0;
+        const investigation = hadAttention || projectEvidence.length ? {
+            outcome: attention.length ? (parts.length > 1 ? 'reduced-ambiguity' : 'needs-decision') : parts.every(p => p.transient) ? 'historical-only' : 'resolved-proposal',
+            state: 'cannot-determine',
+            evidence: projectEvidence,
+            explanation: attention.length ? 'Evidence informs the proposal but cannot authorize choosing between protected meanings.' : 'Supporting history remains traceable; static evidence does not prove test execution or production rollout. Exact batch review is still required.'
+        } : undefined;
+        const issueSourceIds = new Set([before.id, ...conflicts.map(r => r.target)]);
+        const issueBasis = [...issueSourceIds].sort().map(id => ({ id, revision: catalog.originalHashes.get(id) ?? 'missing' }));
+        proposals.push({ issueBasis, investigation, id: before.id, sourceId: before.id, revision: catalog.originalHashes.get(before.id), path: summary.relativePath, before, outputs, group, changes, evidence: [...parts.flatMap(p => p.evidence), ...projectEvidence.map(e => `${e.kind}: ${e.path}:${e.line} (${e.revision.slice(0, 12)}) ${e.excerpt}`)], attention, confidence: attention.length ? 'limited' : 'high', mapping: before.status === 'disputed' || conflicts.length ? [{ start: 0, end: before.content.length, outputId: before.id }] : parts.flatMap((p, n) => (p.segments ?? [{ start: p.start, end: p.end }]).map(m => ({ ...m, outputId: outputs[n]?.id ?? before.id }))).sort((a, b) => a.start - b.start) });
+    }
+    // Only source-identical normative cores with equal applicability/authority can
+    // share an output. Similar vocabulary is never a semantic equivalence proof.
+    const cores = new Map();
+    for (const p of proposals.filter(p => !p.attention.length))
+        for (const o of p.outputs.filter(o => o.contextPolicy === 'required')) {
+            const key = digest([o.content, o.applicability, o.scope, o.scopeRef, o.authority, o.priority, p.path.startsWith('local/')]);
+            cores.set(key, [...(cores.get(key) ?? []), { proposal: p, output: o }]);
+        }
+    for (const [key, group] of cores)
+        if (new Set(group.map(g => g.proposal.id)).size > 1) {
+            const shared = { ...group[0].output, id: `mem_curate_shared_${key.slice(0, 20)}` };
+            for (const field of ['sourceSessions', 'derivedFrom', 'supersedes', 'related'])
+                shared[field] = [...new Set(group.flatMap(g => g.output[field]))];
+            shared.related = [...new Set([...shared.related, ...group.map(g => g.proposal.id)])];
+            shared.evidence = Array.from(new Map(group.flatMap(g => (g.output.evidence ?? []).map(e => [JSON.stringify(e), e]))).values());
+            shared.relations = Array.from(new Map(group.flatMap(g => (g.output.relations ?? []).map(e => [JSON.stringify(e), e]))).values());
+            for (const g of group) {
+                const old = g.output.id;
+                g.proposal.outputs = g.proposal.outputs.map(o => o.id === old ? structuredClone(shared) : o);
+                g.proposal.mapping.forEach(m => { if (m.outputId === old)
+                    m.outputId = shared.id; });
+                g.proposal.consolidationSources = group.map(g => g.proposal.id);
+                g.proposal.changes.push('normative-consolidation');
+                g.proposal.evidence.push('Identical normative core, applicability, authority and priority; all source provenance retained.');
+            }
+        }
+    const fingerprint = digest(catalog.summaries.map(s => [s.id, catalog.originalHashes.get(s.id)]).sort());
+    const plan = seal({ version: 1, engine: CURATION_ENGINE, project: path.resolve(root), knowledgeSchema: 3, fingerprint, proposals, summary: corpusSummary(proposals), accountedSources: proposals.length, evidenceRoot: inventory.root, evidenceTruncated: inventory.truncated, ...(inventory.sensitiveExcluded ? { evidenceExclusions: [{ reason: 'Sensitive evidence excluded', count: inventory.sensitiveExcluded }] } : {}) });
+    validateCurationPlan(plan);
+    return plan;
+}
+export function validateCurationPlan(plan) {
+    assertSafeCurationData(plan);
+    const { planId, ...body } = plan;
+    if (digest(body) !== planId)
+        throw new Error('Curation plan changed');
+    if (plan.engine !== CURATION_ENGINE || plan.knowledgeSchema !== 3 || new Set(plan.proposals.map(p => p.sourceId)).size !== plan.proposals.length || plan.accountedSources !== plan.proposals.length)
+        throw new Error('Invalid curation accounting');
+    for (const p of plan.proposals) {
+        if (!p.outputs.length || p.before.id !== p.sourceId)
+            throw new Error('Unaccounted curation source');
+        for (const o of p.outputs) {
+            const parsed = parseKnowledge(renderKnowledge(o), `${o.id}.md`, 3);
+            if (parsed.category !== o.category || parsed.status !== o.status || parsed.content !== o.content)
+                throw new Error("Invalid canonical proposal");
+            if (!p.before.sourceSessions.every(v => o.sourceSessions.includes(v)) || !p.before.derivedFrom.every(v => o.derivedFrom.includes(v)) || !(p.before.evidence ?? []).every(v => (o.evidence ?? []).some(e => JSON.stringify(e) === JSON.stringify(v))) || !p.before.related.every(v => o.related.includes(v)) || !p.before.supersedes.every(v => o.supersedes.includes(v)))
+                throw new Error('Curation provenance or relationships were lost');
+            if (o.authority !== p.before.authority || o.priority !== p.before.priority)
+                throw new Error('Curation cannot infer authority or criticality');
+        }
+        if (p.outputs.length === 1 && p.outputs[0].content.trim() !== p.before.content.trim())
+            throw new Error("Unaccounted source meaning");
+        if (p.outputs.length > 1) {
+            const reproduced = p.mapping.map(m => p.before.content.slice(m.start, m.end)).join('');
+            if (reproduced.replace(/\s+/g, ' ') !== p.before.content.trim().replace(/\s+/g, ' '))
+                throw new Error('Unaccounted source clauses');
+            for (const output of p.outputs) {
+                if (output.content !== p.mapping.filter(m => m.outputId === output.id).map(m => p.before.content.slice(m.start, m.end).trim()).join('\n\n'))
+                    throw new Error('Invalid clause mapping');
+            }
+        }
+    }
+}
+function selected(plan, ids, revision) {
+    if (revision) {
+        validateRevision(revision);
+        if (revisionHash(revision.typedPlan.plan) !== revisionHash(plan))
+            throw new Error('Revision plan binding changed');
+    }
+    else
+        validateCurationPlan(plan);
+    if (!ids.length || new Set(ids).size !== ids.length)
+        throw new Error('Select a non-empty exact batch');
+    return ids.map(id => {
+        const p = plan.proposals.find(p => p.id === id);
+        if (!p || p.attention.length || !p.changes.length)
+            throw new Error(`Proposal needs individual analysis or has no change: ${id}`);
+        return p;
+    });
+}
+/** Exact review material for a trusted host adapter; never itself a capability. */
+function proposalEntries(p) { return p.outputs.length === 1 && p.outputs[0].id === p.sourceId ? [{ before: p.before, after: p.outputs[0] }] : [...p.outputs.map(after => ({ before: undefined, after })), { before: p.before, after: { ...p.before, status: 'superseded', related: [...new Set([...p.before.related, ...p.outputs.map(i => i.id)])] } }]; }
+export function curationReviewEntries(plan, ids, revision) { const chosen = selected(plan, ids, revision); for (const p of chosen)
+    if (p.consolidationSources?.some(id => !ids.includes(id)))
+        throw new Error('Select the complete normative consolidation group'); return [...new Map(chosen.flatMap(proposalEntries).map(e => [e.after.id, e])).values()]; }
+/** A pre-commit source/evidence conflict; no curation writes have started. */
+export class StaleCurationPlanError extends Error {
+}
+export async function applyKnowledgeCuration(root, plan, ids, receipt) {
+    if (plan.memorySyncSources)
+        throw new Error('Sync analysis cannot grant curation Apply authority');
+    if (path.resolve(root) !== plan.project)
+        throw new Error('Curation project mismatch');
+    const chosen = selected(plan, ids, receipt?.reviewSnapshot?.revision), entries = curationReviewEntries(plan, ids, receipt?.reviewSnapshot?.revision);
+    // No approved boolean can mint this capability. Fail before mutation/lock.
+    for (const e of entries) {
+        const d = evaluateKnowledgeTransition(root, e.after, e.before, { exact: true });
+        if (d.decision !== 'allowed')
+            throw new KnowledgePolicyReviewRequired(d);
+    }
+    const commit = async () => {
+        await recoverSyncTransaction(root);
+        const prior = (await listCheckpoints(root)).find(c => receipt?.reviewRevisionId ? c.curation?.review?.operationId === receipt.operationId : c.curation?.planId === plan.planId && digest(c.curation.selected) === digest(ids));
+        if (prior) {
+            await buildIndex(root);
+            return { checkpoint: prior.id, repeated: true };
+        }
+        for (const e of chosen.flatMap(p => p.investigation?.evidence ?? [])) {
+            const absolute = path.resolve(plan.evidenceRoot, e.path);
+            try {
+                if (!absolute.startsWith(path.resolve(plan.evidenceRoot) + path.sep) || await fs.realpath(absolute) !== absolute || sha256(await fs.readFile(absolute, 'utf8')) !== e.revision)
+                    throw new StaleCurationPlanError(`Stale project evidence: ${e.path}`);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    throw new StaleCurationPlanError(`Missing project evidence: ${e.path}`);
+                throw error;
+            }
+        }
+        const writes = [];
+        const preimages = [];
+        for (const p of chosen) {
+            const current = await fs.readFile(await checkedDataPath(root, p.path), 'utf8').catch(error => {
+                if (error.code === 'ENOENT')
+                    throw new StaleCurationPlanError(`Missing curation source: ${p.sourceId}`);
+                throw error;
+            });
+            if (sha256(current) !== p.revision)
+                throw new StaleCurationPlanError(`Stale curation source: ${p.sourceId}`);
+            preimages.push({ path: p.path, revision: p.revision, content: current });
+        }
+        for (const e of entries) {
+            const p = chosen.find(p => p.sourceId === e.before?.id || p.outputs.some(i => i.id === e.after.id));
+            writes.push({ path: e.before ? p.path : `${p.path.startsWith('local/') ? 'local/' : ''}memory/${e.after.id}.md`, before: e.before ? p.revision : null, after: renderKnowledge(e.after) });
+        }
+        const id = sortableId('chk');
+        writes.push({ path: `checkpoints/${id}.json`, before: null, after: JSON.stringify({ id, createdAt: new Date().toISOString(), previousCheckpoint: null, sessions: [], createdMemory: entries.filter(e => !e.before).map(e => e.after.id), updatedMemory: ids, supersededMemory: entries.filter(e => e.after.status === 'superseded').map(e => e.after.id), duplicateMemory: [], conflicts: [], curation: { ...(receipt ? { review: receipt } : {}), reviewEvidence: trustedKnowledgeBatchEvidence(root), planId: plan.planId, engine: plan.engine, selected: ids, leftUnchanged: plan.proposals.filter(p => !ids.includes(p.id)).map(p => p.id), plan, preimages, postimages: writes.map(w => ({ path: w.path, revision: sha256(w.after), content: w.after })) } }, null, 2) + '\n' });
+        await commitSyncTransaction(root, writes, { policyMode: 'exact' });
+        await buildIndex(root);
+        return { checkpoint: id, repeated: false };
+    };
+    return ownsSyncLock(root) ? commit() : withSyncLock(root, commit);
+}
+export async function curationRecommendation(root) {
+    const plan = await planKnowledgeCuration(root);
+    const { curationReviewView } = await import('./curation-review.js');
+    const { review, projection } = await curationReviewView(root, plan);
+    return { planId: plan.planId, reviewId: review?.snapshot.reviewId, state: projection.lifecycle,
+        prominent: !projection.paused && (projection.needsInputNow > 0 || projection.readyChangeGroups > 0), projection };
+}
+export async function deferKnowledgeCuration(root, planId) {
+    const plan = await planKnowledgeCuration(root);
+    if (plan.planId !== planId)
+        throw new Error('Curation changed; refresh');
+    return withSyncLock(root, async () => { await recoverSyncTransaction(root); const id = sortableId('chk'); await commitSyncTransaction(root, [{ path: `checkpoints/${id}.json`, before: null, after: JSON.stringify({ id, createdAt: new Date().toISOString(), sessions: [], curationDefer: planId }) + '\n' }]); return { state: 'deferred' }; });
+}
+// Explicitly labelled examples, not a claim of representative project coverage.
+export const CURATION_TASKS = ['Synthetic example: review documentation', 'Synthetic example: run unit tests', 'Synthetic example: review deployment'];
+function contextMetrics(c) { return { unknownRequired: c.applicability?.unknownRequired ?? 0, applicabilityDecisions: c.applicability?.decisions, requiredIds: c.required.map(i => i.id), requiredCandidates: c.required.length + c.metrics.requiredGlobalExcludedItems, requiredCandidateTokens: c.metrics.requiredGlobalCandidateTokens, requiredSelected: c.required.length, requiredSelectedTokens: c.metrics.requiredGlobalTokens, requiredOmissions: c.metrics.requiredGlobalExcludedItems, relevantSelected: c.relevant.length, relevantOmittedByItemLimit: c.selection.omittedRelevantByItemLimit, relevantOmittedByMarginalValue: c.selection.omittedRelevantByMarginalValue ?? 0, allocation: c.allocation, totalContextTokens: c.metrics.contextTokens, pressure: c.metrics.requiredGlobalPressure, contextNeeded: c.policyReadiness?.state === 'context-needed', readiness: c.policyReadiness, limits: c.limits }; }
+/** Real selector over an isolated canonical corpus; no lifecycle Prepare/Sync. */
+export async function simulateKnowledgeCuration(root, plan, tasks = CURATION_TASKS, mode = 'safe-batch', selectedIds, revision) {
+    if (revision) {
+        validateRevision(revision);
+        if (revision.typedPlan.plan.planId !== plan.planId)
+            throw new Error('Simulation revision mismatch');
+    }
+    else
+        validateCurationPlan(plan);
+    if (path.resolve(root) !== plan.project)
+        throw new Error('Simulation project mismatch');
+    if (selectedIds?.length)
+        curationReviewEntries(plan, selectedIds, revision);
+    const temp = await fs.mkdtemp(path.join(await ensureDataDirectory(root, '.cache'), 'prodero-curation-simulation-'));
+    try {
+        await ensureStorageDirectory(path.join(temp, '.prodero'), true);
+        const config = await readConfig(root);
+        await fs.writeFile(path.join(temp, '.prodero/config.json'), JSON.stringify(config), { mode: PRIVATE_FILE_MODE });
+        // Copy only canonical stores consumed by the selector, never caches or sessions.
+        for (const dir of ['memory', 'local/memory', 'skills', 'local/skills']) {
+            const from = await checkedDataPath(root, dir);
+            try {
+                await copyStorageTree(from, path.join(temp, '.prodero', dir), true);
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            }
+        }
+        const copied = await loadMemoryCatalog(temp, { persistCache: false });
+        await Promise.all(copied.summaries.map(i => copied.load(i.id)));
+        if (digest(copied.summaries.map(i => [i.id, copied.originalHashes.get(i.id)]).sort()) !== plan.fingerprint)
+            throw new Error('Simulation corpus changed since planning');
+        const before = await Promise.all(tasks.map(async (task) => ({ task, before: contextMetrics(await prepareContext(temp, { query: task })) })));
+        for (const p of plan.proposals) {
+            if (sha256(await fs.readFile(await checkedDataPath(temp, p.path), 'utf8')) !== p.revision)
+                throw new Error(`Stale simulation source: ${p.id}`);
+            if ((mode === 'safe-batch' && p.attention.length) || !p.changes.length || (selectedIds && !selectedIds.includes(p.id)))
+                continue;
+            for (const entry of proposalEntries(p))
+                await fs.writeFile(await checkedDataPath(temp, entry.before ? p.path : `${p.path.startsWith('local/') ? 'local/' : ''}memory/${entry.after.id}.md`), renderKnowledge(entry.after), { mode: PRIVATE_FILE_MODE });
+        }
+        return await Promise.all(before.map(async (row) => ({ ...row, after: contextMetrics(await prepareContext(temp, { query: row.task })) })));
+    }
+    finally {
+        await fs.rm(temp, { recursive: true, force: true });
+    }
+}
+export function renderCurationText(plan, projection) {
+    return `Knowledge cleanup\n${renderReviewProjection(projection)}.\nNo knowledge is removed automatically.\n` + plan.proposals.map(p => {
+        const item = projection.items.find(i => i.proposalIds.includes(p.id));
+        const status = item.issue?.state === 'deferred' ? 'Deferred clarification' : item.disposition === 'keep_current' ? 'Keep current' : item.disposition === 'deferred' && item.outcome === 'proposed' ? 'Deferred change' : item.outcome === 'unresolved' ? 'Needs clarification' : item.outcome === 'proposed' ? 'Proposed change' : 'Unchanged';
+        return `${p.group} · ${p.before.title}\n${status}\nCurrently: ${p.before.contextPolicy} · ${applicabilityLabel(p.before)}\n${item.outcome === 'unresolved' ? 'No actionable suggestion is available yet.' : `Suggested: ${p.outputs.map(i => `${i.category}, ${i.contextPolicy}, ${applicabilityLabel(i)}`).join('; ')}`}\nWhy: ${p.evidence.join('; ')}`;
+    }).join('\n\n');
+}
+//# sourceMappingURL=knowledge-curation.js.map