@xopcai/xopc 0.0.159 → 0.0.161

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

@@ -1,13 +1,26 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { getMemoryRecord, upsertMemoryRecord } from "../storage/sqlite/memory-records-repository.js";
+import { upsertKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
+import "../storage/sqlite/index.js";
 import { ActivityService } from "../activity/service.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { buildSessionKey, init_session_key } from "../routing/session-key.js";
 import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
+import { nextMemoryReviewAt } from "../agent/memory/lifecycle.js";
+import { addWorkUnderstandingThreadFeedback, attachWorkUnderstandingThreadEvidence, getWorkUnderstandingThread, listWorkUnderstandingThreads } from "./thread-repository.js";
 import { previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, summarizeWorkContextSnapshot } from "./probe.js";
-import { analyzeWorkContext, workDiscoveryResultMarkdown } from "./analyzer.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, recordWorkDiscoverySourceRefresh, updateWorkDiscoverySourceRefreshForRun } from "./incremental-repository.js";
+import { appendWorkUnderstandingEvidence, getWorkUnderstandingInvestigationForRun, listWorkUnderstandingEvidence } from "./investigation-repository.js";
+import { investigateWorkContext } from "./investigator.js";
+import { persistWorkThreadsFromDiscovery } from "./thread-service.js";
 import { createWorkDiscoveryRun, getWorkDiscoveryOnboardingState, getWorkDiscoveryRun, getWorkDiscoveryRunByIdempotencyKey, setWorkDiscoveryFeedback, setWorkDiscoveryOnboardingState, updateWorkDiscoveryRun } from "./repository.js";
-import { randomUUID } from "node:crypto";
+import { getWorkDiscoveryDirectorySource, listWorkDiscoveryDirectorySources, revokeWorkDiscoveryDirectorySource, upsertWorkDiscoveryDirectorySource } from "./source-repository.js";
+import { createHash, randomUUID } from "node:crypto";
 //#region src/work-discovery/service.ts
 init_schema();
 init_session_key();
@@ -47,8 +60,19 @@ function errorCode(error) {
 	if (message.includes("timeout")) return "analysis_timeout";
 	return "internal_error";
 }
+function hasLongVerbatimOverlap(value, sources, minimumLength = 32) {
+	const normalized = value.replace(/\s+/g, " ").trim();
+	if (normalized.length < minimumLength) return false;
+	const sourceText = sources.map((source) => source.replace(/\s+/g, " "));
+	for (let index = 0; index <= normalized.length - minimumLength; index += Math.max(1, Math.floor(minimumLength / 2))) {
+		const fragment = normalized.slice(index, index + minimumLength);
+		if (sourceText.some((source) => source.includes(fragment))) return true;
+	}
+	return false;
+}
 var WorkDiscoveryService = class {
 	abortControllers = /* @__PURE__ */ new Map();
+	candidateContexts = /* @__PURE__ */ new Map();
 	activity = new ActivityService();
 	constructor(options) {
 		this.options = options;
@@ -68,6 +92,339 @@ var WorkDiscoveryService = class {
 	getRun(id) {
 		return getWorkDiscoveryRun(id);
 	}
+	getInvestigation(runId) {
+		const investigation = getWorkUnderstandingInvestigationForRun(runId);
+		return investigation ? {
+			investigation,
+			evidence: listWorkUnderstandingEvidence(investigation.id)
+		} : null;
+	}
+	listWorkThreads(options = {}) {
+		return listWorkUnderstandingThreads(options);
+	}
+	getWorkThread(id) {
+		return getWorkUnderstandingThread(id);
+	}
+	getSourceLineage(sourceId) {
+		return getWorkUnderstandingSourceLineage(sourceId);
+	}
+	deleteSourceDerivedData(sourceId) {
+		return deleteWorkUnderstandingDerivedData(sourceId);
+	}
+	getUnderstandingMetrics() {
+		return getWorkUnderstandingMetrics();
+	}
+	updateWorkThread(input) {
+		return addWorkUnderstandingThreadFeedback({
+			threadId: input.id,
+			decision: input.decision,
+			correctedTitle: input.correctedTitle,
+			correctedSummary: input.correctedSummary
+		});
+	}
+	async discoverCandidates(signal) {
+		return discoverWorkCandidates({
+			existingProjects: this.options.projects.list({
+				status: "active",
+				limit: 500
+			}).items.map((project) => ({
+				id: project.id,
+				workspaceRoot: project.workspaceRoot
+			})),
+			approvedDirectories: listWorkDiscoveryDirectorySources().map((source) => ({
+				id: source.id,
+				rootPath: source.rootPath
+			})),
+			signal
+		});
+	}
+	listDirectorySources() {
+		return listWorkDiscoveryDirectorySources();
+	}
+	async grantDirectorySource(rootPath) {
+		const preview = await previewWorkDiscoveryRoot(rootPath);
+		return upsertWorkDiscoveryDirectorySource({
+			rootPath: preview.canonicalRootPath,
+			displayName: preview.displayName,
+			fingerprint: preview.fingerprint
+		});
+	}
+	async checkDirectorySources() {
+		const checks = [];
+		for (const source of listWorkDiscoveryDirectorySources()) try {
+			const preview = await previewWorkDiscoveryRoot(source.rootPath);
+			checks.push(recordWorkDiscoverySourceRefresh({
+				sourceId: source.id,
+				changed: !workDiscoveryFingerprintsEqual(source.fingerprint, preview.fingerprint),
+				previousFingerprint: source.fingerprint,
+				currentFingerprint: preview.fingerprint
+			}));
+		} catch (error) {
+			log.warn({
+				err: error,
+				sourceId: source.id,
+				path: source.rootPath
+			}, "Work source change check failed");
+		}
+		return checks;
+	}
+	async refreshDirectorySourceIfChanged(input) {
+		const source = getWorkDiscoveryDirectorySource(input.id);
+		if (!source || source.status !== "active") throw new Error("Approved work folder not found");
+		const preview = await previewWorkDiscoveryRoot(source.rootPath);
+		if (!!workDiscoveryFingerprintsEqual(source.fingerprint, preview.fingerprint)) return {
+			changed: false,
+			refresh: recordWorkDiscoverySourceRefresh({
+				sourceId: source.id,
+				changed: false,
+				previousFingerprint: source.fingerprint,
+				currentFingerprint: preview.fingerprint
+			})
+		};
+		const activeRefresh = findActiveWorkDiscoverySourceRefresh(source.id, preview.fingerprint);
+		const activeRun = activeRefresh?.discoveryRunId ? getWorkDiscoveryRun(activeRefresh.discoveryRunId) : null;
+		if (activeRefresh && activeRun) return {
+			changed: true,
+			reused: true,
+			refresh: activeRefresh,
+			run: activeRun
+		};
+		const run = await this.startRun({
+			rootPath: preview.canonicalRootPath,
+			source: "manual_selected_directory",
+			idempotencyKey: input.idempotencyKey
+		});
+		return {
+			changed: true,
+			run,
+			refresh: recordWorkDiscoverySourceRefresh({
+				sourceId: source.id,
+				changed: true,
+				previousFingerprint: source.fingerprint,
+				currentFingerprint: preview.fingerprint,
+				status: "queued",
+				discoveryRunId: run.id
+			})
+		};
+	}
+	revokeDirectorySource(id) {
+		return revokeWorkDiscoveryDirectorySource(id);
+	}
+	async importPersonalContext(rawItems, signal, runId) {
+		let remaining = 3e5;
+		const allowedSources = new Set([
+			"apple_notes",
+			"calendar",
+			"reminders"
+		]);
+		const items = rawItems.flatMap((value) => {
+			if (!value || typeof value !== "object" || remaining <= 0) return [];
+			const raw = value;
+			const id = typeof raw.id === "string" ? raw.id.trim().slice(0, 500) : "";
+			const title = typeof raw.title === "string" ? raw.title.trim().slice(0, 300) : "";
+			const source = typeof raw.source === "string" && allowedSources.has(raw.source) ? raw.source : null;
+			if (!id || !title || !source) return [];
+			const content = typeof raw.content === "string" ? raw.content.trim().slice(0, Math.min(12e3, remaining)) : "";
+			remaining -= content.length;
+			const timestamp = (key) => {
+				const value = raw[key];
+				if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+				return Number.isFinite(new Date(value).getTime()) ? value : void 0;
+			};
+			return [{
+				id,
+				source,
+				title,
+				...typeof raw.group === "string" && raw.group.trim() ? { group: raw.group.trim().slice(0, 200) } : {},
+				content,
+				...timestamp("createdAt") ? { createdAt: timestamp("createdAt") } : {},
+				...timestamp("modifiedAt") ? { modifiedAt: timestamp("modifiedAt") } : {},
+				...timestamp("startsAt") ? { startsAt: timestamp("startsAt") } : {},
+				...timestamp("endsAt") ? { endsAt: timestamp("endsAt") } : {}
+			}];
+		}).slice(0, 150);
+		if (!items.length) throw new Error("No readable personal context was provided");
+		const linkedRun = runId ? getWorkDiscoveryRun(runId) : null;
+		const analysis = await analyzePersonalContext({
+			config: this.options.getConfig(),
+			items,
+			...linkedRun?.result ? { workContext: {
+				projectSummary: linkedRun.result.projectSummary,
+				currentState: linkedRun.result.currentState,
+				uncertainties: linkedRun.result.uncertainties,
+				workThreads: linkedRun.result.workThreads
+			} } : {},
+			signal
+		});
+		const calendarItems = items.filter((item) => item.source === "calendar" && item.startsAt != null);
+		if (calendarItems.length > 0) upsertKnowledgeSourceItems(calendarItems.map((item) => {
+			const normalizedText = JSON.stringify({
+				title: item.title,
+				description: item.content,
+				start: new Date(item.startsAt).toISOString(),
+				...item.endsAt != null ? { end: new Date(item.endsAt).toISOString() } : {},
+				...item.group ? { calendar: item.group } : {}
+			});
+			return {
+				sourceInstanceId: "desktop:calendar",
+				externalId: item.id,
+				itemType: "calendar_event",
+				authorRole: "unknown",
+				occurredAt: new Date(item.startsAt).toISOString(),
+				...item.modifiedAt != null ? { sourceUpdatedAt: new Date(item.modifiedAt).toISOString() } : {},
+				contentHash: createHash("sha256").update(normalizedText).digest("hex"),
+				normalizedText,
+				metadata: {
+					provider: "desktop-calendar",
+					calendar: item.group ?? ""
+				},
+				sensitivity: "personal",
+				retentionClass: "bounded",
+				synthesisPipeline: "user_understanding",
+				synthesisStatus: "ignored"
+			};
+		}));
+		const rawContents = items.flatMap((item) => item.content ? [item.content] : []);
+		const safeProfileCandidates = analysis.profileCandidates.filter((candidate) => !hasLongVerbatimOverlap(candidate.statement, rawContents));
+		const safeWorkThreadCandidates = analysis.workThreadCandidates.filter((candidate) => !hasLongVerbatimOverlap(candidate.title, rawContents) && !hasLongVerbatimOverlap(candidate.summary, rawContents));
+		const agentId = getDefaultAgentId(this.options.getConfig());
+		const profileCandidates = safeProfileCandidates.map((candidate) => {
+			const autoRemember = candidate.confidence === "high" && candidate.category !== "focus" && candidate.evidence.length >= 2;
+			const record = upsertMemoryRecord({
+				providerId: "local",
+				kind: candidate.category === "preference" ? "preference" : candidate.category === "workflow" ? "routine" : "derived_insight",
+				sourceAgentId: agentId,
+				content: candidate.statement,
+				source: {
+					provider: "personal-context",
+					path: "personal-context://onboarding"
+				},
+				confidence: candidate.confidence === "high" ? .9 : candidate.confidence === "medium" ? .72 : .58,
+				tags: [
+					"user-understanding",
+					"personal-context",
+					`work-discovery:${candidate.category}`
+				],
+				status: autoRemember ? "active" : "candidate",
+				sensitivity: "normal",
+				explicitness: "inferred",
+				durability: candidate.category === "focus" ? "ephemeral" : candidate.category === "workflow" ? "recurring" : "durable",
+				importance: candidate.category === "focus" ? .75 : .65,
+				disclosurePolicy: "referenceable"
+			});
+			return {
+				...candidate,
+				status: autoRemember ? "accepted" : "pending",
+				memoryRecordId: record.id
+			};
+		});
+		const investigation = linkedRun ? getWorkUnderstandingInvestigationForRun(linkedRun.id) : null;
+		const contextEvidence = investigation ? safeWorkThreadCandidates.map((candidate) => {
+			const topicHash = createHash("sha256").update(candidate.topicKey).digest("hex").slice(0, 16);
+			return appendWorkUnderstandingEvidence({
+				investigationId: investigation.id,
+				projectId: linkedRun.projectId,
+				sourceType: "personal_context",
+				sourceRef: `personal-context://thread/${topicHash}`,
+				observation: candidate.summary,
+				contentHash: createHash("sha256").update(JSON.stringify(candidate.evidenceRefs)).digest("hex"),
+				sensitivity: "normal"
+			});
+		}) : [];
+		const workThreads = linkedRun && contextEvidence.length ? persistWorkThreadsFromDiscovery({
+			projectId: linkedRun.projectId,
+			result: {
+				projectSummary: "Personal work context",
+				currentState: "Work streams inferred from explicitly connected personal sources.",
+				uncertainties: [],
+				suggestions: [],
+				workThreadCandidates: safeWorkThreadCandidates.map((candidate, index) => ({
+					...candidate,
+					evidenceRefs: contextEvidence[index] ? [contextEvidence[index].sourceRef] : []
+				}))
+			},
+			snapshot: {
+				root: {
+					displayName: "Personal Context",
+					projectKind: "general",
+					markerReasons: ["explicitly_connected_personal_context"]
+				},
+				structure: {
+					sampledPaths: [],
+					metadataOnlyFiles: [],
+					omittedPathCount: 0
+				},
+				documents: [],
+				limits: {
+					policyVersion: 1,
+					fileCount: 0,
+					contentBytes: 0,
+					truncated: false
+				}
+			},
+			evidence: contextEvidence
+		}) : [];
+		log.info({
+			runId,
+			itemCount: items.length,
+			candidateCount: profileCandidates.length,
+			workThreadCount: workThreads.length
+		}, "Personal context analyzed");
+		return {
+			profileCandidates,
+			workThreads,
+			autoRemembered: profileCandidates.filter((candidate) => candidate.status === "accepted")
+		};
+	}
+	updatePersonalContextProfile(input) {
+		return input.decisions.flatMap((decision) => {
+			const record = getMemoryRecord(decision.memoryRecordId);
+			if (!record || record.source.provider !== "personal-context") return [];
+			const statement = decision.status === "edited" ? decision.statement?.trim().slice(0, 500) : void 0;
+			if (decision.status === "edited" && !statement) return [];
+			const updated = this.preserveMemoryRecord(record, {
+				providerId: "local",
+				status: decision.status === "rejected" ? "rejected" : "active",
+				...statement ? {
+					content: statement,
+					explicitness: "explicit",
+					confidence: 1
+				} : {},
+				...decision.status !== "rejected" ? { reviewAfter: nextMemoryReviewAt(record) } : {}
+			});
+			return [{
+				memoryRecordId: updated.id,
+				status: decision.status,
+				statement: updated.content
+			}];
+		});
+	}
+	async rescanDirectorySource(input) {
+		const source = getWorkDiscoveryDirectorySource(input.id);
+		if (!source || source.status !== "active") throw new Error("Approved work folder not found");
+		const preview = await previewWorkDiscoveryRoot(source.rootPath);
+		upsertWorkDiscoveryDirectorySource({
+			rootPath: preview.canonicalRootPath,
+			displayName: preview.displayName,
+			fingerprint: preview.fingerprint
+		});
+		return this.startRun({
+			rootPath: preview.canonicalRootPath,
+			source: "manual_selected_directory",
+			idempotencyKey: input.idempotencyKey
+		});
+	}
+	async startQuickRun(input) {
+		const candidates = await this.discoverCandidates();
+		const primary = candidates[0];
+		if (!primary) throw new Error("No accessible work projects were found");
+		return this.startRun({
+			rootPath: primary.rootPath,
+			source: "onboarding_selected_directory",
+			idempotencyKey: input.idempotencyKey,
+			candidateContext: candidates
+		});
+	}
 	async startRun(input) {
 		const existing = getWorkDiscoveryRunByIdempotencyKey(input.idempotencyKey);
 		if (existing) return existing;
@@ -154,6 +511,7 @@ var WorkDiscoveryService = class {
 		});
 		const controller = new AbortController();
 		this.abortControllers.set(run.id, controller);
+		if (input.candidateContext?.length) this.candidateContexts.set(run.id, input.candidateContext.slice(0, 8));
 		this.execute(run, controller.signal);
 		return run;
 	}
@@ -185,11 +543,81 @@ var WorkDiscoveryService = class {
 				snapshot: summarizeWorkContextSnapshot(snapshot)
 			});
 			this.publish(current);
-			const analysis = await analyzeWorkContext({
+			const approvedSource = listWorkDiscoveryDirectorySources().find((source) => source.rootPath === run.rootPath);
+			const investigation = await investigateWorkContext({
 				config: this.options.getConfig(),
 				snapshot,
+				rootPath: run.rootPath,
+				discoveryRunId: run.id,
+				projectId: run.projectId,
+				...approvedSource ? { sourceGrantId: approvedSource.id } : {},
 				signal
 			});
+			const investigatedSnapshot = {
+				...snapshot,
+				documents: investigation.documents,
+				limits: {
+					...snapshot.limits,
+					contentBytes: investigation.documents.reduce((sum, document) => sum + document.excerpt.length, 0),
+					truncated: snapshot.limits.truncated || investigation.degraded
+				}
+			};
+			const candidateContext = this.candidateContexts.get(run.id) ?? (run.source === "onboarding_selected_directory" ? await this.discoverCandidates(signal) : void 0);
+			const unifiedEvidence = [...investigation.evidence];
+			for (const candidate of candidateContext ?? []) {
+				if (candidate.rootPath === run.rootPath) continue;
+				const sourceRef = candidate.projectId ? `project://${candidate.projectId}` : `project-candidate://${createHash("sha256").update(candidate.rootPath).digest("hex").slice(0, 16)}`;
+				unifiedEvidence.push(appendWorkUnderstandingEvidence({
+					investigationId: investigation.investigation.id,
+					...candidate.projectId ? { projectId: candidate.projectId } : {},
+					sourceType: "project_metadata",
+					sourceRef,
+					observation: `${candidate.displayName} is a related work area with ${candidate.changedFileCount} changed files and activity score ${candidate.score}.`,
+					contentHash: createHash("sha256").update(JSON.stringify({
+						score: candidate.score,
+						branch: candidate.branch,
+						changedFileCount: candidate.changedFileCount
+					})).digest("hex"),
+					...candidate.lastActiveAt ? { observedAt: candidate.lastActiveAt } : {},
+					sensitivity: "normal"
+				}));
+			}
+			const analysis = await analyzeWorkContext({
+				config: this.options.getConfig(),
+				snapshot: investigatedSnapshot,
+				...candidateContext?.length ? { candidateContext } : {},
+				signal
+			});
+			const discoveredProjects = candidateContext?.map((candidate) => ({
+				rootPath: candidate.rootPath,
+				displayName: candidate.displayName,
+				score: candidate.score,
+				projectKind: candidate.projectKind,
+				...candidate.lastActiveAt ? { lastActiveAt: candidate.lastActiveAt } : {},
+				evidence: candidate.evidence
+			}));
+			const baseResult = {
+				...analysis.result,
+				investigation: {
+					id: investigation.investigation.id,
+					hypotheses: investigation.investigation.plan.hypotheses,
+					questions: investigation.investigation.plan.questions,
+					toolCallCount: investigation.investigation.toolCallCount,
+					contentCharsRead: investigation.investigation.contentCharsRead,
+					degraded: investigation.degraded
+				},
+				...discoveredProjects?.length ? { discoveredProjects } : {}
+			};
+			const workThreads = persistWorkThreadsFromDiscovery({
+				projectId: run.projectId,
+				result: baseResult,
+				snapshot: investigatedSnapshot,
+				evidence: unifiedEvidence
+			});
+			const result = this.persistProfileCandidates(run, {
+				...baseResult,
+				...workThreads.length ? { workThreads } : {}
+			});
 			current = updateWorkDiscoveryRun(run.id, {
 				status: "analyzing",
 				stage: "next_steps"
@@ -197,11 +625,11 @@ var WorkDiscoveryService = class {
 			this.publish(current);
 			await this.options.sessions.appendTranscriptCustomMessageEntry(run.sessionKey, {
 				customType: "work-discovery-result",
-				content: workDiscoveryResultMarkdown(analysis.result),
+				content: workDiscoveryResultMarkdown(result),
 				display: true,
 				details: {
 					runId: run.id,
-					result: analysis.result
+					result
 				}
 			});
 			const project = this.options.projects.get(run.projectId);
@@ -209,12 +637,28 @@ var WorkDiscoveryService = class {
 				name: project ? `Continue work on ${project.name}` : "Continue recent work",
 				hiddenFromSessionList: false
 			});
+			if (approvedSource) try {
+				const preview = await previewWorkDiscoveryRoot(run.rootPath);
+				upsertWorkDiscoveryDirectorySource({
+					rootPath: preview.canonicalRootPath,
+					displayName: preview.displayName,
+					fingerprint: preview.fingerprint,
+					scanned: true
+				});
+			} catch (error) {
+				log.debug({
+					err: error,
+					runId: run.id,
+					phase: "source_fingerprint"
+				}, "Work source fingerprint update failed");
+			}
 			current = updateWorkDiscoveryRun(run.id, {
 				status: "completed",
 				stage: "next_steps",
-				result: analysis.result,
+				result,
 				completedAt: Date.now()
 			});
+			updateWorkDiscoverySourceRefreshForRun(run.id, "completed");
 			this.activity.record({
 				type: "work_discovery.completed",
 				primaryObject: {
@@ -237,8 +681,8 @@ var WorkDiscoveryService = class {
 				},
 				payload: {
 					policyVersion: run.scanPolicyVersion,
-					suggestionCount: analysis.result.suggestions.length,
-					lowConfidence: analysis.result.lowConfidence === true
+					suggestionCount: result.suggestions.length,
+					lowConfidence: result.lowConfidence === true
 				},
 				scopes: [{
 					scopeKind: "project",
@@ -268,6 +712,7 @@ var WorkDiscoveryService = class {
 				errorMessage: message,
 				...canceled ? { canceledAt: Date.now() } : { completedAt: Date.now() }
 			});
+			updateWorkDiscoverySourceRefreshForRun(run.id, "failed");
 			if (current) this.publish(current);
 			this.activity.record({
 				type: canceled ? "work_discovery.canceled" : "work_discovery.failed",
@@ -305,8 +750,110 @@ var WorkDiscoveryService = class {
 			}, `Work discovery failed: ${message}`);
 		} finally {
 			this.abortControllers.delete(run.id);
+			this.candidateContexts.delete(run.id);
 		}
 	}
+	persistProfileCandidates(run, result) {
+		if (!result.profileCandidates?.length) return result;
+		const profileCandidates = result.profileCandidates.map((candidate) => {
+			const kind = candidate.category === "preference" ? "preference" : candidate.category === "workflow" ? "routine" : "derived_insight";
+			const confidence = candidate.confidence === "high" ? .9 : candidate.confidence === "medium" ? .72 : .58;
+			const durability = candidate.category === "focus" ? "ephemeral" : candidate.category === "workflow" ? "recurring" : "durable";
+			const record = upsertMemoryRecord({
+				providerId: "local",
+				kind,
+				sourceAgentId: run.agentId,
+				sessionKey: run.sessionKey,
+				projectId: run.projectId,
+				content: candidate.statement,
+				source: {
+					provider: "work-discovery",
+					path: `work-discovery://${run.id}`
+				},
+				confidence,
+				tags: [
+					"user-understanding",
+					"work-discovery",
+					`work-discovery:${candidate.category}`
+				],
+				status: "candidate",
+				sensitivity: "normal",
+				explicitness: "inferred",
+				durability,
+				importance: candidate.category === "focus" ? .75 : .65,
+				disclosurePolicy: "referenceable"
+			});
+			return {
+				...candidate,
+				memoryRecordId: record.id
+			};
+		});
+		return {
+			...result,
+			profileCandidates
+		};
+	}
+	updateProfileCandidates(input) {
+		const run = getWorkDiscoveryRun(input.runId);
+		if (!run?.result?.profileCandidates?.length) return null;
+		const decisions = new Map(input.decisions.map((decision) => [decision.id, decision]));
+		const profileCandidates = run.result.profileCandidates.map((candidate) => {
+			const decision = decisions.get(candidate.id);
+			if (!decision || !candidate.memoryRecordId) return candidate;
+			const record = getMemoryRecord(candidate.memoryRecordId);
+			if (!record) return candidate;
+			const statement = decision.status === "edited" ? decision.statement?.trim().slice(0, 500) : void 0;
+			if (decision.status === "edited" && !statement) return candidate;
+			this.preserveMemoryRecord(record, {
+				status: decision.status === "rejected" ? "rejected" : "active",
+				...statement ? {
+					content: statement,
+					explicitness: "explicit",
+					confidence: 1
+				} : {},
+				...decision.status !== "rejected" ? { reviewAfter: nextMemoryReviewAt(record) } : {}
+			});
+			return {
+				...candidate,
+				...statement ? { statement } : {},
+				status: decision.status
+			};
+		});
+		return updateWorkDiscoveryRun(run.id, { result: {
+			...run.result,
+			profileCandidates
+		} });
+	}
+	preserveMemoryRecord(record, patch) {
+		return upsertMemoryRecord({
+			id: record.id,
+			providerId: "local",
+			kind: record.kind,
+			sourceAgentId: record.provenance.sourceAgentId,
+			workspaceId: record.scope.workspaceId,
+			sessionKey: record.scope.sessionKey,
+			projectId: record.scope.projectId,
+			content: record.content,
+			source: record.source,
+			confidence: record.confidence,
+			tags: record.tags,
+			status: record.status,
+			sensitivity: record.sensitivity,
+			canonicalKey: record.canonicalKey,
+			explicitness: record.explicitness,
+			durability: record.durability,
+			importance: record.importance,
+			disclosurePolicy: record.disclosurePolicy,
+			evidence: record.evidence,
+			reviewAfter: record.reviewAfter,
+			expiresAt: record.expiresAt,
+			validFrom: record.validFrom,
+			validTo: record.validTo,
+			supersedesRecordId: record.supersedesRecordId,
+			conflictGroupId: record.conflictGroupId,
+			...patch
+		});
+	}
 	cancelRun(id) {
 		const run = getWorkDiscoveryRun(id);
 		if (!run) return null;
@@ -352,6 +899,29 @@ var WorkDiscoveryService = class {
 			recognitionDecision: input.decision,
 			...correctedIntent ? { correctedIntent } : {}
 		});
+		const investigation = getWorkUnderstandingInvestigationForRun(run.id);
+		if (investigation && input.decision !== "dismissed") {
+			const observation = correctedIntent ? `The user explicitly stated their current intent: ${correctedIntent}` : "The user explicitly confirmed the inferred current work understanding.";
+			const evidence = appendWorkUnderstandingEvidence({
+				investigationId: investigation.id,
+				projectId: run.projectId,
+				sourceType: "user_statement",
+				sourceRef: `session://${createHash("sha256").update(run.sessionKey).digest("hex").slice(0, 16)}/recognition`,
+				observation,
+				contentHash: createHash("sha256").update(observation).digest("hex"),
+				observedAt: Date.now(),
+				sensitivity: "normal"
+			});
+			const currentThreads = listWorkUnderstandingThreads({
+				projectId: run.projectId,
+				limit: 50
+			}).filter((thread) => thread.horizon === "current").slice(0, 3);
+			for (const thread of currentThreads) attachWorkUnderstandingThreadEvidence({
+				threadId: thread.id,
+				evidenceId: evidence.id,
+				projectId: run.projectId
+			});
+		}
 		if (run.source === "onboarding_selected_directory") setWorkDiscoveryOnboardingState({
 			status: input.decision === "dismissed" ? "dismissed" : "completed",
 			activeRunId: input.decision === "dismissed" ? null : run.id

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

@@ -0,0 +1,13 @@
+import type { WorkDiscoveryDirectorySource, WorkDiscoveryPreview } from './types.js';
+export declare function listWorkDiscoveryDirectorySources(options?: {
+    includeRevoked?: boolean;
+}): WorkDiscoveryDirectorySource[];
+export declare function getWorkDiscoveryDirectorySource(id: string): WorkDiscoveryDirectorySource | null;
+export declare function upsertWorkDiscoveryDirectorySource(input: {
+    rootPath: string;
+    displayName: string;
+    fingerprint?: WorkDiscoveryPreview['fingerprint'];
+    scanned?: boolean;
+    nowMs?: number;
+}): WorkDiscoveryDirectorySource;
+export declare function revokeWorkDiscoveryDirectorySource(id: string, nowMs?: number): WorkDiscoveryDirectorySource | null;