@prodero/curator 0.0.0-stage → 0.1.0

package/dist/core/promotion.js

@@ -0,0 +1,279 @@
+import { applicabilitySchema, sameApplicability } from "./applicability.js";
+import { CONTEXT_POLICIES, KNOWLEDGE_AUTHORITIES } from "./knowledge-policy.js";
+import { reconcileCandidate } from './reconciliation.js';
+import { assertNoSecrets } from "./secrets.js";
+import { z } from "zod";
+import { buildIndex } from "./index.js";
+import { intelligenceTelemetry } from "./intelligence.js";
+import { sortableId } from "./ids.js";
+import { loadMemoryCatalog } from "./memory-index.js";
+import { tokens } from "./matching.js";
+import { renderKnowledge } from "./memory.js";
+import { exactKnowledge, isExtractivelyGrounded } from "./semantic-safety.js";
+import { listCheckpoints, sha256 } from "./storage.js";
+import { commitSyncTransaction, fileHash, recoverSyncTransaction, safeProjectPath, withSyncLock, ownsSyncLock } from "./sync-transaction.js";
+const dispositionSchema = z.enum(["new", "merge", "supersede", "covered", "conflict"]);
+const revisionSchema = z.object({ id: z.string(), layer: z.enum(["local", "versioned"]), path: z.string(), hash: z.string() }).strict();
+const itemSchema = z.object({
+    applicability: applicabilitySchema.optional(), version: z.union([z.literal(1), z.literal(2), z.literal(3)]).optional(), contextPolicy: z.enum(CONTEXT_POLICIES).optional(), authority: z.enum(KNOWLEDGE_AUTHORITIES).optional(),
+    kind: z.literal("instruction").optional(), enforcement: z.enum(CONTEXT_POLICIES).optional(),
+    archivedAt: z.string().optional(),
+    id: z.string(), scope: z.enum(["global", "module", "task"]), scopeRef: z.string().nullable(), scopeKind: z.enum(["path", "topic"]).optional(),
+    category: z.enum(["principle", "invariant", "decision", "constraint", "lesson", "state", "instruction"]),
+    priority: z.enum(["critical", "important", "normal", "contextual"]), status: z.enum(["active", "superseded", "deprecated", "consolidated", "duplicate", "disputed"]),
+    title: z.string(), content: z.string(), createdAt: z.string(), updatedAt: z.string(), sourceSessions: z.array(z.string()),
+    derivedFrom: z.array(z.string()), supersedes: z.array(z.string()), related: z.array(z.string()),
+    relations: z.array(z.object({ type: z.enum(["related_to", "depends_on", "implements", "applies_to", "supersedes", "superseded_by", "consolidates", "consolidated_into", "contradicts", "learned_from"]), target: z.string() }).strict()).optional(),
+    evidence: z.array(z.object({ kind: z.enum(["session_observation", "source_file", "test", "git_commit", "documentation", "user_instruction"]), ref: z.string() }).strict()).optional(),
+}).strict();
+const promotionActionSchema = z.object({
+    disposition: dispositionSchema, localIds: z.array(z.string()).min(1), targetId: z.string().nullable(), before: itemSchema.nullable(), draft: itemSchema.nullable(),
+    reason: z.string(), recommended: z.boolean(), recommendationSignals: z.array(z.string()),
+}).strict();
+export const promotionPreviewSchema = z.object({
+    version: z.literal(1), previewId: z.string(), createdAt: z.string(), mode: z.enum(["deterministic", "assisted"]), notice: z.string().optional(),
+    actions: z.array(promotionActionSchema), revisions: z.array(revisionSchema),
+    summary: z.object({ new: z.number(), merge: z.number(), supersede: z.number(), covered: z.number(), conflict: z.number() }).strict(),
+}).strict();
+const withPromotionLock = (root, operation, options) => ownsSyncLock(root) ? operation() : withSyncLock(root, operation, options);
+const unique = (values) => [...new Set(values)].sort();
+const current = (item) => item.status === "active" || item.status === "disputed";
+const samePolicy = (a, b) => a.contextPolicy === b.contextPolicy && a.authority === b.authority;
+const sameBoundary = (a, b) => a.scope === b.scope && a.scopeRef === b.scopeRef && a.scopeKind === b.scopeKind && a.category === b.category && sameApplicability(a, b);
+function similarity(a, b) {
+    const left = new Set(a.tokens), right = new Set(b.tokens);
+    const intersection = [...left].filter((token) => right.has(token)).length;
+    return intersection / Math.max(1, Math.min(left.size, right.size));
+}
+export function promotionSignals(local, versioned, now = new Date()) {
+    let score = 0;
+    const signals = [];
+    if (local.sourceSessionCount >= 2) {
+        score += 2;
+        signals.push(`Recurred across ${local.sourceSessionCount} sessions`);
+    }
+    if (local.priority === "critical") {
+        score += 3;
+        signals.push("Critical knowledge");
+    }
+    else if (local.priority === "important") {
+        score += 2;
+        signals.push("Important knowledge");
+    }
+    if (["principle", "invariant", "constraint", "instruction", "decision"].includes(local.category)) {
+        score += 2;
+        signals.push(`Architecturally significant ${local.category}`);
+    }
+    const ageDays = (now.getTime() - Date.parse(local.updatedAt)) / 86_400_000;
+    if (Number.isFinite(ageDays) && ageDays >= 7) {
+        score += 1;
+        signals.push("Persisted locally for at least seven days");
+    }
+    if (local.relations.length || local.related.length) {
+        score += 1;
+        signals.push("Connected to other knowledge");
+    }
+    const covered = versioned.some((item) => sameBoundary(local, item) && samePolicy(local, item) && item.normalizedContent === local.normalizedContent);
+    if (!covered) {
+        score += 1;
+        signals.push("Not already covered by Versioned Knowledge");
+    }
+    return { score, signals, recommended: score >= 4 && !covered };
+}
+export async function promotionRecommendations(root, options = {}) {
+    const catalog = await loadMemoryCatalog(root, options);
+    const versioned = catalog.summaries.filter((item) => item.layer === "versioned" && current(item));
+    return catalog.summaries.filter((item) => item.layer === "local" && current(item)).map((item) => ({ id: item.id, title: item.title, ...promotionSignals(item, versioned) }))
+        .sort((a, b) => Number(b.recommended) - Number(a.recommended) || b.score - a.score || a.id.localeCompare(b.id));
+}
+function draftFromLocal(local, now, target) {
+    return target ? {
+        ...target, title: local.title, content: local.content, updatedAt: now,
+        sourceSessions: unique([...target.sourceSessions, ...local.sourceSessions]), derivedFrom: unique([...target.derivedFrom, ...local.derivedFrom]),
+        related: unique([...target.related, ...local.related, local.id]), relations: [...(target.relations ?? []), ...(local.relations ?? [])].filter((relation, index, all) => all.findIndex((other) => other.type === relation.type && other.target === relation.target) === index),
+        evidence: [...(target.evidence ?? []), ...(local.evidence ?? [])],
+    } : { ...local, id: sortableId("mem"), status: "active", createdAt: now, updatedAt: now, related: unique(local.related) };
+}
+function deterministicAction(local, localSummary, candidates, recommendation, now) {
+    const exact = candidates.find(({ item }) => sameBoundary(local, item) && samePolicy(local, item) && exactKnowledge(item.content) === exactKnowledge(local.content));
+    if (exact)
+        return { disposition: "covered", localIds: [local.id], targetId: exact.item.id, before: exact.item, draft: null, reason: "Versioned Knowledge already covers the local knowledge exactly.", recommended: recommendation.recommended, recommendationSignals: recommendation.signals };
+    if (local.status === "disputed")
+        return { disposition: "conflict", localIds: [local.id], targetId: null, before: null, draft: null, reason: "Disputed Local Knowledge requires focused human resolution before publication.", recommended: recommendation.recommended, recommendationSignals: recommendation.signals };
+    const explicit = candidates.find(({ item }) => local.supersedes.includes(item.id));
+    if (explicit) {
+        const draft = draftFromLocal(local, now);
+        draft.supersedes = unique([...draft.supersedes, explicit.item.id]);
+        return { disposition: "supersede", localIds: [local.id], targetId: explicit.item.id, before: explicit.item, draft, reason: "The local knowledge explicitly supersedes current Versioned Knowledge.", recommended: recommendation.recommended, recommendationSignals: recommendation.signals };
+    }
+    const related = candidates.filter(({ item }) => sameBoundary(local, item) && samePolicy(local, item)).sort((a, b) => similarity(localSummary, b.summary) - similarity(localSummary, a.summary) || a.item.id.localeCompare(b.item.id))[0];
+    if (related) {
+        const score = similarity(localSummary, related.summary);
+        if (exactKnowledge(related.item.content).includes(exactKnowledge(local.content)))
+            return { disposition: "covered", localIds: [local.id], targetId: related.item.id, before: related.item, draft: null, reason: "Versioned Knowledge already contains the local observation.", recommended: recommendation.recommended, recommendationSignals: recommendation.signals };
+        if (score >= 0.65 && exactKnowledge(local.content).includes(exactKnowledge(related.item.content)))
+            return { disposition: "merge", localIds: [local.id], targetId: related.item.id, before: related.item, draft: draftFromLocal(local, now, related.item), reason: "The local observation extends an existing Versioned Knowledge item.", recommended: recommendation.recommended, recommendationSignals: recommendation.signals };
+    }
+    return { disposition: "new", localIds: [local.id], targetId: null, before: null, draft: draftFromLocal(local, now), reason: "No sufficiently similar Versioned Knowledge item covers this durable local knowledge.", recommended: recommendation.recommended, recommendationSignals: recommendation.signals };
+}
+async function assistedAction(provider, local, deterministic, candidates, now) {
+    const localTokens = tokens(`${local.title} ${local.content} ${local.scopeRef ?? ""}`);
+    const related = candidates.filter(({ item }) => sameBoundary(local, item) && samePolicy(local, item)).sort((a, b) => b.summary.tokens.filter((token) => localTokens.has(token)).length - a.summary.tokens.filter((token) => localTokens.has(token)).length || a.item.id.localeCompare(b.item.id)).slice(0, 12).map(({ item }) => item);
+    const candidate = { id: `candidate_${local.id}`, kind: "knowledge", title: local.title, content: local.content, category: local.category, scope: local.scope, scopeRef: local.scopeRef, scopeKind: local.scopeKind, priority: local.priority, applicability: local.applicability, sources: [local.id], evidence: [{ source: local.id, quote: local.content }], supersedes: local.supersedes };
+    const telemetry = intelligenceTelemetry(provider);
+    const response = await reconcileCandidate(candidate, related, provider, telemetry);
+    const targetId = response.sources.find((id) => id !== candidate.id) ?? null;
+    const target = targetId ? related.find((item) => item.id === targetId) : undefined;
+    const base = { localIds: [local.id], recommended: deterministic.recommended, recommendationSignals: deterministic.recommendationSignals, reason: response.reason };
+    if (response.action === "CREATE" && !targetId)
+        return { ...base, disposition: "new", targetId: null, before: null, draft: draftFromLocal(local, now) };
+    if (response.action === "NO_CHANGE" && target)
+        return { ...base, disposition: "covered", targetId, before: target, draft: null };
+    if (response.action === "MERGE" && target && response.canonical && sameBoundary(local, target) && sameBoundary({ ...response.canonical, applicability: response.canonical.applicability ?? target.applicability }, target) && isExtractivelyGrounded(response.canonical.content, [local.content, target.content])) {
+        return { ...base, disposition: "merge", targetId, before: target, draft: { ...draftFromLocal(local, now, target), ...response.canonical } };
+    }
+    if (response.action === "SUPERSEDE" && target && local.supersedes.includes(target.id)) {
+        const draft = draftFromLocal(local, now);
+        draft.supersedes = unique([...draft.supersedes, target.id]);
+        return { ...base, disposition: "supersede", targetId, before: target, draft };
+    }
+    if ((response.action === "CONFLICT" || response.action === "UNCERTAIN") && target)
+        return { ...base, disposition: "conflict", targetId, before: target, draft: null };
+    if (response.action === "LINK" && target) {
+        const draft = draftFromLocal(local, now);
+        draft.relations = [...(draft.relations ?? []), { type: "related_to", target: target.id }];
+        return { ...base, disposition: "new", targetId: null, before: null, draft };
+    }
+    return deterministic;
+}
+export async function previewKnowledgePromotion(root, options = {}) {
+    const catalog = await loadMemoryCatalog(root);
+    const localSummaries = catalog.summaries.filter((item) => item.layer === "local" && current(item));
+    const versionedSummaries = catalog.summaries.filter((item) => item.layer === "versioned" && current(item));
+    const recommendations = new Map(localSummaries.map((item) => [item.id, promotionSignals(item, versionedSummaries)]));
+    const selected = localSummaries.filter((item) => options.ids?.length ? options.ids.includes(item.id) : options.includeAll === false ? recommendations.get(item.id).recommended : true);
+    if (options.ids?.some((id) => !selected.some((item) => item.id === id)))
+        throw new Error("Promotion requires current Local Knowledge ids.");
+    const versioned = await Promise.all(versionedSummaries.map(async (summary) => ({ summary, item: await catalog.load(summary.id) })));
+    const now = new Date().toISOString();
+    const actions = [];
+    let notice;
+    for (const summary of selected.sort((a, b) => a.id.localeCompare(b.id))) {
+        const local = await catalog.load(summary.id);
+        const fallback = deterministicAction(local, summary, versioned, recommendations.get(summary.id), now);
+        if (options.provider && local.status !== "disputed") {
+            try {
+                actions.push(await assistedAction(options.provider, local, fallback, versioned, now));
+            }
+            catch {
+                actions.push(fallback);
+                notice = "Semantic reasoning was unavailable for at least one candidate; conservative deterministic proposals are shown.";
+            }
+        }
+        else
+            actions.push(fallback);
+    }
+    const targetWriters = new Map();
+    for (const action of actions.filter((candidate) => candidate.targetId && (candidate.disposition === "merge" || candidate.disposition === "supersede"))) {
+        const group = targetWriters.get(action.targetId) ?? [];
+        group.push(action);
+        targetWriters.set(action.targetId, group);
+    }
+    for (const group of targetWriters.values()) {
+        if (group.length < 2)
+            continue;
+        const superseding = group.filter((action) => action.disposition === "supersede");
+        const keep = superseding.length === 1 ? superseding[0] : null;
+        for (const action of group)
+            if (action !== keep)
+                Object.assign(action, { disposition: "conflict", draft: null, reason: "Multiple local proposals would modify the same Versioned Knowledge item; consolidate this conflict in a fresh focused review." });
+    }
+    const promotedIds = new Map();
+    for (const action of actions)
+        if (action.disposition !== "conflict") {
+            const publishedId = action.disposition === "covered" || action.disposition === "merge" ? action.targetId : action.draft?.id;
+            if (publishedId)
+                for (const id of action.localIds)
+                    promotedIds.set(id, publishedId);
+        }
+    for (const action of actions)
+        if (action.draft) {
+            action.draft.related = unique(action.draft.related.map((id) => promotedIds.get(id) ?? id));
+            action.draft.supersedes = unique(action.draft.supersedes.map((id) => promotedIds.get(id) ?? id));
+            action.draft.relations = (action.draft.relations ?? []).map((relation) => ({ ...relation, target: promotedIds.get(relation.target) ?? relation.target }));
+        }
+    const involved = new Set(actions.flatMap((action) => [...action.localIds, ...(action.targetId ? [action.targetId] : [])]));
+    const revisions = await Promise.all(catalog.summaries.filter((item) => involved.has(item.id)).map(async (item) => ({ id: item.id, layer: item.layer, path: item.relativePath, hash: (await fileHash(await safeProjectPath(root, item.relativePath))) })));
+    const summary = { new: 0, merge: 0, supersede: 0, covered: 0, conflict: 0 };
+    for (const action of actions)
+        summary[action.disposition]++;
+    const base = promotionPreviewSchema.omit({ previewId: true }).parse({ version: 1, createdAt: now, mode: options.provider ? "assisted" : "deterministic", ...(notice ? { notice } : {}), actions, revisions: revisions.sort((a, b) => a.path.localeCompare(b.path)), summary });
+    return { ...base, previewId: sha256(JSON.stringify(base)) };
+}
+export async function applyKnowledgePromotion(root, rawPreview, approved) {
+    assertNoSecrets(rawPreview);
+    if (!approved)
+        throw new Error("Versioned Knowledge promotion requires workflow approval of the exact preview.");
+    const preview = promotionPreviewSchema.parse(rawPreview);
+    const { previewId, ...base } = preview;
+    if (sha256(JSON.stringify(base)) !== previewId)
+        throw new Error("Promotion preview was modified; generate a fresh review.");
+    return withPromotionLock(root, async () => {
+        await recoverSyncTransaction(root);
+        const previous = (await listCheckpoints(root)).find(c => c.note === `Approved Local to Versioned Knowledge promotion ${previewId}`);
+        if (previous)
+            return { previewId, checkpoint: previous.id, created: previous.createdMemory, updated: previous.updatedMemory, superseded: previous.supersededMemory, covered: previous.duplicateMemory, conflicts: previous.conflicts, published: previous.createdMemory.length + previous.updatedMemory.length, alreadyApplied: true, revisions: previous.promotionRevisions ?? [] };
+        for (const revision of preview.revisions)
+            if (await fileHash(await safeProjectPath(root, revision.path)) !== revision.hash)
+                throw new Error("Knowledge changed after promotion review; generate a fresh preview.");
+        const catalog = await loadMemoryCatalog(root);
+        const writes = [];
+        const created = [], updated = [], superseded = [], covered = [], conflicts = [];
+        const now = new Date().toISOString();
+        for (const action of preview.actions) {
+            const local = await catalog.load(action.localIds[0]);
+            const localSummary = catalog.summaries.find((item) => item.id === local.id && item.layer === "local");
+            if (!localSummary)
+                throw new Error("Promotion candidate is no longer Local Knowledge.");
+            if (action.disposition === "conflict") {
+                conflicts.push(local.id);
+                continue;
+            }
+            const localUpdated = { ...local, status: action.disposition === "covered" ? "duplicate" : "consolidated", updatedAt: now, related: unique([...local.related, ...(action.targetId ? [action.targetId] : []), ...(action.draft ? [action.draft.id] : [])]) };
+            writes.push({ path: localSummary.relativePath, before: (await fileHash(await safeProjectPath(root, localSummary.relativePath))), after: renderKnowledge(localUpdated) });
+            if (action.disposition === "covered") {
+                covered.push(local.id);
+                continue;
+            }
+            if (!action.draft)
+                throw new Error("Publishable promotion action is missing a reviewed draft.");
+            if (action.disposition === "merge") {
+                const target = catalog.summaries.find((item) => item.id === action.targetId && item.layer === "versioned");
+                if (!target || action.draft.id !== target.id)
+                    throw new Error("Merge target is not current Versioned Knowledge.");
+                writes.push({ path: target.relativePath, before: (await fileHash(await safeProjectPath(root, target.relativePath))), after: renderKnowledge(action.draft) });
+                updated.push(target.id);
+            }
+            else {
+                writes.push({ path: `memory/${action.draft.id}.md`, before: null, after: renderKnowledge(action.draft) });
+                created.push(action.draft.id);
+                if (action.disposition === "supersede") {
+                    const targetSummary = catalog.summaries.find((item) => item.id === action.targetId && item.layer === "versioned");
+                    if (!targetSummary)
+                        throw new Error("Supersession target is not current Versioned Knowledge.");
+                    const target = await catalog.load(targetSummary.id);
+                    const retired = { ...target, status: "superseded", updatedAt: now, related: unique([...target.related, action.draft.id]) };
+                    writes.push({ path: targetSummary.relativePath, before: (await fileHash(await safeProjectPath(root, targetSummary.relativePath))), after: renderKnowledge(retired) });
+                    superseded.push(target.id);
+                }
+            }
+        }
+        const checkpointId = sortableId("chk");
+        const checkpoints = await listCheckpoints(root);
+        const checkpoint = { id: checkpointId, createdAt: now, previousCheckpoint: checkpoints.at(-1)?.id ?? null, sessions: [], consolidation: "not-performed", createdMemory: created, createdSkills: [], updatedMemory: updated, supersededMemory: superseded, duplicateMemory: covered, conflicts, summary: { sessions: 0, candidates: preview.actions.length, created: created.length, consolidated: updated.length, duplicates: covered.length, superseded: superseded.length, conflicts: conflicts.length }, promotionRevisions: writes.map(w => ({ path: w.path, hash: sha256(w.after) })), note: `Approved Local to Versioned Knowledge promotion ${preview.previewId}` };
+        await commitSyncTransaction(root, [...writes, { path: `checkpoints/${checkpointId}.json`, before: null, after: `${JSON.stringify(checkpoint, null, 2)}\n` }], { policyMode: "exact" });
+        await buildIndex(root);
+        return { previewId, checkpoint: checkpointId, created, updated, superseded, covered, conflicts, published: created.length + updated.length, alreadyApplied: false, revisions: checkpoint.promotionRevisions };
+    });
+}
+//# sourceMappingURL=promotion.js.map

package/dist/core/reconciliation.js

@@ -0,0 +1,61 @@
+import { exactKnowledge, evidenceSentences } from './semantic-safety.js';
+import { intelligenceTelemetry, INTELLIGENCE_LIMITS, reconcileSchema, requestIntelligence } from './intelligence.js';
+import { estimateTokens } from './telemetry.js';
+/** Offline classification uses proof, not polarity, titles, dates or token overlap. */
+export function deterministicClassification(candidate, old) {
+    if (candidate.supersedes.includes(old.id))
+        return 'state_transition';
+    if (exactKnowledge(candidate.content) === exactKnowledge(old.content))
+        return 'duplicate';
+    const incoming = evidenceSentences(candidate.content), previous = evidenceSentences(old.content);
+    if (incoming.every(s => previous.includes(s)))
+        return 'supporting';
+    if (previous.every(s => incoming.includes(s)))
+        return 'refinement';
+    return 'unresolved';
+}
+/** Legacy actions remain readable; uncertainty alone never establishes incompatibility. */
+export function actionClassification(action) {
+    return action.classification ?? { SUPERSEDE: 'state_transition', MERGE: 'refinement', NO_CHANGE: 'supporting', CONFLICT: 'potential_conflict', UNCERTAIN: 'unresolved', LINK: 'independent', CREATE: 'independent' }[action.action];
+}
+export function normalizeReconciliation(action, hasCandidate = true) {
+    const classification = actionClassification(action);
+    if (classification === 'potential_conflict' && action.sources.length < 2)
+        throw new Error('Potential conflict requires incompatible evidence.');
+    if (action.action === 'SUPERSEDE' && classification !== 'state_transition')
+        throw new Error('Supersession requires state_transition classification.');
+    if (action.action === 'NO_CHANGE' && !['duplicate', 'supporting'].includes(classification))
+        throw new Error('No change requires duplicate or supporting evidence.');
+    if (classification === 'potential_conflict' && !['CONFLICT', 'UNCERTAIN'].includes(action.action))
+        throw new Error('Potential conflict requires a conflict action.');
+    if (['CONFLICT', 'UNCERTAIN'].includes(action.action) && classification !== 'potential_conflict') {
+        return { ...action, classification, action: !hasCandidate || action.sources.length > 1 ? 'LINK' : 'CREATE', canonical: null };
+    }
+    return { ...action, classification };
+}
+/** Both session review and consolidation use this bounded semantic reconciliation path. */
+export async function reconcileCandidate(candidate, related, provider, telemetry = intelligenceTelemetry(provider)) {
+    const bounded = [];
+    for (const old of related.slice(0, INTELLIGENCE_LIMITS.relatedMemories)) {
+        if (estimateTokens(JSON.stringify({ candidate, related: [...bounded, old] })) <= INTELLIGENCE_LIMITS.reconcileInputTokens)
+            bounded.push(old);
+    }
+    const action = reconcileSchema.parse(await requestIntelligence(provider, 'reconcile', { candidate, related: bounded }, telemetry)).actions[0];
+    const allowed = new Set([candidate.id, ...bounded.map(m => m.id)]);
+    if (!action.sources.includes(candidate.id) || new Set(action.sources).size !== action.sources.length || action.sources.some(id => !allowed.has(id)))
+        throw new Error('Invalid reconciliation sources: unknown, duplicate or out-of-area ID.');
+    return normalizeReconciliation(action);
+}
+export function reconciliationSignal(kind, memory) {
+    const detail = {
+        state_transition: 'Knowledge evolution detected — newer evidence updates earlier project state.',
+        refinement: 'Knowledge refined — newer evidence adds detail to earlier knowledge.',
+        duplicate: 'Already covered by existing knowledge.',
+        supporting: 'Supporting evidence confirms earlier knowledge.',
+        potential_conflict: 'Potential conflict — incompatible claims need review to determine the current state.',
+        unresolved: 'Related evidence will be reconciled during consolidation.',
+        independent: 'Related knowledge provides additional context.',
+    }[kind];
+    return { kind, detail, severity: kind === 'potential_conflict' ? 'warning' : 'info', requiresReview: kind === 'potential_conflict', ...(memory ? { memory: { id: memory.id, title: memory.title, content: memory.content } } : {}) };
+}
+//# sourceMappingURL=reconciliation.js.map

package/dist/core/secrets.js

@@ -0,0 +1,67 @@
+/** Best-effort screening, shared by core storage and plugin/provider boundaries. Not complete DLP. */
+function placeholder(value) {
+    return /^(?:<[^>]+>|\$[\w{][\w}]*|\$\{[^}]+\}|process\.env\.[\w]+|os\.environ(?:\[[^\]]+\]|\.get\([^)]*\))|example|placeholder|changeme|your[_-].*|redacted|\*+|x{3,}|undefined|null)$/i.test(value);
+}
+export function hasSecret(value) {
+    if (/-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|npm_[A-Za-z0-9]{20,}|(?:AKIA|ASIA)[0-9A-Z]{16})\b|https?:\/\/[^\s/:]+:[^\s/@]+@/i.test(value))
+        return true;
+    // Require a credential field and an assigned value, not a mention of a sensitive word.
+    // Prefix components cover SERVICE_PASSWORD, AWS_SECRET_ACCESS_KEY and vendor TOKEN names.
+    const assignment = /\b((?:[a-z][a-z0-9]*[_-])*_?(?:password|passwd|secret|api[_-]?key|access[_-]?token|auth[_-]?token|refresh[_-]?token|session[_-]?token|client[_-]?secret|secret[_-]?(?:access[_-]?)?key|access[_-]?key[_-]?id|private[_-]?key|account[_-]?key|shared[_-]?access[_-]?signature|authorization)|[a-z][a-z0-9]*(?:[_-][a-z0-9]+)*[_-]token|_auth)[ \t]*["']?[ \t]*(:(?!:)|=(?!=|>))[ \t]*(?:"([^"\r\n]*)"|'([^'\r\n]*)'|`([^`\r\n]*)`|([^\s\\"',;]+))/gi;
+    for (let match; (match = assignment.exec(value)) !== null;) {
+        // An inline Markdown span can end immediately after a field name (`authorization:`).
+        // That closing backtick is not the opening quote of a credential value. Resume
+        // after it so a later assignment in the same prose is still screened.
+        if (match[5] !== undefined && match[2] === ':') {
+            const opening = match.index + match[0].indexOf('`');
+            const lineStart = value.lastIndexOf('\n', match.index - 1) + 1;
+            const preceding = value.slice(lineStart, opening).match(/`+/g) ?? [];
+            const spanStart = value.lastIndexOf('`', opening - 1) + 1;
+            const heading = value.slice(spanStart, opening);
+            if (preceding.filter(run => run.length === 1).length % 2 === 1 && /^[A-Za-z][A-Za-z \t-]*:$/.test(heading)) {
+                assignment.lastIndex = opening + 1;
+                continue;
+            }
+        }
+        const quoted = match[3] !== undefined || match[4] !== undefined || match[5] !== undefined;
+        const token = (match[3] ?? match[4] ?? match[5] ?? match[6]).trim();
+        // This exact Core workflow enum describes review semantics, not a credential.
+        // Do not exempt other authorization values or the same literal in credential fields.
+        if (match[1].toLowerCase() === 'authorization' && token === 'explicit_workflow_and_exact_preview_required')
+            continue;
+        if (placeholder(token) || /^(?:Bearer|Basic) /i.test(token) && placeholder(token.replace(/^(?:Bearer|Basic) +/i, '')))
+            continue;
+        // Ordinary type declarations, variable/member references and function calls aren't literals.
+        const declaration = /\b(?:const|let|var)\s+$/.test(value.slice(Math.max(0, match.index - 16), match.index));
+        if (!quoted && (/^(?:string|number|boolean|unknown|any|never|true|false|password|token|secret)[)}\]]*$/i.test(token) || /^(?:process\.env|os\.environ|config|env|settings)[.\[]/.test(token) || declaration && /^[A-Za-z_$][\w$]*(?:[.(\[]|$)/.test(token)))
+            continue;
+        if (/^(?:Bearer|Basic)$/i.test(token))
+            continue;
+        if (token.length >= 6)
+            return true;
+    }
+    // Unquoted HTTP authorization headers have a scheme followed by the credential.
+    for (const match of value.matchAll(/\bauthorization[ \t]*:[ \t]*(?:Bearer|Basic)[ \t]+([^\s"',;]+)/gi)) {
+        if (match[1].length >= 6 && !placeholder(match[1]))
+            return true;
+    }
+    // Sampling/import boundaries also pass JSON-encoded source strings. Decode valid JSON
+    // rather than letting escaped quotes hide an assignment from the same detector.
+    if (/^\s*[\[{"]/.test(value)) {
+        try {
+            const parsed = JSON.parse(value);
+            if (typeof parsed === 'string')
+                return hasSecret(parsed);
+            if (parsed && typeof parsed === 'object')
+                return secretStrings(parsed).some(hasSecret);
+        }
+        catch { /* Ordinary source code is not JSON. */ }
+    }
+    return false;
+}
+const secretStrings = (input) => typeof input === 'string' ? [input] : Array.isArray(input) ? input.flatMap(secretStrings) : input && typeof input === 'object' ? Object.entries(input).flatMap(([key, v]) => [typeof v === 'string' ? `${key}=${JSON.stringify(v)}` : '', ...secretStrings(v)]) : [];
+export function assertNoSecrets(value) {
+    if (secretStrings(value).some(hasSecret))
+        throw new Error('Potential credential detected. Remove secrets before storing or sharing Prodero content. No secret value is included in this diagnostic.');
+}
+//# sourceMappingURL=secrets.js.map

package/dist/core/semantic-safety.js

@@ -0,0 +1,33 @@
+/** Order and punctuation are evidence. Retrieval's bag-of-words key is not an equality key. */
+export function exactKnowledge(value) { return value.trim().replace(/\s+/g, ' '); }
+const groups = [
+    /\b(?:not|never|no|without|cannot|can't|isn't|doesn't)\b/gi,
+    /\b(?:enabled|disabled)\b/gi, /\b(?:allowed|forbidden|prohibited)\b/gi,
+    /\b(?:before|after)\b/gi, /\b(?:required|optional)\b/gi,
+    /\b(?:always|sometimes)\b/gi, /\bv?\d+(?:\.\d+)*\b/gi,
+];
+const words = (s) => s.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+export function semanticRisk(a, b) {
+    if (exactKnowledge(a) === exactKnowledge(b))
+        return false;
+    const left = words(a), right = words(b);
+    // A bag-of-words match with a different sequence must never imply equality.
+    if (left.slice().sort().join(' ') === right.slice().sort().join(' ') && left.join(' ') !== right.join(' '))
+        return true;
+    if ((/[→←]|->|<-/.test(a + b)) && exactKnowledge(a) !== exactKnowledge(b))
+        return true;
+    return groups.some((pattern) => {
+        const x = [...new Set(a.toLowerCase().match(pattern) ?? [])].sort().join('|');
+        const y = [...new Set(b.toLowerCase().match(pattern) ?? [])].sort().join('|');
+        return x !== y && Boolean(x || y);
+    });
+}
+export function evidenceSentences(content) {
+    return content.split(/(?:\r?\n)+|(?<=[.!?])\s+/u).map(exactKnowledge).filter(Boolean);
+}
+/** MVP uses extractive factual bodies: the model can select/compact, but cannot manufacture sentences. */
+export function isExtractivelyGrounded(content, sources) {
+    const allowed = new Set(sources.flatMap(evidenceSentences));
+    return evidenceSentences(content).every((sentence) => allowed.has(sentence));
+}
+//# sourceMappingURL=semantic-safety.js.map

package/dist/core/session-index.js

@@ -0,0 +1,112 @@
+import { z } from "zod";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { parseFrontmatter } from "./format.js";
+import { parseSession } from "./sessions.js";
+import { ensureDerivedStateRoot, exists, projectDataPath, checkedDataPath, parseCheckpointData, sha256, writeFileAtomic } from "./storage.js";
+const EMPTY_CACHE = { version: 3, checkpoints: {}, sessions: {} };
+function stamp(stat) { return { size: Number(stat.size), mtimeMs: Number(stat.mtimeMs), ctimeMs: Number(stat.ctimeMs) }; }
+function sameStamp(left, right) { return Boolean(left && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs); }
+const stampSchema = z.object({ size: z.number().nonnegative(), mtimeMs: z.number().finite(), ctimeMs: z.number().finite() });
+const cacheSchema = z.object({
+    version: z.literal(3),
+    checkpoints: z.record(stampSchema.extend({ id: z.string(), createdAt: z.string(), processedKeys: z.array(z.string()), observationHashes: z.array(z.string()).optional() })),
+    sessions: z.record(stampSchema.extend({ id: z.string(), parentSessionId: z.string().regex(/^sess_[a-zA-Z0-9_]+$/).optional(), sha256: z.string().regex(/^[a-f0-9]{64}$/), status: z.enum(["active", "open", "closed"]), hasObservations: z.boolean() })),
+});
+async function readCache(root) {
+    await ensureDerivedStateRoot(root);
+    const target = await checkedDataPath(root, ".cache", "session-index.json");
+    if (!(await exists(target)))
+        return { cache: structuredClone(EMPTY_CACHE), state: "missing" };
+    try {
+        const parsed = cacheSchema.parse(JSON.parse(await fs.readFile(target, "utf8")));
+        return { cache: parsed, state: "warm" };
+    }
+    catch {
+        // Disposable derived JSON is rebuilt below; canonical sessions/checkpoints remain authoritative.
+    }
+    await fs.rm(target, { force: true });
+    return { cache: structuredClone(EMPTY_CACHE), state: "invalid" };
+}
+function parseCheckpoint(content, filename) {
+    const checkpoint = parseCheckpointData(content, filename);
+    return { observationHashes: checkpoint.observationHashes ?? [], id: checkpoint.id, createdAt: checkpoint.createdAt, processedKeys: checkpoint.sessions.map((session) => `${session.path}:${session.sha256}`), size: 0, mtimeMs: 0, ctimeMs: 0 };
+}
+export async function discoverSessions(root, options = {}) {
+    const { cache, state } = await readCache(root);
+    const nextCheckpoints = {};
+    const processed = new Set();
+    const processedObservations = new Set();
+    let checkpointFilesRead = 0;
+    const checkpointDirectory = await checkedDataPath(root, "checkpoints");
+    const checkpointNames = (await fs.readdir(checkpointDirectory)).filter((name) => name.endsWith(".json")).sort();
+    for (const name of checkpointNames) {
+        const target = await checkedDataPath(root, "checkpoints", name);
+        const fileStamp = stamp(await fs.stat(target));
+        let entry = cache.checkpoints[name];
+        if (!sameStamp(entry, fileStamp)) {
+            entry = { ...parseCheckpoint(await fs.readFile(target, "utf8"), name), ...fileStamp };
+            checkpointFilesRead += 1;
+        }
+        nextCheckpoints[name] = entry;
+        for (const hash of entry.observationHashes ?? [])
+            processedObservations.add(hash);
+        for (const key of entry.processedKeys)
+            processed.add(key);
+    }
+    const nextSessions = {};
+    const sessions = [];
+    let sessionBodiesRead = 0;
+    const sessionDirectory = await checkedDataPath(root, "sessions");
+    const sessionNames = (await fs.readdir(sessionDirectory)).filter((name) => name.endsWith(".md") && !name.startsWith(".")).sort();
+    for (const name of sessionNames) {
+        const target = await checkedDataPath(root, "sessions", name);
+        const fileStamp = stamp(await fs.stat(target));
+        let cached = cache.sessions[name];
+        let parsed;
+        if (!sameStamp(cached, fileStamp)) {
+            const content = await fs.readFile(target, "utf8");
+            sessionBodiesRead += 1;
+            parsed = parseSession(content, name);
+            if (name.startsWith("sess_")) {
+                const { metadata } = parseFrontmatter(content);
+                if (metadata.id !== path.basename(name, ".md") || !["open", "active", "closed"].includes(String(metadata.status)) || typeof metadata.created_at !== "string") {
+                    throw new Error(`Invalid Prodero session: ${name} metadata is missing, malformed, or does not match the filename.`);
+                }
+            }
+            cached = {
+                ...fileStamp,
+                id: parsed.id,
+                parentSessionId: parsed.parentSessionId,
+                sha256: sha256(content),
+                status: parsed.status,
+                hasObservations: Object.values(parsed.sections).some((items) => items.length > 0),
+            };
+        }
+        nextSessions[name] = cached;
+        const pending = cached.hasObservations && !processed.has(`${name}:${cached.sha256}`);
+        const needsBody = options.loadPendingBodies && pending && (!options.onlyClosed || cached.status === "closed");
+        if (needsBody && !parsed) {
+            parsed = parseSession(await fs.readFile(target, "utf8"), name);
+            sessionBodiesRead += 1;
+        }
+        sessions.push({ id: cached.id, parentSessionId: cached.parentSessionId, path: name, sha256: cached.sha256, status: cached.status, hasObservations: cached.hasObservations, pending, session: parsed });
+    }
+    const nextCache = { version: 3, checkpoints: nextCheckpoints, sessions: nextSessions };
+    await ensureDerivedStateRoot(root);
+    await writeFileAtomic(projectDataPath(root, ".cache", "session-index.json"), `${JSON.stringify(nextCache)}\n`);
+    const checkpointEntries = Object.values(nextCheckpoints).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return {
+        processedObservations,
+        processedSessionPaths: new Set([...processed].map(key => key.slice(0, key.lastIndexOf(":")))),
+        sessions,
+        checkpointCount: checkpointEntries.length,
+        latestCheckpointId: checkpointEntries.at(-1)?.id ?? null,
+        lastSyncAt: checkpointEntries.at(-1)?.createdAt ?? null,
+        sessionFilesScanned: sessionNames.length,
+        sessionBodiesRead,
+        checkpointFilesRead,
+        cacheState: state === "warm" && (sessionBodiesRead > 0 || checkpointFilesRead > 0) ? "stale" : state,
+    };
+}
+//# sourceMappingURL=session-index.js.map