@xopcai/xopc 0.0.225 → 0.0.228

package/dist/src/storage/sqlite/migrations/runner.js

@@ -12,7 +12,7 @@ const log = createLogger("Sqlite:Migrations");
 /** Baseline schema version applied from schema.sql on first open. */
 const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-const XOPC_DB_SCHEMA_VERSION = 134;
+const XOPC_DB_SCHEMA_VERSION = 136;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function backupBeforeTaskCutover(db, databasePath) {
 	db.exec("PRAGMA wal_checkpoint(FULL)");
@@ -57,7 +57,7 @@ function applySingleMigration(db, migration) {
 * Each step runs in its own transaction and updates schema_meta on success.
 */
 function applyPendingMigrations(db, options = {}) {
-	const targetVersion = options.targetVersion ?? 134;
+	const targetVersion = options.targetVersion ?? 136;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
@@ -94,7 +94,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 134;
+	const appVersion = options.targetVersion ?? 136;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,

package/dist/src/storage/sqlite/migrations/runner.ts

@@ -19,7 +19,7 @@ const log = createLogger('Sqlite:Migrations');
 export const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 
 /** Latest schema version this release supports (increment when adding migrations). */
-export const XOPC_DB_SCHEMA_VERSION = 134;
+export const XOPC_DB_SCHEMA_VERSION = 136;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 

package/dist/src/storage/sqlite/schema.js

@@ -32,7 +32,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 11;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 134,
+		targetVersion: 136,
 		databasePath: options.databasePath
 	});
 }

package/dist/src/storage/sqlite/session-input-repository.d.ts

@@ -31,6 +31,11 @@ export type SessionInputState = {
     inputs: SessionInput[];
 };
 export declare function getSessionInputState(sessionKey: string): SessionInputState;
+/** Durable active webchat runs claimed by the session-input coordinator. */
+export declare function listActiveSessionInputRuns(): Array<{
+    sessionKey: string;
+    runId: string;
+}>;
 export declare function findSessionInput(sessionKey: string, clientMessageId: string): SessionInput | undefined;
 export declare function getSessionInputById(sessionKey: string, id: string): SessionInput | undefined;
 export declare function insertSessionInput(input: {

package/dist/src/storage/sqlite/session-input-repository.js

@@ -56,6 +56,14 @@ function getSessionInputState(sessionKey) {
 		})
 	};
 }
+/** Durable active webchat runs claimed by the session-input coordinator. */
+function listActiveSessionInputRuns() {
+	return getSqliteDatabase().prepare(`SELECT session_key, active_run_id
+    FROM session_input_runtime WHERE active_run_id IS NOT NULL`).all().map((row) => ({
+		sessionKey: row.session_key,
+		runId: row.active_run_id
+	}));
+}
 function findSessionInput(sessionKey, clientMessageId) {
 	const row = getSqliteDatabase().prepare(`${SELECT_INPUTS} WHERE session_key = ? AND client_message_id = ?`).get(sessionKey, clientMessageId);
 	return row ? mapInput(row) : void 0;
@@ -158,4 +166,4 @@ function recoverSessionInputState() {
 	});
 }
 //#endregion
-export { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus };
+export { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, insertSessionInput, listActiveSessionInputRuns, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus };

package/dist/src/storage/sqlite/user-people-repository.d.ts

@@ -0,0 +1,32 @@
+import type { UserPerson, UserPersonIndexEntry, UserPersonKind, UserRelationshipSummary } from '../../user-context/relationships/types.js';
+export declare function replaceUserPeopleIndex(entries: UserPersonIndexEntry[], revision: {
+    sourceChangeSequence: number;
+    sourceGrantsUpdatedAt: number;
+}, principalId?: string, nowMs?: number): void;
+export declare function getUserPeopleIndexState(principalId?: string): {
+    sourceChangeSequence: number;
+    sourceGrantsUpdatedAt: number;
+    rebuiltAt: number;
+} | null;
+export declare function listUserPeople(options?: {
+    query?: string;
+    kind?: UserPersonKind;
+    sourceInstanceId?: string;
+    includeHidden?: boolean;
+    hiddenOnly?: boolean;
+    offset?: number;
+    limit?: number;
+    principalId?: string;
+}): {
+    items: UserPerson[];
+    total: number;
+    nextOffset?: number;
+};
+export declare function getUserPerson(personId: string, principalId?: string): UserPerson | null;
+export declare function updateUserPerson(personId: string, patch: {
+    displayName?: string | null;
+    kind?: UserPersonKind | null;
+    hidden?: boolean;
+}, principalId?: string): UserPerson | null;
+export declare function summarizeUserPeople(principalId?: string): UserRelationshipSummary;
+export declare function mergeUserPeople(sourcePersonId: string, targetPersonId: string, principalId?: string): UserPerson | null;

package/dist/src/storage/sqlite/user-people-repository.js

@@ -0,0 +1,246 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
+//#region src/storage/sqlite/user-people-repository.ts
+function sourceMetadata(sourceInstanceId) {
+	if (!sourceInstanceId.startsWith("composio:")) return {};
+	const connectorId = sourceInstanceId.split(":")[1];
+	if (!connectorId) return {};
+	return {
+		connectorId,
+		toolkit: connectorId.replace(/^composio-/, "")
+	};
+}
+function handlesFor(personId) {
+	return getSqliteDatabase().prepare(`SELECT handle_id, handle_type, display_value,
+    source_instance_id, verification, first_observed_at, last_observed_at
+    FROM user_person_handles WHERE person_id = ?
+    ORDER BY CASE handle_type WHEN 'email' THEN 0 WHEN 'provider_user' THEN 1 WHEN 'username' THEN 2 ELSE 3 END,
+      last_observed_at DESC`).all(personId).map((row) => ({
+		id: row.handle_id,
+		type: row.handle_type,
+		value: row.display_value,
+		sourceInstanceId: row.source_instance_id,
+		verification: row.verification,
+		firstObservedAt: row.first_observed_at,
+		lastObservedAt: row.last_observed_at
+	}));
+}
+function sourcesFor(personId) {
+	return getSqliteDatabase().prepare(`SELECT source_instance_id, interaction_count,
+    first_observed_at, last_observed_at FROM user_person_source_stats
+    WHERE person_id = ? ORDER BY last_observed_at DESC`).all(personId).map((row) => ({
+		sourceInstanceId: row.source_instance_id,
+		...sourceMetadata(row.source_instance_id),
+		interactionCount: row.interaction_count,
+		firstObservedAt: row.first_observed_at,
+		lastObservedAt: row.last_observed_at
+	}));
+}
+function fromRow(row, includeDetails = false) {
+	const handles = handlesFor(row.person_id);
+	const sources = sourcesFor(row.person_id);
+	const primaryHandle = handles.find((handle) => handle.type === "email")?.value ?? handles.find((handle) => handle.type === "provider_user" || handle.type === "username")?.value;
+	return {
+		id: row.person_id,
+		displayName: row.user_display_name ?? row.display_name,
+		kind: row.user_kind ?? row.inferred_kind,
+		hidden: row.hidden === 1,
+		confidence: row.confidence,
+		...primaryHandle ? { primaryHandle } : {},
+		interactionCount: sources.reduce((total, source) => total + source.interactionCount, 0),
+		firstObservedAt: row.first_observed_at,
+		lastObservedAt: row.last_observed_at,
+		handles: includeDetails ? handles : [],
+		sources
+	};
+}
+function replaceUserPeopleIndex(entries, revision, principalId = USER_CONTEXT_PRINCIPAL_ID, nowMs = Date.now()) {
+	runSqliteWriteTransaction((db) => {
+		const mergedRows = db.prepare(`SELECT person_id, merged_into_person_id FROM user_people
+      WHERE principal_id = ? AND merged_into_person_id IS NOT NULL`).all(principalId);
+		const mergedTargets = new Map(mergedRows.map((row) => [row.person_id, row.merged_into_person_id]));
+		const targetFor = (personId) => {
+			const seen = /* @__PURE__ */ new Set();
+			let current = personId;
+			while (mergedTargets.has(current) && !seen.has(current)) {
+				seen.add(current);
+				current = mergedTargets.get(current);
+			}
+			return current;
+		};
+		db.prepare(`DELETE FROM user_person_source_stats
+      WHERE person_id IN (SELECT person_id FROM user_people WHERE principal_id = ?)`).run(principalId);
+		db.prepare(`DELETE FROM user_person_handles
+      WHERE person_id IN (SELECT person_id FROM user_people WHERE principal_id = ?)
+        AND verification != 'user_confirmed'`).run(principalId);
+		for (const entry of entries) {
+			const personId = targetFor(entry.id);
+			if (personId === entry.id) db.prepare(`INSERT INTO user_people (
+        person_id, principal_id, display_name, inferred_kind, confidence,
+        first_observed_at, last_observed_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(person_id) DO UPDATE SET
+        display_name = excluded.display_name,
+        inferred_kind = excluded.inferred_kind,
+        confidence = excluded.confidence,
+        first_observed_at = MIN(user_people.first_observed_at, excluded.first_observed_at),
+        last_observed_at = excluded.last_observed_at,
+        updated_at = excluded.updated_at`).run(entry.id, principalId, entry.displayName, entry.inferredKind, entry.confidence, entry.firstObservedAt, entry.lastObservedAt, nowMs, nowMs);
+			for (const handle of entry.handles) db.prepare(`INSERT INTO user_person_handles (
+          handle_id, person_id, handle_type, normalized_value, display_value,
+          source_instance_id, verification, first_observed_at, last_observed_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(handle_type, normalized_value, source_instance_id) DO UPDATE SET
+          person_id = excluded.person_id,
+          display_value = excluded.display_value,
+          verification = CASE WHEN user_person_handles.verification = 'user_confirmed'
+            THEN 'user_confirmed' ELSE excluded.verification END,
+          first_observed_at = MIN(user_person_handles.first_observed_at, excluded.first_observed_at),
+          last_observed_at = excluded.last_observed_at,
+          updated_at = excluded.updated_at`).run(handle.id, personId, handle.type, handle.value.toLocaleLowerCase(), handle.value, handle.sourceInstanceId, handle.verification, handle.firstObservedAt, handle.lastObservedAt, nowMs, nowMs);
+			for (const source of entry.sources) db.prepare(`INSERT INTO user_person_source_stats (
+          person_id, source_instance_id, interaction_count, first_observed_at,
+          last_observed_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(person_id, source_instance_id) DO UPDATE SET
+          interaction_count = user_person_source_stats.interaction_count + excluded.interaction_count,
+          first_observed_at = MIN(user_person_source_stats.first_observed_at, excluded.first_observed_at),
+          last_observed_at = MAX(user_person_source_stats.last_observed_at, excluded.last_observed_at),
+          updated_at = excluded.updated_at`).run(personId, source.sourceInstanceId, source.interactionCount, source.firstObservedAt, source.lastObservedAt, nowMs);
+		}
+		db.prepare(`DELETE FROM user_people
+      WHERE principal_id = ? AND merged_into_person_id IS NULL AND hidden = 0
+        AND user_display_name IS NULL AND user_kind IS NULL
+        AND NOT EXISTS (SELECT 1 FROM user_person_source_stats s WHERE s.person_id = user_people.person_id)
+        AND NOT EXISTS (SELECT 1 FROM user_person_handles h WHERE h.person_id = user_people.person_id)`).run(principalId);
+		db.prepare(`INSERT INTO user_people_index_state (
+      principal_id, source_change_sequence, source_grants_updated_at, rebuilt_at
+    ) VALUES (?, ?, ?, ?)
+    ON CONFLICT(principal_id) DO UPDATE SET
+      source_change_sequence = excluded.source_change_sequence,
+      source_grants_updated_at = excluded.source_grants_updated_at,
+      rebuilt_at = excluded.rebuilt_at`).run(principalId, revision.sourceChangeSequence, revision.sourceGrantsUpdatedAt, nowMs);
+	});
+}
+function getUserPeopleIndexState(principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const row = getSqliteDatabase().prepare(`SELECT source_change_sequence, source_grants_updated_at, rebuilt_at
+    FROM user_people_index_state WHERE principal_id = ?`).get(principalId);
+	return row ? {
+		sourceChangeSequence: row.source_change_sequence,
+		sourceGrantsUpdatedAt: row.source_grants_updated_at,
+		rebuiltAt: row.rebuilt_at
+	} : null;
+}
+function listUserPeople(options = {}) {
+	const principalId = options.principalId ?? "local-owner";
+	const clauses = [
+		"p.principal_id = ?",
+		"p.merged_into_person_id IS NULL",
+		"EXISTS (SELECT 1 FROM user_person_source_stats active_source WHERE active_source.person_id = p.person_id)"
+	];
+	const params = [principalId];
+	if (options.hiddenOnly) clauses.push("p.hidden = 1");
+	else if (!options.includeHidden) clauses.push("p.hidden = 0");
+	if (options.kind) {
+		clauses.push("COALESCE(p.user_kind, p.inferred_kind) = ?");
+		params.push(options.kind);
+	}
+	if (options.sourceInstanceId) {
+		clauses.push("EXISTS (SELECT 1 FROM user_person_source_stats filtered_source WHERE filtered_source.person_id = p.person_id AND filtered_source.source_instance_id = ?)");
+		params.push(options.sourceInstanceId);
+	}
+	const query = options.query?.trim().toLocaleLowerCase();
+	if (query) {
+		clauses.push(`(LOWER(COALESCE(p.user_display_name, p.display_name)) LIKE ? OR EXISTS (
+      SELECT 1 FROM user_person_handles search_handle
+      WHERE search_handle.person_id = p.person_id AND search_handle.normalized_value LIKE ?
+    ))`);
+		params.push(`%${query}%`, `%${query}%`);
+	}
+	const where = clauses.join(" AND ");
+	const total = Number(getSqliteDatabase().prepare(`SELECT COUNT(*) AS count FROM user_people p WHERE ${where}`).get(...params).count);
+	const limit = Math.max(1, Math.min(100, Math.floor(options.limit ?? 30)));
+	const offset = Math.max(0, Math.floor(options.offset ?? 0));
+	const rows = getSqliteDatabase().prepare(`SELECT p.* FROM user_people p WHERE ${where}
+    ORDER BY p.last_observed_at DESC, COALESCE(p.user_display_name, p.display_name) ASC
+    LIMIT ? OFFSET ?`).all(...params, limit, offset);
+	return {
+		items: rows.map((row) => fromRow(row)),
+		total,
+		...offset + rows.length < total ? { nextOffset: offset + rows.length } : {}
+	};
+}
+function getUserPerson(personId, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const row = getSqliteDatabase().prepare(`SELECT * FROM user_people
+    WHERE person_id = ? AND principal_id = ? AND merged_into_person_id IS NULL`).get(personId, principalId);
+	return row ? fromRow(row, true) : null;
+}
+function updateUserPerson(personId, patch, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const current = getUserPerson(personId, principalId);
+	if (!current) return null;
+	runSqliteWriteTransaction((db) => db.prepare(`UPDATE user_people SET
+    user_display_name = ?, user_kind = ?, hidden = ?, updated_at = ?
+    WHERE person_id = ? AND principal_id = ?`).run(patch.displayName === void 0 ? getUserDisplayName(personId) : patch.displayName, patch.kind === void 0 ? getUserKind(personId) : patch.kind, patch.hidden === void 0 ? Number(current.hidden) : Number(patch.hidden), Date.now(), personId, principalId));
+	return getUserPerson(personId, principalId);
+}
+function getUserDisplayName(personId) {
+	return getSqliteDatabase().prepare("SELECT user_display_name AS value FROM user_people WHERE person_id = ?").get(personId)?.value ?? null;
+}
+function getUserKind(personId) {
+	return getSqliteDatabase().prepare("SELECT user_kind AS value FROM user_people WHERE person_id = ?").get(personId)?.value ?? null;
+}
+function summarizeUserPeople(principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const row = getSqliteDatabase().prepare(`SELECT
+    SUM(CASE WHEN hidden = 0 AND COALESCE(user_kind, inferred_kind) = 'person' THEN 1 ELSE 0 END) AS people,
+    SUM(CASE WHEN hidden = 0 AND COALESCE(user_kind, inferred_kind) IN ('bot', 'service', 'group') THEN 1 ELSE 0 END) AS automated,
+    SUM(CASE WHEN hidden = 0 AND COALESCE(user_kind, inferred_kind) = 'unknown' THEN 1 ELSE 0 END) AS needs_review,
+    SUM(CASE WHEN hidden = 1 THEN 1 ELSE 0 END) AS hidden,
+    MAX(last_observed_at) AS last_updated_at
+    FROM user_people p WHERE principal_id = ? AND merged_into_person_id IS NULL
+      AND EXISTS (SELECT 1 FROM user_person_source_stats s WHERE s.person_id = p.person_id)`).get(principalId);
+	const sources = Number(getSqliteDatabase().prepare(`SELECT COUNT(DISTINCT source_instance_id) AS count
+    FROM user_person_source_stats s JOIN user_people p ON p.person_id = s.person_id
+    WHERE p.principal_id = ? AND p.merged_into_person_id IS NULL`).get(principalId).count);
+	return {
+		people: Number(row.people ?? 0),
+		automatedAccounts: Number(row.automated ?? 0),
+		needsReview: Number(row.needs_review ?? 0),
+		hidden: Number(row.hidden ?? 0),
+		sources,
+		...row.last_updated_at == null ? {} : { lastUpdatedAt: row.last_updated_at }
+	};
+}
+function mergeUserPeople(sourcePersonId, targetPersonId, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	if (sourcePersonId === targetPersonId) return getUserPerson(targetPersonId, principalId);
+	const source = getUserPerson(sourcePersonId, principalId);
+	const target = getUserPerson(targetPersonId, principalId);
+	if (!source || !target) return null;
+	runSqliteWriteTransaction((db) => {
+		const duplicateHandles = db.prepare(`SELECT source.handle_id FROM user_person_handles source
+      JOIN user_person_handles target
+        ON target.person_id = ? AND target.handle_type = source.handle_type
+        AND target.normalized_value = source.normalized_value
+        AND target.source_instance_id = source.source_instance_id
+      WHERE source.person_id = ?`).all(targetPersonId, sourcePersonId);
+		for (const duplicate of duplicateHandles) db.prepare("DELETE FROM user_person_handles WHERE handle_id = ?").run(duplicate.handle_id);
+		db.prepare("UPDATE user_person_handles SET person_id = ?, updated_at = ? WHERE person_id = ?").run(targetPersonId, Date.now(), sourcePersonId);
+		const sourceStats = db.prepare("SELECT * FROM user_person_source_stats WHERE person_id = ?").all(sourcePersonId);
+		for (const stat of sourceStats) db.prepare(`INSERT INTO user_person_source_stats (
+        person_id, source_instance_id, interaction_count, first_observed_at,
+        last_observed_at, last_source_item_id, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(person_id, source_instance_id) DO UPDATE SET
+        interaction_count = user_person_source_stats.interaction_count + excluded.interaction_count,
+        first_observed_at = MIN(user_person_source_stats.first_observed_at, excluded.first_observed_at),
+        last_observed_at = MAX(user_person_source_stats.last_observed_at, excluded.last_observed_at),
+        last_source_item_id = CASE WHEN excluded.last_observed_at >= user_person_source_stats.last_observed_at
+          THEN excluded.last_source_item_id ELSE user_person_source_stats.last_source_item_id END,
+        updated_at = excluded.updated_at`).run(targetPersonId, stat.source_instance_id, stat.interaction_count, stat.first_observed_at, stat.last_observed_at, stat.last_source_item_id, Date.now());
+		db.prepare("DELETE FROM user_person_source_stats WHERE person_id = ?").run(sourcePersonId);
+		db.prepare(`UPDATE user_people SET merged_into_person_id = ?, updated_at = ?
+      WHERE person_id = ? AND principal_id = ?`).run(targetPersonId, Date.now(), sourcePersonId, principalId);
+	});
+	return getUserPerson(targetPersonId, principalId);
+}
+//#endregion
+export { getUserPeopleIndexState, getUserPerson, listUserPeople, mergeUserPeople, replaceUserPeopleIndex, summarizeUserPeople, updateUserPerson };

package/dist/src/tasks/index.js

@@ -1,12 +1,12 @@
 import { TaskRepository } from "./task-repository.js";
 import { TaskConversationConflictError, TaskConversationRepository } from "./task-conversation-repository.js";
+import { enqueueTaskAttentionRequiredEvent, enqueueTaskChanged, enqueueTaskChangedEvent } from "./task-change-events.js";
 import { TaskRunRepository } from "./task-run-repository.js";
 import { TaskReadModelProjector } from "./task-read-model-projector.js";
 import { resolveExecutionContext } from "./execution-context.js";
 import { AttentionGovernor } from "./attention-governor.js";
 import { HomeQueryService, buildHomeWorkbench, decisionFromTask } from "./home-query-service.js";
 import { TaskContextRepository } from "./task-context-repository.js";
-import { enqueueTaskChanged, enqueueTaskChangedEvent } from "./task-change-events.js";
 import { TaskDependencyError, TaskDependencyService } from "./task-dependency-service.js";
 import { TaskApplicationService } from "./task-application-service.js";
 import { TaskWorkflowCoordinator } from "./task-workflow-coordinator.js";
@@ -22,4 +22,4 @@ import { TaskDeletionService } from "./task-deletion-service.js";
 import { TaskOutboxDispatcher } from "./task-outbox-dispatcher.js";
 import { TaskRunDispatcher } from "./task-run-dispatcher.js";
 import { TaskSignalService } from "./task-signal-service.js";
-export { AttentionGovernor, HomeQueryService, ModelTaskContractPlanner, ProjectMonitoringService, ProjectOperatingViewService, TaskApplicationService, TaskContextRepository, TaskConversationConflictError, TaskConversationRepository, TaskDeletionService, TaskDependencyError, TaskDependencyService, TaskHandoffService, TaskOutboxDispatcher, TaskReadModelProjector, TaskRepository, TaskRunCoordinator, TaskRunDispatcher, TaskRunRepository, TaskSignalService, TaskValueMetricsService, TaskWorkflowCoordinator, assembleTaskContext, buildHomeWorkbench, buildTaskExecutionDirective, decideProactiveDisposition, decisionFromTask, defineTaskContract, enqueueTaskChanged, enqueueTaskChangedEvent, getTaskContextManifest, getTaskExecutionBrief, isInQuietHours, nextQuietHoursEnd, parseTaskContractResponse, proactiveDispositionReason, resolveExecutionContext, summarizeProjectOperatingView };
+export { AttentionGovernor, HomeQueryService, ModelTaskContractPlanner, ProjectMonitoringService, ProjectOperatingViewService, TaskApplicationService, TaskContextRepository, TaskConversationConflictError, TaskConversationRepository, TaskDeletionService, TaskDependencyError, TaskDependencyService, TaskHandoffService, TaskOutboxDispatcher, TaskReadModelProjector, TaskRepository, TaskRunCoordinator, TaskRunDispatcher, TaskRunRepository, TaskSignalService, TaskValueMetricsService, TaskWorkflowCoordinator, assembleTaskContext, buildHomeWorkbench, buildTaskExecutionDirective, decideProactiveDisposition, decisionFromTask, defineTaskContract, enqueueTaskAttentionRequiredEvent, enqueueTaskChanged, enqueueTaskChangedEvent, getTaskContextManifest, getTaskExecutionBrief, isInQuietHours, nextQuietHoursEnd, parseTaskContractResponse, proactiveDispositionReason, resolveExecutionContext, summarizeProjectOperatingView };

package/dist/src/tasks/task-application-service.js

@@ -1,9 +1,9 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { TaskRepository } from "./task-repository.js";
+import { enqueueTaskAttentionRequiredEvent, enqueueTaskChangedEvent } from "./task-change-events.js";
 import { TaskRunRepository } from "./task-run-repository.js";
 import { TaskReadModelProjector } from "./task-read-model-projector.js";
 import { TaskContextRepository } from "./task-context-repository.js";
-import { enqueueTaskChangedEvent } from "./task-change-events.js";
 import { TaskDependencyService } from "./task-dependency-service.js";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/tasks/task-application-service.ts
@@ -153,6 +153,15 @@ var TaskApplicationService = class {
 				],
 				actor
 			});
+			else if (started.ok === false && started.reason === "blocked") {
+				if (!this.#runs.listActiveWaits(current.id).some((wait) => wait.kind === "approval" || wait.kind === "user_input")) enqueueTaskAttentionRequiredEvent(db, {
+					taskId: current.id,
+					taskTitle: current.title,
+					...current.projectId ? { projectId: current.projectId } : {},
+					reason: "blocked",
+					correlationId: input.idempotencyKey
+				});
+			}
 			return started;
 		});
 	}
@@ -275,11 +284,15 @@ var TaskApplicationService = class {
 				}
 			}
 			if (result.ok === false) {
-				if (result.reason === "blocked") this.enqueueEvent(db, "task.attention_required.v2", task.id, input.idempotencyKey, {
-					taskId: task.id,
-					reason: "blocked",
-					projectId: task.projectId
-				});
+				if (result.reason === "blocked") {
+					if (!this.#runs.listActiveWaits(task.id).some((wait) => wait.kind === "approval" || wait.kind === "user_input")) enqueueTaskAttentionRequiredEvent(db, {
+						taskId: task.id,
+						taskTitle: task.title,
+						...task.projectId ? { projectId: task.projectId } : {},
+						reason: "blocked",
+						correlationId: input.idempotencyKey
+					});
+				}
 				return result;
 			}
 			this.recordCommand(db, {
@@ -301,6 +314,10 @@ var TaskApplicationService = class {
 				runId: result.runId
 			});
 			if (result.model.task.phase !== task.phase) this.enqueueEvent(db, "task.phase_changed.v2", task.id, input.idempotencyKey, {
+				task: {
+					id: result.model.task.id,
+					title: result.model.task.title
+				},
 				taskId: task.id,
 				from: task.phase,
 				to: result.model.task.phase,
@@ -344,6 +361,14 @@ var TaskApplicationService = class {
 			const task = this.#tasks.require(run.taskId);
 			if (input.receipt.status !== "succeeded") {
 				const model = this.#projector.project(task);
+				enqueueTaskAttentionRequiredEvent(db, {
+					taskId: task.id,
+					taskTitle: task.title,
+					...task.projectId ? { projectId: task.projectId } : {},
+					reason: "failed",
+					detail: input.terminalMessage ?? input.receipt.summary,
+					correlationId: run.id
+				});
 				enqueueTaskChangedEvent(db, {
 					taskId: task.id,
 					projectId: task.projectId,
@@ -370,6 +395,17 @@ var TaskApplicationService = class {
 				...phase === "closed" ? { resolution: "done" } : {}
 			});
 			if (!updated) throw new Error("Task changed while its run was being finalized");
+			this.enqueueEvent(db, "task.phase_changed.v2", updated.id, run.id, {
+				task: {
+					id: updated.id,
+					title: updated.title
+				},
+				taskId: updated.id,
+				from: task.phase,
+				to: updated.phase,
+				resolution: updated.resolution,
+				projectId: updated.projectId
+			});
 			enqueueTaskChangedEvent(db, {
 				taskId: updated.id,
 				projectId: updated.projectId,

package/dist/src/tasks/task-change-events.d.ts

@@ -10,4 +10,13 @@ export type TaskChangeInput = {
     occurredAt?: number;
 };
 export declare function enqueueTaskChangedEvent(db: DatabaseSync, input: TaskChangeInput): void;
+export declare function enqueueTaskAttentionRequiredEvent(db: DatabaseSync, input: {
+    taskId: string;
+    taskTitle: string;
+    projectId?: string;
+    reason: 'blocked' | 'failed' | 'user_input' | 'approval';
+    detail?: string;
+    correlationId: string;
+    occurredAt?: number;
+}): void;
 export declare function enqueueTaskChanged(input: TaskChangeInput): void;

package/dist/src/tasks/task-change-events.js

@@ -22,8 +22,24 @@ function enqueueTaskChangedEvent(db, input) {
 		occurredAt
 	}), occurredAt);
 }
+function enqueueTaskAttentionRequiredEvent(db, input) {
+	const occurredAt = input.occurredAt ?? Date.now();
+	db.prepare(`INSERT INTO domain_outbox (
+      event_id, event_type, subject_kind, subject_id, correlation_id,
+      payload_json, created_at
+    ) VALUES (?, 'task.attention_required.v2', 'task', ?, ?, ?, ?)`).run(randomUUID(), input.taskId, input.correlationId, JSON.stringify({
+		task: {
+			id: input.taskId,
+			title: input.taskTitle
+		},
+		taskId: input.taskId,
+		reason: input.reason,
+		...input.detail ? { detail: input.detail } : {},
+		...input.projectId ? { projectId: input.projectId } : {}
+	}), occurredAt);
+}
 function enqueueTaskChanged(input) {
 	runSqliteWriteTransaction((db) => enqueueTaskChangedEvent(db, input));
 }
 //#endregion
-export { enqueueTaskChanged, enqueueTaskChangedEvent };
+export { enqueueTaskAttentionRequiredEvent, enqueueTaskChanged, enqueueTaskChangedEvent };

package/dist/src/tasks/task-outbox-dispatcher.js

@@ -10,10 +10,14 @@ var TaskOutboxDispatcher = class {
        ORDER BY created_at, event_id LIMIT ?`).all(Math.max(1, Math.min(500, Math.floor(limit))));
 		let published = 0;
 		for (const row of rows) try {
+			const payload = JSON.parse(row.payload_json);
 			this.publish({
 				type: row.event_type,
 				source: "tasks",
-				payload: JSON.parse(row.payload_json),
+				payload: {
+					...payload,
+					sourceEventId: row.event_id
+				},
 				occurredAtMs: row.created_at
 			});
 			runSqliteWriteTransaction((db) => {

package/dist/src/tasks/task-run-dispatcher.js

@@ -2,12 +2,14 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { TaskRepository } from "./task-repository.js";
 import { TaskRunRepository } from "./task-run-repository.js";
+import { TaskApplicationService } from "./task-application-service.js";
 //#region src/tasks/task-run-dispatcher.ts
 init_logger();
 const log = createLogger("TaskRunDispatcher");
 var TaskRunDispatcher = class {
 	#runs = new TaskRunRepository();
 	#tasks = new TaskRepository();
+	#application = new TaskApplicationService();
 	#draining = /* @__PURE__ */ new Set();
 	constructor(deps) {
 		this.deps = deps;
@@ -49,9 +51,9 @@ var TaskRunDispatcher = class {
 						"running",
 						"waiting",
 						"verifying"
-					].includes(current.status)) this.#runs.finalize({
+					].includes(current.status)) this.#application.completeRun({
 						runId: current.id,
-						expectedVersion: current.version,
+						expectedRunVersion: current.version,
 						terminalCode: "dispatch_failed",
 						terminalMessage: error instanceof Error ? error.message : String(error),
 						receipt: {

package/dist/src/tasks/task-run-repository.js

@@ -1,4 +1,5 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { enqueueTaskAttentionRequiredEvent } from "./task-change-events.js";
 import { randomUUID } from "node:crypto";
 //#region src/tasks/task-run-repository.ts
 const ACTIVE_RUN_STATUSES = [
@@ -237,6 +238,18 @@ var TaskRunRepository = class {
 				reason: input.reason.trim(),
 				resumeAt: input.resumeAt
 			}, input.actor ?? { kind: "system" }, now);
+			if (input.kind === "user_input" || input.kind === "approval") {
+				const task = db.prepare("SELECT title, project_id FROM tasks WHERE task_id = ?").get(input.taskId);
+				if (task) enqueueTaskAttentionRequiredEvent(db, {
+					taskId: input.taskId,
+					taskTitle: task.title,
+					...task.project_id ? { projectId: task.project_id } : {},
+					reason: input.kind,
+					detail: input.reason.trim(),
+					correlationId: id,
+					occurredAt: now
+				});
+			}
 		});
 		return this.requireWait(id);
 	}

package/dist/src/user-context/relationships/indexer.d.ts

@@ -0,0 +1,13 @@
+import type { KnowledgeSourceItem } from '../../knowledge/types.js';
+import type { UserPersonIndexEntry } from './types.js';
+type PersonSignal = {
+    name?: string;
+    email?: string;
+    username?: string;
+};
+export declare function personIdentityKey(signal: PersonSignal, sourceInstanceId: string): string | undefined;
+export declare function personIdForIdentity(signal: PersonSignal, sourceInstanceId: string): string | undefined;
+export declare function buildUserPeopleIndex(items: KnowledgeSourceItem[]): UserPersonIndexEntry[];
+export declare function rebuildUserPeopleIndex(): UserPersonIndexEntry[];
+export declare function ensureUserPeopleIndex(): void;
+export {};