@lemoncat7/dsh-knowledge 1.0.2 → 1.0.11

package/lib/local-provider.js

@@ -8,12 +8,13 @@ import { knowledgeDocumentPath } from './documents/path.js';
 import { KnowledgeDocumentStore } from './documents/store.js';
 const ENTRY_COLUMNS = `
   id, knowledge_base_id, title, body, type, tags_json, scope_kind, scope_id, confidence,
-  status, version, source_json, created_at, updated_at
+  status, document_state, finalized_at, finalization_note, version, source_json, created_at, updated_at
 `;
 const JOINED_ENTRY_COLUMNS = `
   e.id AS id, e.knowledge_base_id AS knowledge_base_id, e.title AS title, e.body AS body, e.type AS type,
   e.tags_json AS tags_json, e.scope_kind AS scope_kind, e.scope_id AS scope_id,
-  e.confidence AS confidence, e.status AS status, e.version AS version,
+  e.confidence AS confidence, e.status AS status, e.document_state AS document_state,
+  e.finalized_at AS finalized_at, e.finalization_note AS finalization_note, e.version AS version,
   e.source_json AS source_json, e.created_at AS created_at, e.updated_at AS updated_at
 `;
 export class LocalKnowledgeProvider {
@@ -33,7 +34,7 @@ export class LocalKnowledgeProvider {
     }
     migrate() {
         let version = Number(this.db.prepare('PRAGMA user_version').get().user_version ?? 0);
-        if (version > 6)
+        if (version > 9)
             throw new Error(`knowledge database schema ${version} is newer than this plugin supports`);
         if (version === 0)
             this.db.exec(`
@@ -205,6 +206,43 @@ export class LocalKnowledgeProvider {
             version = 5;
         if (version === 5)
             this.db.exec('PRAGMA user_version = 6;');
+        if (version <= 5)
+            version = 6;
+        if (version === 6)
+            this.db.exec(`
+      BEGIN IMMEDIATE;
+      ALTER TABLE knowledge_entries ADD COLUMN document_state TEXT NOT NULL DEFAULT 'open'
+        CHECK(document_state IN ('open','resolved','complete'));
+      ALTER TABLE knowledge_entries ADD COLUMN finalized_at TEXT;
+      ALTER TABLE knowledge_entries ADD COLUMN finalization_note TEXT;
+      ALTER TABLE knowledge_documents ADD COLUMN document_state TEXT NOT NULL DEFAULT 'open'
+        CHECK(document_state IN ('open','resolved','complete'));
+      ALTER TABLE knowledge_documents ADD COLUMN finalized_at TEXT;
+      ALTER TABLE knowledge_documents ADD COLUMN finalization_note TEXT;
+      PRAGMA user_version = 7;
+      COMMIT;
+    `);
+        if (version <= 6)
+            version = 7;
+        if (version === 7)
+            this.db.exec(`
+      BEGIN IMMEDIATE;
+      ALTER TABLE knowledge_bases ADD COLUMN writeback_policy TEXT NOT NULL DEFAULT 'conservative'
+        CHECK(writeback_policy IN ('conservative','proactive'));
+      UPDATE knowledge_bases SET writeback_policy=(SELECT writeback_policy FROM knowledge_settings WHERE id=1);
+      PRAGMA user_version = 8;
+      COMMIT;
+    `);
+        if (version <= 7)
+            version = 8;
+        if (version === 8)
+            this.db.exec(`
+      BEGIN IMMEDIATE;
+      ALTER TABLE knowledge_settings ADD COLUMN writeback_provider TEXT;
+      ALTER TABLE knowledge_settings ADD COLUMN writeback_model TEXT;
+      PRAGMA user_version = 9;
+      COMMIT;
+    `);
         // Alpha v2 used a migration note as the default base's routing description.
         // Clear only that exact placeholder so existing user-authored descriptions stay untouched.
         this.db.prepare("UPDATE knowledge_bases SET description='' WHERE id=? AND description=?")
@@ -216,9 +254,12 @@ export class LocalKnowledgeProvider {
     }
     async getSettings() {
         this.assertOpen();
-        const row = this.db.prepare('SELECT writeback_policy,updated_at FROM knowledge_settings WHERE id=1').get();
+        const row = this.db.prepare('SELECT writeback_policy,writeback_provider,writeback_model,updated_at FROM knowledge_settings WHERE id=1').get();
+        const provider = row.writeback_provider == null ? undefined : String(row.writeback_provider);
+        const model = row.writeback_model == null ? undefined : String(row.writeback_model);
         return {
             writebackPolicy: String(row.writeback_policy),
+            ...provider === undefined || model === undefined ? {} : { writebackProvider: provider, writebackModel: model },
             updatedAt: String(row.updated_at),
         };
     }
@@ -226,9 +267,18 @@ export class LocalKnowledgeProvider {
         this.assertOpen();
         const patch = normalizeKnowledgeSettings(input);
         const updatedAt = nowIso();
-        this.db.prepare('UPDATE knowledge_settings SET writeback_policy=?,updated_at=? WHERE id=1')
-            .run(patch.writebackPolicy, updatedAt);
-        return { ...patch, updatedAt };
+        const current = await this.getSettings();
+        const clearRoute = patch.writebackProvider === null || patch.writebackModel === null;
+        const next = {
+            writebackPolicy: patch.writebackPolicy ?? current.writebackPolicy,
+            ...clearRoute ? {} : patch.writebackProvider && patch.writebackModel
+                ? { writebackProvider: patch.writebackProvider, writebackModel: patch.writebackModel }
+                : current.writebackProvider && current.writebackModel ? { writebackProvider: current.writebackProvider, writebackModel: current.writebackModel } : {},
+            updatedAt,
+        };
+        this.db.prepare('UPDATE knowledge_settings SET writeback_policy=?,writeback_provider=?,writeback_model=?,updated_at=? WHERE id=1')
+            .run(next.writebackPolicy, next.writebackProvider ?? null, next.writebackModel ?? null, updatedAt);
+        return next;
     }
     async listKnowledgeBases() {
         this.assertOpen();
@@ -248,9 +298,9 @@ export class LocalKnowledgeProvider {
         const base = { ...draft, id: newId(), status: 'active', createdAt: timestamp, updatedAt: timestamp };
         this.db.prepare(`
       INSERT INTO knowledge_bases(
-        id,name,description,default_tags_json,extraction_instructions,writeback_provider,writeback_model,status,created_at,updated_at
-      ) VALUES(?,?,?,?,?,?,?,'active',?,?)
-    `).run(base.id, base.name, base.description, JSON.stringify(base.defaultTags), base.extractionInstructions, base.writebackProvider ?? null, base.writebackModel ?? null, timestamp, timestamp);
+        id,name,description,default_tags_json,extraction_instructions,writeback_policy,writeback_provider,writeback_model,status,created_at,updated_at
+      ) VALUES(?,?,?,?,?,?,?,?,'active',?,?)
+    `).run(base.id, base.name, base.description, JSON.stringify(base.defaultTags), base.extractionInstructions, base.writebackPolicy, base.writebackProvider ?? null, base.writebackModel ?? null, timestamp, timestamp);
         await this.syncKnowledgeDocuments(base.id);
         return base;
     }
@@ -264,9 +314,9 @@ export class LocalKnowledgeProvider {
         const updated = { ...current, ...draft, updatedAt: nowIso() };
         this.db.prepare(`
       UPDATE knowledge_bases SET
-        name=?,description=?,default_tags_json=?,extraction_instructions=?,writeback_provider=?,writeback_model=?,updated_at=?
+        name=?,description=?,default_tags_json=?,extraction_instructions=?,writeback_policy=?,writeback_provider=?,writeback_model=?,updated_at=?
       WHERE id=?
-    `).run(updated.name, updated.description, JSON.stringify(updated.defaultTags), updated.extractionInstructions, updated.writebackProvider ?? null, updated.writebackModel ?? null, updated.updatedAt, id);
+    `).run(updated.name, updated.description, JSON.stringify(updated.defaultTags), updated.extractionInstructions, updated.writebackPolicy, updated.writebackProvider ?? null, updated.writebackModel ?? null, updated.updatedAt, id);
         await this.syncKnowledgeDocuments(id);
         return updated;
     }
@@ -283,6 +333,7 @@ export class LocalKnowledgeProvider {
             description: patch.description ?? current.description,
             defaultTags: patch.defaultTags ?? current.defaultTags,
             extractionInstructions: patch.extractionInstructions ?? current.extractionInstructions,
+            writebackPolicy: patch.writebackPolicy ?? current.writebackPolicy,
             ...clearRoute || provider === undefined || model === undefined ? {} : { writebackProvider: provider, writebackModel: model },
         });
     }
@@ -642,11 +693,15 @@ export class LocalKnowledgeProvider {
         }
         const id = newId();
         const timestamp = nowIso();
-        const entry = { ...draft, id, status: 'active', version: 1, createdAt: timestamp, updatedAt: timestamp };
+        const entry = {
+            ...draft, id, status: 'active', documentState: 'open', version: 1,
+            createdAt: timestamp, updatedAt: timestamp,
+        };
         this.db.prepare(`
       INSERT INTO knowledge_entries (
-        id,knowledge_base_id,title,body,type,tags_json,scope_kind,scope_id,confidence,status,version,content_hash,source_json,created_at,updated_at
-      ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+        id,knowledge_base_id,title,body,type,tags_json,scope_kind,scope_id,confidence,status,
+        document_state,finalized_at,finalization_note,version,content_hash,source_json,created_at,updated_at
+      ) VALUES (?,?,?,?,?,?,?,?,?,?,'open',NULL,NULL,?,?,?,?,?)
     `).run(id, draft.knowledgeBaseId, draft.title, draft.body, draft.type, JSON.stringify(draft.tags), draft.scope.kind, draft.scope.kind === 'project' ? draft.scope.id : null, draft.confidence, 'active', 1, contentHash(draft), draft.source === undefined ? null : JSON.stringify(draft.source), timestamp, timestamp);
         this.writeVersion(entry, 'create');
         this.upsertFts(entry);
@@ -662,11 +717,81 @@ export class LocalKnowledgeProvider {
         await this.syncKnowledgeDocuments(entry.knowledgeBaseId);
         return entry;
     }
+    async finalize(id, state, note) {
+        this.assertOpen();
+        await this.documentsReady;
+        const entry = this.transaction(() => {
+            const row = this.db.prepare(`SELECT ${ENTRY_COLUMNS} FROM knowledge_entries WHERE id=?`).get(id);
+            if (row === undefined)
+                throw notFound('knowledge entry', id);
+            const current = rowToEntry(row);
+            if (current.status !== 'active')
+                throw conflict('only active knowledge documents can be finalized');
+            const finalizationNote = normalizeFinalizationNote(note);
+            if (current.documentState === state && current.finalizationNote === finalizationNote)
+                return current;
+            if (current.documentState !== 'open')
+                throw finalizedConflict(current);
+            const timestamp = nowIso();
+            const updated = {
+                ...current,
+                documentState: state,
+                finalizedAt: timestamp,
+                ...finalizationNote === undefined ? {} : { finalizationNote },
+                version: current.version + 1,
+                updatedAt: timestamp,
+            };
+            this.db.prepare(`
+        UPDATE knowledge_entries
+        SET document_state=?,finalized_at=?,finalization_note=?,version=?,updated_at=?
+        WHERE id=?
+      `).run(state, timestamp, finalizationNote ?? null, updated.version, timestamp, id);
+            this.writeVersion(updated, 'update');
+            this.upsertFts(updated);
+            return updated;
+        });
+        await this.syncKnowledgeDocuments(entry.knowledgeBaseId);
+        return entry;
+    }
+    async reopen(id) {
+        this.assertOpen();
+        await this.documentsReady;
+        const entry = this.transaction(() => {
+            const row = this.db.prepare(`SELECT ${ENTRY_COLUMNS} FROM knowledge_entries WHERE id=?`).get(id);
+            if (row === undefined)
+                throw notFound('knowledge entry', id);
+            const current = rowToEntry(row);
+            if (current.status !== 'active')
+                throw conflict('only active knowledge documents can be reopened');
+            if (current.documentState === 'open')
+                return current;
+            const timestamp = nowIso();
+            const { finalizedAt: _finalizedAt, finalizationNote: _finalizationNote, ...reopened } = current;
+            const updated = {
+                ...reopened,
+                documentState: 'open',
+                version: current.version + 1,
+                updatedAt: timestamp,
+            };
+            this.db.prepare(`
+        UPDATE knowledge_entries
+        SET document_state='open',finalized_at=NULL,finalization_note=NULL,version=?,updated_at=?
+        WHERE id=?
+      `).run(updated.version, timestamp, id);
+            this.writeVersion(updated, 'update');
+            this.upsertFts(updated);
+            return updated;
+        });
+        await this.syncKnowledgeDocuments(entry.knowledgeBaseId);
+        return entry;
+    }
     updateEntry(id, input, changeKind) {
         const currentRow = this.db.prepare(`SELECT ${ENTRY_COLUMNS} FROM knowledge_entries WHERE id = ?`).get(id);
         if (currentRow === undefined)
             throw notFound('knowledge entry', id);
         const current = rowToEntry(currentRow);
+        if (current.documentState !== 'open')
+            throw finalizedConflict(current);
         const draft = normalizeDraft(input);
         if (this.db.prepare("SELECT id FROM knowledge_bases WHERE id=? AND status='active'").get(draft.knowledgeBaseId) === undefined) {
             throw notFound('active knowledge base', draft.knowledgeBaseId);
@@ -676,6 +801,7 @@ export class LocalKnowledgeProvider {
             ...draft,
             id,
             status: 'active',
+            documentState: current.documentState,
             version: current.version + 1,
             createdAt: current.createdAt,
             updatedAt: timestamp,
@@ -724,7 +850,11 @@ export class LocalKnowledgeProvider {
     }
     async propose(input, sourceKey) {
         this.assertOpen();
-        return this.insertCandidate(normalizeProposal(input), sourceKey);
+        const proposal = normalizeProposal(input);
+        const finalized = this.finalizedMatch(proposal);
+        if (finalized !== undefined)
+            throw finalizedConflict(finalized);
+        return this.insertCandidate(proposal, sourceKey);
     }
     async writeDirect(input, sourceKey) {
         this.assertOpen();
@@ -734,6 +864,8 @@ export class LocalKnowledgeProvider {
             const resolution = this.resolveDirectProposal(normalizeProposal(input));
             if (resolution.outcome === 'duplicate')
                 return { outcome: 'duplicate', ...resolution.entry === undefined ? {} : { entry: resolution.entry } };
+            if (resolution.outcome === 'finalized')
+                return { outcome: 'finalized', entry: resolution.entry };
             const candidate = this.insertCandidate(resolution.proposal, sourceKey);
             if (candidate.status !== 'pending')
                 return { outcome: 'duplicate', candidate };
@@ -790,6 +922,8 @@ export class LocalKnowledgeProvider {
             return { outcome: 'conflict', proposal };
         if (proposal.action === 'update') {
             const target = this.activeEntry(proposal.targetId);
+            if (target.documentState !== 'open')
+                return { outcome: 'finalized', entry: target };
             if (target.knowledgeBaseId !== proposal.draft.knowledgeBaseId) {
                 throw conflict('direct-write update cannot move knowledge between knowledge bases');
             }
@@ -811,6 +945,8 @@ export class LocalKnowledgeProvider {
         const target = bodyMatch ?? titleMatch ?? referenceMatch;
         if (target === undefined)
             return { outcome: 'created', proposal };
+        if (target.documentState !== 'open')
+            return { outcome: 'finalized', entry: target };
         if (potentiallyConflicts(target, proposal.draft)) {
             return {
                 outcome: 'conflict',
@@ -825,6 +961,16 @@ export class LocalKnowledgeProvider {
             proposal: { ...proposal, action: 'update', targetId: target.id, draft },
         };
     }
+    finalizedMatch(proposal) {
+        if (proposal.action !== 'create') {
+            const target = this.activeEntry(proposal.targetId);
+            return target.documentState === 'open' ? undefined : target;
+        }
+        const entries = this.activeEntriesForDraft(proposal.draft);
+        return entries.find(entry => entry.documentState !== 'open' && (normalizedBody(entry.body) === normalizedBody(proposal.draft.body)
+            || normalizedTitle(entry.title) === normalizedTitle(proposal.draft.title)
+            || sharesCanonicalTopicReference(entry, proposal.draft)));
+    }
     activeEntry(id) {
         const row = this.db.prepare(`SELECT ${ENTRY_COLUMNS} FROM knowledge_entries WHERE id=? AND status='active'`).get(id);
         if (row === undefined)
@@ -858,6 +1004,9 @@ export class LocalKnowledgeProvider {
             let draft = decision.draft === undefined ? candidate.draft : normalizeDraft(decision.draft);
             if (decision.decision === 'approve') {
                 if (candidate.action === 'conflict') {
+                    if (decision.resolution !== 'merge') {
+                        throw conflict('conflict candidate requires an explicit merge resolution');
+                    }
                     if (candidate.targetId === undefined)
                         throw new Error('candidate target is missing');
                     const targetRow = this.db.prepare(`SELECT ${ENTRY_COLUMNS} FROM knowledge_entries WHERE id = ?`).get(candidate.targetId);
@@ -877,8 +1026,22 @@ export class LocalKnowledgeProvider {
                         reason: candidate.reason,
                     });
                     if (resolution.outcome === 'conflict') {
-                        throw conflict('knowledge changed during review and now requires conflict resolution');
+                        const proposal = resolution.proposal;
+                        this.db.prepare(`
+              UPDATE knowledge_candidates
+              SET action='conflict', target_id=?, draft_json=?, reason=?
+              WHERE id=? AND status='pending'
+            `).run(proposal.targetId ?? null, JSON.stringify(proposal.draft), proposal.reason, id);
+                        return {
+                            ...candidate,
+                            action: 'conflict',
+                            ...proposal.targetId === undefined ? {} : { targetId: proposal.targetId },
+                            draft: proposal.draft,
+                            reason: proposal.reason,
+                        };
                     }
+                    if (resolution.outcome === 'finalized')
+                        throw finalizedConflict(resolution.entry);
                     if (resolution.outcome !== 'duplicate') {
                         if (resolution.proposal.action === 'create')
                             this.insertEntry(resolution.proposal.draft);
@@ -1000,6 +1163,9 @@ export class LocalKnowledgeProvider {
             confidence: entry.confidence,
             ...entry.source === undefined ? {} : { source: entry.source },
             status: entry.status,
+            documentState: entry.documentState,
+            ...entry.finalizedAt === undefined ? {} : { finalizedAt: entry.finalizedAt },
+            ...entry.finalizationNote === undefined ? {} : { finalizationNote: entry.finalizationNote },
         };
         this.db.prepare(`INSERT INTO knowledge_versions(id,knowledge_id,version,snapshot_json,change_kind,created_at) VALUES(?,?,?,?,?,?)`)
             .run(newId(), entry.id, entry.version, JSON.stringify(snapshot), changeKind, nowIso());
@@ -1039,6 +1205,9 @@ export class LocalKnowledgeProvider {
                     scope: entry.scope,
                     confidence: entry.confidence,
                     status: entry.status,
+                    documentState: entry.documentState,
+                    ...entry.finalizedAt === undefined ? {} : { finalizedAt: entry.finalizedAt },
+                    ...entry.finalizationNote === undefined ? {} : { finalizationNote: entry.finalizationNote },
                 },
                 title: entry.title,
                 body: entry.body,
@@ -1063,17 +1232,23 @@ export class LocalKnowledgeProvider {
         for (const document of desired.values()) {
             this.db.prepare(`
         INSERT INTO knowledge_documents(
-          id,knowledge_base_id,rel_path,title,content,entry_count,content_hash,created_at,updated_at
-        ) VALUES(?,?,?,?,?,?,?,?,?)
+          id,knowledge_base_id,rel_path,title,content,entry_count,content_hash,
+          document_state,finalized_at,finalization_note,created_at,updated_at
+        ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)
         ON CONFLICT(id) DO UPDATE SET
           knowledge_base_id=excluded.knowledge_base_id,rel_path=excluded.rel_path,
           title=excluded.title,content=excluded.content,entry_count=excluded.entry_count,
-          content_hash=excluded.content_hash,updated_at=excluded.updated_at
+          content_hash=excluded.content_hash,document_state=excluded.document_state,
+          finalized_at=excluded.finalized_at,finalization_note=excluded.finalization_note,
+          updated_at=excluded.updated_at
         WHERE knowledge_documents.content_hash<>excluded.content_hash
            OR knowledge_documents.rel_path<>excluded.rel_path
            OR knowledge_documents.title<>excluded.title
            OR knowledge_documents.entry_count<>excluded.entry_count
-      `).run(document.entry.id, knowledgeBaseId, document.relPath, document.entry.title, document.content, 1, document.contentHash, document.entry.createdAt, document.entry.updatedAt);
+           OR knowledge_documents.document_state<>excluded.document_state
+           OR knowledge_documents.finalized_at IS NOT excluded.finalized_at
+           OR knowledge_documents.finalization_note IS NOT excluded.finalization_note
+      `).run(document.entry.id, knowledgeBaseId, document.relPath, document.entry.title, document.content, 1, document.contentHash, document.entry.documentState, document.entry.finalizedAt ?? null, document.entry.finalizationNote ?? null, document.entry.createdAt, document.entry.updatedAt);
         }
         for (const row of existing) {
             if (!desired.has(String(row.id)))
@@ -1098,6 +1273,9 @@ function rowToEntry(row) {
             : { kind: 'project', id: String(row.scope_id) },
         confidence: Number(row.confidence),
         status: String(row.status),
+        documentState: row.document_state == null ? 'open' : String(row.document_state),
+        ...row.finalized_at == null ? {} : { finalizedAt: String(row.finalized_at) },
+        ...row.finalization_note == null ? {} : { finalizationNote: String(row.finalization_note) },
         version: Number(row.version),
         ...source === undefined ? {} : { source },
         createdAt: String(row.created_at),
@@ -1113,6 +1291,9 @@ function rowToDocument(row) {
         content: String(row.content),
         entryCount: Number(row.entry_count),
         contentHash: String(row.content_hash),
+        documentState: row.document_state == null ? 'open' : String(row.document_state),
+        ...row.finalized_at == null ? {} : { finalizedAt: String(row.finalized_at) },
+        ...row.finalization_note == null ? {} : { finalizationNote: String(row.finalization_note) },
         createdAt: String(row.created_at),
         updatedAt: String(row.updated_at),
     };
@@ -1121,6 +1302,8 @@ function rowToVersion(row) {
     const snapshot = JSON.parse(String(row.snapshot_json));
     if (snapshot.knowledgeBaseId === undefined)
         snapshot.knowledgeBaseId = DEFAULT_KNOWLEDGE_BASE_ID;
+    if (snapshot.documentState === undefined)
+        snapshot.documentState = 'open';
     return {
         id: String(row.id),
         knowledgeId: String(row.knowledge_id),
@@ -1193,6 +1376,8 @@ function potentiallyConflicts(current, incoming) {
     const incomingBody = normalizedBody(incoming.body);
     if (currentBody === incomingBody || currentBody.includes(incomingBody) || incomingBody.includes(currentBody))
         return false;
+    if (addsDistinctMarkdownSections(current.body, incoming.body))
+        return false;
     const overlap = termOverlap(currentBody, incomingBody);
     if (overlap < 0.35)
         return false;
@@ -1205,6 +1390,18 @@ function potentiallyConflicts(current, incoming) {
     return currentValues.length > 0 && incomingValues.length > 0
         && !currentValues.some(value => incomingValues.includes(value));
 }
+function addsDistinctMarkdownSections(current, incoming) {
+    const currentHeadings = markdownHeadings(current);
+    const incomingHeadings = markdownHeadings(incoming);
+    if (currentHeadings.size === 0 || incomingHeadings.size === 0)
+        return false;
+    return [...incomingHeadings].every(heading => !currentHeadings.has(heading));
+}
+function markdownHeadings(value) {
+    return new Set([...value.matchAll(/^#{1,6}\s+(.+)$/gmu)]
+        .map(match => normalizedTitle(match[1] ?? ''))
+        .filter(Boolean));
+}
 function normalizedTitle(value) {
     return value.normalize('NFKC').toLocaleLowerCase().replace(/[\p{P}\p{S}\s]+/gu, '');
 }
@@ -1269,6 +1466,7 @@ function rowToKnowledgeBase(row) {
         description: String(row.description),
         defaultTags: JSON.parse(String(row.default_tags_json)),
         extractionInstructions: String(row.extraction_instructions),
+        writebackPolicy: String(row.writeback_policy),
         ...writebackProvider === undefined || writebackModel === undefined ? {} : { writebackProvider, writebackModel },
         status: String(row.status),
         createdAt: String(row.created_at),
@@ -1377,4 +1575,16 @@ function notFound(kind, id) {
 function conflict(message) {
     return Object.assign(new Error(message), { code: 'CONFLICT' });
 }
+function finalizedConflict(entry) {
+    const label = entry.documentState === 'resolved' ? 'resolved' : 'collection complete';
+    return conflict(`knowledge document "${entry.title}" (${entry.id}) is finalized as ${label}; reopen it before making changes`);
+}
+function normalizeFinalizationNote(value) {
+    const note = value?.trim();
+    if (!note)
+        return undefined;
+    if (note.length > 1000)
+        throw new Error('finalization note must contain at most 1000 characters');
+    return note;
+}
 //# sourceMappingURL=local-provider.js.map