@xopcai/xopc 0.0.159 → 0.0.161

package/dist/src/proactive/watch-repository.js

@@ -0,0 +1,129 @@
+import { requireXopcDatabase } from "../storage/sqlite/connection.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/proactive/watch-repository.ts
+function watchFromRow(row) {
+	let config = {};
+	try {
+		const parsed = JSON.parse(row.config_json);
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) config = parsed;
+	} catch {
+		config = {};
+	}
+	return {
+		id: row.watch_id,
+		threadId: row.thread_id,
+		...row.goal_id ? { goalId: row.goal_id } : {},
+		automationId: row.automation_id,
+		kind: row.kind,
+		status: row.status,
+		config,
+		...row.trial_ends_at != null ? { trialEndsAt: row.trial_ends_at } : {},
+		...row.last_cursor ? { lastCursor: row.last_cursor } : {},
+		...row.last_run_at != null ? { lastRunAt: row.last_run_at } : {},
+		...row.last_useful_result_at != null ? { lastUsefulResultAt: row.last_useful_result_at } : {},
+		consecutiveEmptyRuns: row.consecutive_empty_runs,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function listFocusWatches(options = {}) {
+	const clauses = [];
+	const values = [];
+	if (options.threadId) {
+		clauses.push("thread_id = ?");
+		values.push(options.threadId);
+	}
+	if (options.status) {
+		clauses.push("status = ?");
+		values.push(options.status);
+	}
+	const { db } = requireXopcDatabase();
+	return db.prepare(`SELECT * FROM focus_watches ${clauses.length ? `WHERE ${clauses.join(" AND ")}` : ""}
+     ORDER BY updated_at DESC`).all(...values).map(watchFromRow);
+}
+function getFocusWatchByThreadAndKind(threadId, kind) {
+	const { db } = requireXopcDatabase();
+	const row = db.prepare("SELECT * FROM focus_watches WHERE thread_id = ? AND kind = ?").get(threadId, kind);
+	return row ? watchFromRow(row) : null;
+}
+function getFocusWatchByAutomationId(automationId) {
+	const { db } = requireXopcDatabase();
+	const row = db.prepare("SELECT * FROM focus_watches WHERE automation_id = ?").get(automationId);
+	return row ? watchFromRow(row) : null;
+}
+function createFocusWatch(input) {
+	const now = input.nowMs ?? Date.now();
+	const id = randomUUID();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO focus_watches (
+        watch_id, thread_id, goal_id, automation_id, kind, status, config_json,
+        trial_ends_at, consecutive_empty_runs, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, 'active', ?, ?, 0, ?, ?)`).run(id, input.threadId, input.goalId ?? null, input.automationId, input.kind, JSON.stringify(input.config ?? {}), input.trialEndsAt ?? null, now, now);
+	});
+	return getFocusWatchByThreadAndKind(input.threadId, input.kind);
+}
+function setFocusWatchStatus(id, status, nowMs = Date.now()) {
+	let changed = false;
+	runSqliteWriteTransaction((db) => {
+		changed = db.prepare("UPDATE focus_watches SET status = ?, updated_at = ? WHERE watch_id = ?").run(status, nowMs, id).changes > 0;
+	});
+	if (!changed) return null;
+	const { db } = requireXopcDatabase();
+	return watchFromRow(db.prepare("SELECT * FROM focus_watches WHERE watch_id = ?").get(id));
+}
+function restartFocusWatchTrial(id, trialEndsAt, nowMs = Date.now()) {
+	let changed = false;
+	runSqliteWriteTransaction((db) => {
+		changed = db.prepare(`UPDATE focus_watches
+       SET status = 'active', trial_ends_at = ?, consecutive_empty_runs = 0, updated_at = ?
+       WHERE watch_id = ?`).run(trialEndsAt, nowMs, id).changes > 0;
+	});
+	if (!changed) return null;
+	const { db } = requireXopcDatabase();
+	return watchFromRow(db.prepare("SELECT * FROM focus_watches WHERE watch_id = ?").get(id));
+}
+function recordFocusWatchRun(input) {
+	const now = input.nowMs ?? Date.now();
+	let changed = false;
+	runSqliteWriteTransaction((db) => {
+		changed = db.prepare(`UPDATE focus_watches SET
+        last_cursor = ?,
+        last_run_at = ?,
+        last_useful_result_at = CASE WHEN ? = 'meaningful' THEN ? ELSE last_useful_result_at END,
+        consecutive_empty_runs = CASE
+          WHEN ? = 'meaningful' THEN 0
+          WHEN ? = 'empty' THEN consecutive_empty_runs + 1
+          ELSE consecutive_empty_runs
+        END,
+        updated_at = ?
+       WHERE watch_id = ? AND (last_cursor IS NULL OR last_cursor <> ?)`).run(input.runId, now, input.outcome, now, input.outcome, input.outcome, now, input.id, input.runId).changes > 0;
+	});
+	if (!changed) return null;
+	return listFocusWatches().find((watch) => watch.id === input.id) ?? null;
+}
+function recordFocusWatchFeedback(id, useful, nowMs = Date.now()) {
+	const watch = listFocusWatches().find((item) => item.id === id);
+	if (!watch) return null;
+	const previous = watch.config.feedback && typeof watch.config.feedback === "object" && !Array.isArray(watch.config.feedback) ? watch.config.feedback : {};
+	const approved = typeof previous.approved === "number" ? previous.approved : 0;
+	const dismissed = typeof previous.dismissed === "number" ? previous.dismissed : 0;
+	const consecutiveDismissed = useful ? 0 : (typeof previous.consecutiveDismissed === "number" ? previous.consecutiveDismissed : 0) + 1;
+	const config = {
+		...watch.config,
+		feedback: {
+			approved: approved + (useful ? 1 : 0),
+			dismissed: dismissed + (useful ? 0 : 1),
+			consecutiveDismissed
+		}
+	};
+	runSqliteWriteTransaction((db) => {
+		db.prepare("UPDATE focus_watches SET config_json = ?, updated_at = ? WHERE watch_id = ?").run(JSON.stringify(config), nowMs, id);
+	});
+	return {
+		watch: listFocusWatches().find((item) => item.id === id),
+		consecutiveDismissed
+	};
+}
+//#endregion
+export { createFocusWatch, getFocusWatchByAutomationId, getFocusWatchByThreadAndKind, listFocusWatches, recordFocusWatchFeedback, recordFocusWatchRun, restartFocusWatchTrial, setFocusWatchStatus };

package/dist/src/storage/sqlite/knowledge-repository.d.ts

@@ -39,6 +39,7 @@ export declare function getKnowledgeConsumerWatermark(consumerId: string, source
 export declare function setKnowledgeConsumerWatermark(consumerId: string, sourceInstanceId: string, sequence: number, nowMs?: number): void;
 export declare function listKnowledgeSourceItems(options?: {
     sourceInstanceId?: string;
+    itemType?: string;
     synthesisStatus?: KnowledgeSynthesisStatus;
     includeDeleted?: boolean;
     limit?: number;

package/dist/src/storage/sqlite/knowledge-repository.js

@@ -238,6 +238,10 @@ function listKnowledgeSourceItems(options = {}) {
 		where.push("source_instance_id = ?");
 		params.push(options.sourceInstanceId);
 	}
+	if (options.itemType) {
+		where.push("item_type = ?");
+		params.push(options.itemType);
+	}
 	if (options.synthesisStatus) {
 		where.push("synthesis_status = ?");
 		params.push(options.synthesisStatus);

package/dist/src/storage/sqlite/migrations/047_work_discovery_sources.sql

@@ -0,0 +1,16 @@
+CREATE TABLE IF NOT EXISTS work_discovery_sources (
+  source_id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL CHECK (kind = 'directory'),
+  root_path TEXT,
+  display_name TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'revoked')),
+  scope_json TEXT NOT NULL DEFAULT '{}',
+  fingerprint_json TEXT,
+  last_scanned_at INTEGER,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  UNIQUE(kind, root_path)
+);
+
+CREATE INDEX idx_work_discovery_sources_kind_status
+  ON work_discovery_sources(kind, status, updated_at DESC);

package/dist/src/storage/sqlite/migrations/048_work_understanding_investigations.sql

@@ -0,0 +1,40 @@
+CREATE TABLE IF NOT EXISTS work_understanding_investigations (
+  investigation_id TEXT PRIMARY KEY,
+  discovery_run_id TEXT NOT NULL UNIQUE,
+  status TEXT NOT NULL CHECK (status IN (
+    'planning', 'investigating', 'synthesizing', 'completed', 'failed', 'canceled'
+  )),
+  plan_json TEXT NOT NULL DEFAULT '{}',
+  budget_json TEXT NOT NULL,
+  tool_call_count INTEGER NOT NULL DEFAULT 0,
+  content_chars_read INTEGER NOT NULL DEFAULT 0,
+  error_message TEXT,
+  started_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  FOREIGN KEY (discovery_run_id) REFERENCES work_discovery_runs(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS work_understanding_evidence (
+  evidence_id TEXT PRIMARY KEY,
+  investigation_id TEXT NOT NULL,
+  source_grant_id TEXT,
+  project_id TEXT,
+  source_type TEXT NOT NULL CHECK (source_type IN (
+    'file', 'git', 'project_metadata', 'personal_context', 'session', 'user_statement'
+  )),
+  source_ref TEXT NOT NULL,
+  observation TEXT NOT NULL,
+  content_hash TEXT,
+  observed_at INTEGER,
+  collected_at INTEGER NOT NULL,
+  sensitivity TEXT NOT NULL DEFAULT 'normal' CHECK (sensitivity IN ('normal', 'restricted')),
+  FOREIGN KEY (investigation_id) REFERENCES work_understanding_investigations(investigation_id) ON DELETE CASCADE,
+  FOREIGN KEY (source_grant_id) REFERENCES work_discovery_sources(source_id) ON DELETE SET NULL,
+  FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE SET NULL
+);
+
+CREATE INDEX idx_work_understanding_evidence_investigation
+  ON work_understanding_evidence(investigation_id, collected_at ASC);
+
+CREATE INDEX idx_work_understanding_evidence_source
+  ON work_understanding_evidence(source_grant_id, source_type, collected_at DESC);

package/dist/src/storage/sqlite/migrations/049_work_understanding_threads.sql

@@ -0,0 +1,52 @@
+CREATE TABLE IF NOT EXISTS work_understanding_threads (
+  thread_id TEXT PRIMARY KEY,
+  canonical_key TEXT NOT NULL UNIQUE,
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('active', 'paused', 'blocked', 'completed', 'uncertain')),
+  horizon TEXT NOT NULL CHECK (horizon IN ('current', 'ongoing', 'long_term')),
+  focus_score REAL NOT NULL,
+  confidence REAL NOT NULL,
+  user_status TEXT NOT NULL DEFAULT 'unreviewed' CHECK (user_status IN ('unreviewed', 'confirmed', 'corrected', 'rejected')),
+  parent_thread_id TEXT,
+  first_observed_at INTEGER NOT NULL,
+  last_observed_at INTEGER NOT NULL,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  FOREIGN KEY (parent_thread_id) REFERENCES work_understanding_threads(thread_id) ON DELETE SET NULL
+);
+
+CREATE TABLE IF NOT EXISTS work_understanding_thread_projects (
+  thread_id TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY (thread_id, project_id),
+  FOREIGN KEY (thread_id) REFERENCES work_understanding_threads(thread_id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS work_understanding_thread_evidence (
+  thread_id TEXT NOT NULL,
+  evidence_id TEXT NOT NULL,
+  relation TEXT NOT NULL DEFAULT 'supports' CHECK (relation IN ('supports', 'contradicts', 'context')),
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY (thread_id, evidence_id),
+  FOREIGN KEY (thread_id) REFERENCES work_understanding_threads(thread_id) ON DELETE CASCADE,
+  FOREIGN KEY (evidence_id) REFERENCES work_understanding_evidence(evidence_id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS work_understanding_thread_feedback (
+  feedback_id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL,
+  decision TEXT NOT NULL CHECK (decision IN ('confirmed', 'corrected', 'rejected', 'paused', 'completed')),
+  corrected_title TEXT,
+  corrected_summary TEXT,
+  created_at INTEGER NOT NULL,
+  FOREIGN KEY (thread_id) REFERENCES work_understanding_threads(thread_id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_work_understanding_threads_focus
+  ON work_understanding_threads(user_status, status, focus_score DESC, last_observed_at DESC);
+
+CREATE INDEX idx_work_understanding_thread_projects_project
+  ON work_understanding_thread_projects(project_id, created_at DESC);

package/dist/src/storage/sqlite/migrations/050_work_discovery_source_refreshes.sql

@@ -0,0 +1,15 @@
+CREATE TABLE IF NOT EXISTS work_discovery_source_refreshes (
+  refresh_id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL,
+  discovery_run_id TEXT,
+  changed INTEGER NOT NULL CHECK (changed IN (0, 1)),
+  previous_fingerprint_json TEXT,
+  current_fingerprint_json TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('checked', 'queued', 'completed', 'failed')),
+  checked_at INTEGER NOT NULL,
+  FOREIGN KEY (source_id) REFERENCES work_discovery_sources(source_id) ON DELETE CASCADE,
+  FOREIGN KEY (discovery_run_id) REFERENCES work_discovery_runs(id) ON DELETE SET NULL
+);
+
+CREATE INDEX idx_work_discovery_source_refreshes_source
+  ON work_discovery_source_refreshes(source_id, checked_at DESC);

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[]>;