@xopcai/xopc 0.0.173 → 0.0.174

package/dist/src/proactive/trial-expiry-reconciler.js

@@ -1,30 +0,0 @@
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
-//#region src/proactive/trial-expiry-reconciler.ts
-init_logger();
-const DEFAULT_RECONCILE_INTERVAL_MS = 6e4;
-const log = createLogger("FocusTrialExpiry");
-function startTrialExpiryReconciler(service, intervalMs = DEFAULT_RECONCILE_INTERVAL_MS) {
-	let stopped = false;
-	let pending = null;
-	const reconcile = () => {
-		if (stopped || pending) return;
-		pending = service.reconcileExpiredTrials().then((pausedCount) => {
-			if (pausedCount > 0) log.info({ pausedCount }, "Expired focus watch trials paused");
-		}).catch((err) => {
-			log.warn({ err }, "Focus watch trial expiry reconciliation failed");
-		}).finally(() => {
-			pending = null;
-		});
-	};
-	reconcile();
-	const timer = setInterval(reconcile, intervalMs);
-	timer.unref();
-	return async () => {
-		stopped = true;
-		clearInterval(timer);
-		await pending;
-	};
-}
-//#endregion
-export { startTrialExpiryReconciler };

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

@@ -1,66 +0,0 @@
-import type { WorkUnderstandingThread } from '../work-discovery/types.js';
-export type FocusWatchKind = 'progress' | 'staleness' | 'deadline' | 'intelligence';
-export type FocusWatchStatus = 'active' | 'paused';
-export interface FocusWatch {
-    id: string;
-    threadId: string;
-    goalId?: string;
-    automationId: string;
-    kind: FocusWatchKind;
-    status: FocusWatchStatus;
-    config: Record<string, unknown>;
-    trialEndsAt?: number;
-    lastCursor?: string;
-    lastRunAt?: number;
-    lastUsefulResultAt?: number;
-    consecutiveEmptyRuns: number;
-    createdAt: number;
-    updatedAt: number;
-}
-export interface FocusView {
-    id: string;
-    title: string;
-    summary: string;
-    status: WorkUnderstandingThread['status'];
-    horizon: WorkUnderstandingThread['horizon'];
-    confidence: number;
-    focusScore: number;
-    userStatus: WorkUnderstandingThread['userStatus'];
-    projectIds: string[];
-    goalId?: string;
-    nextAction?: string;
-    blockedReason?: string;
-    watches: FocusWatch[];
-    lastObservedAt: number;
-}
-export type ProactiveInsightStatus = 'unread' | 'read' | 'approved' | 'dismissed';
-export interface ProactiveEvidence {
-    label: string;
-    source?: string;
-    publishedAt?: string;
-}
-export interface ProactiveInsight {
-    id: string;
-    watchId: string;
-    runId: string;
-    kind: FocusWatchKind;
-    title: string;
-    summary: string;
-    whyItMatters: string;
-    nextAction: string;
-    evidence: ProactiveEvidence[];
-    valueScore: number;
-    valueReasons: string[];
-    status: ProactiveInsightStatus;
-    createdAt: number;
-    updatedAt: number;
-}
-export interface FocusCalendarSignal {
-    id: string;
-    focusId: string;
-    focusTitle: string;
-    title: string;
-    startsAt: number;
-    endsAt?: number;
-    sourceInstanceId: string;
-}

package/dist/src/proactive/value-score.d.ts

@@ -1,13 +0,0 @@
-import type { FocusWatchKind } from './types.js';
-export interface ProactiveValueScore {
-    score: number;
-    reasons: string[];
-    shouldDeliver: boolean;
-}
-export declare function scoreProactiveValue(input: {
-    kind: FocusWatchKind;
-    evidenceCount: number;
-    hasNextAction: boolean;
-    approvedCount: number;
-    dismissedCount: number;
-}): ProactiveValueScore;

package/dist/src/proactive/value-score.js

@@ -1,30 +0,0 @@
-//#region src/proactive/value-score.ts
-function scoreProactiveValue(input) {
-	const reasons = [];
-	let score = .15;
-	if (input.evidenceCount > 0) {
-		score += Math.min(.25, input.evidenceCount * .1);
-		reasons.push("evidence_backed");
-	}
-	if (input.hasNextAction) {
-		score += .25;
-		reasons.push("actionable");
-	}
-	const urgency = input.kind === "deadline" ? .25 : input.kind === "staleness" ? .2 : .15;
-	score += urgency;
-	reasons.push(input.kind === "deadline" ? "time_sensitive" : "focus_relevant");
-	const rated = input.approvedCount + input.dismissedCount;
-	if (rated > 0) {
-		const approvalRate = input.approvedCount / rated;
-		score += (approvalRate - .5) * .4;
-		reasons.push(approvalRate >= .5 ? "historically_useful" : "historically_dismissed");
-	}
-	score = Math.max(0, Math.min(1, score));
-	return {
-		score,
-		reasons,
-		shouldDeliver: score >= .65
-	};
-}
-//#endregion
-export { scoreProactiveValue };

package/dist/src/proactive/watch-repository.d.ts

@@ -1,28 +0,0 @@
-import type { FocusWatch, FocusWatchKind, FocusWatchStatus } from './types.js';
-export declare function listFocusWatches(options?: {
-    threadId?: string;
-    status?: FocusWatchStatus;
-}): FocusWatch[];
-export declare function getFocusWatchByThreadAndKind(threadId: string, kind: FocusWatchKind): FocusWatch | null;
-export declare function getFocusWatchByAutomationId(automationId: string): FocusWatch | null;
-export declare function createFocusWatch(input: {
-    threadId: string;
-    goalId?: string;
-    automationId: string;
-    kind: FocusWatchKind;
-    config?: Record<string, unknown>;
-    trialEndsAt?: number;
-    nowMs?: number;
-}): FocusWatch;
-export declare function setFocusWatchStatus(id: string, status: FocusWatchStatus, nowMs?: number): FocusWatch | null;
-export declare function restartFocusWatchTrial(id: string, trialEndsAt: number, nowMs?: number): FocusWatch | null;
-export declare function recordFocusWatchRun(input: {
-    id: string;
-    runId: string;
-    outcome: 'meaningful' | 'empty' | 'failed';
-    nowMs?: number;
-}): FocusWatch | null;
-export declare function recordFocusWatchFeedback(id: string, useful: boolean, nowMs?: number): {
-    watch: FocusWatch;
-    consecutiveDismissed: number;
-} | null;

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

@@ -1,129 +0,0 @@
-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/work-discovery/governance.d.ts

@@ -1,25 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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/thread-repository.d.ts

@@ -1,34 +0,0 @@
-import type { WorkUnderstandingThread } from './types.js';
-export declare function getWorkUnderstandingThread(id: string): WorkUnderstandingThread | null;
-export declare function getWorkUnderstandingThreadByCanonicalKey(key: string): WorkUnderstandingThread | null;
-export declare function listWorkUnderstandingThreads(options?: {
-    projectId?: string;
-    includeRejected?: boolean;
-    limit?: number;
-}): WorkUnderstandingThread[];
-export declare function upsertWorkUnderstandingThread(input: {
-    canonicalKey: string;
-    title: string;
-    summary: string;
-    status: WorkUnderstandingThread['status'];
-    horizon: WorkUnderstandingThread['horizon'];
-    focusScore: number;
-    confidence: number;
-    projectIds: string[];
-    evidenceIds: string[];
-    observedAt?: number;
-    nowMs?: number;
-}): WorkUnderstandingThread;
-export declare function addWorkUnderstandingThreadFeedback(input: {
-    threadId: string;
-    decision: 'confirmed' | 'corrected' | 'rejected' | 'paused' | 'completed';
-    correctedTitle?: string;
-    correctedSummary?: string;
-    nowMs?: number;
-}): WorkUnderstandingThread | null;
-export declare function attachWorkUnderstandingThreadEvidence(input: {
-    threadId: string;
-    evidenceId: string;
-    projectId?: string;
-    nowMs?: number;
-}): WorkUnderstandingThread | null;

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

@@ -1,112 +0,0 @@
-import { requireXopcDatabase } from "../storage/sqlite/connection.js";
-import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import { randomUUID } from "node:crypto";
-//#region src/work-discovery/thread-repository.ts
-function idsForThread(table, column, id) {
-	const { db } = requireXopcDatabase();
-	return db.prepare(`SELECT ${column} AS id FROM ${table} WHERE thread_id = ? ORDER BY created_at ASC`).all(id).map((row) => row.id);
-}
-function threadFromRow(row) {
-	return {
-		id: row.thread_id,
-		canonicalKey: row.canonical_key,
-		title: row.title,
-		summary: row.summary,
-		status: row.status,
-		horizon: row.horizon,
-		focusScore: row.focus_score,
-		confidence: row.confidence,
-		userStatus: row.user_status,
-		projectIds: idsForThread("work_understanding_thread_projects", "project_id", row.thread_id),
-		evidenceIds: idsForThread("work_understanding_thread_evidence", "evidence_id", row.thread_id),
-		...row.parent_thread_id ? { parentThreadId: row.parent_thread_id } : {},
-		firstObservedAt: row.first_observed_at,
-		lastObservedAt: row.last_observed_at,
-		createdAt: row.created_at,
-		updatedAt: row.updated_at
-	};
-}
-function getWorkUnderstandingThread(id) {
-	const { db } = requireXopcDatabase();
-	const row = db.prepare("SELECT * FROM work_understanding_threads WHERE thread_id = ?").get(id);
-	return row ? threadFromRow(row) : null;
-}
-function getWorkUnderstandingThreadByCanonicalKey(key) {
-	const { db } = requireXopcDatabase();
-	const row = db.prepare("SELECT * FROM work_understanding_threads WHERE canonical_key = ?").get(key);
-	return row ? threadFromRow(row) : null;
-}
-function listWorkUnderstandingThreads(options = {}) {
-	const { db } = requireXopcDatabase();
-	const clauses = [];
-	const args = [];
-	if (!options.includeRejected) clauses.push("t.user_status <> 'rejected'");
-	if (options.projectId) {
-		clauses.push("EXISTS (SELECT 1 FROM work_understanding_thread_projects p WHERE p.thread_id = t.thread_id AND p.project_id = ?)");
-		args.push(options.projectId);
-	}
-	args.push(Math.max(1, Math.min(200, options.limit ?? 50)));
-	return db.prepare(`SELECT t.* FROM work_understanding_threads t
-     ${clauses.length ? `WHERE ${clauses.join(" AND ")}` : ""}
-     ORDER BY t.focus_score DESC, t.last_observed_at DESC LIMIT ?`).all(...args).map(threadFromRow);
-}
-function upsertWorkUnderstandingThread(input) {
-	const now = input.nowMs ?? Date.now();
-	const observedAt = input.observedAt ?? now;
-	const id = getWorkUnderstandingThreadByCanonicalKey(input.canonicalKey)?.id ?? randomUUID();
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`INSERT INTO work_understanding_threads (
-        thread_id, canonical_key, title, summary, status, horizon, focus_score,
-        confidence, user_status, first_observed_at, last_observed_at, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'unreviewed', ?, ?, ?, ?)
-      ON CONFLICT(canonical_key) DO UPDATE SET
-        title = CASE WHEN work_understanding_threads.user_status = 'corrected' THEN work_understanding_threads.title ELSE excluded.title END,
-        summary = CASE WHEN work_understanding_threads.user_status = 'corrected' THEN work_understanding_threads.summary ELSE excluded.summary END,
-        status = CASE WHEN work_understanding_threads.status IN ('paused', 'completed') THEN work_understanding_threads.status ELSE excluded.status END,
-        horizon = excluded.horizon,
-        focus_score = CASE WHEN work_understanding_threads.user_status = 'confirmed'
-          THEN MIN(100, excluded.focus_score + 12) ELSE excluded.focus_score END,
-        confidence = CASE WHEN work_understanding_threads.user_status IN ('confirmed', 'corrected')
-          THEN MAX(work_understanding_threads.confidence, excluded.confidence) ELSE excluded.confidence END,
-        last_observed_at = excluded.last_observed_at,
-        updated_at = excluded.updated_at`).run(id, input.canonicalKey, input.title.slice(0, 200), input.summary.slice(0, 2e3), input.status, input.horizon, Math.max(0, Math.min(100, input.focusScore)), Math.max(0, Math.min(1, input.confidence)), observedAt, observedAt, now, now);
-		const row = db.prepare("SELECT thread_id FROM work_understanding_threads WHERE canonical_key = ?").get(input.canonicalKey);
-		const projectInsert = db.prepare("INSERT OR IGNORE INTO work_understanding_thread_projects (thread_id, project_id, created_at) VALUES (?, ?, ?)");
-		for (const projectId of [...new Set(input.projectIds)].slice(0, 20)) projectInsert.run(row.thread_id, projectId, now);
-		const evidenceInsert = db.prepare(`INSERT OR IGNORE INTO work_understanding_thread_evidence (thread_id, evidence_id, relation, created_at)
-       VALUES (?, ?, 'supports', ?)`);
-		for (const evidenceId of [...new Set(input.evidenceIds)].slice(0, 50)) evidenceInsert.run(row.thread_id, evidenceId, now);
-	});
-	return getWorkUnderstandingThreadByCanonicalKey(input.canonicalKey);
-}
-function addWorkUnderstandingThreadFeedback(input) {
-	const thread = getWorkUnderstandingThread(input.threadId);
-	if (!thread) return null;
-	const now = input.nowMs ?? Date.now();
-	const userStatus = input.decision === "confirmed" ? "confirmed" : input.decision === "corrected" ? "corrected" : input.decision === "rejected" ? "rejected" : thread.userStatus;
-	const status = input.decision === "paused" || input.decision === "completed" ? input.decision : thread.status;
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`INSERT INTO work_understanding_thread_feedback (
-        feedback_id, thread_id, decision, corrected_title, corrected_summary, created_at
-      ) VALUES (?, ?, ?, ?, ?, ?)`).run(randomUUID(), thread.id, input.decision, input.correctedTitle ?? null, input.correctedSummary ?? null, now);
-		db.prepare(`UPDATE work_understanding_threads SET title = ?, summary = ?, status = ?, user_status = ?,
-       focus_score = ?, confidence = ?, updated_at = ? WHERE thread_id = ?`).run(input.decision === "corrected" && input.correctedTitle?.trim() ? input.correctedTitle.trim().slice(0, 200) : thread.title, input.decision === "corrected" && input.correctedSummary?.trim() ? input.correctedSummary.trim().slice(0, 2e3) : thread.summary, status, userStatus, input.decision === "confirmed" ? Math.min(100, thread.focusScore + 12) : thread.focusScore, input.decision === "confirmed" || input.decision === "corrected" ? 1 : thread.confidence, now, thread.id);
-	});
-	return getWorkUnderstandingThread(thread.id);
-}
-function attachWorkUnderstandingThreadEvidence(input) {
-	const thread = getWorkUnderstandingThread(input.threadId);
-	if (!thread) return null;
-	const now = input.nowMs ?? Date.now();
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`INSERT OR IGNORE INTO work_understanding_thread_evidence (thread_id, evidence_id, relation, created_at)
-       VALUES (?, ?, 'supports', ?)`).run(thread.id, input.evidenceId, now);
-		if (input.projectId) db.prepare("INSERT OR IGNORE INTO work_understanding_thread_projects (thread_id, project_id, created_at) VALUES (?, ?, ?)").run(thread.id, input.projectId, now);
-		db.prepare(`UPDATE work_understanding_threads SET confidence = MIN(1, confidence + 0.05),
-       focus_score = MIN(100, focus_score + 4), last_observed_at = MAX(last_observed_at, ?), updated_at = ?
-       WHERE thread_id = ?`).run(now, now, thread.id);
-	});
-	return getWorkUnderstandingThread(thread.id);
-}
-//#endregion
-export { addWorkUnderstandingThreadFeedback, attachWorkUnderstandingThreadEvidence, getWorkUnderstandingThread, getWorkUnderstandingThreadByCanonicalKey, listWorkUnderstandingThreads, upsertWorkUnderstandingThread };