@xopcai/xopc 0.0.188 → 0.0.190

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

@@ -0,0 +1,383 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
+import { randomUUID } from "node:crypto";
+//#region src/storage/sqlite/user-context-repository.ts
+const UNDERSTANDING_SELECT = `
+  SELECT u.*, v.statement, v.payload_json
+  FROM user_understandings u
+  JOIN user_understanding_versions v ON v.version_id = u.current_version_id
+`;
+function scopeFromRow(type, id) {
+	return id ? {
+		type,
+		id
+	} : { type };
+}
+function understandingFromRow(row) {
+	return {
+		id: row.understanding_id,
+		kind: row.kind,
+		canonicalKey: row.canonical_key,
+		status: row.status,
+		scope: scopeFromRow(row.scope_type, row.scope_id),
+		explicitness: row.explicitness,
+		durability: row.durability,
+		sensitivity: row.sensitivity,
+		disclosurePolicy: row.disclosure_policy,
+		confidence: row.confidence,
+		statement: row.statement,
+		payload: JSON.parse(row.payload_json),
+		versionId: row.current_version_id,
+		...row.valid_from === null ? {} : { validFrom: row.valid_from },
+		...row.valid_to === null ? {} : { validTo: row.valid_to },
+		...row.expires_at === null ? {} : { expiresAt: row.expires_at },
+		...row.review_at === null ? {} : { reviewAt: row.review_at },
+		...row.conflict_group_id ? { conflictGroupId: row.conflict_group_id } : {},
+		...row.supersedes_id ? { supersedesId: row.supersedes_id } : {},
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function ruleFromRow(row) {
+	return {
+		id: row.rule_id,
+		category: row.category,
+		status: row.status,
+		priority: row.priority,
+		scope: scopeFromRow(row.scope_type, row.scope_id),
+		conditions: JSON.parse(row.conditions_json),
+		statement: row.statement,
+		revisionId: row.current_revision_id,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function getUserProfile(principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM user_profiles WHERE principal_id = ?").get(principalId);
+	if (!row) return {
+		callName: "",
+		role: "",
+		primaryGoal: "",
+		pronouns: "",
+		timezone: "",
+		locale: "",
+		accessibility: {},
+		createdAt: 0,
+		updatedAt: 0
+	};
+	return {
+		callName: row.call_name,
+		role: row.role,
+		primaryGoal: row.primary_goal,
+		pronouns: row.pronouns,
+		timezone: row.timezone,
+		locale: row.locale,
+		accessibility: JSON.parse(row.accessibility_json),
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function updateUserProfile(patch, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const current = getUserProfile(principalId);
+	const now = Date.now();
+	const next = {
+		...current,
+		...patch,
+		createdAt: current.createdAt || now,
+		updatedAt: now
+	};
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`
+      INSERT INTO user_profiles (
+        principal_id, call_name, role, primary_goal, pronouns, timezone, locale, accessibility_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(principal_id) DO UPDATE SET
+        call_name = excluded.call_name,
+        role = excluded.role,
+        primary_goal = excluded.primary_goal,
+        pronouns = excluded.pronouns,
+        timezone = excluded.timezone,
+        locale = excluded.locale,
+        accessibility_json = excluded.accessibility_json,
+        updated_at = excluded.updated_at
+    `).run(principalId, next.callName, next.role, next.primaryGoal, next.pronouns, next.timezone, next.locale, JSON.stringify(next.accessibility), next.createdAt, next.updatedAt);
+	});
+	return next;
+}
+function createUnderstanding(input, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const id = randomUUID();
+	const versionId = randomUUID();
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO user_understandings (
+      understanding_id, principal_id, kind, canonical_key, status, scope_type, scope_id,
+      explicitness, durability, sensitivity, disclosure_policy, confidence, valid_from,
+      valid_to, expires_at, review_at, current_version_id, conflict_group_id, supersedes_id,
+      created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, principalId, input.kind, input.canonicalKey, input.status, input.scope.type, input.scope.id ?? null, input.explicitness, input.durability, input.sensitivity, input.disclosurePolicy, input.confidence, input.validFrom ?? null, input.validTo ?? null, input.expiresAt ?? null, input.reviewAt ?? null, versionId, input.conflictGroupId ?? null, input.supersedesId ?? null, now, now);
+		db.prepare(`INSERT INTO user_understanding_versions (
+      version_id, understanding_id, statement, payload_json, created_by, change_reason, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(versionId, id, input.statement.trim(), JSON.stringify(input.payload ?? {}), input.createdBy, input.changeReason, now);
+		db.prepare("INSERT INTO user_understanding_fts (statement, understanding_id, version_id) VALUES (?, ?, ?)").run(input.statement.trim(), id, versionId);
+	});
+	return getUnderstanding(id);
+}
+function getUnderstanding(id) {
+	const row = getSqliteDatabase().prepare(`${UNDERSTANDING_SELECT} WHERE u.understanding_id = ?`).get(id);
+	return row ? understandingFromRow(row) : void 0;
+}
+function listUnderstandings(statuses, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const db = getSqliteDatabase();
+	if (!statuses?.length) return db.prepare(`${UNDERSTANDING_SELECT} WHERE u.principal_id = ? ORDER BY u.updated_at DESC`).all(principalId).map(understandingFromRow);
+	const placeholders = statuses.map(() => "?").join(", ");
+	return db.prepare(`${UNDERSTANDING_SELECT} WHERE u.principal_id = ? AND u.status IN (${placeholders}) ORDER BY u.updated_at DESC`).all(principalId, ...statuses).map(understandingFromRow);
+}
+function reviseUnderstanding(id, statement, options) {
+	const current = getUnderstanding(id);
+	if (!current) throw new Error(`User understanding not found: ${id}`);
+	const versionId = randomUUID();
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO user_understanding_versions (
+      version_id, understanding_id, statement, payload_json, created_by, change_reason, created_at
+    ) VALUES (?, ?, ?, ?, 'user', ?, ?)`).run(versionId, id, statement.trim(), JSON.stringify(options.payload ?? current.payload), options.changeReason, now);
+		db.prepare(`UPDATE user_understandings
+      SET current_version_id = ?, canonical_key = ?, explicitness = ?, confidence = ?, updated_at = ?
+      WHERE understanding_id = ?`).run(versionId, options.canonicalKey ?? current.canonicalKey, options.explicitness ?? current.explicitness, options.confidence ?? current.confidence, now, id);
+		db.prepare("DELETE FROM user_understanding_fts WHERE understanding_id = ?").run(id);
+		db.prepare("INSERT INTO user_understanding_fts (statement, understanding_id, version_id) VALUES (?, ?, ?)").run(statement.trim(), id, versionId);
+	});
+	return getUnderstanding(id);
+}
+function setUnderstandingStatus(id, status, confirmation) {
+	const now = Date.now();
+	getSqliteDatabase().prepare(`UPDATE user_understandings
+    SET status = ?,
+        explicitness = COALESCE(?, explicitness),
+        confidence = COALESCE(?, confidence),
+        updated_at = ?
+    WHERE understanding_id = ?`).run(status, confirmation?.explicitness ?? null, confirmation?.confidence ?? null, now, id);
+	const result = getUnderstanding(id);
+	if (!result) throw new Error(`User understanding not found: ${id}`);
+	return result;
+}
+function rejectUnderstanding(id, reason) {
+	const current = getUnderstanding(id);
+	if (!current) throw new Error(`User understanding not found: ${id}`);
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare("UPDATE user_understandings SET status = 'rejected', updated_at = ? WHERE understanding_id = ?").run(now, id);
+		db.prepare(`INSERT INTO context_suppressions (
+      suppression_id, principal_id, canonical_key, scope_type, scope_id, reason, expires_at, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, NULL, ?)
+    ON CONFLICT DO UPDATE SET reason = excluded.reason, expires_at = NULL`).run(randomUUID(), USER_CONTEXT_PRINCIPAL_ID, current.canonicalKey, current.scope.type, current.scope.id ?? null, reason, now);
+	});
+	return getUnderstanding(id);
+}
+function deleteUnderstanding(id) {
+	return runSqliteWriteTransaction((db) => {
+		db.prepare("DELETE FROM user_understanding_fts WHERE understanding_id = ?").run(id);
+		return Number(db.prepare("DELETE FROM user_understandings WHERE understanding_id = ?").run(id).changes) > 0;
+	});
+}
+function isUnderstandingSuppressed(canonicalKey, scope, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const row = getSqliteDatabase().prepare(`SELECT 1 FROM context_suppressions
+    WHERE principal_id = ? AND canonical_key = ? AND scope_type = ?
+      AND COALESCE(scope_id, '') = COALESCE(?, '')
+      AND (expires_at IS NULL OR expires_at > ?)`).get(principalId, canonicalKey, scope.type, scope.id ?? null, Date.now());
+	return Boolean(row);
+}
+function createCollaborationRule(input, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const id = randomUUID();
+	const revisionId = randomUUID();
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO collaboration_rules (
+      rule_id, principal_id, category, status, priority, scope_type, scope_id,
+      conditions_json, current_revision_id, created_at, updated_at
+    ) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?)`).run(id, principalId, input.category, input.priority, input.scope.type, input.scope.id ?? null, JSON.stringify(input.conditions), revisionId, now, now);
+		db.prepare(`INSERT INTO collaboration_rule_revisions (
+      revision_id, rule_id, statement, created_by, created_at
+    ) VALUES (?, ?, ?, 'user', ?)`).run(revisionId, id, input.statement.trim(), now);
+	});
+	return getCollaborationRule(id);
+}
+function getCollaborationRule(id) {
+	const row = getSqliteDatabase().prepare(`SELECT r.*, v.statement FROM collaboration_rules r
+    JOIN collaboration_rule_revisions v ON v.revision_id = r.current_revision_id
+    WHERE r.rule_id = ?`).get(id);
+	return row ? ruleFromRow(row) : void 0;
+}
+function listCollaborationRules(principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	return getSqliteDatabase().prepare(`SELECT r.*, v.statement FROM collaboration_rules r
+    JOIN collaboration_rule_revisions v ON v.revision_id = r.current_revision_id
+    WHERE r.principal_id = ? ORDER BY r.priority ASC, r.updated_at DESC`).all(principalId).map(ruleFromRow);
+}
+function reviseCollaborationRule(id, statement) {
+	if (!getCollaborationRule(id)) throw new Error(`Collaboration rule not found: ${id}`);
+	const revisionId = randomUUID();
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO collaboration_rule_revisions (
+      revision_id, rule_id, statement, created_by, created_at
+    ) VALUES (?, ?, ?, 'user', ?)`).run(revisionId, id, statement.trim(), now);
+		db.prepare("UPDATE collaboration_rules SET current_revision_id = ?, updated_at = ? WHERE rule_id = ?").run(revisionId, now, id);
+	});
+	return getCollaborationRule(id);
+}
+function setCollaborationRuleStatus(id, status) {
+	getSqliteDatabase().prepare("UPDATE collaboration_rules SET status = ?, updated_at = ? WHERE rule_id = ?").run(status, Date.now(), id);
+	const result = getCollaborationRule(id);
+	if (!result) throw new Error(`Collaboration rule not found: ${id}`);
+	return result;
+}
+function deleteCollaborationRule(id) {
+	return Number(getSqliteDatabase().prepare("DELETE FROM collaboration_rules WHERE rule_id = ?").run(id).changes) > 0;
+}
+function createContextEvidence(input, principalId = USER_CONTEXT_PRINCIPAL_ID) {
+	const existing = getSqliteDatabase().prepare(`SELECT * FROM context_evidence
+    WHERE principal_id = ? AND source_type = ?
+      AND COALESCE(source_instance_id, '') = COALESCE(?, '') AND source_ref = ?`).get(principalId, input.sourceType, input.sourceInstanceId ?? null, input.sourceRef);
+	if (existing) return {
+		id: existing.evidence_id,
+		sourceType: existing.source_type,
+		...existing.source_instance_id ? { sourceInstanceId: existing.source_instance_id } : {},
+		sourceRef: existing.source_ref,
+		...existing.redacted_excerpt ? { redactedExcerpt: existing.redacted_excerpt } : {},
+		trustLevel: existing.trust_level,
+		observedAt: existing.observed_at,
+		createdAt: existing.created_at
+	};
+	const evidence = {
+		...input,
+		id: randomUUID(),
+		createdAt: Date.now()
+	};
+	getSqliteDatabase().prepare(`INSERT INTO context_evidence (
+    evidence_id, principal_id, source_type, source_instance_id, source_ref,
+    redacted_excerpt, trust_level, observed_at, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(evidence.id, principalId, evidence.sourceType, evidence.sourceInstanceId ?? null, evidence.sourceRef, evidence.redactedExcerpt ?? null, evidence.trustLevel, evidence.observedAt, evidence.createdAt);
+	return evidence;
+}
+function linkUnderstandingEvidence(versionId, evidenceId, relation, confidence) {
+	getSqliteDatabase().prepare(`INSERT INTO understanding_evidence_links (
+    version_id, evidence_id, relation, confidence
+  ) VALUES (?, ?, ?, ?)
+  ON CONFLICT(version_id, evidence_id, relation) DO UPDATE SET confidence = excluded.confidence`).run(versionId, evidenceId, relation, confidence);
+}
+function listUnderstandingEvidence(understandingId, relation) {
+	return getSqliteDatabase().prepare(`SELECT DISTINCT e.* FROM context_evidence e
+    JOIN understanding_evidence_links l ON l.evidence_id = e.evidence_id
+    JOIN user_understanding_versions v ON v.version_id = l.version_id
+    WHERE v.understanding_id = ? AND (? IS NULL OR l.relation = ?)
+    ORDER BY e.observed_at DESC`).all(understandingId, relation ?? null, relation ?? null).map((row) => ({
+		id: row.evidence_id,
+		sourceType: row.source_type,
+		...row.source_instance_id ? { sourceInstanceId: row.source_instance_id } : {},
+		sourceRef: row.source_ref,
+		...row.redacted_excerpt ? { redactedExcerpt: row.redacted_excerpt } : {},
+		trustLevel: row.trust_level,
+		observedAt: row.observed_at,
+		createdAt: row.created_at
+	}));
+}
+function recordContextRun(input) {
+	const existing = getSqliteDatabase().prepare("SELECT context_run_id FROM context_runs WHERE turn_id = ?").get(input.turnId);
+	const runId = existing?.context_run_id ?? randomUUID();
+	runSqliteWriteTransaction((db) => {
+		if (existing) {
+			db.prepare(`UPDATE context_runs SET principal_id = ?, session_key = ?, query = ?, budget = ?, duration_ms = ?
+        WHERE context_run_id = ?`).run(input.principalId ?? "local-owner", input.sessionKey, input.query, input.budget, input.durationMs, runId);
+			db.prepare("DELETE FROM context_run_items WHERE context_run_id = ?").run(runId);
+		} else db.prepare(`INSERT INTO context_runs (
+        context_run_id, principal_id, turn_id, session_key, query, budget, duration_ms, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(runId, input.principalId ?? "local-owner", input.turnId, input.sessionKey, input.query, input.budget, input.durationMs, Date.now());
+		const insert = db.prepare(`INSERT INTO context_run_items (
+      context_run_id, object_type, object_id, version_id, decision, reason, content_snapshot,
+      source_label, rank, score, injected_chars
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+		for (const item of input.items) insert.run(runId, item.objectType, item.objectId, item.versionId ?? null, item.decision, item.reason, item.content, item.sourceLabel, item.rank ?? null, item.score ?? null, item.injectedChars);
+	});
+	return runId;
+}
+function getTurnPersonalization(turnId) {
+	const db = getSqliteDatabase();
+	const run = db.prepare("SELECT context_run_id FROM context_runs WHERE turn_id = ?").get(turnId);
+	if (!run) return void 0;
+	const rows = db.prepare("SELECT * FROM context_run_items WHERE context_run_id = ? ORDER BY rank ASC, object_type ASC").all(run.context_run_id);
+	return {
+		runId: run.context_run_id,
+		items: rows.map((row) => ({
+			objectType: row.object_type,
+			objectId: row.object_id,
+			...row.version_id ? { versionId: row.version_id } : {},
+			decision: row.decision,
+			reason: row.reason,
+			content: row.content_snapshot,
+			sourceLabel: row.source_label,
+			...row.rank === null ? {} : { rank: row.rank },
+			...row.score === null ? {} : { score: row.score },
+			injectedChars: row.injected_chars
+		}))
+	};
+}
+function recordContextFeedback(input) {
+	if (Boolean(input.objectType) !== Boolean(input.objectId)) throw new Error("objectType and objectId must be provided together");
+	getSqliteDatabase().prepare(`INSERT INTO context_feedback (
+    feedback_id, turn_id, context_run_id, object_type, object_id, rating, reason, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT DO UPDATE SET rating = excluded.rating, reason = excluded.reason, created_at = excluded.created_at`).run(randomUUID(), input.turnId, input.runId, input.objectType ?? null, input.objectId ?? null, input.rating, input.reason ?? null, Date.now());
+}
+function hasContextConsent(understandingId, sessionKey) {
+	const now = Date.now();
+	return Boolean(getSqliteDatabase().prepare(`SELECT 1 FROM context_consents
+    WHERE understanding_id = ? AND status = 'granted'
+      AND (grant_scope = 'always' OR session_key = ?)
+      AND (expires_at IS NULL OR expires_at > ?)
+    LIMIT 1`).get(understandingId, sessionKey, now));
+}
+function consumeContextConsent(understandingId, sessionKey) {
+	const db = getSqliteDatabase();
+	const now = Date.now();
+	const granted = db.prepare(`SELECT consent_id, grant_scope FROM context_consents
+    WHERE understanding_id = ? AND status = 'granted'
+      AND (grant_scope = 'always' OR session_key = ?)
+      AND (expires_at IS NULL OR expires_at > ?)
+    ORDER BY CASE grant_scope WHEN 'once' THEN 0 WHEN 'session' THEN 1 ELSE 2 END
+    LIMIT 1`).get(understandingId, sessionKey, now);
+	if (granted) {
+		if (granted.grant_scope === "once") db.prepare("UPDATE context_consents SET status = 'consumed', updated_at = ? WHERE consent_id = ?").run(now, granted.consent_id);
+		return "granted";
+	}
+	return db.prepare(`SELECT 1 FROM context_consents
+    WHERE understanding_id = ? AND session_key = ? AND status = 'denied' LIMIT 1`).get(understandingId, sessionKey) ? "denied" : "missing";
+}
+function ensureContextConsent(understandingId, sessionKey, purpose) {
+	const db = getSqliteDatabase();
+	const existing = db.prepare(`SELECT consent_id, purpose FROM context_consents
+    WHERE understanding_id = ? AND session_key = ? AND status = 'pending'`).get(understandingId, sessionKey);
+	if (existing) return {
+		id: existing.consent_id,
+		understandingId,
+		purpose: existing.purpose
+	};
+	const id = randomUUID();
+	const now = Date.now();
+	db.prepare(`INSERT INTO context_consents (
+    consent_id, principal_id, understanding_id, session_key, purpose, status,
+    grant_scope, expires_at, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, 'pending', NULL, NULL, ?, ?)`).run(id, USER_CONTEXT_PRINCIPAL_ID, understandingId, sessionKey, purpose, now, now);
+	return {
+		id,
+		understandingId,
+		purpose
+	};
+}
+function decideContextConsent(id, decision) {
+	const expiresAt = decision === "once" ? Date.now() + 5 * 6e4 : null;
+	const result = getSqliteDatabase().prepare(`UPDATE context_consents
+    SET status = ?, grant_scope = ?, expires_at = ?, updated_at = ? WHERE consent_id = ?`).run(decision === "deny" ? "denied" : "granted", decision === "deny" ? null : decision, expiresAt, Date.now(), id);
+	return Number(result.changes) > 0;
+}
+//#endregion
+export { consumeContextConsent, createCollaborationRule, createContextEvidence, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, linkUnderstandingEvidence, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile };

package/dist/src/tasks/home-query-service.d.ts

@@ -77,7 +77,7 @@ export declare function buildHomeBriefing(input: {
         id: string;
         kind: "task" | "agent_judgment" | "connector_approval";
         title: string;
-        reason: "paused" | "external" | "blocked" | "dependency" | "user_input" | "approval_required" | "overdue" | "needs_input" | "user_approval" | "scheduled" | "retry" | "due_soon" | "decision_needed";
+        reason: "external" | "paused" | "blocked" | "dependency" | "user_input" | "approval_required" | "overdue" | "needs_input" | "user_approval" | "scheduled" | "retry" | "due_soon" | "decision_needed";
         urgency: "now" | "soon";
         href: string;
         updatedAt: number;

package/dist/src/tui/backends/embedded-backend.js

@@ -185,7 +185,7 @@ var EmbeddedBackend = class {
 				this.onEvent?.({
 					event,
 					data: payload,
-					source: "broadcast"
+					source: "embedded"
 				});
 			}
 		};
@@ -311,7 +311,10 @@ var EmbeddedBackend = class {
 		(async () => {
 			try {
 				const messageForAgent = opts.message.trimStart().startsWith("/") ? opts.message : prependEnvelopeTimestamp(opts.message);
-				const stream = agent.turnDispatcher.processDirectStreaming(messageForAgent, opts.sessionKey, opts.attachments, opts.thinking, {
+				const stream = agent.turnDispatcher.processDirectStreaming(messageForAgent, opts.sessionKey, {
+					type: "system",
+					source: "cli"
+				}, opts.attachments, opts.thinking, {
 					signal,
 					runId
 				});

package/dist/src/tui/backends/{gateway-sse-backend.d.ts → gateway-realtime-backend.d.ts}

@@ -4,22 +4,24 @@ import type { ChatSendOptions, HistoryMessage, TuiBackend, TuiCompactionResult,
 import type { SessionInfo } from '../tui-types.js';
 import type { ReviewContext } from '../../review/review-git.js';
 import { type GatewayCredential } from '../../gateway/credential.js';
-interface GatewaySSEOptions {
+interface GatewayRealtimeOptions {
     url: string;
     credential?: GatewayCredential;
 }
-export declare function normalizeGatewaySseEvent(evt: TuiEvent): TuiEvent;
 /**
- * TUI backend that communicates with a running xopc gateway via HTTP + SSE.
+ * TUI backend that communicates with a running xopc gateway via REST + realtime WebSocket.
  *
- * - Agent input: durable session input REST plus resumable run SSE
- * - Broadcast events: `GET /api/events` via long-lived SSE
+ * - Agent input: durable session input REST plus replayable run topics
+ * - Broadcast events: gateway realtime topic
  * - REST calls for sessions, models, etc.
  */
-export declare class GatewaySseBackend implements TuiBackend {
+export declare class GatewayRealtimeBackend implements TuiBackend {
     private readonly baseUrl;
     private readonly credential;
-    private eventAbort;
+    private readonly clientId;
+    private realtime;
+    private activeRunId;
+    private observedSessionKey;
     private chatAbort;
     onEvent?: (evt: TuiEvent) => void;
     onConnected?: () => void;
@@ -28,7 +30,7 @@ export declare class GatewaySseBackend implements TuiBackend {
         expected: number;
         received: number;
     }) => void;
-    constructor(opts: GatewaySSEOptions);
+    constructor(opts: GatewayRealtimeOptions);
     get connectionLabel(): string;
     start(): void;
     stop(): void;
@@ -156,7 +158,8 @@ export declare class GatewaySseBackend implements TuiBackend {
     deleteSession(sessionKey: string): Promise<{
         ok: boolean;
     }>;
-    private startEventStream;
-    private scheduleReconnect;
+    private startRealtime;
+    private handleRealtimeEvent;
+    private unsubscribeActiveRun;
 }
 export {};