@xopcai/xopc 0.0.159 → 0.0.160

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

@@ -0,0 +1,25 @@
+export interface WorkUnderstandingSourceLineage {
+    sourceId: string;
+    evidenceCount: number;
+    threadCount: number;
+    memoryRecordCount: number;
+    discoveryRunCount: number;
+}
+export declare function getWorkUnderstandingSourceLineage(sourceId: string): WorkUnderstandingSourceLineage | null;
+export declare function deleteWorkUnderstandingDerivedData(sourceId: string): {
+    deletedMemoryRecords: number;
+    evidenceCount: number | bigint;
+    deletedThreads: number;
+    retainedThreads: number;
+};
+export declare function getWorkUnderstandingMetrics(): {
+    completedInvestigations: number;
+    averageToolCalls: number;
+    activeThreads: number;
+    confirmedThreads: number;
+    recognitionConfirmationRate: number;
+    evidenceBySource: {
+        sourceType: string;
+        count: number;
+    }[];
+};

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

@@ -0,0 +1,96 @@
+import { requireXopcDatabase } from "../storage/sqlite/connection.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { deleteMemoryRecord, listMemoryRecords } from "../storage/sqlite/memory-records-repository.js";
+//#region src/work-discovery/governance.ts
+function memoryRecordsForSource(sourceId, rootPath) {
+	const { db } = requireXopcDatabase();
+	const runIds = rootPath ? db.prepare("SELECT id FROM work_discovery_runs WHERE root_path = ?").all(rootPath).map((row) => row.id) : [];
+	const runPaths = new Set(runIds.map((id) => `work-discovery://${id}`));
+	const records = [];
+	for (let offset = 0;; offset += 500) {
+		const page = listMemoryRecords({
+			limit: 500,
+			offset
+		});
+		records.push(...page.filter((record) => runPaths.has(record.source.path)));
+		if (page.length < 500) break;
+	}
+	return records;
+}
+function getWorkUnderstandingSourceLineage(sourceId) {
+	const { db } = requireXopcDatabase();
+	const source = db.prepare("SELECT root_path FROM work_discovery_sources WHERE source_id = ?").get(sourceId);
+	if (!source) return null;
+	const evidenceCount = db.prepare("SELECT COUNT(*) AS count FROM work_understanding_evidence WHERE source_grant_id = ?").get(sourceId).count;
+	const threadCount = db.prepare(`SELECT COUNT(DISTINCT te.thread_id) AS count
+     FROM work_understanding_thread_evidence te
+     JOIN work_understanding_evidence e ON e.evidence_id = te.evidence_id
+     WHERE e.source_grant_id = ?`).get(sourceId).count;
+	const discoveryRunCount = source.root_path ? db.prepare("SELECT COUNT(*) AS count FROM work_discovery_runs WHERE root_path = ?").get(source.root_path).count : 0;
+	return {
+		sourceId,
+		evidenceCount,
+		threadCount,
+		memoryRecordCount: memoryRecordsForSource(sourceId, source.root_path).length,
+		discoveryRunCount
+	};
+}
+function deleteWorkUnderstandingDerivedData(sourceId) {
+	if (!getWorkUnderstandingSourceLineage(sourceId)) return null;
+	const { db } = requireXopcDatabase();
+	const memoryRecords = memoryRecordsForSource(sourceId, db.prepare("SELECT root_path FROM work_discovery_sources WHERE source_id = ?").get(sourceId).root_path).filter((record) => record.explicitness !== "explicit");
+	const affectedThreadIds = db.prepare(`SELECT DISTINCT te.thread_id AS id
+     FROM work_understanding_thread_evidence te
+     JOIN work_understanding_evidence e ON e.evidence_id = te.evidence_id
+     WHERE e.source_grant_id = ?`).all(sourceId).map((row) => row.id);
+	const result = runSqliteWriteTransaction((transaction) => {
+		transaction.prepare(`DELETE FROM work_understanding_thread_evidence
+       WHERE evidence_id IN (SELECT evidence_id FROM work_understanding_evidence WHERE source_grant_id = ?)`).run(sourceId);
+		const evidence = transaction.prepare("DELETE FROM work_understanding_evidence WHERE source_grant_id = ?").run(sourceId);
+		let deletedThreads = 0;
+		let retainedThreads = 0;
+		for (const threadId of affectedThreadIds) {
+			if (transaction.prepare("SELECT COUNT(*) AS count FROM work_understanding_thread_evidence WHERE thread_id = ?").get(threadId).count > 0) continue;
+			const thread = transaction.prepare("SELECT user_status, status FROM work_understanding_threads WHERE thread_id = ?").get(threadId);
+			if (!thread) continue;
+			if (thread.user_status === "confirmed" || thread.user_status === "corrected") {
+				transaction.prepare(`UPDATE work_understanding_threads SET confidence = MIN(confidence, 0.5),
+           status = CASE WHEN status IN ('paused', 'completed') THEN status ELSE 'uncertain' END,
+           updated_at = ? WHERE thread_id = ?`).run(Date.now(), threadId);
+				retainedThreads += 1;
+			} else {
+				transaction.prepare("DELETE FROM work_understanding_threads WHERE thread_id = ?").run(threadId);
+				deletedThreads += 1;
+			}
+		}
+		return {
+			evidenceCount: evidence.changes,
+			deletedThreads,
+			retainedThreads
+		};
+	});
+	const deletedMemoryRecords = memoryRecords.filter((record) => deleteMemoryRecord(record.id)).length;
+	return {
+		...result,
+		deletedMemoryRecords
+	};
+}
+function getWorkUnderstandingMetrics() {
+	const { db } = requireXopcDatabase();
+	const scalar = (sql) => db.prepare(sql).get().value;
+	const evidenceBySource = db.prepare("SELECT source_type AS sourceType, COUNT(*) AS count FROM work_understanding_evidence GROUP BY source_type").all();
+	const recognition = db.prepare(`SELECT recognition_decision AS decision, COUNT(*) AS count
+     FROM work_discovery_feedback GROUP BY recognition_decision`).all();
+	const reviewed = recognition.reduce((sum, item) => sum + (item.decision === "dismissed" ? 0 : item.count), 0);
+	const confirmed = recognition.find((item) => item.decision === "confirmed")?.count ?? 0;
+	return {
+		completedInvestigations: scalar("SELECT COUNT(*) AS value FROM work_understanding_investigations WHERE status = 'completed'"),
+		averageToolCalls: scalar("SELECT COALESCE(AVG(tool_call_count), 0) AS value FROM work_understanding_investigations"),
+		activeThreads: scalar("SELECT COUNT(*) AS value FROM work_understanding_threads WHERE status IN ('active', 'blocked') AND user_status <> 'rejected'"),
+		confirmedThreads: scalar("SELECT COUNT(*) AS value FROM work_understanding_threads WHERE user_status IN ('confirmed', 'corrected')"),
+		recognitionConfirmationRate: reviewed ? confirmed / reviewed : 0,
+		evidenceBySource
+	};
+}
+//#endregion
+export { deleteWorkUnderstandingDerivedData, getWorkUnderstandingMetrics, getWorkUnderstandingSourceLineage };

package/dist/src/work-discovery/incremental-repository.d.ts

@@ -0,0 +1,13 @@
+import type { WorkDiscoveryPreview, WorkDiscoverySourceRefresh } from './types.js';
+export declare function recordWorkDiscoverySourceRefresh(input: {
+    sourceId: string;
+    changed: boolean;
+    previousFingerprint?: WorkDiscoveryPreview['fingerprint'];
+    currentFingerprint: WorkDiscoveryPreview['fingerprint'];
+    status?: WorkDiscoverySourceRefresh['status'];
+    discoveryRunId?: string;
+    checkedAt?: number;
+}): WorkDiscoverySourceRefresh;
+export declare function listWorkDiscoverySourceRefreshes(sourceId: string, limit?: number): WorkDiscoverySourceRefresh[];
+export declare function findActiveWorkDiscoverySourceRefresh(sourceId: string, fingerprint: WorkDiscoveryPreview['fingerprint']): WorkDiscoverySourceRefresh | null;
+export declare function updateWorkDiscoverySourceRefreshForRun(runId: string, status: 'completed' | 'failed'): void;

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

@@ -0,0 +1,55 @@
+import { requireXopcDatabase } from "../storage/sqlite/connection.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { workDiscoveryFingerprintsEqual } from "./incremental.js";
+import { randomUUID } from "node:crypto";
+//#region src/work-discovery/incremental-repository.ts
+function parseFingerprint(value) {
+	if (!value) return void 0;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+function fromRow(row) {
+	return {
+		id: row.refresh_id,
+		sourceId: row.source_id,
+		changed: row.changed === 1,
+		...parseFingerprint(row.previous_fingerprint_json) ? { previousFingerprint: parseFingerprint(row.previous_fingerprint_json) } : {},
+		currentFingerprint: parseFingerprint(row.current_fingerprint_json),
+		status: row.status,
+		...row.discovery_run_id ? { discoveryRunId: row.discovery_run_id } : {},
+		checkedAt: row.checked_at
+	};
+}
+function recordWorkDiscoverySourceRefresh(input) {
+	const id = randomUUID();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO work_discovery_source_refreshes (
+        refresh_id, source_id, discovery_run_id, changed, previous_fingerprint_json,
+        current_fingerprint_json, status, checked_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.sourceId, input.discoveryRunId ?? null, input.changed ? 1 : 0, input.previousFingerprint ? JSON.stringify(input.previousFingerprint) : null, JSON.stringify(input.currentFingerprint), input.status ?? "checked", input.checkedAt ?? Date.now());
+	});
+	const { db } = requireXopcDatabase();
+	return fromRow(db.prepare("SELECT * FROM work_discovery_source_refreshes WHERE refresh_id = ?").get(id));
+}
+function listWorkDiscoverySourceRefreshes(sourceId, limit = 20) {
+	const { db } = requireXopcDatabase();
+	return db.prepare("SELECT * FROM work_discovery_source_refreshes WHERE source_id = ? ORDER BY checked_at DESC LIMIT ?").all(sourceId, Math.max(1, Math.min(100, limit))).map(fromRow);
+}
+function findActiveWorkDiscoverySourceRefresh(sourceId, fingerprint) {
+	const { db } = requireXopcDatabase();
+	return db.prepare(`SELECT refresh.* FROM work_discovery_source_refreshes refresh
+     JOIN work_discovery_runs run ON run.id = refresh.discovery_run_id
+     WHERE refresh.source_id = ? AND refresh.status = 'queued'
+       AND run.status IN ('queued', 'probing', 'analyzing')
+     ORDER BY refresh.checked_at DESC`).all(sourceId).map(fromRow).find((refresh) => workDiscoveryFingerprintsEqual(refresh.currentFingerprint, fingerprint)) ?? null;
+}
+function updateWorkDiscoverySourceRefreshForRun(runId, status) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare("UPDATE work_discovery_source_refreshes SET status = ? WHERE discovery_run_id = ?").run(status, runId);
+	});
+}
+//#endregion
+export { findActiveWorkDiscoverySourceRefresh, listWorkDiscoverySourceRefreshes, recordWorkDiscoverySourceRefresh, updateWorkDiscoverySourceRefreshForRun };

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

@@ -0,0 +1,2 @@
+import type { WorkDiscoveryPreview } from './types.js';
+export declare function workDiscoveryFingerprintsEqual(left: WorkDiscoveryPreview['fingerprint'] | undefined, right: WorkDiscoveryPreview['fingerprint']): boolean;

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

@@ -0,0 +1,7 @@
+//#region src/work-discovery/incremental.ts
+function workDiscoveryFingerprintsEqual(left, right) {
+	if (!left) return false;
+	return left.branch === right.branch && left.changedFileCount === right.changedFileCount && left.contentSignature === right.contentSignature && JSON.stringify(left.recentAreas) === JSON.stringify(right.recentAreas);
+}
+//#endregion
+export { workDiscoveryFingerprintsEqual };

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

@@ -2,4 +2,14 @@ export * from './types.js';
 export * from './repository.js';
 export * from './probe.js';
 export * from './analyzer.js';
+export * from './candidate-discovery.js';
 export * from './service.js';
+export * from './source-repository.js';
+export * from './investigation-repository.js';
+export * from './investigator.js';
+export * from './incremental.js';
+export * from './incremental-repository.js';
+export * from './governance.js';
+export * from './evaluation.js';
+export * from './thread-repository.js';
+export * from './thread-service.js';

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

@@ -1,5 +1,15 @@
-import { WORK_DISCOVERY_SCAN_POLICY_VERSION, canonicalWorkDiscoveryRoot, previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, summarizeWorkContextSnapshot } from "./probe.js";
-import { analyzeWorkContext, workDiscoveryResultMarkdown } from "./analyzer.js";
+import { addWorkUnderstandingThreadFeedback, attachWorkUnderstandingThreadEvidence, getWorkUnderstandingThread, getWorkUnderstandingThreadByCanonicalKey, listWorkUnderstandingThreads, upsertWorkUnderstandingThread } from "./thread-repository.js";
+import { WORK_DISCOVERY_SCAN_POLICY_VERSION, canonicalWorkDiscoveryRoot, previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, readWorkDiscoveryTextExcerpt, searchWorkDiscoveryText, summarizeWorkContextSnapshot } from "./probe.js";
+import { analyzePersonalContext, analyzeWorkContext, workDiscoveryResultMarkdown } from "./analyzer.js";
+import { discoverWorkCandidates } from "./candidate-discovery.js";
+import { deleteWorkUnderstandingDerivedData, getWorkUnderstandingMetrics, getWorkUnderstandingSourceLineage } from "./governance.js";
+import { workDiscoveryFingerprintsEqual } from "./incremental.js";
+import { findActiveWorkDiscoverySourceRefresh, listWorkDiscoverySourceRefreshes, recordWorkDiscoverySourceRefresh, updateWorkDiscoverySourceRefreshForRun } from "./incremental-repository.js";
+import { appendWorkUnderstandingEvidence, createWorkUnderstandingInvestigation, getWorkUnderstandingInvestigation, getWorkUnderstandingInvestigationForRun, listWorkUnderstandingEvidence, resetWorkUnderstandingInvestigation, updateWorkUnderstandingEvidenceObservation, updateWorkUnderstandingInvestigation } from "./investigation-repository.js";
+import { DEFAULT_WORK_INVESTIGATION_BUDGET, investigateWorkContext } from "./investigator.js";
+import { persistWorkThreadsFromDiscovery } from "./thread-service.js";
 import { createWorkDiscoveryRun, getWorkDiscoveryOnboardingState, getWorkDiscoveryRun, getWorkDiscoveryRunByIdempotencyKey, setWorkDiscoveryFeedback, setWorkDiscoveryOnboardingState, updateWorkDiscoveryRun } from "./repository.js";
+import { getWorkDiscoveryDirectorySource, listWorkDiscoveryDirectorySources, revokeWorkDiscoveryDirectorySource, upsertWorkDiscoveryDirectorySource } from "./source-repository.js";
 import { WorkDiscoveryService } from "./service.js";
-export { WORK_DISCOVERY_SCAN_POLICY_VERSION, WorkDiscoveryService, analyzeWorkContext, canonicalWorkDiscoveryRoot, createWorkDiscoveryRun, getWorkDiscoveryOnboardingState, getWorkDiscoveryRun, getWorkDiscoveryRunByIdempotencyKey, previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, setWorkDiscoveryFeedback, setWorkDiscoveryOnboardingState, summarizeWorkContextSnapshot, updateWorkDiscoveryRun, workDiscoveryResultMarkdown };
+import { evaluateWorkUnderstandingCase } from "./evaluation.js";
+export { DEFAULT_WORK_INVESTIGATION_BUDGET, WORK_DISCOVERY_SCAN_POLICY_VERSION, WorkDiscoveryService, addWorkUnderstandingThreadFeedback, analyzePersonalContext, analyzeWorkContext, appendWorkUnderstandingEvidence, attachWorkUnderstandingThreadEvidence, canonicalWorkDiscoveryRoot, createWorkDiscoveryRun, createWorkUnderstandingInvestigation, deleteWorkUnderstandingDerivedData, discoverWorkCandidates, evaluateWorkUnderstandingCase, findActiveWorkDiscoverySourceRefresh, getWorkDiscoveryDirectorySource, getWorkDiscoveryOnboardingState, getWorkDiscoveryRun, getWorkDiscoveryRunByIdempotencyKey, getWorkUnderstandingInvestigation, getWorkUnderstandingInvestigationForRun, getWorkUnderstandingMetrics, getWorkUnderstandingSourceLineage, getWorkUnderstandingThread, getWorkUnderstandingThreadByCanonicalKey, investigateWorkContext, listWorkDiscoveryDirectorySources, listWorkDiscoverySourceRefreshes, listWorkUnderstandingEvidence, listWorkUnderstandingThreads, persistWorkThreadsFromDiscovery, previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, readWorkDiscoveryTextExcerpt, recordWorkDiscoverySourceRefresh, resetWorkUnderstandingInvestigation, revokeWorkDiscoveryDirectorySource, searchWorkDiscoveryText, setWorkDiscoveryFeedback, setWorkDiscoveryOnboardingState, summarizeWorkContextSnapshot, updateWorkDiscoveryRun, updateWorkDiscoverySourceRefreshForRun, updateWorkUnderstandingEvidenceObservation, updateWorkUnderstandingInvestigation, upsertWorkDiscoveryDirectorySource, upsertWorkUnderstandingThread, workDiscoveryFingerprintsEqual, workDiscoveryResultMarkdown };

package/dist/src/work-discovery/investigation-repository.d.ts

@@ -0,0 +1,16 @@
+import type { WorkUnderstandingEvidenceItem, WorkUnderstandingInvestigation, WorkUnderstandingInvestigationBudget } from './types.js';
+export declare function createWorkUnderstandingInvestigation(input: {
+    discoveryRunId: string;
+    budget: WorkUnderstandingInvestigationBudget;
+    nowMs?: number;
+}): WorkUnderstandingInvestigation;
+export declare function getWorkUnderstandingInvestigation(id: string): WorkUnderstandingInvestigation | null;
+export declare function getWorkUnderstandingInvestigationForRun(runId: string): WorkUnderstandingInvestigation | null;
+export declare function updateWorkUnderstandingInvestigation(id: string, patch: Partial<Pick<WorkUnderstandingInvestigation, 'status' | 'plan' | 'toolCallCount' | 'contentCharsRead' | 'completedAt' | 'errorMessage'>>): WorkUnderstandingInvestigation | null;
+export declare function resetWorkUnderstandingInvestigation(id: string, budget: WorkUnderstandingInvestigationBudget, nowMs?: number): WorkUnderstandingInvestigation | null;
+export declare function appendWorkUnderstandingEvidence(input: Omit<WorkUnderstandingEvidenceItem, 'id' | 'collectedAt'> & {
+    id?: string;
+    collectedAt?: number;
+}): WorkUnderstandingEvidenceItem;
+export declare function updateWorkUnderstandingEvidenceObservation(id: string, observation: string): void;
+export declare function listWorkUnderstandingEvidence(investigationId: string): WorkUnderstandingEvidenceItem[];

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

@@ -0,0 +1,122 @@
+import { requireXopcDatabase } from "../storage/sqlite/connection.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/work-discovery/investigation-repository.ts
+function parseJson(value, fallback) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return fallback;
+	}
+}
+function investigationFromRow(row) {
+	return {
+		id: row.investigation_id,
+		discoveryRunId: row.discovery_run_id,
+		status: row.status,
+		plan: parseJson(row.plan_json, {
+			hypotheses: [],
+			questions: []
+		}),
+		budget: parseJson(row.budget_json, {
+			maxToolCalls: 0,
+			maxContentChars: 0,
+			maxDurationMs: 0
+		}),
+		toolCallCount: row.tool_call_count,
+		contentCharsRead: row.content_chars_read,
+		startedAt: row.started_at,
+		...row.completed_at != null ? { completedAt: row.completed_at } : {},
+		...row.error_message ? { errorMessage: row.error_message } : {}
+	};
+}
+function evidenceFromRow(row) {
+	return {
+		id: row.evidence_id,
+		investigationId: row.investigation_id,
+		...row.source_grant_id ? { sourceGrantId: row.source_grant_id } : {},
+		...row.project_id ? { projectId: row.project_id } : {},
+		sourceType: row.source_type,
+		sourceRef: row.source_ref,
+		observation: row.observation,
+		...row.content_hash ? { contentHash: row.content_hash } : {},
+		...row.observed_at != null ? { observedAt: row.observed_at } : {},
+		collectedAt: row.collected_at,
+		sensitivity: row.sensitivity === "restricted" ? "restricted" : "normal"
+	};
+}
+function createWorkUnderstandingInvestigation(input) {
+	const now = input.nowMs ?? Date.now();
+	const id = randomUUID();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO work_understanding_investigations (
+        investigation_id, discovery_run_id, status, plan_json, budget_json,
+        tool_call_count, content_chars_read, started_at
+      ) VALUES (?, ?, 'planning', ?, ?, 0, 0, ?)`).run(id, input.discoveryRunId, JSON.stringify({
+			hypotheses: [],
+			questions: []
+		}), JSON.stringify(input.budget), now);
+	});
+	return getWorkUnderstandingInvestigation(id);
+}
+function getWorkUnderstandingInvestigation(id) {
+	const { db } = requireXopcDatabase();
+	const row = db.prepare("SELECT * FROM work_understanding_investigations WHERE investigation_id = ?").get(id);
+	return row ? investigationFromRow(row) : null;
+}
+function getWorkUnderstandingInvestigationForRun(runId) {
+	const { db } = requireXopcDatabase();
+	const row = db.prepare("SELECT * FROM work_understanding_investigations WHERE discovery_run_id = ?").get(runId);
+	return row ? investigationFromRow(row) : null;
+}
+function updateWorkUnderstandingInvestigation(id, patch) {
+	const existing = getWorkUnderstandingInvestigation(id);
+	if (!existing) return null;
+	const next = {
+		...existing,
+		...patch
+	};
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`UPDATE work_understanding_investigations SET
+        status = ?, plan_json = ?, tool_call_count = ?, content_chars_read = ?,
+        error_message = ?, completed_at = ? WHERE investigation_id = ?`).run(next.status, JSON.stringify(next.plan), next.toolCallCount, next.contentCharsRead, next.errorMessage ?? null, next.completedAt ?? null, id);
+	});
+	return getWorkUnderstandingInvestigation(id);
+}
+function resetWorkUnderstandingInvestigation(id, budget, nowMs = Date.now()) {
+	if (!getWorkUnderstandingInvestigation(id)) return null;
+	runSqliteWriteTransaction((db) => {
+		db.prepare("DELETE FROM work_understanding_evidence WHERE investigation_id = ?").run(id);
+		db.prepare(`UPDATE work_understanding_investigations SET
+        status = 'planning', plan_json = ?, budget_json = ?, tool_call_count = 0,
+        content_chars_read = 0, error_message = NULL, started_at = ?, completed_at = NULL
+       WHERE investigation_id = ?`).run(JSON.stringify({
+			hypotheses: [],
+			questions: []
+		}), JSON.stringify(budget), nowMs, id);
+	});
+	return getWorkUnderstandingInvestigation(id);
+}
+function appendWorkUnderstandingEvidence(input) {
+	const id = input.id ?? randomUUID();
+	const collectedAt = input.collectedAt ?? Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO work_understanding_evidence (
+        evidence_id, investigation_id, source_grant_id, project_id, source_type,
+        source_ref, observation, content_hash, observed_at, collected_at, sensitivity
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.investigationId, input.sourceGrantId ?? null, input.projectId ?? null, input.sourceType, input.sourceRef, input.observation, input.contentHash ?? null, input.observedAt ?? null, collectedAt, input.sensitivity);
+	});
+	const { db } = requireXopcDatabase();
+	return evidenceFromRow(db.prepare("SELECT * FROM work_understanding_evidence WHERE evidence_id = ?").get(id));
+}
+function updateWorkUnderstandingEvidenceObservation(id, observation) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare("UPDATE work_understanding_evidence SET observation = ? WHERE evidence_id = ?").run(observation.slice(0, 1e3), id);
+	});
+}
+function listWorkUnderstandingEvidence(investigationId) {
+	const { db } = requireXopcDatabase();
+	return db.prepare("SELECT * FROM work_understanding_evidence WHERE investigation_id = ? ORDER BY collected_at ASC").all(investigationId).map(evidenceFromRow);
+}
+//#endregion
+export { appendWorkUnderstandingEvidence, createWorkUnderstandingInvestigation, getWorkUnderstandingInvestigation, getWorkUnderstandingInvestigationForRun, listWorkUnderstandingEvidence, resetWorkUnderstandingInvestigation, updateWorkUnderstandingEvidenceObservation, updateWorkUnderstandingInvestigation };

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

@@ -0,0 +1,55 @@
+import type { Config } from '../config/schema.js';
+import type { WorkContextDocument, WorkContextSnapshot, WorkUnderstandingEvidenceItem, WorkUnderstandingInvestigation, WorkUnderstandingInvestigationBudget } from './types.js';
+export declare const DEFAULT_WORK_INVESTIGATION_BUDGET: WorkUnderstandingInvestigationBudget;
+type InvestigationAction = {
+    tool: 'read_text_excerpt';
+    relativePath: string;
+    reason: string;
+} | {
+    tool: 'search_authorized_text';
+    query: string;
+    reason: string;
+} | {
+    tool: 'finish';
+    reason: string;
+};
+export interface InvestigationDecision {
+    hypotheses: string[];
+    questions: string[];
+    evidenceSummaries: Array<{
+        evidenceId: string;
+        observation: string;
+    }>;
+    action: InvestigationAction;
+}
+interface RuntimeEvidence {
+    record: WorkUnderstandingEvidenceItem;
+    content: string;
+    modifiedAt?: number;
+}
+export interface WorkInvestigationResult {
+    investigation: WorkUnderstandingInvestigation;
+    evidence: WorkUnderstandingEvidenceItem[];
+    documents: WorkContextDocument[];
+    degraded: boolean;
+}
+declare function chooseAction(input: {
+    config: Config;
+    snapshot: WorkContextSnapshot;
+    runtimeEvidence: RuntimeEvidence[];
+    toolCallsRemaining: number;
+    contentCharsRemaining: number;
+    signal?: AbortSignal;
+}): Promise<InvestigationDecision | null>;
+export declare function investigateWorkContext(input: {
+    config: Config;
+    snapshot: WorkContextSnapshot;
+    rootPath: string;
+    discoveryRunId: string;
+    projectId: string;
+    sourceGrantId?: string;
+    budget?: Partial<WorkUnderstandingInvestigationBudget>;
+    decisionProvider?: typeof chooseAction;
+    signal?: AbortSignal;
+}): Promise<WorkInvestigationResult>;
+export {};