@xopcai/xopc 0.0.159 → 0.0.161

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

@@ -0,0 +1,72 @@
+import { requireXopcDatabase } from "../storage/sqlite/connection.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/work-discovery/source-repository.ts
+function parseJson(value) {
+	if (!value) return void 0;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+function directorySource(row) {
+	if (row.kind !== "directory" || !row.root_path) return null;
+	return {
+		id: row.source_id,
+		kind: "directory",
+		rootPath: row.root_path,
+		displayName: row.display_name,
+		status: row.status === "revoked" ? "revoked" : "active",
+		scope: { readOnly: true },
+		...parseJson(row.fingerprint_json) ? { fingerprint: parseJson(row.fingerprint_json) } : {},
+		...row.last_scanned_at != null ? { lastScannedAt: row.last_scanned_at } : {},
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function readDirectorySource(db, id) {
+	const row = db.prepare("SELECT * FROM work_discovery_sources WHERE source_id = ?").get(id);
+	return row ? directorySource(row) : null;
+}
+function listWorkDiscoveryDirectorySources(options = {}) {
+	const { db } = requireXopcDatabase();
+	return db.prepare(`SELECT * FROM work_discovery_sources
+     WHERE kind = 'directory' ${options.includeRevoked ? "" : "AND status = 'active'"}
+     ORDER BY updated_at DESC`).all().flatMap((row) => {
+		const source = directorySource(row);
+		return source ? [source] : [];
+	});
+}
+function getWorkDiscoveryDirectorySource(id) {
+	const { db } = requireXopcDatabase();
+	return readDirectorySource(db, id);
+}
+function upsertWorkDiscoveryDirectorySource(input) {
+	const now = input.nowMs ?? Date.now();
+	const id = randomUUID();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO work_discovery_sources (
+        source_id, kind, root_path, display_name, status, scope_json, fingerprint_json,
+        last_scanned_at, created_at, updated_at
+      ) VALUES (?, 'directory', ?, ?, 'active', ?, ?, ?, ?, ?)
+      ON CONFLICT(kind, root_path) DO UPDATE SET
+        display_name = excluded.display_name,
+        status = 'active',
+        scope_json = excluded.scope_json,
+        fingerprint_json = COALESCE(excluded.fingerprint_json, work_discovery_sources.fingerprint_json),
+        last_scanned_at = COALESCE(excluded.last_scanned_at, work_discovery_sources.last_scanned_at),
+        updated_at = excluded.updated_at`).run(id, input.rootPath, input.displayName, JSON.stringify({ readOnly: true }), input.fingerprint ? JSON.stringify(input.fingerprint) : null, input.scanned ? now : null, now, now);
+	});
+	const { db } = requireXopcDatabase();
+	return directorySource(db.prepare(`SELECT * FROM work_discovery_sources WHERE kind = 'directory' AND root_path = ?`).get(input.rootPath));
+}
+function revokeWorkDiscoveryDirectorySource(id, nowMs = Date.now()) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`UPDATE work_discovery_sources SET status = 'revoked', updated_at = ?
+       WHERE source_id = ? AND kind = 'directory'`).run(nowMs, id);
+	});
+	return getWorkDiscoveryDirectorySource(id);
+}
+//#endregion
+export { getWorkDiscoveryDirectorySource, listWorkDiscoveryDirectorySources, revokeWorkDiscoveryDirectorySource, upsertWorkDiscoveryDirectorySource };

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

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

@@ -0,0 +1,112 @@
+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 };

package/dist/src/work-discovery/thread-service.d.ts

@@ -0,0 +1,8 @@
+import type { WorkContextSnapshot, WorkDiscoveryResult, WorkUnderstandingEvidenceItem, WorkUnderstandingThread } from './types.js';
+export declare function persistWorkThreadsFromDiscovery(input: {
+    projectId: string;
+    result: WorkDiscoveryResult;
+    snapshot: WorkContextSnapshot;
+    evidence: WorkUnderstandingEvidenceItem[];
+    nowMs?: number;
+}): WorkUnderstandingThread[];

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

@@ -0,0 +1,104 @@
+import { listWorkUnderstandingThreads, upsertWorkUnderstandingThread } from "./thread-repository.js";
+//#region src/work-discovery/thread-service.ts
+function confidenceValue(value) {
+	return value === "high" ? .9 : value === "medium" ? .72 : .55;
+}
+function recencyPoints(observedAt, nowMs) {
+	if (!observedAt) return 8;
+	const days = Math.max(0, (nowMs - observedAt) / 864e5);
+	if (days <= 2) return 40;
+	if (days <= 7) return 32;
+	if (days <= 14) return 24;
+	if (days <= 30) return 14;
+	return 5;
+}
+function focusScore(input) {
+	const latest = input.evidence.reduce((value, item) => item.observedAt != null && (value == null || item.observedAt > value) ? item.observedAt : value, void 0);
+	const commitDays = new Set((input.snapshot.git?.recentCommits ?? []).flatMap((commit) => commit.committedAt ? [new Date(commit.committedAt).toISOString().slice(0, 10)] : []));
+	const sourceTypes = new Set(input.evidence.map((item) => item.sourceType));
+	const continuity = Math.min(20, commitDays.size * 5);
+	const corroboration = Math.min(15, input.evidence.length * 3 + Math.max(0, sourceTypes.size - 1) * 5);
+	const unfinished = input.candidate.status === "active" ? 15 : input.candidate.status === "blocked" ? 12 : 3;
+	const confidence = Math.round(confidenceValue(input.candidate.confidence) * 10);
+	const horizonAdjustment = input.candidate.horizon === "current" ? 0 : input.candidate.horizon === "ongoing" ? -4 : -8;
+	return Math.max(0, Math.min(100, Math.round(recencyPoints(latest, input.nowMs) + continuity + corroboration + unfinished + confidence + horizonAdjustment)));
+}
+function fallbackCandidate(result, evidence) {
+	return {
+		topicKey: "current-project-work",
+		title: result.projectSummary.slice(0, 200),
+		summary: result.currentState.slice(0, 2e3),
+		status: result.lowConfidence ? "uncertain" : "active",
+		horizon: "current",
+		confidence: result.lowConfidence ? "low" : "medium",
+		evidenceRefs: evidence.slice(0, 6).map((item) => item.sourceRef)
+	};
+}
+function titleTokens(value) {
+	return new Set(value.toLocaleLowerCase().match(/[\p{L}\p{N}]{2,}/gu)?.filter((token) => ![
+		"the",
+		"and",
+		"for",
+		"with",
+		"from",
+		"this",
+		"that"
+	].includes(token)).slice(0, 30) ?? []);
+}
+function titleSimilarity(left, right) {
+	const leftTokens = titleTokens(left);
+	const rightTokens = titleTokens(right);
+	if (!leftTokens.size || !rightTokens.size) return 0;
+	return [...leftTokens].filter((token) => rightTokens.has(token)).length / Math.max(leftTokens.size, rightTokens.size);
+}
+function canonicalKeyForCandidate(input) {
+	const proposed = `${input.projectId}:${input.candidate.horizon}:${input.candidate.topicKey}`.slice(0, 300);
+	const existing = listWorkUnderstandingThreads({
+		projectId: input.projectId,
+		includeRejected: true,
+		limit: 100
+	});
+	const exact = existing.find((thread) => thread.canonicalKey === proposed);
+	if (exact) return exact.canonicalKey;
+	return existing.filter((thread) => thread.horizon === input.candidate.horizon && thread.userStatus !== "rejected").map((thread) => ({
+		thread,
+		similarity: titleSimilarity(thread.title, input.candidate.title)
+	})).filter((item) => item.similarity >= .5).sort((left, right) => right.similarity - left.similarity)[0]?.thread.canonicalKey ?? proposed;
+}
+function persistWorkThreadsFromDiscovery(input) {
+	const nowMs = input.nowMs ?? Date.now();
+	const candidates = input.result.workThreadCandidates?.length ? input.result.workThreadCandidates : input.evidence.length ? [fallbackCandidate(input.result, input.evidence)] : [];
+	const persist = (candidate) => {
+		const evidence = candidate.evidenceRefs.flatMap((ref) => {
+			const match = input.evidence.find((item) => item.sourceRef === ref);
+			return match ? [match] : [];
+		});
+		if (!evidence.length) return [];
+		return [upsertWorkUnderstandingThread({
+			canonicalKey: canonicalKeyForCandidate({
+				projectId: input.projectId,
+				candidate
+			}),
+			title: candidate.title,
+			summary: candidate.summary,
+			status: candidate.status,
+			horizon: candidate.horizon,
+			focusScore: focusScore({
+				candidate,
+				evidence,
+				snapshot: input.snapshot,
+				nowMs
+			}),
+			confidence: confidenceValue(candidate.confidence),
+			projectIds: [input.projectId],
+			evidenceIds: evidence.map((item) => item.id),
+			observedAt: evidence.reduce((latest, item) => Math.max(latest, item.observedAt ?? nowMs), 0) || nowMs,
+			nowMs
+		})];
+	};
+	const persisted = candidates.flatMap(persist);
+	if (persisted.length || !input.evidence.length || !input.result.workThreadCandidates?.length) return persisted;
+	return persist(fallbackCandidate(input.result, input.evidence));
+}
+//#endregion
+export { persistWorkThreadsFromDiscovery };

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

@@ -9,6 +9,122 @@ export interface WorkDiscoveryOnboardingState {
 export type WorkDiscoveryRunStatus = 'queued' | 'probing' | 'analyzing' | 'completed' | 'failed' | 'canceled';
 export type WorkDiscoveryStage = 'folder_structure' | 'recent_progress' | 'next_steps';
 export type WorkDiscoverySource = 'onboarding_selected_directory' | 'manual_selected_directory';
+export type WorkDiscoveryCandidateSource = 'existing_project' | 'approved_directory' | 'common_work_root' | 'personal_work_root';
+export interface WorkDiscoveryCandidate {
+    id: string;
+    rootPath: string;
+    displayName: string;
+    source: WorkDiscoveryCandidateSource;
+    projectId?: string;
+    projectKind: 'coding' | 'general' | 'unknown';
+    projectKindConfidence: number;
+    score: number;
+    lastActiveAt?: number;
+    branch?: string;
+    changedFileCount: number;
+    evidence: string[];
+}
+export interface WorkDiscoveryDirectorySource {
+    id: string;
+    kind: 'directory';
+    rootPath: string;
+    displayName: string;
+    status: 'active' | 'revoked';
+    scope: {
+        readOnly: true;
+    };
+    fingerprint?: WorkDiscoveryPreview['fingerprint'];
+    lastScannedAt?: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface WorkDiscoverySourceRefresh {
+    id: string;
+    sourceId: string;
+    changed: boolean;
+    previousFingerprint?: WorkDiscoveryPreview['fingerprint'];
+    currentFingerprint: WorkDiscoveryPreview['fingerprint'];
+    status: 'checked' | 'queued' | 'completed' | 'failed';
+    discoveryRunId?: string;
+    checkedAt: number;
+}
+export type WorkDiscoveryPersonalContextSource = 'apple_notes' | 'calendar' | 'reminders';
+export interface WorkDiscoveryPersonalContextItem {
+    id: string;
+    source: WorkDiscoveryPersonalContextSource;
+    title: string;
+    group?: string;
+    content: string;
+    createdAt?: number;
+    modifiedAt?: number;
+    startsAt?: number;
+    endsAt?: number;
+}
+export type WorkUnderstandingInvestigationStatus = 'planning' | 'investigating' | 'synthesizing' | 'completed' | 'failed' | 'canceled';
+export type WorkUnderstandingEvidenceSourceType = 'file' | 'git' | 'project_metadata' | 'personal_context' | 'session' | 'user_statement';
+export interface WorkUnderstandingInvestigationBudget {
+    maxToolCalls: number;
+    maxContentChars: number;
+    maxDurationMs: number;
+}
+export interface WorkUnderstandingInvestigation {
+    id: string;
+    discoveryRunId: string;
+    status: WorkUnderstandingInvestigationStatus;
+    plan: {
+        hypotheses: string[];
+        questions: string[];
+    };
+    budget: WorkUnderstandingInvestigationBudget;
+    toolCallCount: number;
+    contentCharsRead: number;
+    startedAt: number;
+    completedAt?: number;
+    errorMessage?: string;
+}
+export interface WorkUnderstandingEvidenceItem {
+    id: string;
+    investigationId: string;
+    sourceGrantId?: string;
+    projectId?: string;
+    sourceType: WorkUnderstandingEvidenceSourceType;
+    sourceRef: string;
+    observation: string;
+    contentHash?: string;
+    observedAt?: number;
+    collectedAt: number;
+    sensitivity: 'normal' | 'restricted';
+}
+export type WorkUnderstandingThreadStatus = 'active' | 'paused' | 'blocked' | 'completed' | 'uncertain';
+export type WorkUnderstandingThreadHorizon = 'current' | 'ongoing' | 'long_term';
+export type WorkUnderstandingThreadUserStatus = 'unreviewed' | 'confirmed' | 'corrected' | 'rejected';
+export interface WorkUnderstandingThreadCandidate {
+    topicKey: string;
+    title: string;
+    summary: string;
+    status: WorkUnderstandingThreadStatus;
+    horizon: WorkUnderstandingThreadHorizon;
+    confidence: 'high' | 'medium' | 'low';
+    evidenceRefs: string[];
+}
+export interface WorkUnderstandingThread {
+    id: string;
+    canonicalKey: string;
+    title: string;
+    summary: string;
+    status: WorkUnderstandingThreadStatus;
+    horizon: WorkUnderstandingThreadHorizon;
+    focusScore: number;
+    confidence: number;
+    userStatus: WorkUnderstandingThreadUserStatus;
+    projectIds: string[];
+    evidenceIds: string[];
+    parentThreadId?: string;
+    firstObservedAt: number;
+    lastObservedAt: number;
+    createdAt: number;
+    updatedAt: number;
+}
 export type WorkDiscoveryErrorCode = 'folder_unavailable' | 'folder_not_readable' | 'nothing_useful_found' | 'model_unavailable' | 'analysis_invalid' | 'analysis_timeout' | 'canceled' | 'internal_error';
 export interface WorkDiscoveryEvidence {
     path?: string;
@@ -32,9 +148,37 @@ export interface WorkDiscoveryResult {
     currentState: string;
     uncertainties: string[];
     suggestions: WorkDiscoverySuggestion[];
+    discoveredProjects?: Array<{
+        rootPath: string;
+        displayName: string;
+        score: number;
+        projectKind: 'coding' | 'general' | 'unknown';
+        lastActiveAt?: number;
+        evidence: string[];
+    }>;
+    profileCandidates?: WorkDiscoveryProfileCandidate[];
     primarySuggestionId?: string;
     lowConfidence?: boolean;
     contextQuestion?: string;
+    investigation?: {
+        id: string;
+        hypotheses: string[];
+        questions: string[];
+        toolCallCount: number;
+        contentCharsRead: number;
+        degraded: boolean;
+    };
+    workThreadCandidates?: WorkUnderstandingThreadCandidate[];
+    workThreads?: WorkUnderstandingThread[];
+}
+export interface WorkDiscoveryProfileCandidate {
+    id: string;
+    memoryRecordId?: string;
+    category: 'role' | 'focus' | 'technology' | 'workflow' | 'preference';
+    statement: string;
+    confidence: 'high' | 'medium' | 'low';
+    evidence: string[];
+    status: 'pending' | 'accepted' | 'edited' | 'rejected';
 }
 export type WorkDiscoveryRecognitionDecision = 'confirmed' | 'corrected' | 'different_goal' | 'dismissed';
 export interface WorkDiscoveryFeedback {
@@ -127,6 +271,7 @@ export interface WorkDiscoveryPreview {
         branch?: string;
         changedFileCount: number;
         recentAreas: string[];
+        contentSignature: string;
         generatedAt: number;
     };
     provider: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xopcai/xopc",
-  "version": "0.0.159",
+  "version": "0.0.161",
   "description": "Local-first AI system that remembers context, coordinates AI, and sustains long-term progress.",
   "type": "module",
   "main": "dist/src/index.js",

package/skills/creative/hatch-pet/SKILL.md

@@ -26,7 +26,7 @@ Recommended questions for a new pet:
    - Choices: `Soft and cute`, `Techy and energetic`, `Calm and focused`, `Describe my own`
    - Default: `Soft and cute`
 3. Signature work behavior: ask which behavior should be most recognizable.
-   - Choices: `Typing at a laptop`, `Searching a toolbox`, `Celebrating completed work`, `Describe my own`
+   - Choices: `Creating at a laptop`, `Investigating clues`, `Celebrating completed work`, `Describe my own`
    - Default: `Typing at a laptop`
 
 For an existing pet update, ask only what is missing for the requested refinement:
@@ -44,7 +44,7 @@ After clarification, synthesize one complete `prompt` for `create_desktop_pet`.
 
 - The pet's base form, silhouette, colors, face/expression, and visual style.
 - Personality and short dialogue tone.
-- Required desktop-helper animation ideas: idle, greeting, thinking, typing at a laptop, searching through a toolbox, reading/searching, file or terminal work, success celebration, and error/blocked reaction.
+- Required v2 desktop-helper animation ideas: idle/sleep/wake, greeting and petting, preparing, researching, reading, creating, executing, safely waiting, success celebration, concern, and picked-up/released reactions.
 - Any user-requested refinements, constraints, or brand cues.
 - A note that the pet should read clearly at small desktop size and feel cute, lively, and polished.
 

package/dist/gateway/static/root/assets/activity-store-C-57rvkX.js

@@ -1 +0,0 @@
-import{p as e}from"./locale-store-C_M71MK9.js";var t=`xopc.activity-center.v1`,n=80;function r(e){return e===`error`?`failed`:e===`warning`?`attention`:`done`}function i(){if(!(typeof window>`u`))return window.location.hash.replace(/^#/,``)||`${window.location.pathname}${window.location.search}`||void 0}function a(){try{let e=globalThis.localStorage?.getItem(t);if(!e)return[];let r=JSON.parse(e);return Array.isArray(r.items)?r.items.filter(e=>e&&typeof e.id==`string`&&typeof e.title==`string`).slice(0,n):[]}catch{return[]}}function o(e){try{globalThis.localStorage?.setItem(t,JSON.stringify({items:e}))}catch{}}function s(e){return`${e.toString(36)}-${Math.random().toString(36).slice(2,8)}`}var c=e(e=>({items:a(),add:t=>e(e=>{let a=t.title.trim();if(!a)return e;let c=Date.now(),l=t.tone??`info`,u=t.dedupeKey?e.items.findIndex(e=>e.dedupeKey===t.dedupeKey):-1,d=[{id:u>=0?e.items[u].id:s(c),tone:l,status:t.status??r(l),title:a,message:t.message?.trim()||void 0,source:t.source?.trim()||void 0,href:t.href??i(),dedupeKey:t.dedupeKey,createdAt:u>=0?e.items[u].createdAt:c,updatedAt:c,read:t.read??!1,occurrences:u>=0?e.items[u].occurrences+1:1},...u>=0?e.items.filter((e,t)=>t!==u):e.items].slice(0,n);return o(d),{items:d}}),markAllRead:()=>e(e=>{let t=e.items.map(e=>({...e,read:!0}));return o(t),{items:t}}),remove:t=>e(e=>{let n=e.items.filter(e=>e.id!==t);return o(n),{items:n}}),clearFinished:()=>e(e=>{let t=e.items.filter(e=>e.status!==`done`);return o(t),{items:t}}),clear:()=>{o([]),e({items:[]})}}));function l(e){c.getState().add(e)}export{c as n,l as t};