@pellux/goodvibes-sdk 1.1.0 → 1.3.0

package/dist/platform/knowledge/service.js

@@ -8,6 +8,7 @@ import { renderKnowledgeMap } from './map.js';
 import { KnowledgeProjectionService } from './projections.js';
 import { KnowledgeSemanticService } from './semantic/index.js';
 import { KnowledgeStore } from './store.js';
+import { reviewKnowledgeNodeRecord, queryKnowledgeIssues, queryKnowledgeNodes, } from './service-node-admin.js';
 import { ingestBrowserKnowledge } from './browser-history/index.js';
 import { buildKnowledgePacket, buildKnowledgePacketSync, buildKnowledgePromptPacket, buildKnowledgePromptPacketSync, searchKnowledge, } from './packet.js';
 import { ingestKnowledgeArtifact, ingestKnowledgeBookmarkSeeds, ingestKnowledgeConnectorInput, ingestKnowledgeUrl, ingestKnowledgeWithConnector, importKnowledgeBookmarksFromFile, importKnowledgeUrlsFromFile, refreshKnowledgeSources, pickKnowledgeRefreshCandidates, recompileKnowledgeSource, } from './ingest.js';
@@ -175,59 +176,34 @@ export class KnowledgeService {
     listNodes(limit = 100) {
         return this.queryNodes({ limit }).items;
     }
+    /** The append-only revision history of a node, oldest first. (Defect 1.) */
+    listNodeRevisions(nodeId) {
+        return this.store.listNodeRevisions(nodeId);
+    }
+    /** Honest hard delete of a single node — removes the row and its history. (Defect 6.) */
+    async deleteNode(id) {
+        return { deleted: await this.store.deleteNode(id) };
+    }
+    /** Honest hard delete of a single source and its derived records. (Defect 6.) */
+    async deleteSource(id) {
+        return { deleted: await this.store.deleteSource(id) };
+    }
+    /** Merge one node into another, re-pointing cross-reference edges. (Defect 5.) */
+    async mergeNodes(loserId, winnerId) {
+        return this.store.mergeNodes(loserId, winnerId);
+    }
+    /** Accept/reject a pending node — the decide step that governs activation. (Defect 2.) */
+    async reviewNode(input) {
+        return reviewKnowledgeNodeRecord(this.store, input);
+    }
     queryNodes(input = {}) {
-        const limit = Math.max(1, input.limit ?? 100);
-        const offset = Math.max(0, input.offset ?? 0);
-        const queryTokens = tokenize(input.query ?? '');
-        const scopeLookup = this.getScopeLookup();
-        const items = this.store.listNodes(Number.MAX_SAFE_INTEGER).filter((node) => {
-            if (!knowledgeNodeMatchesScope(node, input, scopeLookup))
-                return false;
-            if (input.kind && node.kind !== input.kind)
-                return false;
-            if (input.status && node.status !== input.status)
-                return false;
-            if (queryTokens.length === 0)
-                return true;
-            const haystack = [
-                node.title,
-                node.summary ?? '',
-                node.aliases.join(' '),
-                JSON.stringify(node.metadata),
-            ].join(' ').toLowerCase();
-            return queryTokens.every((token) => haystack.includes(token));
-        });
-        return {
-            total: items.length,
-            items: items.slice(offset, offset + limit),
-        };
+        return queryKnowledgeNodes(this.store, this.getScopeLookup(), input);
     }
     listIssues(limit = 100) {
         return this.queryIssues({ limit }).items;
     }
     queryIssues(input = {}) {
-        const limit = Math.max(1, input.limit ?? 100);
-        const offset = Math.max(0, input.offset ?? 0);
-        const queryTokens = tokenize(input.query ?? '');
-        const scopeLookup = this.getScopeLookup();
-        const items = this.store.listIssues(Number.MAX_SAFE_INTEGER).filter((issue) => {
-            if (!knowledgeIssueMatchesScope(issue, input, scopeLookup))
-                return false;
-            if (input.severity && issue.severity !== input.severity)
-                return false;
-            if (input.status && issue.status !== input.status)
-                return false;
-            if (input.code && issue.code !== input.code)
-                return false;
-            if (queryTokens.length === 0)
-                return true;
-            const haystack = [issue.message, issue.code, JSON.stringify(issue.metadata)].join(' ').toLowerCase();
-            return queryTokens.every((token) => haystack.includes(token));
-        });
-        return {
-            total: items.length,
-            items: items.slice(offset, offset + limit),
-        };
+        return queryKnowledgeIssues(this.store, this.getScopeLookup(), input);
     }
     async reviewIssue(input) {
         return reviewKnowledgeIssue(this.store, input);

package/dist/platform/knowledge/store-config.d.ts

@@ -1,12 +1,46 @@
 export declare const REGULAR_KNOWLEDGE_DB_FILE = "knowledge-wiki.sqlite";
 export declare const HOME_GRAPH_KNOWLEDGE_DB_FILE = "knowledge-home-graph.sqlite";
 export declare const GOODVIBES_AGENT_KNOWLEDGE_DB_FILE = "knowledge-agent.sqlite";
+/**
+ * The three physically separate knowledge families. There is one KnowledgeStore
+ * class and one schema; the wall between the general wiki, the home-graph, and the
+ * agent personal-ops knowledge is held by construction — separate SQLite files
+ * opened by separate store instances. When a caller declares which family it is
+ * constructing, the store asserts the resolved file name matches that family so a
+ * mis-wired construction site fails loudly instead of silently sharing a file.
+ */
+export type KnowledgeStoreFamily = 'wiki' | 'home-graph' | 'agent';
+export declare const KNOWLEDGE_FAMILY_DB_FILE: Readonly<Record<KnowledgeStoreFamily, string>>;
 export interface KnowledgeStoreConfig {
     readonly dbPath?: string | undefined;
     readonly dbFileName?: string | undefined;
+    /**
+     * The knowledge family this store belongs to. When provided, the resolved db
+     * file name must match {@link KNOWLEDGE_FAMILY_DB_FILE} for that family, or
+     * construction throws — the cheap guard that turns a silent cross-family
+     * mis-wire into a loud failure.
+     */
+    readonly family?: KnowledgeStoreFamily | undefined;
+    /**
+     * Auto-accept confidence threshold for the node review gate. A synthesized node
+     * whose confidence is at or above this value is activated with honest
+     * 'auto-accepted' provenance; below it, the node is held as 'draft'
+     * (pending review) and is not served by search/ask until reviewed. Defaults to
+     * {@link DEFAULT_NODE_AUTO_ACCEPT_CONFIDENCE}.
+     */
+    readonly nodeAutoAcceptConfidence?: number | undefined;
     readonly configManager?: {
         getControlPlaneConfigDir?: (() => string) | undefined;
     };
 }
+/**
+ * Default auto-accept threshold. Chosen just below the lowest confidence the
+ * existing synthesis producers emit (deterministic facts at 45, deterministic
+ * wiki pages at 55) so those flows keep activating — now with honest,
+ * numeric provenance rather than silently — while genuinely low-confidence
+ * synthesized content (below 40) is held as 'draft' for review. The mechanism is
+ * the deliverable; consumers raise this threshold to hold more for review.
+ */
+export declare const DEFAULT_NODE_AUTO_ACCEPT_CONFIDENCE = 40;
 export declare function resolveKnowledgeDbPath(config: KnowledgeStoreConfig): string;
 //# sourceMappingURL=store-config.d.ts.map

package/dist/platform/knowledge/store-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-config.d.ts","sourceRoot":"","sources":["../../../src/platform/knowledge/store-config.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,yBAAyB,0BAA4B,CAAC;AACnE,eAAO,MAAM,4BAA4B,gCAAgC,CAAC;AAC1E,eAAO,MAAM,iCAAiC,2BAA2B,CAAC;AAE1E,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,aAAa,CAAC,EAAE;QACvB,wBAAwB,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;KACvD,CAAC;CACH;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,oBAAoB,GAAG,MAAM,CAS3E"}
+{"version":3,"file":"store-config.d.ts","sourceRoot":"","sources":["../../../src/platform/knowledge/store-config.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,yBAAyB,0BAA4B,CAAC;AACnE,eAAO,MAAM,4BAA4B,gCAAgC,CAAC;AAC1E,eAAO,MAAM,iCAAiC,2BAA2B,CAAC;AAE1E;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,YAAY,GAAG,OAAO,CAAC;AAEnE,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,MAAM,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAIlF,CAAC;AAEH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACnD;;;;;;OAMG;IACH,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvD,QAAQ,CAAC,aAAa,CAAC,EAAE;QACvB,wBAAwB,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;KACvD,CAAC;CACH;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,mCAAmC,KAAK,CAAC;AAEtD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,oBAAoB,GAAG,MAAM,CAmB3E"}

package/dist/platform/knowledge/store-config.js

@@ -1,7 +1,22 @@
+import { basename } from 'node:path';
 import { DEFAULT_KNOWLEDGE_DB_FILE, resolveKnowledgeDbPathFromControlPlaneDir, } from './store-schema.js';
 export const REGULAR_KNOWLEDGE_DB_FILE = DEFAULT_KNOWLEDGE_DB_FILE;
 export const HOME_GRAPH_KNOWLEDGE_DB_FILE = 'knowledge-home-graph.sqlite';
 export const GOODVIBES_AGENT_KNOWLEDGE_DB_FILE = 'knowledge-agent.sqlite';
+export const KNOWLEDGE_FAMILY_DB_FILE = Object.freeze({
+    wiki: REGULAR_KNOWLEDGE_DB_FILE,
+    'home-graph': HOME_GRAPH_KNOWLEDGE_DB_FILE,
+    agent: GOODVIBES_AGENT_KNOWLEDGE_DB_FILE,
+});
+/**
+ * Default auto-accept threshold. Chosen just below the lowest confidence the
+ * existing synthesis producers emit (deterministic facts at 45, deterministic
+ * wiki pages at 55) so those flows keep activating — now with honest,
+ * numeric provenance rather than silently — while genuinely low-confidence
+ * synthesized content (below 40) is held as 'draft' for review. The mechanism is
+ * the deliverable; consumers raise this threshold to hold more for review.
+ */
+export const DEFAULT_NODE_AUTO_ACCEPT_CONFIDENCE = 40;
 export function resolveKnowledgeDbPath(config) {
     const controlPlaneDir = typeof config.configManager?.getControlPlaneConfigDir === 'function'
         ? config.configManager.getControlPlaneConfigDir()
@@ -11,5 +26,13 @@ export function resolveKnowledgeDbPath(config) {
         : undefined);
     if (!dbPath)
         throw new Error('KnowledgeStore requires an explicit dbPath or configManager.getControlPlaneConfigDir().');
+    if (config.family) {
+        const expected = KNOWLEDGE_FAMILY_DB_FILE[config.family];
+        const actual = basename(dbPath);
+        if (actual !== expected) {
+            throw new Error(`KnowledgeStore family mismatch: constructed for '${config.family}' (expected file '${expected}') but resolved db file is '${actual}'. `
+                + 'This guards the wall between the wiki, home-graph, and agent knowledge families — the construction site is wired to the wrong file.');
+        }
+    }
     return dbPath;
 }

package/dist/platform/knowledge/store-load.d.ts

@@ -1,5 +1,5 @@
 import type { SQLiteStore } from '../state/sqlite-store.js';
-import type { KnowledgeConsolidationCandidateRecord, KnowledgeConsolidationReportRecord, KnowledgeEdgeRecord, KnowledgeExtractionRecord, KnowledgeIssueRecord, KnowledgeJobRunRecord, KnowledgeNodeRecord, KnowledgeRefinementTaskRecord, KnowledgeScheduleRecord, KnowledgeSourceRecord, KnowledgeUsageRecord } from './types.js';
+import type { KnowledgeConsolidationCandidateRecord, KnowledgeConsolidationReportRecord, KnowledgeEdgeRecord, KnowledgeExtractionRecord, KnowledgeIssueRecord, KnowledgeJobRunRecord, KnowledgeNodeRecord, KnowledgeNodeRevisionRecord, KnowledgeRefinementTaskRecord, KnowledgeScheduleRecord, KnowledgeSemanticEnrichmentStateRecord, KnowledgeSourceRecord, KnowledgeUsageRecord } from './types.js';
 export interface KnowledgeStoreSnapshot {
     readonly sources: KnowledgeSourceRecord[];
     readonly nodes: KnowledgeNodeRecord[];
@@ -12,6 +12,8 @@ export interface KnowledgeStoreSnapshot {
     readonly consolidationCandidates: KnowledgeConsolidationCandidateRecord[];
     readonly consolidationReports: KnowledgeConsolidationReportRecord[];
     readonly schedules: KnowledgeScheduleRecord[];
+    readonly nodeRevisions: KnowledgeNodeRevisionRecord[];
+    readonly semanticEnrichmentStates: KnowledgeSemanticEnrichmentStateRecord[];
 }
 export declare function loadKnowledgeStoreSnapshot(sqlite: SQLiteStore): KnowledgeStoreSnapshot;
 //# sourceMappingURL=store-load.d.ts.map

package/dist/platform/knowledge/store-load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-load.d.ts","sourceRoot":"","sources":["../../../src/platform/knowledge/store-load.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAc5D,OAAO,KAAK,EACV,qCAAqC,EACrC,kCAAkC,EAClC,mBAAmB,EACnB,yBAAyB,EACzB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,6BAA6B,EAC7B,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,qBAAqB,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,mBAAmB,EAAE,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,mBAAmB,EAAE,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC;IACxC,QAAQ,CAAC,WAAW,EAAE,yBAAyB,EAAE,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,qBAAqB,EAAE,CAAC;IAC1C,QAAQ,CAAC,eAAe,EAAE,6BAA6B,EAAE,CAAC;IAC1D,QAAQ,CAAC,YAAY,EAAE,oBAAoB,EAAE,CAAC;IAC9C,QAAQ,CAAC,uBAAuB,EAAE,qCAAqC,EAAE,CAAC;IAC1E,QAAQ,CAAC,oBAAoB,EAAE,kCAAkC,EAAE,CAAC;IACpE,QAAQ,CAAC,SAAS,EAAE,uBAAuB,EAAE,CAAC;CAC/C;AAQD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,WAAW,GAAG,sBAAsB,CActF"}
+{"version":3,"file":"store-load.d.ts","sourceRoot":"","sources":["../../../src/platform/knowledge/store-load.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAgB5D,OAAO,KAAK,EACV,qCAAqC,EACrC,kCAAkC,EAClC,mBAAmB,EACnB,yBAAyB,EACzB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,2BAA2B,EAC3B,6BAA6B,EAC7B,uBAAuB,EACvB,sCAAsC,EACtC,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,qBAAqB,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,mBAAmB,EAAE,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,mBAAmB,EAAE,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC;IACxC,QAAQ,CAAC,WAAW,EAAE,yBAAyB,EAAE,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,qBAAqB,EAAE,CAAC;IAC1C,QAAQ,CAAC,eAAe,EAAE,6BAA6B,EAAE,CAAC;IAC1D,QAAQ,CAAC,YAAY,EAAE,oBAAoB,EAAE,CAAC;IAC9C,QAAQ,CAAC,uBAAuB,EAAE,qCAAqC,EAAE,CAAC;IAC1E,QAAQ,CAAC,oBAAoB,EAAE,kCAAkC,EAAE,CAAC;IACpE,QAAQ,CAAC,SAAS,EAAE,uBAAuB,EAAE,CAAC;IAC9C,QAAQ,CAAC,aAAa,EAAE,2BAA2B,EAAE,CAAC;IACtD,QAAQ,CAAC,wBAAwB,EAAE,sCAAsC,EAAE,CAAC;CAC7E;AAQD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,WAAW,GAAG,sBAAsB,CAgBtF"}

package/dist/platform/knowledge/store-load.js

@@ -1,4 +1,4 @@
-import { mapCandidateRow, mapEdgeRow, mapExtractionRow, mapIssueRow, mapJobRunRow, mapNodeRow, mapRefinementTaskRow, mapReportRow, mapScheduleRow, mapSourceRow, mapUsageRow, } from './store-schema.js';
+import { mapCandidateRow, mapEdgeRow, mapExtractionRow, mapIssueRow, mapJobRunRow, mapNodeRevisionRow, mapNodeRow, mapRefinementTaskRow, mapReportRow, mapScheduleRow, mapSemanticEnrichmentStateRow, mapSourceRow, mapUsageRow, } from './store-schema.js';
 function loadRows(sqlite, sql, mapRow) {
     const rows = sqlite.exec(sql);
     if (!rows.length)
@@ -18,5 +18,7 @@ export function loadKnowledgeStoreSnapshot(sqlite) {
         consolidationCandidates: loadRows(sqlite, 'SELECT * FROM knowledge_consolidation_candidates', mapCandidateRow),
         consolidationReports: loadRows(sqlite, 'SELECT * FROM knowledge_consolidation_reports', mapReportRow),
         schedules: loadRows(sqlite, 'SELECT * FROM knowledge_schedules', mapScheduleRow),
+        nodeRevisions: loadRows(sqlite, 'SELECT * FROM knowledge_node_revisions ORDER BY node_id, revision', mapNodeRevisionRow),
+        semanticEnrichmentStates: loadRows(sqlite, 'SELECT * FROM knowledge_semantic_enrichment_state', mapSemanticEnrichmentStateRow),
     };
 }

package/dist/platform/knowledge/store-node-history.d.ts

@@ -0,0 +1,49 @@
+import type { SQLiteStore } from '../state/sqlite-store.js';
+import type { KnowledgeStore } from './store.js';
+import type { KnowledgeNodeRecord, KnowledgeNodeRevisionRecord, KnowledgeNodeUpsertInput, KnowledgeSemanticEnrichmentStateRecord } from './types.js';
+export declare function writeKnowledgeNodeRow(sqlite: SQLiteStore, record: KnowledgeNodeRecord): void;
+export declare function clampConfidence(value: number): number;
+/**
+ * Decide a node's effective status and stamp honest review provenance so a node is
+ * never silently active. (Invariants 2 & 4.)
+ * - An explicit producer status (or a review that applied facts) is honored and
+ *   labelled 'explicit'/'reviewed'.
+ * - An already-active node stays active; if it predates the gate it is labelled
+ *   'pre-gate' (folds/migrations never get downgraded).
+ * - A new/draft node auto-accepts at/above the configured confidence threshold
+ *   (labelled 'auto-accepted') or is held as 'draft' pending review otherwise.
+ */
+export declare function resolveNodeActivation(args: {
+    readonly input: KnowledgeNodeUpsertInput;
+    readonly existing: KnowledgeNodeRecord | undefined;
+    readonly confidence: number;
+    readonly metadata: Record<string, unknown>;
+    readonly now: number;
+    readonly autoAcceptConfidence: number;
+}): {
+    status: KnowledgeNodeRecord['status'];
+    metadata: Record<string, unknown>;
+};
+/**
+ * Record an append-only revision on a content-changing upsert: preserve the
+ * overwritten prior content and note what changed. (Invariant 8.)
+ */
+export declare function recordKnowledgeNodeRevisions(sqlite: SQLiteStore, nodeRevisions: Map<string, KnowledgeNodeRevisionRecord[]>, record: KnowledgeNodeRecord, existing: KnowledgeNodeRecord | undefined, now: number): void;
+export declare function listKnowledgeNodeRevisions(nodeRevisions: Map<string, KnowledgeNodeRevisionRecord[]>, nodeId: string): KnowledgeNodeRevisionRecord[];
+/**
+ * Merge one node into another: re-point every edge that referenced the loser onto
+ * the winner (deduping and dropping self-loops), record a `merged_into` edge, and
+ * mark the loser 'stale' with a `mergedInto` stamp. Keeps cross-references live on
+ * the surviving node. (Invariant 7.)
+ */
+export declare function mergeKnowledgeNodes(store: KnowledgeStore, loserId: string, winnerId: string): Promise<{
+    merged: boolean;
+    repointedEdges: number;
+}>;
+export declare function upsertKnowledgeSemanticEnrichmentState(sqlite: SQLiteStore, states: Map<string, KnowledgeSemanticEnrichmentStateRecord>, input: {
+    readonly sourceId: string;
+    readonly textHash?: string | undefined;
+    readonly enrichedAt?: number | undefined;
+    readonly metadata?: Record<string, unknown> | undefined;
+}): KnowledgeSemanticEnrichmentStateRecord;
+//# sourceMappingURL=store-node-history.d.ts.map

package/dist/platform/knowledge/store-node-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-node-history.d.ts","sourceRoot":"","sources":["../../../src/platform/knowledge/store-node-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EACV,mBAAmB,EAInB,2BAA2B,EAC3B,wBAAwB,EACxB,sCAAsC,EACvC,MAAM,YAAY,CAAC;AAEpB,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAmB5F;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUrD;AA0BD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,QAAQ,CAAC,KAAK,EAAE,wBAAwB,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACnD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;CACvC,GAAG;IAAE,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CA4D/E;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,2BAA2B,EAAE,CAAC,EACzD,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,EAAE,mBAAmB,GAAG,SAAS,EACzC,GAAG,EAAE,MAAM,GACV,IAAI,CAeN;AAED,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,2BAA2B,EAAE,CAAC,EACzD,MAAM,EAAE,MAAM,GACb,2BAA2B,EAAE,CAE/B;AAkGD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAAC,CAiDtD;AAED,wBAAgB,sCAAsC,CACpD,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,sCAAsC,CAAC,EAC3D,KAAK,EAAE;IACL,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CACzD,GACA,sCAAsC,CAyBxC"}

package/dist/platform/knowledge/store-node-history.js

@@ -0,0 +1,331 @@
+import { nowMs } from './store-schema.js';
+import { DEFAULT_NODE_AUTO_ACCEPT_CONFIDENCE } from './store-config.js';
+export function writeKnowledgeNodeRow(sqlite, record) {
+    sqlite.run(`
+    INSERT OR REPLACE INTO knowledge_nodes (
+      id, kind, slug, title, summary, aliases, status, confidence, source_id, metadata, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `, [
+        record.id,
+        record.kind,
+        record.slug,
+        record.title,
+        record.summary ?? null,
+        JSON.stringify([...record.aliases]),
+        record.status,
+        record.confidence,
+        record.sourceId ?? null,
+        JSON.stringify(record.metadata),
+        record.createdAt,
+        record.updatedAt,
+    ]);
+}
+export function clampConfidence(value) {
+    // A non-finite value (NaN/Infinity — slips past a `??` guard, which only catches
+    // null/undefined) resolves to the auto-accept default rather than poisoning the
+    // gate with `NaN >= threshold === false` and silently drafting the node forever.
+    if (!Number.isFinite(value))
+        return DEFAULT_NODE_AUTO_ACCEPT_CONFIDENCE;
+    // Confidence is a 0-100 score everywhere. A fractional value below 1 (e.g. 0.9) is
+    // almost certainly a 0-1 probability a producer/LLM emitted despite that contract —
+    // scale it up so 0.9 → 90 instead of Math.round truncating it to a draft-holding 1.
+    const scaled = value > 0 && value < 1 ? value * 100 : value;
+    return Math.max(0, Math.min(100, Math.round(scaled)));
+}
+function isPlainRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function readNodeReviewer(metadata) {
+    const review = metadata.review;
+    if (!isPlainRecord(review))
+        return undefined;
+    const reviewer = review.reviewer;
+    return typeof reviewer === 'string' && reviewer.trim().length > 0 ? reviewer.trim() : 'knowledge-review';
+}
+function readNodeProvenanceState(metadata) {
+    const provenance = metadata.reviewProvenance;
+    if (!isPlainRecord(provenance))
+        return undefined;
+    return typeof provenance.state === 'string' ? provenance.state : undefined;
+}
+function stampNodeProvenance(metadata, provenance) {
+    return { ...metadata, reviewProvenance: provenance };
+}
+/**
+ * Decide a node's effective status and stamp honest review provenance so a node is
+ * never silently active. (Invariants 2 & 4.)
+ * - An explicit producer status (or a review that applied facts) is honored and
+ *   labelled 'explicit'/'reviewed'.
+ * - An already-active node stays active; if it predates the gate it is labelled
+ *   'pre-gate' (folds/migrations never get downgraded).
+ * - A new/draft node auto-accepts at/above the configured confidence threshold
+ *   (labelled 'auto-accepted') or is held as 'draft' pending review otherwise.
+ */
+export function resolveNodeActivation(args) {
+    const { input, existing, confidence, metadata, now, autoAcceptConfidence } = args;
+    const reviewer = readNodeReviewer(metadata);
+    const reviewedByFacts = reviewer !== undefined;
+    if (input.status) {
+        const state = reviewedByFacts ? 'reviewed' : 'explicit';
+        return {
+            status: input.status,
+            metadata: stampNodeProvenance(metadata, {
+                state,
+                reason: reviewedByFacts
+                    ? `reviewed: status set to '${input.status}' by ${reviewer}`
+                    : `explicit: producer set status '${input.status}'`,
+                decidedAt: now,
+                ...(reviewer !== undefined ? { reviewer } : {}),
+            }),
+        };
+    }
+    if (reviewedByFacts && existing) {
+        return {
+            status: existing.status,
+            metadata: stampNodeProvenance(metadata, {
+                state: 'reviewed',
+                reason: `reviewed by ${reviewer}`,
+                decidedAt: now,
+                reviewer,
+            }),
+        };
+    }
+    if (existing && existing.status === 'active') {
+        if (readNodeProvenanceState(metadata))
+            return { status: 'active', metadata };
+        return {
+            status: 'active',
+            metadata: stampNodeProvenance(metadata, {
+                state: 'pre-gate',
+                reason: 'pre-gate: node was active before the review gate; left active',
+                decidedAt: now,
+            }),
+        };
+    }
+    if (confidence >= autoAcceptConfidence) {
+        return {
+            status: 'active',
+            metadata: stampNodeProvenance(metadata, {
+                state: 'auto-accepted',
+                reason: `auto-accepted: confidence ${confidence} >= auto-accept threshold ${autoAcceptConfidence}`,
+                decidedAt: now,
+                threshold: autoAcceptConfidence,
+            }),
+        };
+    }
+    return {
+        status: 'draft',
+        metadata: stampNodeProvenance(metadata, {
+            state: 'pending-review',
+            reason: `pending review: confidence ${confidence} < auto-accept threshold ${autoAcceptConfidence}`,
+            decidedAt: now,
+            threshold: autoAcceptConfidence,
+        }),
+    };
+}
+/**
+ * Record an append-only revision on a content-changing upsert: preserve the
+ * overwritten prior content and note what changed. (Invariant 8.)
+ */
+export function recordKnowledgeNodeRevisions(sqlite, nodeRevisions, record, existing, now) {
+    const list = nodeRevisions.get(record.id) ?? [];
+    if (existing) {
+        const changedFields = diffKnowledgeNodeFields(existing, record);
+        if (changedFields.length === 0)
+            return; // idempotent re-upsert (e.g. a provenance-only restamp)
+        if (list.length === 0) {
+            // First tracked change to a pre-existing node: preserve the overwritten prior
+            // content as the baseline revision so it is never lost.
+            appendNodeRevision(sqlite, list, existing, 'create', [], now);
+        }
+        appendNodeRevision(sqlite, list, record, 'update', changedFields, now);
+    }
+    else {
+        appendNodeRevision(sqlite, list, record, 'create', [], now);
+    }
+    nodeRevisions.set(record.id, list);
+}
+export function listKnowledgeNodeRevisions(nodeRevisions, nodeId) {
+    return [...(nodeRevisions.get(nodeId) ?? [])].sort((a, b) => a.revision - b.revision);
+}
+function appendNodeRevision(sqlite, list, snapshot, changeKind, changedFields, now) {
+    const revision = (list[list.length - 1]?.revision ?? 0) + 1;
+    const rev = {
+        id: `noderev-${snapshot.id}-${revision}`,
+        nodeId: snapshot.id,
+        revision,
+        changeKind,
+        changedFields: [...changedFields],
+        kind: snapshot.kind,
+        slug: snapshot.slug,
+        title: snapshot.title,
+        ...(snapshot.summary ? { summary: snapshot.summary } : {}),
+        aliases: [...snapshot.aliases],
+        status: snapshot.status,
+        confidence: snapshot.confidence,
+        ...(snapshot.sourceId ? { sourceId: snapshot.sourceId } : {}),
+        metadata: snapshot.metadata,
+        nodeCreatedAt: snapshot.createdAt,
+        nodeUpdatedAt: snapshot.updatedAt,
+        recordedAt: now,
+    };
+    sqlite.run(`
+    INSERT OR REPLACE INTO knowledge_node_revisions (
+      id, node_id, revision, change_kind, changed_fields, kind, slug, title, summary,
+      aliases, status, confidence, source_id, metadata, node_created_at, node_updated_at, recorded_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `, [
+        rev.id,
+        rev.nodeId,
+        rev.revision,
+        rev.changeKind,
+        JSON.stringify(rev.changedFields),
+        rev.kind,
+        rev.slug,
+        rev.title,
+        rev.summary ?? null,
+        JSON.stringify([...rev.aliases]),
+        rev.status,
+        rev.confidence,
+        rev.sourceId ?? null,
+        JSON.stringify(rev.metadata),
+        rev.nodeCreatedAt,
+        rev.nodeUpdatedAt,
+        rev.recordedAt,
+    ]);
+    list.push(rev);
+}
+function diffKnowledgeNodeFields(prev, next) {
+    const changed = [];
+    // Identity fields are tracked: an id-based upsert that changes ONLY the kind or
+    // slug (all other fields identical) is still a real content change and must
+    // record a revision — otherwise `changedFields` is empty, the early return in
+    // recordKnowledgeNodeRevisions fires, and the prior slug/kind is lost from
+    // history with no trace.
+    if (prev.kind !== next.kind)
+        changed.push('kind');
+    if (prev.slug !== next.slug)
+        changed.push('slug');
+    if (prev.title !== next.title)
+        changed.push('title');
+    if ((prev.summary ?? '') !== (next.summary ?? ''))
+        changed.push('summary');
+    if (prev.status !== next.status)
+        changed.push('status');
+    if (prev.confidence !== next.confidence)
+        changed.push('confidence');
+    if ((prev.sourceId ?? '') !== (next.sourceId ?? ''))
+        changed.push('sourceId');
+    if (!sameStringSet(prev.aliases, next.aliases))
+        changed.push('aliases');
+    if (stableMetadataForDiff(prev.metadata) !== stableMetadataForDiff(next.metadata))
+        changed.push('metadata');
+    return changed;
+}
+function sameStringSet(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const set = new Set(a);
+    return b.every((entry) => set.has(entry));
+}
+// Compare metadata for revision purposes ignoring the volatile review-provenance
+// stamp (its decidedAt changes on every write); a provenance-only restamp must not
+// count as a content change.
+function stableMetadataForDiff(metadata) {
+    const { reviewProvenance: _reviewProvenance, ...rest } = metadata;
+    return stableStringify(rest);
+}
+function stableStringify(value) {
+    if (Array.isArray(value))
+        return `[${value.map((entry) => stableStringify(entry)).join(',')}]`;
+    if (isPlainRecord(value)) {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+    }
+    return JSON.stringify(value ?? null);
+}
+/**
+ * Merge one node into another: re-point every edge that referenced the loser onto
+ * the winner (deduping and dropping self-loops), record a `merged_into` edge, and
+ * mark the loser 'stale' with a `mergedInto` stamp. Keeps cross-references live on
+ * the surviving node. (Invariant 7.)
+ */
+export async function mergeKnowledgeNodes(store, loserId, winnerId) {
+    if (loserId === winnerId)
+        return { merged: false, repointedEdges: 0 };
+    const loser = store.getNode(loserId);
+    const winner = store.getNode(winnerId);
+    if (!loser || !winner)
+        return { merged: false, repointedEdges: 0 };
+    const mergedAt = nowMs();
+    let repointedEdges = 0;
+    await store.batch(async () => {
+        for (const edge of store.listEdges()) {
+            const fromMatch = edge.fromKind === 'node' && edge.fromId === loserId;
+            const toMatch = edge.toKind === 'node' && edge.toId === loserId;
+            if (!fromMatch && !toMatch)
+                continue;
+            const newFromId = fromMatch ? winnerId : edge.fromId;
+            const newToId = toMatch ? winnerId : edge.toId;
+            await store.deleteEdge(edge.id);
+            if (newFromId === newToId && edge.fromKind === edge.toKind)
+                continue;
+            await store.upsertEdge({
+                fromKind: edge.fromKind,
+                fromId: newFromId,
+                toKind: edge.toKind,
+                toId: newToId,
+                relation: edge.relation,
+                weight: edge.weight,
+                metadata: { ...edge.metadata, repointedFromNodeId: loserId, repointedAt: mergedAt },
+            });
+            repointedEdges += 1;
+        }
+        await store.upsertEdge({
+            fromKind: 'node',
+            fromId: loserId,
+            toKind: 'node',
+            toId: winnerId,
+            relation: 'merged_into',
+            metadata: { mergedAt },
+        });
+        await store.upsertNode({
+            id: loser.id,
+            kind: loser.kind,
+            slug: loser.slug,
+            title: loser.title,
+            ...(loser.summary ? { summary: loser.summary } : {}),
+            aliases: [...loser.aliases],
+            status: 'stale',
+            confidence: loser.confidence,
+            ...(loser.sourceId ? { sourceId: loser.sourceId } : {}),
+            metadata: { ...loser.metadata, mergedInto: winnerId, mergedAt },
+        });
+    });
+    return { merged: true, repointedEdges };
+}
+export function upsertKnowledgeSemanticEnrichmentState(sqlite, states, input) {
+    const existing = states.get(input.sourceId);
+    const now = nowMs();
+    const record = {
+        sourceId: input.sourceId,
+        ...(input.textHash ? { textHash: input.textHash } : {}),
+        ...(typeof input.enrichedAt === 'number' ? { enrichedAt: input.enrichedAt } : {}),
+        metadata: input.metadata ?? {},
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+    };
+    sqlite.run(`
+    INSERT OR REPLACE INTO knowledge_semantic_enrichment_state (
+      source_id, text_hash, enriched_at, metadata, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?)
+  `, [
+        record.sourceId,
+        record.textHash ?? null,
+        record.enrichedAt ?? null,
+        JSON.stringify(record.metadata),
+        record.createdAt,
+        record.updatedAt,
+    ]);
+    states.set(record.sourceId, record);
+    return record;
+}

package/dist/platform/knowledge/store-record-delete.d.ts

@@ -0,0 +1,25 @@
+import type { SQLiteStore } from '../state/sqlite-store.js';
+import type { KnowledgeConsolidationCandidateRecord, KnowledgeEdgeRecord, KnowledgeExtractionRecord, KnowledgeIssueRecord, KnowledgeNodeRecord, KnowledgeNodeRevisionRecord, KnowledgeRefinementTaskRecord, KnowledgeSemanticEnrichmentStateRecord, KnowledgeSourceRecord, KnowledgeUsageRecord } from './types.js';
+/**
+ * The store internals needed to cascade a single-record hard delete. Both node and
+ * source deletes cascade edges, issues, usage records, consolidation candidates and
+ * refinement tasks (Defect 7 closed the refinement-task gap); node delete also
+ * purges revision history and source delete purges derived extraction/enrichment
+ * rows. Honest hard delete — no soft-hide. (Defect 6.)
+ */
+export interface KnowledgeRecordDeleteView {
+    readonly sqlite: SQLiteStore;
+    readonly sources: Map<string, KnowledgeSourceRecord>;
+    readonly nodes: Map<string, KnowledgeNodeRecord>;
+    readonly edges: Map<string, KnowledgeEdgeRecord>;
+    readonly issues: Map<string, KnowledgeIssueRecord>;
+    readonly extractions: Map<string, KnowledgeExtractionRecord>;
+    readonly usageRecords: Map<string, KnowledgeUsageRecord>;
+    readonly consolidationCandidates: Map<string, KnowledgeConsolidationCandidateRecord>;
+    readonly refinementTasks: Map<string, KnowledgeRefinementTaskRecord>;
+    readonly nodeRevisions: Map<string, KnowledgeNodeRevisionRecord[]>;
+    readonly semanticEnrichmentStates: Map<string, KnowledgeSemanticEnrichmentStateRecord>;
+}
+export declare function deleteKnowledgeNodeRecord(view: KnowledgeRecordDeleteView, id: string): boolean;
+export declare function deleteKnowledgeSourceRecord(view: KnowledgeRecordDeleteView, id: string): boolean;
+//# sourceMappingURL=store-record-delete.d.ts.map

package/dist/platform/knowledge/store-record-delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-record-delete.d.ts","sourceRoot":"","sources":["../../../src/platform/knowledge/store-record-delete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EACV,qCAAqC,EACrC,mBAAmB,EACnB,yBAAyB,EACzB,oBAAoB,EACpB,mBAAmB,EACnB,2BAA2B,EAC3B,6BAA6B,EAC7B,sCAAsC,EACtC,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACjD,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;IAC7D,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IACzD,QAAQ,CAAC,uBAAuB,EAAE,GAAG,CAAC,MAAM,EAAE,qCAAqC,CAAC,CAAC;IACrF,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,6BAA6B,CAAC,CAAC;IACrE,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,2BAA2B,EAAE,CAAC,CAAC;IACnE,QAAQ,CAAC,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,sCAAsC,CAAC,CAAC;CACxF;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAqC9F;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CA2ChG"}