@xopcai/xopc 0.0.179 → 0.0.187

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

@@ -537,80 +537,76 @@ CREATE INDEX IF NOT EXISTS idx_activity_related_projects_project
   ON activity_related_projects(project_id, activity_id);
 
 CREATE TABLE IF NOT EXISTS discussion_captures (
-  id                         TEXT PRIMARY KEY,
-  client_request_id          TEXT NOT NULL UNIQUE,
-  note_id                    TEXT NOT NULL UNIQUE,
-  project_id                 TEXT,
-  audio_attachment_id        TEXT,
-  source                     TEXT NOT NULL CHECK (source IN ('web', 'electron')),
-  status                     TEXT NOT NULL CHECK (status IN (
-    'recording',
-    'finalizing',
-    'completed',
-    'failed',
-    'cancelled'
+  id TEXT PRIMARY KEY,
+  client_request_id TEXT NOT NULL UNIQUE,
+  note_id TEXT NOT NULL UNIQUE,
+  project_id TEXT,
+  audio_attachment_id TEXT,
+  source TEXT NOT NULL CHECK (source IN ('web', 'electron')),
+  status TEXT NOT NULL CHECK (status IN (
+    'recording', 'stopping', 'sealing', 'organizing',
+    'completed', 'needs_attention', 'cancelled'
   )),
-  processing_stage           TEXT CHECK (processing_stage IN (
-    'original_upload',
-    'final_transcription',
-    'analysis',
-    'note_write'
+  duration_ms INTEGER,
+  expected_last_sequence INTEGER,
+  mime_type TEXT,
+  audio_size_bytes INTEGER,
+  audio_sha256 TEXT,
+  canonical_transcript TEXT,
+  canonical_transcript_sha256 TEXT,
+  transcript_language TEXT,
+  transcript_revision INTEGER NOT NULL DEFAULT 0,
+  generated_title TEXT,
+  project_inference_score REAL,
+  project_inference_source TEXT,
+  failure_stage TEXT CHECK (failure_stage IN (
+    'segment_upload', 'segment_transcription', 'audio_upload',
+    'transcript_sealing', 'organization'
   )),
-  duration_ms                INTEGER,
-  expected_last_sequence     INTEGER,
-  mime_type                  TEXT,
-  audio_size_bytes           INTEGER,
-  audio_sha256               TEXT,
-  transcript_raw             TEXT,
-  transcript_sha256          TEXT,
-  transcript_language        TEXT,
-  stt_provider               TEXT,
-  analysis_json              TEXT,
-  analysis_input_hash        TEXT,
-  analyzer_model_ref         TEXT,
-  generated_title            TEXT,
-  project_inference_score    REAL,
-  project_inference_source   TEXT,
-  finalization_revision      INTEGER NOT NULL DEFAULT 0,
-  attempt_count              INTEGER NOT NULL DEFAULT 0,
-  next_attempt_at            INTEGER,
-  lease_owner                TEXT,
-  lease_expires_at           INTEGER,
-  last_error_code            TEXT,
-  last_error_message         TEXT,
-  recording_started_at       INTEGER NOT NULL,
-  recording_finished_at      INTEGER,
-  created_at                 INTEGER NOT NULL,
-  updated_at                 INTEGER NOT NULL,
-  completed_at               INTEGER,
-  audio_deleted_at           INTEGER,
+  failure_code TEXT,
+  failure_message TEXT,
+  work_lease_owner TEXT,
+  work_lease_expires_at INTEGER,
+  recording_started_at INTEGER NOT NULL,
+  recording_stopped_at INTEGER,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  audio_deleted_at INTEGER,
   FOREIGN KEY (note_id) REFERENCES notes(note_id) ON DELETE CASCADE,
   FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE SET NULL
 );
 
 CREATE INDEX IF NOT EXISTS idx_discussion_captures_queue
-  ON discussion_captures(status, next_attempt_at, created_at);
+  ON discussion_captures(status, work_lease_expires_at, updated_at);
 
 CREATE INDEX IF NOT EXISTS idx_discussion_captures_project
   ON discussion_captures(project_id, updated_at DESC);
 
 CREATE TABLE IF NOT EXISTS discussion_transcript_segments (
-  discussion_id    TEXT NOT NULL,
-  sequence         INTEGER NOT NULL,
-  audio_sha256     TEXT NOT NULL,
-  audio_blob       BLOB,
-  started_at_ms    INTEGER NOT NULL,
-  ended_at_ms      INTEGER NOT NULL,
-  status           TEXT NOT NULL CHECK (status IN ('uploaded', 'transcribing', 'completed', 'failed')),
-  transcript       TEXT,
-  provider         TEXT,
-  attempt_count    INTEGER NOT NULL DEFAULT 0,
-  next_attempt_at  INTEGER,
-  lease_owner      TEXT,
+  discussion_id TEXT NOT NULL,
+  sequence INTEGER NOT NULL,
+  audio_sha256 TEXT NOT NULL,
+  audio_blob BLOB,
+  started_at_ms INTEGER NOT NULL,
+  ended_at_ms INTEGER NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('uploaded', 'transcribing', 'confirmed', 'failed')),
+  raw_text TEXT,
+  display_text TEXT,
+  language TEXT,
+  provider TEXT,
+  confidence REAL,
+  speaker_label TEXT,
+  revision INTEGER NOT NULL DEFAULT 1,
+  corrected_by_user INTEGER NOT NULL DEFAULT 0,
+  corrected_at INTEGER,
+  attempt_count INTEGER NOT NULL DEFAULT 0,
+  next_attempt_at INTEGER,
+  lease_owner TEXT,
   lease_expires_at INTEGER,
-  last_error       TEXT,
-  created_at       INTEGER NOT NULL,
-  updated_at       INTEGER NOT NULL,
+  last_error TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
   PRIMARY KEY (discussion_id, sequence),
   FOREIGN KEY (discussion_id) REFERENCES discussion_captures(id) ON DELETE CASCADE
 );
@@ -618,6 +614,25 @@ CREATE TABLE IF NOT EXISTS discussion_transcript_segments (
 CREATE INDEX IF NOT EXISTS idx_discussion_segments_queue
   ON discussion_transcript_segments(status, next_attempt_at, created_at);
 
+CREATE TABLE IF NOT EXISTS discussion_organizations (
+  id TEXT PRIMARY KEY,
+  discussion_id TEXT NOT NULL,
+  revision INTEGER NOT NULL,
+  input_transcript_sha256 TEXT NOT NULL,
+  prompt_version TEXT NOT NULL,
+  model_ref TEXT NOT NULL,
+  organization_json TEXT,
+  status TEXT NOT NULL CHECK (status IN ('running', 'completed', 'failed')),
+  error_message TEXT,
+  created_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  UNIQUE (discussion_id, revision),
+  FOREIGN KEY (discussion_id) REFERENCES discussion_captures(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_discussion_organizations_latest
+  ON discussion_organizations(discussion_id, revision DESC);
+
 CREATE TABLE IF NOT EXISTS discussion_capture_settings (
   workspace_id               TEXT PRIMARY KEY,
   consent_policy_version     INTEGER NOT NULL,

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

@@ -0,0 +1,59 @@
+export type SessionInputDelivery = 'next' | 'steer';
+export type SessionInputStatus = 'queued' | 'running' | 'injecting' | 'completed' | 'cancelled' | 'failed' | 'interrupted';
+export type SessionInput = {
+    id: string;
+    sessionKey: string;
+    clientMessageId: string;
+    requestedDelivery: SessionInputDelivery;
+    effectiveDelivery: SessionInputDelivery;
+    status: SessionInputStatus;
+    content: string;
+    attachments?: unknown[];
+    thinking?: string;
+    position: number;
+    targetRunId?: string;
+    runId?: string;
+    version: number;
+    error?: string;
+    createdAtMs: number;
+    updatedAtMs: number;
+};
+export type SessionInputState = {
+    sessionKey: string;
+    revision: number;
+    activeRunId?: string;
+    activeInputId?: string;
+    inputs: SessionInput[];
+};
+export declare function getSessionInputState(sessionKey: string): SessionInputState;
+export declare function findSessionInput(sessionKey: string, clientMessageId: string): SessionInput | undefined;
+export declare function insertSessionInput(input: {
+    id: string;
+    sessionKey: string;
+    clientMessageId: string;
+    requestedDelivery: SessionInputDelivery;
+    effectiveDelivery: SessionInputDelivery;
+    status: 'queued' | 'injecting';
+    content: string;
+    attachments?: unknown[];
+    thinking?: string;
+    targetRunId?: string;
+}): SessionInput;
+export declare function claimNextSessionInput(sessionKey: string, runId: string): SessionInput | undefined;
+export declare function finishSessionInputRun(sessionKey: string, runId: string, status: 'completed' | 'failed' | 'cancelled', error?: string): boolean;
+export declare function setSessionInputStatus(id: string, status: SessionInputStatus, patch?: {
+    effectiveDelivery?: SessionInputDelivery;
+    targetRunId?: string | null;
+    error?: string;
+}): boolean;
+export declare function mutateQueuedSessionInput(input: {
+    sessionKey: string;
+    id: string;
+    version: number;
+    content?: string;
+    attachments?: unknown[];
+    thinking?: string;
+    position?: number;
+}): boolean;
+export declare function cancelQueuedSessionInput(sessionKey: string, id: string, version: number): boolean;
+export declare function recoverSessionInputState(): string[];

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

@@ -0,0 +1,147 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+//#region src/storage/sqlite/session-input-repository.ts
+function mapInput(row) {
+	return {
+		id: row.id,
+		sessionKey: row.session_key,
+		clientMessageId: row.client_message_id,
+		requestedDelivery: row.requested_delivery,
+		effectiveDelivery: row.effective_delivery,
+		status: row.status,
+		content: row.content,
+		attachments: row.attachments_json ? JSON.parse(row.attachments_json) : void 0,
+		thinking: row.thinking ?? void 0,
+		position: row.position,
+		targetRunId: row.target_run_id ?? void 0,
+		runId: row.run_id ?? void 0,
+		version: row.version,
+		error: row.error ?? void 0,
+		createdAtMs: row.created_at_ms,
+		updatedAtMs: row.updated_at_ms
+	};
+}
+const SELECT_INPUTS = `SELECT id, session_key, client_message_id, requested_delivery,
+  effective_delivery, status, content, attachments_json, thinking, position,
+  target_run_id, run_id, version, error, created_at_ms, updated_at_ms
+  FROM session_inputs`;
+function ensureRuntime(db, sessionKey) {
+	db.prepare(`INSERT INTO session_input_runtime(session_key, revision, updated_at_ms)
+    VALUES (?, 0, ?) ON CONFLICT(session_key) DO NOTHING`).run(sessionKey, Date.now());
+}
+function bumpRevision(db, sessionKey) {
+	ensureRuntime(db, sessionKey);
+	db.prepare(`UPDATE session_input_runtime SET revision = revision + 1, updated_at_ms = ?
+    WHERE session_key = ?`).run(Date.now(), sessionKey);
+	return db.prepare(`SELECT revision FROM session_input_runtime WHERE session_key = ?`).get(sessionKey).revision;
+}
+function getSessionInputState(sessionKey) {
+	const db = getSqliteDatabase();
+	const runtime = db.prepare(`SELECT revision, active_run_id, active_input_id
+    FROM session_input_runtime WHERE session_key = ?`).get(sessionKey);
+	const rows = db.prepare(`${SELECT_INPUTS} WHERE session_key = ? AND status IN
+    ('queued','running','injecting','interrupted') ORDER BY position, created_at_ms, id`).all(sessionKey);
+	return {
+		sessionKey,
+		revision: runtime?.revision ?? 0,
+		activeRunId: runtime?.active_run_id ?? void 0,
+		activeInputId: runtime?.active_input_id ?? void 0,
+		inputs: rows.map(mapInput)
+	};
+}
+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;
+}
+function insertSessionInput(input) {
+	return runSqliteWriteTransaction((db) => {
+		const existing = db.prepare(`${SELECT_INPUTS} WHERE session_key = ? AND client_message_id = ?`).get(input.sessionKey, input.clientMessageId);
+		if (existing) return mapInput(existing);
+		const now = Date.now();
+		const max = db.prepare(`SELECT COALESCE(MAX(position), 0) AS value FROM session_inputs
+      WHERE session_key = ? AND status IN ('queued','running','injecting','interrupted')`).get(input.sessionKey);
+		db.prepare(`INSERT INTO session_inputs(id, session_key, client_message_id,
+      requested_delivery, effective_delivery, status, content, attachments_json,
+      thinking, position, target_run_id, version, created_at_ms, updated_at_ms)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`).run(input.id, input.sessionKey, input.clientMessageId, input.requestedDelivery, input.effectiveDelivery, input.status, input.content, input.attachments ? JSON.stringify(input.attachments) : null, input.thinking ?? null, max.value + 1, input.targetRunId ?? null, now, now);
+		bumpRevision(db, input.sessionKey);
+		return mapInput(db.prepare(`${SELECT_INPUTS} WHERE id = ?`).get(input.id));
+	});
+}
+function claimNextSessionInput(sessionKey, runId) {
+	return runSqliteWriteTransaction((db) => {
+		ensureRuntime(db, sessionKey);
+		if (db.prepare(`SELECT active_run_id FROM session_input_runtime WHERE session_key = ?`).get(sessionKey).active_run_id) return void 0;
+		const row = db.prepare(`${SELECT_INPUTS} WHERE session_key = ? AND effective_delivery = 'next'
+      AND status = 'queued' ORDER BY position, created_at_ms, id LIMIT 1`).get(sessionKey);
+		if (!row) return void 0;
+		const now = Date.now();
+		db.prepare(`UPDATE session_inputs SET status = 'running', run_id = ?, version = version + 1,
+      updated_at_ms = ? WHERE id = ?`).run(runId, now, row.id);
+		db.prepare(`UPDATE session_input_runtime SET active_run_id = ?, active_input_id = ?,
+      revision = revision + 1, updated_at_ms = ? WHERE session_key = ?`).run(runId, row.id, now, sessionKey);
+		return mapInput(db.prepare(`${SELECT_INPUTS} WHERE id = ?`).get(row.id));
+	});
+}
+function finishSessionInputRun(sessionKey, runId, status, error) {
+	return runSqliteWriteTransaction((db) => {
+		const runtime = db.prepare(`SELECT active_input_id, active_run_id FROM session_input_runtime WHERE session_key = ?`).get(sessionKey);
+		if (!runtime || runtime.active_run_id !== runId) return false;
+		const now = Date.now();
+		if (runtime.active_input_id) db.prepare(`UPDATE session_inputs SET status = ?, error = ?,
+      version = version + 1, updated_at_ms = ? WHERE id = ?`).run(status, error ?? null, now, runtime.active_input_id);
+		db.prepare(`UPDATE session_inputs SET status = ?, error = ?, version = version + 1,
+      updated_at_ms = ? WHERE session_key = ? AND target_run_id = ? AND status = 'injecting'`).run(status === "completed" ? "completed" : "interrupted", status === "completed" ? null : "Current reply ended before steer delivery was confirmed", now, sessionKey, runId);
+		db.prepare(`UPDATE session_input_runtime SET active_run_id = NULL, active_input_id = NULL,
+      revision = revision + 1, updated_at_ms = ?
+      WHERE session_key = ?`).run(now, sessionKey);
+		return true;
+	});
+}
+function setSessionInputStatus(id, status, patch) {
+	return runSqliteWriteTransaction((db) => {
+		const row = db.prepare(`${SELECT_INPUTS} WHERE id = ?`).get(id);
+		if (!row) return false;
+		db.prepare(`UPDATE session_inputs SET status = ?, effective_delivery = ?, target_run_id = ?,
+      error = ?, version = version + 1, updated_at_ms = ? WHERE id = ?`).run(status, patch?.effectiveDelivery ?? row.effective_delivery, patch?.targetRunId !== void 0 ? patch.targetRunId : row.target_run_id, patch?.error ?? row.error, Date.now(), id);
+		bumpRevision(db, row.session_key);
+		return true;
+	});
+}
+function mutateQueuedSessionInput(input) {
+	return runSqliteWriteTransaction((db) => {
+		const row = db.prepare(`${SELECT_INPUTS} WHERE id = ? AND session_key = ?`).get(input.id, input.sessionKey);
+		if (!row || row.status !== "queued" || row.version !== input.version) return false;
+		const now = Date.now();
+		if (input.position !== void 0) {
+			const ordered = db.prepare(`${SELECT_INPUTS} WHERE session_key = ? AND status = 'queued' ORDER BY position, created_at_ms, id`).all(input.sessionKey).filter((item) => item.id !== input.id);
+			ordered.splice(Math.max(0, Math.min(input.position, ordered.length)), 0, row);
+			const stmt = db.prepare(`UPDATE session_inputs SET position = ?, version = version + 1, updated_at_ms = ? WHERE id = ?`);
+			ordered.forEach((item, index) => stmt.run(index + 1, now, item.id));
+		} else db.prepare(`UPDATE session_inputs SET content = ?, attachments_json = ?, thinking = ?, version = version + 1,
+        updated_at_ms = ? WHERE id = ?`).run(input.content ?? row.content, input.attachments ? JSON.stringify(input.attachments) : row.attachments_json, input.thinking ?? row.thinking, now, input.id);
+		bumpRevision(db, input.sessionKey);
+		return true;
+	});
+}
+function cancelQueuedSessionInput(sessionKey, id, version) {
+	return runSqliteWriteTransaction((db) => {
+		const result = db.prepare(`UPDATE session_inputs SET status = 'cancelled', version = version + 1,
+      updated_at_ms = ? WHERE id = ? AND session_key = ? AND version = ? AND status IN ('queued','interrupted')`).run(Date.now(), id, sessionKey, version);
+		if (Number(result.changes) === 0) return false;
+		bumpRevision(db, sessionKey);
+		return true;
+	});
+}
+function recoverSessionInputState() {
+	return runSqliteWriteTransaction((db) => {
+		const keys = db.prepare(`SELECT DISTINCT session_key FROM session_inputs WHERE status IN ('queued','running','injecting')`).all();
+		const now = Date.now();
+		db.prepare(`UPDATE session_inputs SET status = 'interrupted', error = 'Gateway restarted during delivery',
+      version = version + 1, updated_at_ms = ? WHERE status IN ('running','injecting')`).run(now);
+		db.prepare(`UPDATE session_input_runtime SET active_run_id = NULL, active_input_id = NULL,
+      revision = revision + 1, updated_at_ms = ?`).run(now);
+		return keys.map((row) => row.session_key);
+	});
+}
+//#endregion
+export { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputState, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus };

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

@@ -11,7 +11,7 @@ const SESSION_COLUMNS = `
   s.source_channel, s.source_chat_id, s.session_type, s.hidden_from_session_list,
   s.parent_session_key, s.workflow_run_id, s.workflow_definition_id, s.workflow_agent_id, s.workflow_agent_label,
   s.project_id, s.routing_json, s.custom_data_json,
-  s.abort_cutoff_timestamp, s.message_count, s.estimated_tokens, s.compacted_count,
+  s.message_count, s.estimated_tokens, s.compacted_count,
   s.last_flushed_at, s.flush_count,
   s.thinking_level, s.verbose_level,
   t.cwd AS cwd
@@ -32,18 +32,18 @@ function insertSessionAndTranscript(db, sessionKey, sessionId, cwd, metadata) {
       source_channel, source_chat_id, session_type, hidden_from_session_list,
       parent_session_key, workflow_run_id, workflow_definition_id, workflow_agent_id, workflow_agent_label,
       project_id, routing_json, custom_data_json,
-      abort_cutoff_timestamp, message_count, estimated_tokens, compacted_count,
+      message_count, estimated_tokens, compacted_count,
       last_flushed_at, flush_count,
       thinking_level, verbose_level
     ) VALUES (
-      ?, ?, ?, ?, ?, ?,
+      ?, ?, ?, ?, ?,
       ?, ?, ?, ?, ?,
       ?, ?, ?, ?,
       ?, ?, ?, ?, ?,
       ?, ?, ?,
       ?, ?, ?, ?, ?, ?,
       ?, ?
-    )`).run(row.sessionKey, row.agentId, row.sessionId, row.status, row.name, row.tagsJson, row.createdAt, row.updatedAt, row.lastAccessedAt, row.sessionStartedAt, row.lastInteractionAt, row.sourceChannel, row.sourceChatId, row.sessionType, row.hiddenFromSessionList, row.parentSessionKey, row.workflowRunId, row.workflowDefinitionId, row.workflowAgentId, row.workflowAgentLabel, row.projectId, row.routingJson, row.customDataJson, row.abortCutoffTimestamp, row.messageCount, row.estimatedTokens, row.compactedCount, row.lastFlushedAt, row.flushCount, row.thinkingLevel, row.verboseLevel);
+    )`).run(row.sessionKey, row.agentId, row.sessionId, row.status, row.name, row.tagsJson, row.createdAt, row.updatedAt, row.lastAccessedAt, row.sessionStartedAt, row.lastInteractionAt, row.sourceChannel, row.sourceChatId, row.sessionType, row.hiddenFromSessionList, row.parentSessionKey, row.workflowRunId, row.workflowDefinitionId, row.workflowAgentId, row.workflowAgentLabel, row.projectId, row.routingJson, row.customDataJson, row.messageCount, row.estimatedTokens, row.compactedCount, row.lastFlushedAt, row.flushCount, row.thinkingLevel, row.verboseLevel);
 	const now = Date.now();
 	db.prepare(`INSERT INTO transcripts (session_id, session_key, status, created_at, cwd)
      VALUES (?, ?, 'active', ?, ?)`).run(sessionId, sessionKey, now, cwd);
@@ -204,7 +204,6 @@ function patchSessionMetadata(sessionKey, updates) {
         project_id = ?,
         routing_json = ?,
         custom_data_json = ?,
-        abort_cutoff_timestamp = ?,
         message_count = ?,
         estimated_tokens = ?,
         compacted_count = ?,
@@ -212,7 +211,7 @@ function patchSessionMetadata(sessionKey, updates) {
         flush_count = ?,
         thinking_level = ?,
         verbose_level = ?
-      WHERE session_key = ?`).run(merged.status, merged.name ?? null, JSON.stringify(merged.tags ?? []), Date.parse(merged.updatedAt) || now, Date.parse(merged.lastAccessedAt) || now, merged.sessionStartedAt ? Date.parse(merged.sessionStartedAt) : existing.session_started_at, merged.lastInteractionAt ? Date.parse(merged.lastInteractionAt) : existing.last_interaction_at, merged.sourceChannel, merged.sourceChatId, merged.sessionType, merged.hiddenFromSessionList ? 1 : 0, merged.parentSessionKey ?? null, merged.workflowRunId ?? null, merged.workflowDefinitionId ?? null, merged.workflowAgentId ?? null, merged.workflowAgentLabel ?? null, merged.projectId ?? null, merged.routing ? JSON.stringify(merged.routing) : null, merged.customData ? JSON.stringify(merged.customData) : null, merged.abortCutoffTimestamp ?? null, merged.messageCount, merged.estimatedTokens, merged.compactedCount, merged.lastFlushedAt ?? null, merged.flushCount ?? 0, existing.thinking_level, existing.verbose_level, sessionKey);
+      WHERE session_key = ?`).run(merged.status, merged.name ?? null, JSON.stringify(merged.tags ?? []), Date.parse(merged.updatedAt) || now, Date.parse(merged.lastAccessedAt) || now, merged.sessionStartedAt ? Date.parse(merged.sessionStartedAt) : existing.session_started_at, merged.lastInteractionAt ? Date.parse(merged.lastInteractionAt) : existing.last_interaction_at, merged.sourceChannel, merged.sourceChatId, merged.sessionType, merged.hiddenFromSessionList ? 1 : 0, merged.parentSessionKey ?? null, merged.workflowRunId ?? null, merged.workflowDefinitionId ?? null, merged.workflowAgentId ?? null, merged.workflowAgentLabel ?? null, merged.projectId ?? null, merged.routing ? JSON.stringify(merged.routing) : null, merged.customData ? JSON.stringify(merged.customData) : null, merged.messageCount, merged.estimatedTokens, merged.compactedCount, merged.lastFlushedAt ?? null, merged.flushCount ?? 0, existing.thinking_level, existing.verbose_level, sessionKey);
 		const row = readSessionRow(db, sessionKey);
 		if (!row) throw new Error(`Session not found after patch: ${sessionKey}`);
 		return sessionRowToMetadata(sessionKey, row);

package/dist/src/{work → tasks}/attention-governor.d.ts

@@ -1,7 +1,7 @@
-import type { WorkHomeAttention, WorkHomeDecision } from '@xopcai/gateway-contract';
+import type { HomeAttention, HomeDecision } from '@xopcai/gateway-contract';
 export interface AttentionProjection {
-    decisions: WorkHomeDecision[];
-    attention: WorkHomeAttention[];
+    decisions: HomeDecision[];
+    attention: HomeAttention[];
     policy: {
         visibleDecisionCount: number;
         suppressedDecisionCount: number;
@@ -11,8 +11,8 @@ export interface AttentionProjection {
 }
 export declare class AttentionGovernor {
     project(input: {
-        decisions: WorkHomeDecision[];
-        attention: WorkHomeAttention[];
+        decisions: HomeDecision[];
+        attention: HomeAttention[];
         proactiveEnabled: boolean;
         maxDecisions?: number;
         maxAttention?: number;

package/dist/src/{work → tasks}/attention-governor.js

@@ -1,9 +1,8 @@
-//#region src/work/attention-governor.ts
+//#region src/tasks/attention-governor.ts
 function decisionScore(item) {
 	if (item.reason === "approval_required") return 100;
-	if (item.reason === "needs_input") return 95;
-	if (item.reason === "blocked") return 85;
-	if (item.reason === "in_review") return 80;
+	if (item.reason === "needs_input" || item.reason === "user_input" || item.reason === "user_approval") return 95;
+	if (item.reason === "blocked" || item.reason === "dependency" || item.reason === "external") return 85;
 	if (item.kind === "agent_judgment") return Math.round((item.judgment?.valueScore ?? 0) * 70) + (item.urgency === "now" ? 20 : 0);
 	if (item.reason === "overdue") return 70;
 	return 50;

package/dist/src/tasks/execution-context.d.ts

@@ -0,0 +1,23 @@
+import type { SessionMetadata } from '../session/types.js';
+export type ExecutionOrigin = 'chat' | 'task' | 'workflow' | 'automation' | 'browser' | 'proactive';
+export type ExecutionTrigger = 'user' | 'schedule' | 'webhook' | 'proactive' | 'retry';
+export interface ExecutionContext {
+    runId: string;
+    sessionKey: string;
+    channel: string;
+    agentId?: string;
+    strategy?: string;
+    taskId?: string;
+    projectId?: string;
+    origin: ExecutionOrigin;
+    triggerKind: ExecutionTrigger;
+    parentRunId?: string;
+    contextTraceId?: string;
+}
+export declare function resolveExecutionContext(input: {
+    runId: string;
+    sessionKey: string;
+    channel: string;
+    metadata: SessionMetadata;
+    agentId?: string;
+}): ExecutionContext;

package/dist/src/{work → tasks}/execution-context.js

@@ -1,7 +1,7 @@
-//#region src/work/execution-context.ts
+//#region src/tasks/execution-context.ts
 const ORIGINS = new Set([
 	"chat",
-	"goal",
+	"task",
 	"workflow",
 	"automation",
 	"browser",
@@ -20,7 +20,7 @@ function optionalString(value) {
 function metadataOrigin(metadata) {
 	const explicit = optionalString(metadata.customData?.origin);
 	if (explicit && ORIGINS.has(explicit)) return explicit;
-	if (optionalString(metadata.customData?.goalId)) return "goal";
+	if (optionalString(metadata.customData?.taskId)) return "task";
 	if (metadata.sessionType === "workflow-run" || metadata.sessionType === "workflow-subagent") return "workflow";
 	if (metadata.sessionType === "cron") return "automation";
 	if (metadata.sessionType === "heartbeat") return "proactive";
@@ -41,26 +41,13 @@ function resolveExecutionContext(input) {
 		channel: input.channel,
 		agentId: input.agentId,
 		projectId: input.metadata.projectId,
-		outcomeId: optionalString(input.metadata.customData?.outcomeId),
-		goalId: optionalString(input.metadata.customData?.goalId),
-		workItemId: optionalString(input.metadata.customData?.workItemId),
+		taskId: optionalString(input.metadata.customData?.taskId),
 		origin: metadataOrigin(input.metadata),
 		triggerKind: metadataTrigger(input.metadata),
 		parentRunId: optionalString(input.metadata.customData?.parentRunId),
-		contextTraceId: optionalString(input.metadata.customData?.contextTraceId)
-	};
-}
-function executionReceiptContext(context) {
-	return {
-		outcomeId: context.outcomeId,
-		projectId: context.projectId,
-		goalId: context.goalId,
-		workItemId: context.workItemId,
-		origin: context.origin,
-		triggerKind: context.triggerKind,
-		parentRunId: context.parentRunId,
-		contextTraceId: context.contextTraceId
+		contextTraceId: optionalString(input.metadata.customData?.contextTraceId),
+		strategy: optionalString(input.metadata.customData?.strategy)
 	};
 }
 //#endregion
-export { executionReceiptContext, resolveExecutionContext };
+export { resolveExecutionContext };

package/dist/src/{work → tasks}/home-query-service.d.ts

@@ -1,10 +1,17 @@
-import type { WorkHomeResponse } from '@xopcai/gateway-contract';
-import type { GatewayService } from '../gateway/service.js';
+import type { HomeResponse } from '@xopcai/gateway-contract';
 import { type AutomationRun } from '../automations/index.js';
-type HomeDecision = WorkHomeResponse['decisions'][number];
-type HomeAttention = WorkHomeResponse['attention'][number];
-type HomeBriefingWin = WorkHomeResponse['briefing']['wins'][number];
-type HomeAutomation = WorkHomeResponse['upcomingAutomations'][number];
+import type { AutomationService } from '../automations/service/automation-service.js';
+import type { Config } from '../config/schema.js';
+import type { NotesService } from '../notes/service.js';
+import type { ProactiveInboxService } from '../proactive/inbox/service.js';
+import type { ProjectService } from '../projects/project-service.js';
+import type { SessionIndex } from '../session/manager.js';
+import type { WorkflowRunService } from '../workflows/service/workflow-run-service.js';
+import { type TaskReadModel } from './task-read-model-projector.js';
+type HomeDecision = HomeResponse['decisions'][number];
+type HomeAttention = HomeResponse['attention'][number];
+type HomeBriefingWin = HomeResponse['briefing']['wins'][number];
+type HomeAutomation = HomeResponse['upcomingAutomations'][number];
 type HomeAutomationRun = {
     id: string;
     automationId: string;
@@ -18,7 +25,7 @@ type HomeAutomationRun = {
     sessionKey?: string;
     workflowRunId?: string;
 };
-type HomeSnapshot = WorkHomeResponse & {
+type HomeSnapshot = HomeResponse & {
     recentlyOpened: unknown[];
     inboxCount: number;
     pendingTasks: unknown[];
@@ -32,19 +39,34 @@ type HomeSnapshot = WorkHomeResponse & {
     gateway: Record<string, unknown>;
     recentAutomationRuns: HomeAutomationRun[];
 };
-export declare function workItemAttentionRank(item: {
-    status: string;
-    dueAt?: number;
-    priority: string;
-    updatedAt: number;
-}, nowMs: number): number;
+interface HomeGatewayPort {
+    readonly notesServiceInstance: NotesService;
+    readonly sessions: Pick<SessionIndex, 'listSessions'> & {
+        getActiveRun(sessionKey: string): {
+            active: boolean;
+            runId?: string;
+        };
+    };
+    readonly currentConfig: Config;
+    readonly automationServiceInstance: AutomationService;
+    readonly projects: ProjectService;
+    readonly proactiveInbox: ProactiveInboxService;
+    createWorkflowRunService(): WorkflowRunService;
+    getHealth(): {
+        status: string;
+        ready: boolean;
+        httpListening: boolean;
+        version: string;
+        uptime: number;
+    };
+}
+export declare function decisionFromTask(model: TaskReadModel, projectName?: string): HomeDecision | null;
 export declare function buildHomeBriefing(input: {
     locale?: string;
     decisions: HomeDecision[];
     attention: HomeAttention[];
-    activeWorkCount: number;
     activeWorkflowCount: number;
-    activeGoalCount: number;
+    activeTaskCount: number;
     wins: HomeBriefingWin[];
     nextScheduled?: HomeAutomation;
     nowMs: number;
@@ -53,9 +75,9 @@ export declare function buildHomeBriefing(input: {
     summary: string;
     focus: {
         id: string;
-        kind: "work_item" | "goal" | "agent_judgment" | "connector_approval" | "goal_evidence";
+        kind: "task" | "agent_judgment" | "connector_approval";
         title: string;
-        reason: "approval_required" | "blocked" | "needs_input" | "in_review" | "overdue" | "due_soon" | "decision_needed";
+        reason: "paused" | "external" | "blocked" | "dependency" | "user_input" | "approval_required" | "overdue" | "needs_input" | "user_approval" | "scheduled" | "retry" | "due_soon" | "decision_needed";
         urgency: "now" | "soon";
         href: string;
         updatedAt: number;
@@ -82,21 +104,16 @@ export declare function buildHomeBriefing(input: {
         response?: {
             kind: "connector_approval";
             approvalId: string;
-        } | {
-            kind: "goal_evidence";
-            goalId: string;
-            requirementId: string;
         };
     }[];
     progress: {
-        activeWorkCount: number;
         activeWorkflowCount: number;
-        activeGoalCount: number;
+        activeTaskCount: number;
         movingCount: number;
     };
     wins: {
         id: string;
-        kind: "work_item" | "workflow_run" | "automation_run";
+        kind: "task" | "workflow_run" | "automation_run";
         title: string;
         href: string;
         completedAt: number;
@@ -109,10 +126,10 @@ export declare function buildHomeBriefing(input: {
         name?: string;
     };
 };
-export declare class WorkHomeQueryService {
+export declare class HomeQueryService {
     #private;
     private readonly service;
-    constructor(service: GatewayService);
+    constructor(service: HomeGatewayPort);
     getSnapshot(locale?: string): Promise<HomeSnapshot>;
 }
 export {};