@xopcai/xopc 0.0.159 → 0.0.160

package/dist/src/storage/sqlite/migrations/051_focus_watches.sql

@@ -0,0 +1,26 @@
+CREATE TABLE focus_watches (
+  watch_id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL,
+  goal_id TEXT,
+  automation_id TEXT NOT NULL,
+  kind TEXT NOT NULL CHECK (kind IN ('progress', 'staleness', 'deadline', 'intelligence')),
+  status TEXT NOT NULL CHECK (status IN ('active', 'paused')),
+  config_json TEXT NOT NULL DEFAULT '{}',
+  trial_ends_at INTEGER,
+  last_cursor TEXT,
+  last_run_at INTEGER,
+  last_useful_result_at INTEGER,
+  consecutive_empty_runs INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  UNIQUE (thread_id, kind),
+  FOREIGN KEY (thread_id) REFERENCES work_understanding_threads(thread_id) ON DELETE CASCADE,
+  FOREIGN KEY (goal_id) REFERENCES goals(goal_id) ON DELETE SET NULL,
+  FOREIGN KEY (automation_id) REFERENCES automations(automation_id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_focus_watches_thread
+  ON focus_watches(thread_id, status, updated_at DESC);
+
+CREATE INDEX idx_focus_watches_automation
+  ON focus_watches(automation_id);

package/dist/src/storage/sqlite/migrations/052_proactive_insights.sql

@@ -0,0 +1,25 @@
+CREATE TABLE proactive_insights (
+  insight_id TEXT PRIMARY KEY,
+  watch_id TEXT NOT NULL,
+  run_id TEXT NOT NULL UNIQUE,
+  kind TEXT NOT NULL CHECK (kind IN ('progress', 'staleness', 'deadline', 'intelligence')),
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  why_it_matters TEXT NOT NULL,
+  next_action TEXT NOT NULL,
+  evidence_json TEXT NOT NULL,
+  content_hash TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('unread', 'read', 'approved', 'dismissed')),
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  FOREIGN KEY (watch_id) REFERENCES focus_watches(watch_id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_proactive_insights_status
+  ON proactive_insights(status, created_at DESC);
+
+CREATE INDEX idx_proactive_insights_watch
+  ON proactive_insights(watch_id, created_at DESC);
+
+CREATE UNIQUE INDEX idx_proactive_insights_dedupe
+  ON proactive_insights(watch_id, content_hash);

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 46;
+export declare const XOPC_DB_SCHEMA_VERSION = 52;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -12,7 +12,7 @@ const log = createLogger("Sqlite:Migrations");
 /** Baseline schema version applied from schema.sql on first open. */
 const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-const XOPC_DB_SCHEMA_VERSION = 46;
+const XOPC_DB_SCHEMA_VERSION = 52;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function resolveMigrationsDir(override) {
 	if (override) return override;
@@ -46,7 +46,7 @@ function applySingleMigration(db, migration) {
 * Each step runs in its own transaction and updates schema_meta on success.
 */
 function applyPendingMigrations(db, options = {}) {
-	const targetVersion = options.targetVersion ?? 46;
+	const targetVersion = options.targetVersion ?? 52;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
@@ -62,7 +62,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 46;
+	const appVersion = options.targetVersion ?? 52;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,

package/dist/src/storage/sqlite/migrations/runner.ts

@@ -19,7 +19,7 @@ const log = createLogger('Sqlite:Migrations');
 export const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 
 /** Latest schema version this release supports (increment when adding migrations). */
-export const XOPC_DB_SCHEMA_VERSION = 46;
+export const XOPC_DB_SCHEMA_VERSION = 52;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 

package/dist/src/storage/sqlite/schema.js

@@ -31,7 +31,7 @@ function ensureXopcDatabaseSchema(db) {
 		bootstrapFreshDatabase(db);
 		currentVersion = 11;
 	}
-	applyPendingMigrations(db, { targetVersion: 46 });
+	applyPendingMigrations(db, { targetVersion: 52 });
 }
 //#endregion
 export { SCHEMA_META_SCHEMA_VERSION_KEY, XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_SCHEMA_VERSION, ensureSchemaMetaTable, ensureXopcDatabaseSchema, readSchemaVersion, readSchemaVersionForTest, setSchemaVersion };

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

@@ -1,11 +1,22 @@
 import type { Config } from '../config/schema.js';
-import type { WorkContextSnapshot, WorkDiscoveryResult } from './types.js';
+import type { WorkContextSnapshot, WorkDiscoveryCandidate, WorkDiscoveryPersonalContextItem, WorkDiscoveryProfileCandidate, WorkDiscoveryResult, WorkUnderstandingThreadCandidate } from './types.js';
 export declare function analyzeWorkContext(input: {
     config: Config;
     snapshot: WorkContextSnapshot;
+    candidateContext?: WorkDiscoveryCandidate[];
     signal?: AbortSignal;
 }): Promise<{
     modelRef: string;
     result: WorkDiscoveryResult;
 }>;
+export declare function analyzePersonalContext(input: {
+    config: Config;
+    items: WorkDiscoveryPersonalContextItem[];
+    workContext?: Pick<WorkDiscoveryResult, 'projectSummary' | 'currentState' | 'uncertainties' | 'workThreads'>;
+    signal?: AbortSignal;
+}): Promise<{
+    modelRef: string;
+    profileCandidates: WorkDiscoveryProfileCandidate[];
+    workThreadCandidates: WorkUnderstandingThreadCandidate[];
+}>;
 export declare function workDiscoveryResultMarkdown(result: WorkDiscoveryResult): string;

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 };