@xopcai/xopc 0.0.158 → 0.0.160

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/session/client-history.d.ts

@@ -36,6 +36,7 @@ export interface ClientHistoryMessage {
         args?: unknown;
         result?: string;
         isError?: boolean;
+        details?: unknown;
     }>;
 }
 export declare function flattenMessageContent(content: string | unknown[]): string;

package/dist/src/session/client-history.js

@@ -33,22 +33,65 @@ function collectToolResults(messages) {
 		if (!id || typeof id !== "string") continue;
 		map.set(id, {
 			text: flattenMessageContent(m.content),
-			isError: m.isError
+			isError: m.isError,
+			details: m.details
 		});
 	}
 	return map;
 }
-function toolCallsWithResults(tool_calls, results) {
-	if (!tool_calls?.length) return void 0;
+function collectMessageToolCalls(content, openAiToolCalls, rawToolCalls) {
 	const out = [];
-	for (const tc of tool_calls) {
-		const res = results.get(tc.id);
+	const seen = /* @__PURE__ */ new Set();
+	const add = (call) => {
+		const key = call.id ? `id:${call.id}` : `position:${out.length}`;
+		if (seen.has(key)) return;
+		seen.add(key);
+		out.push(call);
+	};
+	for (const call of openAiToolCalls ?? []) add({
+		id: call.id,
+		name: call.function.name,
+		args: safeJsonParseArguments(call.function.arguments)
+	});
+	for (const item of Array.isArray(rawToolCalls) ? rawToolCalls : []) {
+		if (!item || typeof item !== "object") continue;
+		const call = item;
+		const name = typeof call.name === "string" ? call.name : void 0;
+		if (!name) continue;
+		add({
+			id: typeof call.id === "string" ? call.id : void 0,
+			name,
+			args: call.args ?? call.arguments ?? call.input
+		});
+	}
+	for (const item of Array.isArray(content) ? content : []) {
+		if (!item || typeof item !== "object") continue;
+		const call = item;
+		if (call.type !== "toolCall" && call.type !== "tool_use" && call.type !== "tool_call") continue;
+		const fn = call.function && typeof call.function === "object" ? call.function : void 0;
+		const name = typeof call.name === "string" ? call.name : typeof fn?.name === "string" ? fn.name : void 0;
+		if (!name) continue;
+		const rawArgs = call.arguments ?? call.args ?? call.input ?? fn?.arguments;
+		add({
+			id: typeof call.id === "string" ? call.id : void 0,
+			name,
+			args: typeof rawArgs === "string" ? safeJsonParseArguments(rawArgs) : rawArgs
+		});
+	}
+	return out.length ? out : void 0;
+}
+function toolCallsWithResults(toolCalls, results) {
+	if (!toolCalls?.length) return void 0;
+	const out = [];
+	for (const call of toolCalls) {
+		const res = call.id ? results.get(call.id) : void 0;
 		out.push({
-			id: tc.id,
-			name: tc.function.name,
-			args: safeJsonParseArguments(tc.function.arguments),
+			id: call.id,
+			name: call.name,
+			args: call.args,
 			result: res?.text,
-			isError: res?.isError
+			isError: res?.isError,
+			details: res?.details
 		});
 	}
 	return out.length ? out : void 0;
@@ -74,7 +117,7 @@ function messagesToClientHistory(messages, opts) {
 		}
 		if (m.role === "assistant") {
 			const text = flattenMessageContent(m.content);
-			const toolCalls = toolCallsWithResults(m.tool_calls, results);
+			const toolCalls = toolCallsWithResults(collectMessageToolCalls(m.content, m.tool_calls), results);
 			out.push({
 				role: "assistant",
 				content: text,
@@ -108,7 +151,8 @@ function collectHistoryToolResults(messages) {
 		if (!id || typeof id !== "string") continue;
 		map.set(id, {
 			text: flattenMessageContent(m.content ?? ""),
-			isError: m.isError
+			isError: m.isError,
+			details: m.details
 		});
 	}
 	return map;
@@ -380,7 +424,7 @@ function transcriptRowsToClientHistory(rows, opts) {
 			...rawContent ? { rawContent } : {},
 			...displayIndex !== void 0 ? { displayIndex } : {},
 			timestamp: parseTimestampValue(messageRow.timestamp),
-			toolCalls: toolCallsWithResults(messageRow.tool_calls ?? messageRow.toolCalls, results)
+			toolCalls: toolCallsWithResults(collectMessageToolCalls(messageRow.content, messageRow.tool_calls, messageRow.toolCalls), results)
 		});
 	}
 	return out;

package/dist/src/session/types.d.ts

@@ -16,6 +16,7 @@ export interface Message {
     tool_call_id$?: string;
     toolName?: string;
     isError?: boolean;
+    details?: unknown;
     name?: string;
     /** Token usage from the LLM response (assistant messages only). */
     usage?: {

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;