@xopcai/xopc 0.0.159 → 0.0.161

package/dist/src/work-discovery/candidate-discovery.js

@@ -0,0 +1,279 @@
+import { inferProjectKind } from "../projects/project-kind.js";
+import "../projects/index.js";
+import { homedir } from "node:os";
+import { basename, extname, isAbsolute, join, resolve } from "node:path";
+import { constants } from "node:fs";
+import { execFile } from "node:child_process";
+import { access, readFile, readdir, realpath, stat } from "node:fs/promises";
+import { promisify } from "node:util";
+//#region src/work-discovery/candidate-discovery.ts
+const execFileAsync = promisify(execFile);
+const COMMON_WORK_ROOT_NAMES = [
+	"develop",
+	"Developer",
+	"Projects",
+	"workspace",
+	"code",
+	"src"
+];
+const PERSONAL_WORK_ROOT_NAMES = [
+	"Desktop",
+	"Documents",
+	"Downloads"
+];
+const MAX_ROOT_CHILDREN = 100;
+const GIT_TIMEOUT_MS = 2500;
+const RECENT_GENERAL_WORK_MS = 90 * 864e5;
+const GENERAL_WORK_EXTENSIONS = new Set([
+	".doc",
+	".docx",
+	".md",
+	".odt",
+	".pdf",
+	".ppt",
+	".pptx",
+	".rtf",
+	".txt",
+	".xls",
+	".xlsx"
+]);
+function abortIfNeeded(signal) {
+	if (signal?.aborted) throw new DOMException("Work discovery canceled", "AbortError");
+}
+async function readableDirectory(path) {
+	try {
+		const canonical = await realpath(path);
+		if (!(await stat(canonical)).isDirectory()) return null;
+		await access(canonical, constants.R_OK);
+		return canonical;
+	} catch {
+		return null;
+	}
+}
+async function gitSignal(rootPath, signal) {
+	try {
+		const [{ stdout: statusOutput }, { stdout: commitOutput }] = await Promise.all([execFileAsync("git", [
+			"-C",
+			rootPath,
+			"status",
+			"--short",
+			"--branch",
+			"--untracked-files=no"
+		], {
+			timeout: GIT_TIMEOUT_MS,
+			maxBuffer: 128 * 1024,
+			signal
+		}), execFileAsync("git", [
+			"-C",
+			rootPath,
+			"log",
+			"-1",
+			"--format=%ct"
+		], {
+			timeout: GIT_TIMEOUT_MS,
+			maxBuffer: 16 * 1024,
+			signal
+		})]);
+		const statusLines = statusOutput.split("\n").filter(Boolean);
+		const branch = statusLines[0]?.startsWith("## ") ? statusLines[0].slice(3).split("...")[0]?.trim() : void 0;
+		const timestamp = Number(commitOutput.trim()) * 1e3;
+		return {
+			...branch ? { branch } : {},
+			changedFileCount: Math.min(100, Math.max(0, statusLines.length - 1)),
+			...Number.isFinite(timestamp) && timestamp > 0 ? { lastCommitAt: timestamp } : {}
+		};
+	} catch {
+		return { changedFileCount: 0 };
+	}
+}
+async function recentGeneralWorkAt(rootPath, nowMs) {
+	const entries = await readdir(rootPath, { withFileTypes: true }).catch(() => []);
+	let latest;
+	for (const entry of entries.slice(0, MAX_ROOT_CHILDREN)) {
+		if (!entry.isFile() || entry.name.startsWith(".") || !GENERAL_WORK_EXTENSIONS.has(extname(entry.name).toLowerCase())) continue;
+		const info = await stat(join(rootPath, entry.name)).catch(() => null);
+		if (!info?.isFile() || nowMs - info.mtimeMs > RECENT_GENERAL_WORK_MS) continue;
+		latest = latest == null ? info.mtimeMs : Math.max(latest, info.mtimeMs);
+	}
+	return latest;
+}
+async function isCodingRoot(rootPath) {
+	if (inferProjectKind({ workspaceRoot: rootPath }).kind === "coding") return true;
+	return stat(join(rootPath, ".git")).then(() => true).catch(() => false);
+}
+function recencyScore(lastActiveAt, nowMs) {
+	if (!lastActiveAt) return 0;
+	const ageDays = Math.max(0, (nowMs - lastActiveAt) / 864e5);
+	if (ageDays <= 2) return 40;
+	if (ageDays <= 7) return 34;
+	if (ageDays <= 14) return 27;
+	if (ageDays <= 30) return 19;
+	if (ageDays <= 90) return 10;
+	return 2;
+}
+async function probeCandidate(input, nowMs, signal) {
+	abortIfNeeded(signal);
+	const rootPath = await readableDirectory(input.rootPath);
+	if (!rootPath) return null;
+	const [rootInfo, git, personalWorkAt] = await Promise.all([
+		stat(rootPath),
+		gitSignal(rootPath, signal),
+		input.source === "personal_work_root" ? recentGeneralWorkAt(rootPath, nowMs) : void 0
+	]);
+	abortIfNeeded(signal);
+	const inference = inferProjectKind({ workspaceRoot: rootPath });
+	if (input.source === "common_work_root" && !git.lastCommitAt && inference.kind !== "coding") return null;
+	if (input.source === "personal_work_root" && !git.lastCommitAt && inference.kind !== "coding" && !personalWorkAt) return null;
+	const lastActiveAt = Math.max(rootInfo.mtimeMs, git.lastCommitAt ?? 0, personalWorkAt ?? 0) || void 0;
+	const score = Math.min(100, Math.round(recencyScore(lastActiveAt, nowMs) + (git.lastCommitAt ? 20 : 0) + Math.min(10, git.changedFileCount * 2) + Math.round(inference.confidence * 20)));
+	const evidence = [];
+	if (git.lastCommitAt) evidence.push("recent Git activity");
+	if (git.changedFileCount > 0) evidence.push(`${git.changedFileCount} changed files`);
+	if (inference.reasons[0]) evidence.push(inference.reasons[0]);
+	if (input.source === "existing_project") evidence.push("already connected to xopc");
+	if (input.source === "approved_directory") evidence.push("previously approved work folder");
+	return {
+		id: input.projectId ? `project:${input.projectId}` : `path:${rootPath}`,
+		rootPath,
+		displayName: basename(rootPath),
+		source: input.source,
+		...input.projectId ? { projectId: input.projectId } : {},
+		projectKind: inference.kind,
+		projectKindConfidence: inference.confidence,
+		score,
+		...lastActiveAt ? { lastActiveAt } : {},
+		...git.branch ? { branch: git.branch } : {},
+		changedFileCount: git.changedFileCount,
+		evidence: evidence.slice(0, 4)
+	};
+}
+async function commonRootInputs(homeDirectory, signal) {
+	const inputs = [];
+	for (const name of COMMON_WORK_ROOT_NAMES) {
+		abortIfNeeded(signal);
+		const commonRoot = await readableDirectory(join(homeDirectory, name));
+		if (!commonRoot) continue;
+		let entries;
+		try {
+			entries = await readdir(commonRoot, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name)).slice(0, MAX_ROOT_CHILDREN)) {
+			if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+			const directPath = join(commonRoot, entry.name);
+			if (await isCodingRoot(directPath)) {
+				inputs.push({
+					rootPath: directPath,
+					source: "common_work_root"
+				});
+				continue;
+			}
+			const nestedEntries = await readdir(directPath, { withFileTypes: true }).catch(() => []);
+			for (const nested of nestedEntries.sort((left, right) => left.name.localeCompare(right.name)).slice(0, MAX_ROOT_CHILDREN)) {
+				abortIfNeeded(signal);
+				if (!nested.isDirectory() || nested.name.startsWith(".")) continue;
+				const nestedPath = join(directPath, nested.name);
+				if (await isCodingRoot(nestedPath)) inputs.push({
+					rootPath: nestedPath,
+					source: "common_work_root"
+				});
+			}
+		}
+	}
+	return inputs;
+}
+function resolveXdgPath(value, homeDirectory) {
+	const expanded = value.trim().replace(/^"|"$/g, "").replace(/^\$HOME(?=\/|$)|^\$\{HOME\}(?=\/|$)/, homeDirectory);
+	return isAbsolute(expanded) ? resolve(expanded) : null;
+}
+async function personalWorkRoots(homeDirectory, platform, environment) {
+	const roots = PERSONAL_WORK_ROOT_NAMES.map((name) => join(homeDirectory, name));
+	if (platform === "win32") for (const oneDrive of [
+		environment.OneDrive,
+		environment.OneDriveConsumer,
+		environment.OneDriveCommercial
+	]) {
+		if (!oneDrive) continue;
+		roots.push(...PERSONAL_WORK_ROOT_NAMES.map((name) => join(oneDrive, name)));
+	}
+	if (platform === "linux") {
+		const config = await readFile(join(homeDirectory, ".config", "user-dirs.dirs"), "utf8").catch(() => "");
+		for (const line of config.split("\n")) {
+			const match = /^XDG_(?:DESKTOP|DOCUMENTS|DOWNLOAD)_DIR=(.+)$/.exec(line.trim());
+			const path = match?.[1] ? resolveXdgPath(match[1], homeDirectory) : null;
+			if (path) roots.push(path);
+		}
+	}
+	return [...new Set(roots)];
+}
+async function personalRootInputs(roots, nowMs, signal) {
+	const inputs = [];
+	for (const root of roots) {
+		abortIfNeeded(signal);
+		const readableRoot = await readableDirectory(root);
+		if (!readableRoot) continue;
+		const entries = await readdir(readableRoot, { withFileTypes: true }).catch(() => []);
+		for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name)).slice(0, MAX_ROOT_CHILDREN)) {
+			abortIfNeeded(signal);
+			if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+			const directPath = join(readableRoot, entry.name);
+			if (await isCodingRoot(directPath) || await recentGeneralWorkAt(directPath, nowMs)) {
+				inputs.push({
+					rootPath: directPath,
+					source: "personal_work_root"
+				});
+				continue;
+			}
+			const nestedEntries = await readdir(directPath, { withFileTypes: true }).catch(() => []);
+			for (const nested of nestedEntries.sort((left, right) => left.name.localeCompare(right.name)).slice(0, MAX_ROOT_CHILDREN)) {
+				if (!nested.isDirectory() || nested.name.startsWith(".")) continue;
+				const nestedPath = join(directPath, nested.name);
+				if (await isCodingRoot(nestedPath) || await recentGeneralWorkAt(nestedPath, nowMs)) inputs.push({
+					rootPath: nestedPath,
+					source: "personal_work_root"
+				});
+			}
+		}
+	}
+	return inputs;
+}
+async function discoverWorkCandidates(options = {}) {
+	const nowMs = options.nowMs ?? Date.now();
+	const homeDirectory = options.homeDirectory ?? homedir();
+	const existingInputs = (options.existingProjects ?? []).flatMap((project) => {
+		const rootPath = project.workspaceRoot?.trim();
+		return rootPath ? [{
+			rootPath,
+			source: "existing_project",
+			projectId: project.id
+		}] : [];
+	});
+	const approvedInputs = (options.approvedDirectories ?? []).map((source) => ({
+		rootPath: source.rootPath,
+		source: "approved_directory"
+	}));
+	const [commonInputs, personalInputs] = await Promise.all([commonRootInputs(homeDirectory, options.signal), personalWorkRoots(homeDirectory, options.platform ?? process.platform, options.environment ?? process.env).then((roots) => personalRootInputs(roots, nowMs, options.signal))]);
+	const uniqueInputs = /* @__PURE__ */ new Map();
+	for (const input of [
+		...existingInputs,
+		...approvedInputs,
+		...commonInputs,
+		...personalInputs
+	]) {
+		const existing = uniqueInputs.get(input.rootPath);
+		if (!existing || input.source === "existing_project" || input.source === "approved_directory" && existing.source !== "existing_project") uniqueInputs.set(input.rootPath, input);
+	}
+	const candidates = [];
+	const inputs = [...uniqueInputs.values()];
+	for (let index = 0; index < inputs.length; index += 4) {
+		abortIfNeeded(options.signal);
+		const batch = await Promise.all(inputs.slice(index, index + 4).map((input) => probeCandidate(input, nowMs, options.signal)));
+		candidates.push(...batch.filter((item) => Boolean(item)));
+	}
+	const canonicalCandidates = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) if (!canonicalCandidates.get(candidate.rootPath) || candidate.source === "existing_project") canonicalCandidates.set(candidate.rootPath, candidate);
+	return [...canonicalCandidates.values()].sort((a, b) => b.score - a.score || (b.lastActiveAt ?? 0) - (a.lastActiveAt ?? 0) || a.rootPath.localeCompare(b.rootPath)).slice(0, 8);
+}
+//#endregion
+export { discoverWorkCandidates };

package/dist/src/work-discovery/evaluation.d.ts

@@ -0,0 +1,11 @@
+export interface WorkUnderstandingEvaluationCase {
+    expectedThreadKeys: string[];
+    inferredThreadKeys: string[];
+    evidenceBackedThreadKeys: string[];
+}
+export declare function evaluateWorkUnderstandingCase(input: WorkUnderstandingEvaluationCase): {
+    precision: number;
+    recall: number;
+    evidenceCoverage: number;
+    f1: number;
+};

package/dist/src/work-discovery/evaluation.js

@@ -0,0 +1,17 @@
+//#region src/work-discovery/evaluation.ts
+function evaluateWorkUnderstandingCase(input) {
+	const expected = new Set(input.expectedThreadKeys);
+	const inferred = new Set(input.inferredThreadKeys);
+	const evidenceBacked = new Set(input.evidenceBackedThreadKeys);
+	const truePositives = [...inferred].filter((key) => expected.has(key)).length;
+	const precision = inferred.size ? truePositives / inferred.size : expected.size ? 0 : 1;
+	const recall = expected.size ? truePositives / expected.size : 1;
+	return {
+		precision,
+		recall,
+		evidenceCoverage: inferred.size ? [...inferred].filter((key) => evidenceBacked.has(key)).length / inferred.size : 1,
+		f1: precision + recall ? 2 * precision * recall / (precision + recall) : 0
+	};
+}
+//#endregion
+export { evaluateWorkUnderstandingCase };

package/dist/src/work-discovery/governance.d.ts

@@ -0,0 +1,25 @@
+export interface WorkUnderstandingSourceLineage {
+    sourceId: string;
+    evidenceCount: number;
+    threadCount: number;
+    memoryRecordCount: number;
+    discoveryRunCount: number;
+}
+export declare function getWorkUnderstandingSourceLineage(sourceId: string): WorkUnderstandingSourceLineage | null;
+export declare function deleteWorkUnderstandingDerivedData(sourceId: string): {
+    deletedMemoryRecords: number;
+    evidenceCount: number | bigint;
+    deletedThreads: number;
+    retainedThreads: number;
+};
+export declare function getWorkUnderstandingMetrics(): {
+    completedInvestigations: number;
+    averageToolCalls: number;
+    activeThreads: number;
+    confirmedThreads: number;
+    recognitionConfirmationRate: number;
+    evidenceBySource: {
+        sourceType: string;
+        count: number;
+    }[];
+};

package/dist/src/work-discovery/governance.js

@@ -0,0 +1,96 @@
+import { requireXopcDatabase } from "../storage/sqlite/connection.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { deleteMemoryRecord, listMemoryRecords } from "../storage/sqlite/memory-records-repository.js";
+//#region src/work-discovery/governance.ts
+function memoryRecordsForSource(sourceId, rootPath) {
+	const { db } = requireXopcDatabase();
+	const runIds = rootPath ? db.prepare("SELECT id FROM work_discovery_runs WHERE root_path = ?").all(rootPath).map((row) => row.id) : [];
+	const runPaths = new Set(runIds.map((id) => `work-discovery://${id}`));
+	const records = [];
+	for (let offset = 0;; offset += 500) {
+		const page = listMemoryRecords({
+			limit: 500,
+			offset
+		});
+		records.push(...page.filter((record) => runPaths.has(record.source.path)));
+		if (page.length < 500) break;
+	}
+	return records;
+}
+function getWorkUnderstandingSourceLineage(sourceId) {
+	const { db } = requireXopcDatabase();
+	const source = db.prepare("SELECT root_path FROM work_discovery_sources WHERE source_id = ?").get(sourceId);
+	if (!source) return null;
+	const evidenceCount = db.prepare("SELECT COUNT(*) AS count FROM work_understanding_evidence WHERE source_grant_id = ?").get(sourceId).count;
+	const threadCount = db.prepare(`SELECT COUNT(DISTINCT te.thread_id) AS count
+     FROM work_understanding_thread_evidence te
+     JOIN work_understanding_evidence e ON e.evidence_id = te.evidence_id
+     WHERE e.source_grant_id = ?`).get(sourceId).count;
+	const discoveryRunCount = source.root_path ? db.prepare("SELECT COUNT(*) AS count FROM work_discovery_runs WHERE root_path = ?").get(source.root_path).count : 0;
+	return {
+		sourceId,
+		evidenceCount,
+		threadCount,
+		memoryRecordCount: memoryRecordsForSource(sourceId, source.root_path).length,
+		discoveryRunCount
+	};
+}
+function deleteWorkUnderstandingDerivedData(sourceId) {
+	if (!getWorkUnderstandingSourceLineage(sourceId)) return null;
+	const { db } = requireXopcDatabase();
+	const memoryRecords = memoryRecordsForSource(sourceId, db.prepare("SELECT root_path FROM work_discovery_sources WHERE source_id = ?").get(sourceId).root_path).filter((record) => record.explicitness !== "explicit");
+	const affectedThreadIds = db.prepare(`SELECT DISTINCT te.thread_id AS id
+     FROM work_understanding_thread_evidence te
+     JOIN work_understanding_evidence e ON e.evidence_id = te.evidence_id
+     WHERE e.source_grant_id = ?`).all(sourceId).map((row) => row.id);
+	const result = runSqliteWriteTransaction((transaction) => {
+		transaction.prepare(`DELETE FROM work_understanding_thread_evidence
+       WHERE evidence_id IN (SELECT evidence_id FROM work_understanding_evidence WHERE source_grant_id = ?)`).run(sourceId);
+		const evidence = transaction.prepare("DELETE FROM work_understanding_evidence WHERE source_grant_id = ?").run(sourceId);
+		let deletedThreads = 0;
+		let retainedThreads = 0;
+		for (const threadId of affectedThreadIds) {
+			if (transaction.prepare("SELECT COUNT(*) AS count FROM work_understanding_thread_evidence WHERE thread_id = ?").get(threadId).count > 0) continue;
+			const thread = transaction.prepare("SELECT user_status, status FROM work_understanding_threads WHERE thread_id = ?").get(threadId);
+			if (!thread) continue;
+			if (thread.user_status === "confirmed" || thread.user_status === "corrected") {
+				transaction.prepare(`UPDATE work_understanding_threads SET confidence = MIN(confidence, 0.5),
+           status = CASE WHEN status IN ('paused', 'completed') THEN status ELSE 'uncertain' END,
+           updated_at = ? WHERE thread_id = ?`).run(Date.now(), threadId);
+				retainedThreads += 1;
+			} else {
+				transaction.prepare("DELETE FROM work_understanding_threads WHERE thread_id = ?").run(threadId);
+				deletedThreads += 1;
+			}
+		}
+		return {
+			evidenceCount: evidence.changes,
+			deletedThreads,
+			retainedThreads
+		};
+	});
+	const deletedMemoryRecords = memoryRecords.filter((record) => deleteMemoryRecord(record.id)).length;
+	return {
+		...result,
+		deletedMemoryRecords
+	};
+}
+function getWorkUnderstandingMetrics() {
+	const { db } = requireXopcDatabase();
+	const scalar = (sql) => db.prepare(sql).get().value;
+	const evidenceBySource = db.prepare("SELECT source_type AS sourceType, COUNT(*) AS count FROM work_understanding_evidence GROUP BY source_type").all();
+	const recognition = db.prepare(`SELECT recognition_decision AS decision, COUNT(*) AS count
+     FROM work_discovery_feedback GROUP BY recognition_decision`).all();
+	const reviewed = recognition.reduce((sum, item) => sum + (item.decision === "dismissed" ? 0 : item.count), 0);
+	const confirmed = recognition.find((item) => item.decision === "confirmed")?.count ?? 0;
+	return {
+		completedInvestigations: scalar("SELECT COUNT(*) AS value FROM work_understanding_investigations WHERE status = 'completed'"),
+		averageToolCalls: scalar("SELECT COALESCE(AVG(tool_call_count), 0) AS value FROM work_understanding_investigations"),
+		activeThreads: scalar("SELECT COUNT(*) AS value FROM work_understanding_threads WHERE status IN ('active', 'blocked') AND user_status <> 'rejected'"),
+		confirmedThreads: scalar("SELECT COUNT(*) AS value FROM work_understanding_threads WHERE user_status IN ('confirmed', 'corrected')"),
+		recognitionConfirmationRate: reviewed ? confirmed / reviewed : 0,
+		evidenceBySource
+	};
+}
+//#endregion
+export { deleteWorkUnderstandingDerivedData, getWorkUnderstandingMetrics, getWorkUnderstandingSourceLineage };

package/dist/src/work-discovery/incremental-repository.d.ts

@@ -0,0 +1,13 @@
+import type { WorkDiscoveryPreview, WorkDiscoverySourceRefresh } from './types.js';
+export declare function recordWorkDiscoverySourceRefresh(input: {
+    sourceId: string;
+    changed: boolean;
+    previousFingerprint?: WorkDiscoveryPreview['fingerprint'];
+    currentFingerprint: WorkDiscoveryPreview['fingerprint'];
+    status?: WorkDiscoverySourceRefresh['status'];
+    discoveryRunId?: string;
+    checkedAt?: number;
+}): WorkDiscoverySourceRefresh;
+export declare function listWorkDiscoverySourceRefreshes(sourceId: string, limit?: number): WorkDiscoverySourceRefresh[];
+export declare function findActiveWorkDiscoverySourceRefresh(sourceId: string, fingerprint: WorkDiscoveryPreview['fingerprint']): WorkDiscoverySourceRefresh | null;
+export declare function updateWorkDiscoverySourceRefreshForRun(runId: string, status: 'completed' | 'failed'): void;

package/dist/src/work-discovery/incremental-repository.js

@@ -0,0 +1,55 @@
+import { requireXopcDatabase } from "../storage/sqlite/connection.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { workDiscoveryFingerprintsEqual } from "./incremental.js";
+import { randomUUID } from "node:crypto";
+//#region src/work-discovery/incremental-repository.ts
+function parseFingerprint(value) {
+	if (!value) return void 0;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+function fromRow(row) {
+	return {
+		id: row.refresh_id,
+		sourceId: row.source_id,
+		changed: row.changed === 1,
+		...parseFingerprint(row.previous_fingerprint_json) ? { previousFingerprint: parseFingerprint(row.previous_fingerprint_json) } : {},
+		currentFingerprint: parseFingerprint(row.current_fingerprint_json),
+		status: row.status,
+		...row.discovery_run_id ? { discoveryRunId: row.discovery_run_id } : {},
+		checkedAt: row.checked_at
+	};
+}
+function recordWorkDiscoverySourceRefresh(input) {
+	const id = randomUUID();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO work_discovery_source_refreshes (
+        refresh_id, source_id, discovery_run_id, changed, previous_fingerprint_json,
+        current_fingerprint_json, status, checked_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.sourceId, input.discoveryRunId ?? null, input.changed ? 1 : 0, input.previousFingerprint ? JSON.stringify(input.previousFingerprint) : null, JSON.stringify(input.currentFingerprint), input.status ?? "checked", input.checkedAt ?? Date.now());
+	});
+	const { db } = requireXopcDatabase();
+	return fromRow(db.prepare("SELECT * FROM work_discovery_source_refreshes WHERE refresh_id = ?").get(id));
+}
+function listWorkDiscoverySourceRefreshes(sourceId, limit = 20) {
+	const { db } = requireXopcDatabase();
+	return db.prepare("SELECT * FROM work_discovery_source_refreshes WHERE source_id = ? ORDER BY checked_at DESC LIMIT ?").all(sourceId, Math.max(1, Math.min(100, limit))).map(fromRow);
+}
+function findActiveWorkDiscoverySourceRefresh(sourceId, fingerprint) {
+	const { db } = requireXopcDatabase();
+	return db.prepare(`SELECT refresh.* FROM work_discovery_source_refreshes refresh
+     JOIN work_discovery_runs run ON run.id = refresh.discovery_run_id
+     WHERE refresh.source_id = ? AND refresh.status = 'queued'
+       AND run.status IN ('queued', 'probing', 'analyzing')
+     ORDER BY refresh.checked_at DESC`).all(sourceId).map(fromRow).find((refresh) => workDiscoveryFingerprintsEqual(refresh.currentFingerprint, fingerprint)) ?? null;
+}
+function updateWorkDiscoverySourceRefreshForRun(runId, status) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare("UPDATE work_discovery_source_refreshes SET status = ? WHERE discovery_run_id = ?").run(status, runId);
+	});
+}
+//#endregion
+export { findActiveWorkDiscoverySourceRefresh, listWorkDiscoverySourceRefreshes, recordWorkDiscoverySourceRefresh, updateWorkDiscoverySourceRefreshForRun };

package/dist/src/work-discovery/incremental.d.ts

@@ -0,0 +1,2 @@
+import type { WorkDiscoveryPreview } from './types.js';
+export declare function workDiscoveryFingerprintsEqual(left: WorkDiscoveryPreview['fingerprint'] | undefined, right: WorkDiscoveryPreview['fingerprint']): boolean;

package/dist/src/work-discovery/incremental.js

@@ -0,0 +1,7 @@
+//#region src/work-discovery/incremental.ts
+function workDiscoveryFingerprintsEqual(left, right) {
+	if (!left) return false;
+	return left.branch === right.branch && left.changedFileCount === right.changedFileCount && left.contentSignature === right.contentSignature && JSON.stringify(left.recentAreas) === JSON.stringify(right.recentAreas);
+}
+//#endregion
+export { workDiscoveryFingerprintsEqual };

package/dist/src/work-discovery/index.d.ts

@@ -2,4 +2,14 @@ export * from './types.js';
 export * from './repository.js';
 export * from './probe.js';
 export * from './analyzer.js';
+export * from './candidate-discovery.js';
 export * from './service.js';
+export * from './source-repository.js';
+export * from './investigation-repository.js';
+export * from './investigator.js';
+export * from './incremental.js';
+export * from './incremental-repository.js';
+export * from './governance.js';
+export * from './evaluation.js';
+export * from './thread-repository.js';
+export * from './thread-service.js';

package/dist/src/work-discovery/index.js

@@ -1,5 +1,15 @@
-import { WORK_DISCOVERY_SCAN_POLICY_VERSION, canonicalWorkDiscoveryRoot, previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, summarizeWorkContextSnapshot } from "./probe.js";
-import { analyzeWorkContext, workDiscoveryResultMarkdown } from "./analyzer.js";
+import { addWorkUnderstandingThreadFeedback, attachWorkUnderstandingThreadEvidence, getWorkUnderstandingThread, getWorkUnderstandingThreadByCanonicalKey, listWorkUnderstandingThreads, upsertWorkUnderstandingThread } from "./thread-repository.js";
+import { WORK_DISCOVERY_SCAN_POLICY_VERSION, canonicalWorkDiscoveryRoot, previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, readWorkDiscoveryTextExcerpt, searchWorkDiscoveryText, summarizeWorkContextSnapshot } from "./probe.js";
+import { analyzePersonalContext, analyzeWorkContext, workDiscoveryResultMarkdown } from "./analyzer.js";
+import { discoverWorkCandidates } from "./candidate-discovery.js";
+import { deleteWorkUnderstandingDerivedData, getWorkUnderstandingMetrics, getWorkUnderstandingSourceLineage } from "./governance.js";
+import { workDiscoveryFingerprintsEqual } from "./incremental.js";
+import { findActiveWorkDiscoverySourceRefresh, listWorkDiscoverySourceRefreshes, recordWorkDiscoverySourceRefresh, updateWorkDiscoverySourceRefreshForRun } from "./incremental-repository.js";
+import { appendWorkUnderstandingEvidence, createWorkUnderstandingInvestigation, getWorkUnderstandingInvestigation, getWorkUnderstandingInvestigationForRun, listWorkUnderstandingEvidence, resetWorkUnderstandingInvestigation, updateWorkUnderstandingEvidenceObservation, updateWorkUnderstandingInvestigation } from "./investigation-repository.js";
+import { DEFAULT_WORK_INVESTIGATION_BUDGET, investigateWorkContext } from "./investigator.js";
+import { persistWorkThreadsFromDiscovery } from "./thread-service.js";
 import { createWorkDiscoveryRun, getWorkDiscoveryOnboardingState, getWorkDiscoveryRun, getWorkDiscoveryRunByIdempotencyKey, setWorkDiscoveryFeedback, setWorkDiscoveryOnboardingState, updateWorkDiscoveryRun } from "./repository.js";
+import { getWorkDiscoveryDirectorySource, listWorkDiscoveryDirectorySources, revokeWorkDiscoveryDirectorySource, upsertWorkDiscoveryDirectorySource } from "./source-repository.js";
 import { WorkDiscoveryService } from "./service.js";
-export { WORK_DISCOVERY_SCAN_POLICY_VERSION, WorkDiscoveryService, analyzeWorkContext, canonicalWorkDiscoveryRoot, createWorkDiscoveryRun, getWorkDiscoveryOnboardingState, getWorkDiscoveryRun, getWorkDiscoveryRunByIdempotencyKey, previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, setWorkDiscoveryFeedback, setWorkDiscoveryOnboardingState, summarizeWorkContextSnapshot, updateWorkDiscoveryRun, workDiscoveryResultMarkdown };
+import { evaluateWorkUnderstandingCase } from "./evaluation.js";
+export { DEFAULT_WORK_INVESTIGATION_BUDGET, WORK_DISCOVERY_SCAN_POLICY_VERSION, WorkDiscoveryService, addWorkUnderstandingThreadFeedback, analyzePersonalContext, analyzeWorkContext, appendWorkUnderstandingEvidence, attachWorkUnderstandingThreadEvidence, canonicalWorkDiscoveryRoot, createWorkDiscoveryRun, createWorkUnderstandingInvestigation, deleteWorkUnderstandingDerivedData, discoverWorkCandidates, evaluateWorkUnderstandingCase, findActiveWorkDiscoverySourceRefresh, getWorkDiscoveryDirectorySource, getWorkDiscoveryOnboardingState, getWorkDiscoveryRun, getWorkDiscoveryRunByIdempotencyKey, getWorkUnderstandingInvestigation, getWorkUnderstandingInvestigationForRun, getWorkUnderstandingMetrics, getWorkUnderstandingSourceLineage, getWorkUnderstandingThread, getWorkUnderstandingThreadByCanonicalKey, investigateWorkContext, listWorkDiscoveryDirectorySources, listWorkDiscoverySourceRefreshes, listWorkUnderstandingEvidence, listWorkUnderstandingThreads, persistWorkThreadsFromDiscovery, previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, readWorkDiscoveryTextExcerpt, recordWorkDiscoverySourceRefresh, resetWorkUnderstandingInvestigation, revokeWorkDiscoveryDirectorySource, searchWorkDiscoveryText, setWorkDiscoveryFeedback, setWorkDiscoveryOnboardingState, summarizeWorkContextSnapshot, updateWorkDiscoveryRun, updateWorkDiscoverySourceRefreshForRun, updateWorkUnderstandingEvidenceObservation, updateWorkUnderstandingInvestigation, upsertWorkDiscoveryDirectorySource, upsertWorkUnderstandingThread, workDiscoveryFingerprintsEqual, workDiscoveryResultMarkdown };

package/dist/src/work-discovery/investigation-repository.d.ts

@@ -0,0 +1,16 @@
+import type { WorkUnderstandingEvidenceItem, WorkUnderstandingInvestigation, WorkUnderstandingInvestigationBudget } from './types.js';
+export declare function createWorkUnderstandingInvestigation(input: {
+    discoveryRunId: string;
+    budget: WorkUnderstandingInvestigationBudget;
+    nowMs?: number;
+}): WorkUnderstandingInvestigation;
+export declare function getWorkUnderstandingInvestigation(id: string): WorkUnderstandingInvestigation | null;
+export declare function getWorkUnderstandingInvestigationForRun(runId: string): WorkUnderstandingInvestigation | null;
+export declare function updateWorkUnderstandingInvestigation(id: string, patch: Partial<Pick<WorkUnderstandingInvestigation, 'status' | 'plan' | 'toolCallCount' | 'contentCharsRead' | 'completedAt' | 'errorMessage'>>): WorkUnderstandingInvestigation | null;
+export declare function resetWorkUnderstandingInvestigation(id: string, budget: WorkUnderstandingInvestigationBudget, nowMs?: number): WorkUnderstandingInvestigation | null;
+export declare function appendWorkUnderstandingEvidence(input: Omit<WorkUnderstandingEvidenceItem, 'id' | 'collectedAt'> & {
+    id?: string;
+    collectedAt?: number;
+}): WorkUnderstandingEvidenceItem;
+export declare function updateWorkUnderstandingEvidenceObservation(id: string, observation: string): void;
+export declare function listWorkUnderstandingEvidence(investigationId: string): WorkUnderstandingEvidenceItem[];