@xopcai/xopc 0.0.158 → 0.0.160

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

@@ -6,6 +6,7 @@ import { randomUUID } from "node:crypto";
 init_schema();
 init_providers();
 const MAX_MODEL_CONTEXT_CHARS = 12e4;
+const MAX_PERSONAL_CONTEXT_CHARS = 1e5;
 function extractText(content) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return "";
@@ -66,6 +67,46 @@ function validateSuggestion(value, allowedPaths) {
 		verification: strings(item.verification, 4).map((entry) => entry.slice(0, 300))
 	};
 }
+function validateProfileCandidate(value) {
+	if (!value || typeof value !== "object") return null;
+	const item = value;
+	const category = item.category === "role" || item.category === "focus" || item.category === "technology" || item.category === "workflow" || item.category === "preference" ? item.category : void 0;
+	if (!category || typeof item.statement !== "string") return null;
+	const statement = item.statement.trim().slice(0, 500);
+	if (statement.length < 4) return null;
+	const confidence = item.confidence === "high" || item.confidence === "low" ? item.confidence : "medium";
+	return {
+		id: randomUUID(),
+		category,
+		statement,
+		confidence,
+		evidence: strings(item.evidence, 4).map((entry) => entry.slice(0, 300)),
+		status: "pending"
+	};
+}
+function validateWorkThreadCandidate(value, allowedRefs) {
+	if (!value || typeof value !== "object") return null;
+	const item = value;
+	if (typeof item.title !== "string" || typeof item.summary !== "string") return null;
+	const title = item.title.trim().slice(0, 200);
+	const summary = item.summary.trim().slice(0, 2e3);
+	if (!title || !summary) return null;
+	const horizon = item.horizon === "current" || item.horizon === "ongoing" || item.horizon === "long_term" ? item.horizon : "current";
+	const status = item.status === "active" || item.status === "paused" || item.status === "blocked" || item.status === "completed" || item.status === "uncertain" ? item.status : "uncertain";
+	const confidence = item.confidence === "high" || item.confidence === "low" ? item.confidence : "medium";
+	const topicKey = (typeof item.topicKey === "string" ? item.topicKey.toLowerCase() : title.toLowerCase()).replace(/[^a-z0-9\p{L}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, 100) || `thread-${randomUUID().slice(0, 8)}`;
+	const evidenceRefs = strings(item.evidenceRefs, 12).filter((ref) => allowedRefs.has(ref));
+	if (!evidenceRefs.length) return null;
+	return {
+		topicKey,
+		title,
+		summary,
+		horizon,
+		status,
+		confidence,
+		evidenceRefs
+	};
+}
 function suggestionScore(suggestion) {
 	const confidence = suggestion.confidence === "high" ? 3 : suggestion.confidence === "medium" ? 2 : 1;
 	const safety = suggestion.risk === "analysis" ? 3 : suggestion.risk === "command" ? 2 : 1;
@@ -116,7 +157,14 @@ async function analyzeWorkContext(input) {
 		content: [
 			"You help a user resume real work in one explicitly selected local folder.",
 			"Analyze only the supplied bounded snapshot. Never claim that you ran commands, tests, or inspected anything absent from it.",
-			"Return only one JSON object with projectSummary, currentState, uncertainties, suggestions, lowConfidence, and contextQuestion.",
+			"Return only one JSON object with projectSummary, currentState, uncertainties, suggestions, profileCandidates, workThreads, lowConfidence, and contextQuestion.",
+			"profileCandidates contains up to 6 stable, useful facts about the user inferred from the supplied project evidence.",
+			"Each profile candidate has category (role, focus, technology, workflow, or preference), statement, confidence, and evidence.",
+			"Do not infer sensitive traits, identity, health, finances, political views, or anything not directly supported by the work evidence.",
+			"workThreads contains up to 3 evidence-backed work streams with topicKey, title, summary, horizon, status, confidence, and evidenceRefs.",
+			"horizon is current, ongoing, or long_term. status is active, paused, blocked, completed, or uncertain.",
+			"topicKey is a short stable topic identifier. evidenceRefs must use exact relative paths from the snapshot or git://recent-state.",
+			"Distinguish one-off recent edits from work sustained across multiple days. Prefer one current thread and only add ongoing or long_term threads when evidence supports them.",
 			"For a normal result, suggestions must contain exactly 3 materially different next steps.",
 			"Each suggestion must include actionType, title, rationale, evidence, actionPrompt, confidence, expectedOutcome, estimatedMinutes, risk, and verification.",
 			"actionType must be summarize_recent_work, inspect_related_tests, or plan_next_step.",
@@ -127,6 +175,15 @@ async function analyzeWorkContext(input) {
 			"If the current objective is unclear or fewer than three credible suggestions exist, set lowConfidence=true, return suggestions=[], and ask one concise contextQuestion.",
 			"Use Simplified Chinese for every user-facing string when the visible snapshot documents are mainly Chinese; otherwise use English.",
 			"",
+			input.candidateContext?.length ? `Other ranked local work projects (metadata only):\n${JSON.stringify(input.candidateContext.slice(0, 8).map((candidate) => ({
+				displayName: candidate.displayName,
+				projectKind: candidate.projectKind,
+				score: candidate.score,
+				lastActiveAt: candidate.lastActiveAt,
+				branch: candidate.branch,
+				changedFileCount: candidate.changedFileCount,
+				evidence: candidate.evidence
+			})))}` : "",
 			JSON.stringify(compactSnapshot)
 		].join("\n"),
 		timestamp: Date.now()
@@ -140,17 +197,16 @@ async function analyzeWorkContext(input) {
 		modelRef,
 		result: lowConfidenceResult(input.snapshot, typeof parsed.contextQuestion === "string" ? parsed.contextQuestion.trim().slice(0, 500) : void 0)
 	};
-	const allowedPaths = new Set([
-		...input.snapshot.structure.sampledPaths,
-		...input.snapshot.documents.map((document) => document.relativePath),
-		...input.snapshot.git?.changedPaths ?? []
-	]);
+	const allowedPaths = new Set([...input.snapshot.documents.map((document) => document.relativePath), ...input.snapshot.git?.changedPaths ?? []]);
+	const allowedThreadRefs = new Set([...allowedPaths, "git://recent-state"]);
 	const suggestions = Array.isArray(parsed.suggestions) ? parsed.suggestions.map((value) => validateSuggestion(value, allowedPaths)).filter((value) => Boolean(value)) : [];
 	if (suggestions.length !== 3) return {
 		modelRef,
 		result: lowConfidenceResult(input.snapshot)
 	};
 	const primarySuggestion = [...suggestions].sort((a, b) => suggestionScore(b) - suggestionScore(a))[0];
+	const profileCandidates = input.candidateContext?.length && Array.isArray(parsed.profileCandidates) ? parsed.profileCandidates.map(validateProfileCandidate).filter((value) => Boolean(value)).slice(0, 6) : [];
+	const workThreadCandidates = Array.isArray(parsed.workThreads) ? parsed.workThreads.map((value) => validateWorkThreadCandidate(value, allowedThreadRefs)).filter((value) => Boolean(value)).slice(0, 3) : [];
 	const projectSummary = typeof parsed.projectSummary === "string" ? parsed.projectSummary.trim() : "";
 	const currentState = typeof parsed.currentState === "string" ? parsed.currentState.trim() : "";
 	if (!projectSummary || !currentState) throw new Error("Analysis result is missing its summary");
@@ -161,10 +217,73 @@ async function analyzeWorkContext(input) {
 			currentState: currentState.slice(0, 1200),
 			uncertainties: strings(parsed.uncertainties, 6).map((value) => value.slice(0, 500)),
 			suggestions,
+			...profileCandidates.length > 0 ? { profileCandidates } : {},
+			...workThreadCandidates.length > 0 ? { workThreadCandidates } : {},
 			...primarySuggestion ? { primarySuggestionId: primarySuggestion.id } : {}
 		}
 	};
 }
+async function analyzePersonalContext(input) {
+	const modelRef = getAgentDefaultModelRef(input.config);
+	if (!modelRef) throw new Error("No default model configured");
+	let remaining = MAX_PERSONAL_CONTEXT_CHARS;
+	const items = input.items.slice(0, 150).flatMap((item, index) => {
+		if (remaining <= 0) return [];
+		const content = item.content.slice(0, remaining);
+		remaining -= content.length;
+		return [{
+			ref: `${item.source}:${index + 1}`,
+			source: item.source,
+			title: item.title,
+			group: item.group,
+			createdAt: item.createdAt,
+			modifiedAt: item.modifiedAt,
+			startsAt: item.startsAt,
+			endsAt: item.endsAt,
+			content
+		}];
+	});
+	if (!items.some((item) => item.title.trim() || item.content.trim())) return {
+		modelRef,
+		profileCandidates: [],
+		workThreadCandidates: []
+	};
+	const prompt = [
+		"Analyze the bounded personal work context that the user explicitly chose to connect from Apple Notes, Calendar, and Reminders.",
+		"Return only one JSON object with profileCandidates and workThreads.",
+		"profileCandidates contains at most 6 stable, useful work-related facts.",
+		"Each item has category (role, focus, technology, workflow, or preference), statement, confidence, and evidence.",
+		"workThreads contains at most 3 evidence-backed current, ongoing, or long-term work streams.",
+		"Each work thread has topicKey, title, summary, status, horizon, confidence, and evidenceRefs.",
+		"evidenceRefs must contain only the supplied source:index refs. Do not create a thread without direct support.",
+		"Prefer recurring work themes and durable preferences. Do not turn one-off errands or stale notes into user facts.",
+		"Do not infer sensitive identity, health, finances, political views, relationships, passwords, credentials, or private contact details.",
+		"Evidence must be a short paraphrase and must not quote private note content verbatim.",
+		"Calendar and reminder titles may establish commitments and timing, but must not be treated as stable preferences without repeated evidence.",
+		"When a work-directory summary is supplied, reconcile it with the personal sources: identify corroboration, conflicts, and whether an apparent focus is current or merely stale.",
+		"Do not repeat the directory summary as a personal fact unless at least one supplied personal source supports it.",
+		"Use Simplified Chinese when the supplied items are mainly Chinese; otherwise use English.",
+		input.workContext ? `Work-directory understanding from the same one-shot investigation:\n${JSON.stringify(input.workContext)}` : "",
+		JSON.stringify(items)
+	].join("\n");
+	const parsed = parseJson(extractText((await completeWithResolvedCredentials(resolveModel(modelRef), { messages: [{
+		role: "user",
+		content: prompt,
+		timestamp: Date.now()
+	}] }, {
+		maxTokens: 1500,
+		temperature: .1,
+		signal: input.signal
+	})).content));
+	if (!parsed) throw new Error("Personal context analysis did not return valid JSON");
+	const profileCandidates = Array.isArray(parsed.profileCandidates) ? parsed.profileCandidates.map(validateProfileCandidate).filter((value) => Boolean(value)).slice(0, 6) : [];
+	const allowedRefs = new Set(items.map((item) => item.ref));
+	return {
+		modelRef,
+		profileCandidates,
+		workThreadCandidates: Array.isArray(parsed.workThreads) ? parsed.workThreads.map((value) => validateWorkThreadCandidate(value, allowedRefs)).filter((value) => Boolean(value)).slice(0, 3) : []
+	};
+}
 function workDiscoveryResultMarkdown(result) {
 	const lines = [
 		`## What I found`,
@@ -185,4 +304,4 @@ function workDiscoveryResultMarkdown(result) {
 	return lines.join("\n");
 }
 //#endregion
-export { analyzeWorkContext, workDiscoveryResultMarkdown };
+export { analyzePersonalContext, analyzeWorkContext, workDiscoveryResultMarkdown };

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

@@ -0,0 +1,17 @@
+import type { WorkDiscoveryCandidate } from './types.js';
+export interface DiscoverWorkCandidatesOptions {
+    existingProjects?: Array<{
+        id: string;
+        workspaceRoot?: string;
+    }>;
+    approvedDirectories?: Array<{
+        id: string;
+        rootPath: string;
+    }>;
+    homeDirectory?: string;
+    nowMs?: number;
+    signal?: AbortSignal;
+    platform?: NodeJS.Platform;
+    environment?: NodeJS.ProcessEnv;
+}
+export declare function discoverWorkCandidates(options?: DiscoverWorkCandidatesOptions): Promise<WorkDiscoveryCandidate[]>;

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;