dsh-knowledge-library 0.1.0 → 0.2.0

package/dist/core/extract.d.ts

@@ -2,6 +2,7 @@ import type { Segment } from '../types.js';
 export declare function extractArticle(html: string, url: string): {
     title: string;
     author: string | undefined;
+    extraction: string;
     content: string;
 };
 export declare function parseSubtitles(input: string): Segment[];

package/dist/core/extract.js

@@ -1,6 +1,7 @@
 import { parseHTML } from 'linkedom';
 import { Readability } from '@mozilla/readability';
 import TurndownService from 'turndown';
+import { assertArticleAccess } from './page-access.js';
 const markdown = new TurndownService({ headingStyle: 'atx', codeBlockStyle: 'fenced' });
 markdown.remove(['script', 'style', 'iframe', 'form', 'input', 'button']);
 function parseDocument(html, url) {
@@ -16,20 +17,70 @@ function parseDocument(html, url) {
     Object.defineProperties(document, { documentURI: { value: url }, baseURI: { value: baseURI } });
     return document;
 }
+function extractWechatArticle(document, url) {
+    const host = new URL(url).hostname.toLowerCase().replace(/\.$/, '');
+    const body = document.querySelector('#js_content');
+    // Saved WeChat HTML has no HTTP source when imported as a local file.
+    const savedWechat = host === 'import.invalid' && body?.classList.contains('rich_media_content')
+        && document.querySelector('#activity-name.rich_media_title');
+    if (host !== 'mp.weixin.qq.com' && !savedWechat)
+        return null;
+    if (!body || (body.textContent?.trim().length ?? 0) < 40)
+        return null;
+    // WeChat hides the entire body until its scripts run. Read the explicit article
+    // container without running those scripts or discarding it as invisible text.
+    return {
+        title: document.querySelector('#activity-name')?.textContent?.trim()
+            || document.querySelector('meta[property="og:title"]')?.getAttribute('content')?.trim()
+            || document.title,
+        byline: document.querySelector('#js_author_name')?.textContent?.trim()
+            || document.querySelector('#js_name')?.textContent?.trim()
+            || document.querySelector('meta[name="author"]')?.getAttribute('content')?.trim(),
+        content: body.innerHTML,
+        textContent: body.textContent,
+    };
+}
+function normalizeWechatCode(document) {
+    for (const pre of Array.from(document.querySelectorAll('pre'))) {
+        const lines = Array.from(pre.children).filter(node => node.localName === 'code');
+        if (!lines.length || lines.length !== pre.children.length)
+            continue;
+        // WeChat uses one sibling <code> element per line; Turndown's standard
+        // fenced-code rule only reads the first <code>. Merge before conversion.
+        const code = document.createElement('code');
+        code.className = lines[0].className;
+        code.textContent = lines.map(line => {
+            for (const br of Array.from(line.querySelectorAll('br')))
+                br.replaceWith('\n');
+            return (line.textContent || '').replace(/\u00a0/g, ' ').replace(/\n$/, '');
+        }).join('\n');
+        const language = pre.getAttribute('data-lang');
+        if (language && /^[\w+-]+$/.test(language))
+            code.className = `language-${language}`;
+        pre.replaceChildren(code);
+    }
+}
 export function extractArticle(html, url) {
     // Linkedom parses inert DOM only: no script execution, windows, or resource loading.
     // It also avoids the punycode/ dependency that DSH 0.2.1-rc.2 misroutes in packed profiles.
     const document = parseDocument(html, url);
-    for (const node of Array.from(document.querySelectorAll('script,style,iframe,form')))
+    for (const node of Array.from(document.querySelectorAll('script,style,iframe')))
         node.remove();
-    const article = new Readability(document).parse();
+    assertArticleAccess(document, url);
+    for (const node of Array.from(document.querySelectorAll('form')))
+        node.remove();
+    const wechat = extractWechatArticle(document, url);
+    const article = wechat || new Readability(document).parse();
     if (!article?.content || (article.textContent?.trim().length ?? 0) < 40) {
         throw new Error('未提取到有效正文。该网页可能需要登录或动态渲染，请复制正文或导入保存的 HTML。');
     }
-    const clean = parseDocument(`<!doctype html><html><head></head><body>${article.content}</body></html>`, url);
+    const baseUrl = wechat ? document.baseURI : url;
+    const clean = parseDocument(`<!doctype html><html><head></head><body>${article.content}</body></html>`, baseUrl);
+    if (wechat)
+        normalizeWechatCode(clean);
     for (const anchor of Array.from(clean.querySelectorAll('a'))) {
         try {
-            const href = new URL(anchor.getAttribute('href') ?? '', url);
+            const href = new URL(anchor.getAttribute('href') ?? '', baseUrl);
             if (['http:', 'https:'].includes(href.protocol))
                 anchor.setAttribute('href', href.href);
             else
@@ -42,7 +93,12 @@ export function extractArticle(html, url) {
     // Preserve image references; do not silently fetch third-party resources.
     for (const image of Array.from(clean.querySelectorAll('img'))) {
         try {
-            const src = new URL(image.getAttribute('src') ?? '', url);
+            const value = (wechat && image.getAttribute('data-src')) || image.getAttribute('src');
+            if (!value?.trim()) {
+                image.remove();
+                continue;
+            }
+            const src = new URL(value, baseUrl);
             if (['http:', 'https:'].includes(src.protocol))
                 image.setAttribute('src', src.href);
             else
@@ -55,6 +111,7 @@ export function extractArticle(html, url) {
     return {
         title: article.title?.trim() || new URL(url).hostname,
         author: article.byline || undefined,
+        extraction: wechat ? '微信正文容器提取' : 'Readability 正文提取',
         content: markdown.turndown(clean.body.innerHTML).trim(),
     };
 }

package/dist/core/fetch.js

@@ -2,7 +2,45 @@ import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { lookup } from 'node:dns/promises';
 import { isIP } from 'node:net';
+import { setTimeout as delay } from 'node:timers/promises';
 const MAX_BYTES = 6 * 1024 * 1024;
+const MAX_RETRIES = 2;
+const TRANSIENT_ERRORS = new Set(['ECONNRESET', 'ECONNREFUSED', 'EPIPE', 'ETIMEDOUT', 'EAI_AGAIN', 'ENETUNREACH', 'EHOSTUNREACH', 'ERR_STREAM_PREMATURE_CLOSE']);
+function errorCode(error) {
+    return error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+}
+function networkError(error, retries) {
+    const code = errorCode(error);
+    if (TRANSIENT_ERRORS.has(code)) {
+        const reason = code === 'EAI_AGAIN' ? '网页域名暂时无法解析' : '网页连接中断或无法建立';
+        return new Error(`${reason}，已自动重试 ${retries} 次仍未成功。请检查网络或代理后重新采集，也可以打开原网页复制正文。`, { cause: error });
+    }
+    if (code === 'ENOTFOUND')
+        return new Error('网页域名解析失败，请检查网址、网络或代理设置。', { cause: error });
+    if (/CERT|SELF_SIGNED|UNABLE_TO_VERIFY_LEAF_SIGNATURE/.test(code)) {
+        return new Error('网页 HTTPS 证书校验失败，请检查系统时间、网络代理或站点证书后重试。', { cause: error });
+    }
+    if (code === 'EPROTO' || /^ERR_(?:TLS|SSL)_/.test(code)) {
+        return new Error('无法与网页建立安全的 HTTPS 连接，请检查网络、代理或站点的 TLS 配置。', { cause: error });
+    }
+    return error;
+}
+function abortable(operation, signal) {
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason);
+        if (signal.aborted)
+            reject(signal.reason);
+        else
+            signal.addEventListener('abort', onAbort, { once: true });
+        operation.then(value => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, error => {
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
 export function isPublicAddress(address) {
     if (isIP(address) === 4) {
         const [a, b, c] = address.split('.').map(Number);
@@ -39,28 +77,28 @@ export function permittedAddress(hostname, address, policy) {
     if (isPublicAddress(address))
         return true;
     // An explicit deployment opt-in for Clash/Mihomo TUN fake DNS, not a general private-network exemption.
-    return policy.allowProxyFakeIp === true && isIP(hostname) === 0
-        && hostname.includes('.') && !/\.(localhost|local|internal|lan)$/i.test(hostname)
+    const normalized = hostname.replace(/\.$/, '');
+    return policy.allowProxyFakeIp === true && isIP(address) === 4 && isIP(normalized) === 0
+        && normalized.includes('.') && !/\.(localhost|local|internal|lan)$/i.test(normalized)
         && /^198\.(18|19)\.\d{1,3}\.\d{1,3}$/.test(address);
 }
-export async function fetchPublicPage(input, signal, policy = {}) {
+async function fetchPageOnce(input, signal, policy) {
     let url = validateUrl(input);
-    const timeout = AbortSignal.timeout(25_000);
-    const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
     for (let redirect = 0; redirect <= 4; redirect++) {
-        combined.throwIfAborted();
+        signal.throwIfAborted();
         const hostname = url.hostname.replace(/^\[|\]$/g, '');
-        const addresses = await lookup(hostname, { all: true });
+        const addresses = await abortable(lookup(hostname, { all: true }), signal);
+        signal.throwIfAborted();
         if (!addresses.length || addresses.some(item => !permittedAddress(hostname, item.address, policy))) {
             if (addresses.some(item => /^198\.(18|19)\./.test(item.address)))
-                throw new Error('检测到代理 fake-IP DNS。若本机使用 Clash/Mihomo TUN，请启用插件的 allowProxyFakeIp；否则请直接导入文本。');
+                throw new Error('检测到代理 fake-IP DNS。若本机使用 Clash/Mihomo TUN，请在资料库设置中启用“代理兼容”，然后重新采集；否则请复制正文导入。');
             throw new Error('网页采集不访问本机、内网或保留地址，请直接导入文件或文本');
         }
         const address = addresses[0];
         const response = await new Promise((resolve, reject) => {
             const req = (url.protocol === 'https:' ? httpsRequest : httpRequest)(url, {
-                method: 'GET', signal: combined, family: address.family,
-                headers: { 'User-Agent': 'DSH-Knowledge-Library/0.1', Accept: 'text/html,text/plain;q=0.8', 'Accept-Encoding': 'identity' },
+                method: 'GET', signal, family: address.family, agent: false,
+                headers: { 'User-Agent': 'Mozilla/5.0 (compatible; DSH-Knowledge-Library/0.1)', Accept: 'text/html,application/xhtml+xml,text/plain;q=0.8', 'Accept-Encoding': 'identity' },
                 // Pin the validated DNS result so a second resolution cannot reach an internal host.
                 lookup: (_host, _options, callback) => callback(null, address.address, address.family),
             }, res => {
@@ -69,12 +107,15 @@ export async function fetchPublicPage(input, signal, policy = {}) {
                 res.on('data', (chunk) => {
                     size += chunk.length;
                     if (size > MAX_BYTES) {
-                        req.destroy(new Error('网页超过 6 MB，请下载后手动导入'));
+                        const error = new Error('网页超过 6 MB，请下载后手动导入');
+                        reject(error);
+                        req.destroy(error);
                         return;
                     }
                     chunks.push(chunk);
                 });
                 res.on('end', () => resolve({ status: res.statusCode ?? 0, location: res.headers.location, contentType: String(res.headers['content-type'] ?? ''), bytes: Buffer.concat(chunks) }));
+                res.on('aborted', () => reject(Object.assign(new Error('网页响应在传输完成前断开'), { code: 'ECONNRESET' })));
                 res.on('error', reject);
             });
             req.on('error', reject);
@@ -103,3 +144,33 @@ export async function fetchPublicPage(input, signal, policy = {}) {
     }
     throw new Error('网页重定向次数过多');
 }
+export async function fetchPublicPage(input, signal, policy = {}) {
+    const timeout = AbortSignal.timeout(25_000);
+    const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
+    const snapshot = { allowProxyFakeIp: policy.allowProxyFakeIp === true };
+    let retries = 0;
+    try {
+        for (;;) {
+            combined.throwIfAborted();
+            try {
+                return await fetchPageOnce(input, combined, snapshot);
+            }
+            catch (error) {
+                combined.throwIfAborted();
+                if (!TRANSIENT_ERRORS.has(errorCode(error)) || retries >= MAX_RETRIES)
+                    throw error;
+                // Retry a fresh GET from the original URL, rechecking every DNS result and
+                // redirect. DNS, requests and backoff all share the same 25-second limit.
+                await delay(350 * 2 ** retries + Math.floor(Math.random() * 150), undefined, { signal: combined });
+                retries++;
+            }
+        }
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw signal.reason;
+        if (timeout.aborted)
+            throw new Error('网页连接超时，请检查网络或代理后重试，也可以复制正文导入。', { cause: error });
+        throw networkError(error, retries);
+    }
+}

package/dist/core/grouping.d.ts

@@ -0,0 +1,6 @@
+import type { GroupingPlan, MaterialDetail, SourceAnalysis } from '../types.js';
+export declare function groupingTags(value: unknown): string[];
+export declare function parseModelJson(output: string): unknown;
+export declare function sourceAnalysis(value: unknown, source: MaterialDetail): SourceAnalysis;
+/** A plan is a complete partition: every selected source occurs exactly once. */
+export declare function groupingPlan(value: unknown, sourceIds: string[], analyses: SourceAnalysis[], fromModel?: boolean): GroupingPlan;

package/dist/core/grouping.js

@@ -0,0 +1,71 @@
+import { randomUUID } from 'node:crypto';
+import { categoryName } from './library.js';
+const text = (value, max, label, empty = false) => {
+    if (typeof value !== 'string' || value.length > max || (!empty && !value.trim()))
+        throw new Error(`${label}格式不正确`);
+    return value.trim();
+};
+export function groupingTags(value) {
+    if (!Array.isArray(value) || value.length > 12)
+        throw new Error('建议标签最多12个');
+    return [...new Set(value.map(v => text(v, 40, '标签')).filter(Boolean))];
+}
+export function parseModelJson(output) {
+    try {
+        return JSON.parse(output.trim().replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```$/, ''));
+    }
+    catch {
+        throw new Error('模型没有返回有效的整理格式，请重试');
+    }
+}
+export function sourceAnalysis(value, source) {
+    const data = value;
+    if (!data || data.sourceId !== source.id || !['clear', 'uncertain'].includes(data.certainty))
+        throw new Error('逐篇分析的来源或确定性无效');
+    if (!Array.isArray(data.citations) || !data.citations.length || data.citations.length > 20 || data.citations.some(c => c?.materialId !== source.id || !source.segments.some(s => s.id === c.segmentId)))
+        throw new Error('逐篇分析包含无效来源引用');
+    const concepts = groupingTags(data.concepts);
+    const summary = text(data.summary, 2500, '资料概要');
+    if (/library:\/\//.test(summary))
+        throw new Error('逐篇概要请使用独立引用列表，不在概要编写链接');
+    return { sourceId: source.id, theme: text(data.theme, 200, '主题'), summary, concepts, usage: text(data.usage, 800, '用途'), category: categoryName(text(data.category, 180, '建议分类')), tags: groupingTags(data.tags), certainty: data.certainty, uncertainty: text(data.uncertainty, 800, '待核实说明', data.certainty === 'clear'), citations: data.citations.map(c => ({ materialId: c.materialId, segmentId: c.segmentId })) };
+}
+/** A plan is a complete partition: every selected source occurs exactly once. */
+export function groupingPlan(value, sourceIds, analyses, fromModel = false) {
+    const data = value;
+    if (!data || !Array.isArray(data.groups) || !Array.isArray(data.unassigned) || data.groups.length > sourceIds.length || data.unassigned.length > sourceIds.length)
+        throw new Error('分组方案格式不正确');
+    const seen = new Set();
+    const groupIds = new Set();
+    const accept = (id) => {
+        if (typeof id !== 'string' || !sourceIds.includes(id) || seen.has(id))
+            throw new Error('分组资料重复、遗漏或超出所选范围');
+        seen.add(id);
+        return id;
+    };
+    const groups = data.groups.map(group => {
+        if (!group || !Array.isArray(group.sourceIds) || !group.sourceIds.length)
+            throw new Error('每个分组必须包含资料');
+        const id = fromModel ? `group_${randomUUID()}` : group.id;
+        if (typeof id !== 'string' || !/^group_[a-f0-9-]{36}$/.test(id) || groupIds.has(id))
+            throw new Error('分组ID无效或重复');
+        groupIds.add(id);
+        return { id, title: text(group.title, 200, '分组名称'), reason: text(group.reason, 1200, '分组理由'), sourceIds: group.sourceIds.map(accept), category: categoryName(text(group.category, 180, '来源分类')), tags: groupingTags(group.tags) };
+    });
+    const unassigned = data.unassigned.map(item => { if (!item)
+        throw new Error('待整理项无效'); return { sourceId: accept(item.sourceId), reason: text(item.reason, 1200, '待整理理由') }; });
+    if (seen.size !== sourceIds.length)
+        throw new Error('分组资料重复、遗漏或超出所选范围');
+    if (fromModel) {
+        // Uncertain evidence stays pending until a human deliberately assigns it.
+        for (const analysis of analyses.filter(a => a.certainty === 'uncertain')) {
+            for (const group of groups)
+                group.sourceIds = group.sourceIds.filter(id => id !== analysis.sourceId);
+            if (!unassigned.some(item => item.sourceId === analysis.sourceId))
+                unassigned.push({ sourceId: analysis.sourceId, reason: analysis.uncertainty || '资料信息不足，需进一步核实' });
+        }
+    }
+    if (data.applyClassification !== undefined && typeof data.applyClassification !== 'boolean')
+        throw new Error('同步分类选项无效');
+    return { groups: groups.filter(group => group.sourceIds.length), unassigned, applyClassification: fromModel ? true : data.applyClassification ?? true };
+}

package/dist/core/incremental.d.ts

@@ -0,0 +1,14 @@
+import type { Library } from './library.js';
+import type { KnowledgeDraft, MaterialDetail, NoteIntegration } from '../types.js';
+export declare const noteFingerprint: (note: MaterialDetail) => string;
+/** Local lexical recall, followed by full-body model comparison; no silent body truncation. */
+export declare function recallNotes(library: Library, draft: KnowledgeDraft, topic: string, sources: MaterialDetail[]): {
+    candidates: MaterialDetail[];
+    search: {
+        scanned: number;
+        matched: number;
+        compared: number;
+        oversized: number;
+    };
+};
+export declare function integrationValue(value: unknown, candidates: MaterialDetail[], search: NoteIntegration['search']): NoteIntegration;

package/dist/core/incremental.js

@@ -0,0 +1,52 @@
+import { createHash } from 'node:crypto';
+export const noteFingerprint = (note) => createHash('sha256').update(JSON.stringify([note.content, note.segments, note.title, note.category, note.tags, note.citations, note.revision, note.updatedAt, note.deletedAt, note.deletionId])).digest('hex');
+const tokens = (text) => [...new Set((text.toLowerCase().match(/[a-z0-9_]{2,}|[\p{Script=Han}]+/gu) || []).flatMap(term => /^[\p{Script=Han}]/u.test(term) ? Array.from({ length: Math.max(0, term.length - 1) }, (_, index) => term.slice(index, index + 2)) : [term]))].slice(0, 500);
+/** Local lexical recall, followed by full-body model comparison; no silent body truncation. */
+export function recallNotes(library, draft, topic, sources) {
+    const rows = library.db.prepare('SELECT id,meta,content FROM materials ORDER BY updated_at DESC').all();
+    const query = tokens([topic, draft.title, ...draft.tags, ...sources.flatMap(s => [s.title, ...s.tags]), draft.content].join(' '));
+    const notes = rows.map(row => ({ ...row, metadata: JSON.parse(row.meta) })).filter(row => row.metadata.kind === 'note' && !row.metadata.deletedAt);
+    const ranked = notes.map(row => {
+        const title = `${row.metadata.title} ${row.metadata.tags.join(' ')}`.toLowerCase();
+        const body = row.content.toLowerCase();
+        return { ...row, score: query.reduce((sum, term) => sum + (title.includes(term) ? 4 : body.includes(term) ? 1 : 0), 0) };
+    }).filter(row => row.score > 0).sort((a, b) => b.score - a.score);
+    let size = 0;
+    let oversized = 0;
+    const candidates = [];
+    for (const row of ranked) {
+        if (row.content.length > 50_000) {
+            oversized++;
+            continue;
+        }
+        if (candidates.length >= 5 || size + row.content.length > 60_000)
+            continue;
+        const note = library.get(row.id);
+        candidates.push(note);
+        size += note.content.length;
+    }
+    return { candidates, search: { scanned: notes.length, matched: ranked.length, compared: candidates.length, oversized } };
+}
+export function integrationValue(value, candidates, search) {
+    const data = value;
+    const bounded = (v, max, label, empty = false) => {
+        if (typeof v !== 'string' || v.length > max || (!empty && !v.trim()))
+            throw new Error(`增量整理的${label}无效`);
+        return v.trim();
+    };
+    const list = (v) => { if (!Array.isArray(v) || v.length > 12)
+        throw new Error('增量对比列表格式无效'); return v.map(item => bounded(item, 1000, '对比说明')); };
+    if (!data || !['new', 'append', 'duplicate'].includes(data.action))
+        throw new Error('增量整理建议格式无效');
+    const recommendation = data.action;
+    const target = recommendation === 'new' ? undefined : candidates.find(n => n.id === data.noteId);
+    if (recommendation !== 'new' && !target)
+        throw new Error('增量整理指定了未检索的笔记');
+    const content = bounded(data.content, 50_000, '新增正文', recommendation !== 'append');
+    if (recommendation !== 'append' && content)
+        throw new Error('新建或重复建议不应包含追加正文');
+    if (target && content && target.content.includes(content))
+        throw new Error('建议追加的正文已存在，请重新核对');
+    return { recommendation, choice: recommendation, reason: bounded(data.reason, 2000, '建议理由'), overlaps: list(data.overlaps), additions: list(data.additions), conflicts: list(data.conflicts), content, search,
+        ...(target ? { target: { id: target.id, title: target.title, category: target.category, revision: target.revision, fingerprint: noteFingerprint(target), content: target.content } } : {}) };
+}

package/dist/core/jobs.d.ts

@@ -20,6 +20,7 @@ export declare class ImportQueue {
         attempts: number;
         materialId?: string;
         error?: string;
+        errorCode?: "PAGE_REQUIRES_BROWSER";
     }[];
     add(url: string, fields?: CaptureFields): ImportJob;
     retry(id: string): ImportJob;

package/dist/core/jobs.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { atomicJson } from './library.js';
 import { fetchPublicPage, validateUrl } from './fetch.js';
+import { PageAccessError } from './page-access.js';
 export class ImportQueue {
     library;
     fetchPage;
@@ -48,6 +49,7 @@ export class ImportQueue {
             throw new Error('只能重试失败的任务');
         job.status = 'queued';
         job.error = undefined;
+        job.errorCode = undefined;
         job.attempts = 0;
         this.persist();
         this.kick();
@@ -75,10 +77,12 @@ export class ImportQueue {
                     job.materialId = result.material.id;
                     job.status = 'completed';
                     job.error = undefined;
+                    job.errorCode = undefined;
                 }
                 catch (error) {
                     job.status = this.stopped ? 'queued' : 'failed';
                     job.error = error.message;
+                    job.errorCode = error instanceof PageAccessError ? error.code : undefined;
                 }
                 job.updatedAt = new Date().toISOString();
                 this.persist();

package/dist/core/knowledge.d.ts

@@ -0,0 +1,37 @@
+import { Library } from './library.js';
+import type { KnowledgeJob, KnowledgeOverview } from '../types.js';
+import type { KnowledgeModel } from '../knowledge-model.js';
+export declare class KnowledgeQueue {
+    private library;
+    private model;
+    private jobs;
+    private file;
+    private stopped;
+    private running?;
+    private abort?;
+    constructor(library: Library, model: KnowledgeModel);
+    overview(): KnowledgeOverview;
+    get(id: string): KnowledgeJob;
+    private find;
+    private persist;
+    private sources;
+    private checkedSources;
+    add(ids: unknown, topic?: unknown, requestedMode?: unknown): KnowledgeJob;
+    private newJob;
+    cancel(id: string): KnowledgeJob;
+    discard(id: string): KnowledgeJob;
+    editPlan(id: string, value: unknown, version: unknown): KnowledgeJob;
+    confirmPlan(id: string, version: unknown, apply?: unknown, expectedModel?: unknown): KnowledgeJob;
+    private runClassification;
+    rollbackPlan(id: string): KnowledgeJob;
+    edit(id: string, value: unknown, version: unknown, integration?: unknown): KnowledgeJob;
+    confirm(id: string, version: unknown, category?: unknown): import("../types.js").CaptureResult;
+    private progress;
+    private call;
+    private evidence;
+    private analyze;
+    private generate;
+    private kick;
+    idle(): Promise<void>;
+    close(): Promise<void>;
+}