@xopcai/xopc 0.0.248 → 0.0.250

package/dist/src/projects/knowledge-bind.js

@@ -0,0 +1,15 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+//#region src/projects/knowledge-bind.ts
+function bindKnowledgeItemToProject(knowledgeId, projectId) {
+	const db = getSqliteDatabase();
+	if (!db.prepare("SELECT 1 FROM projects WHERE project_id = ?").get(projectId)) throw new Error(`Project not found: ${projectId}`);
+	if (!db.prepare("SELECT 1 FROM knowledge_items WHERE knowledge_id = ?").get(knowledgeId)) throw new Error(`Knowledge item not found: ${knowledgeId}`);
+	runSqliteWriteTransaction((tx) => {
+		const now = Date.now();
+		tx.prepare(`UPDATE knowledge_items SET scope_type = 'project', scope_id = ?, updated_at = ?
+      WHERE knowledge_id = ?`).run(projectId, now, knowledgeId);
+		tx.prepare("UPDATE projects SET last_active_at = ?, updated_at = ? WHERE project_id = ?").run(now, now, projectId);
+	});
+}
+//#endregion
+export { bindKnowledgeItemToProject };

package/dist/src/projects/project-loop.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryRecord } from '../agent/memory/types.js';
+import type { KnowledgeItem } from '../knowledge-memory/index.js';
 import type { ProjectWithDetails } from './types.js';
 export type ProjectWorkflowRunBrief = {
     runId: string;
@@ -18,7 +18,7 @@ export type ProjectAttentionItem = {
 };
 export type ProjectTimelineItem = {
     id: string;
-    kind: 'session' | 'task' | 'workflow' | 'memory';
+    kind: 'session' | 'task' | 'workflow' | 'knowledge';
     title: string;
     detail?: string;
     timestamp: number;
@@ -60,7 +60,7 @@ export declare function buildProjectLoopOverview(input: {
     tasks: ProjectTask[];
     recentWorkflowRuns: ProjectWorkflowRunBrief[];
     failedWorkflowRuns?: ProjectWorkflowRunBrief[];
-    memoryRecords?: MemoryRecord[];
+    knowledgeItems?: KnowledgeItem[];
     nowMs?: number;
     staleAfterMs?: number;
 }): ProjectLoopOverview;

package/dist/src/projects/project-loop.js

@@ -78,12 +78,12 @@ function buildProjectLoopOverview(input) {
 			status: run.status,
 			href: `/workflows?run=${encodeURIComponent(run.runId)}`
 		})),
-		...(input.memoryRecords ?? []).slice(0, 5).map((record) => ({
-			id: `memory:${record.id}`,
-			kind: "memory",
+		...(input.knowledgeItems ?? []).slice(0, 5).map((record) => ({
+			id: `knowledge:${record.id}`,
+			kind: "knowledge",
 			title: record.kind,
 			detail: compactText(record.content),
-			timestamp: Date.parse(record.updatedAt),
+			timestamp: record.updatedAt,
 			status: record.status
 		}))
 	].filter((item) => Number.isFinite(item.timestamp)).sort((left, right) => right.timestamp - left.timestamp).slice(0, 12);

package/dist/src/projects/project-service.d.ts

@@ -11,7 +11,8 @@ export type ProjectSuggestion = {
 export declare class ProjectService {
     private readonly store;
     private readonly signals?;
-    constructor(store?: ProjectStore, signals?: ProactiveSignalPublisher);
+    private readonly workspaceId;
+    constructor(store?: ProjectStore, signals?: ProactiveSignalPublisher, workspaceId?: string);
     private listAllProjects;
     create(input: CreateProjectInput): Project;
     get(id: string): Project | null;

package/dist/src/projects/project-service.js

@@ -9,9 +9,10 @@ import { bindSessionToProject, listProjectSessionKeys, unbindSessionFromProject
 import { createHash } from "node:crypto";
 //#region src/projects/project-service.ts
 var ProjectService = class {
-	constructor(store = new ProjectStore(), signals) {
+	constructor(store = new ProjectStore(), signals, workspaceId = "default") {
 		this.store = store;
 		this.signals = signals;
+		this.workspaceId = workspaceId;
 	}
 	listAllProjects() {
 		const items = [];
@@ -199,7 +200,7 @@ var ProjectService = class {
 				},
 				actor: { kind: "system" },
 				scope: {
-					workspaceId: "default",
+					workspaceId: this.workspaceId,
 					projectId: project.id
 				},
 				occurredAt: new Date(project.updatedAt).toISOString(),

package/dist/src/projects/project-store.js

@@ -308,7 +308,8 @@ var ProjectStore = class {
 			db.prepare(`UPDATE tasks SET project_id = NULL WHERE project_id = ?`).run(id);
 			db.prepare(`UPDATE workflow_runs SET project_id = NULL WHERE project_id = ?`).run(id);
 			db.prepare(`UPDATE automations SET project_id = NULL WHERE project_id = ?`).run(id);
-			db.prepare(`UPDATE memory_records SET project_id = NULL WHERE project_id = ?`).run(id);
+			db.prepare(`UPDATE knowledge_items SET status = 'archived', updated_at = ?
+        WHERE scope_type = 'project' AND scope_id = ?`).run(Date.now(), id);
 			db.prepare(`DELETE FROM projects_fts WHERE project_id = ?`).run(id);
 			db.prepare(`DELETE FROM projects WHERE project_id = ?`).run(id);
 		});

package/dist/src/realtime/runtime.js

@@ -30,6 +30,7 @@ function isAuthorizedTopic(topic, scopes) {
 	if (topic === "logs") return hasGatewayScope(scopes, "gateway.admin");
 	if (topic === "sessions" || topic.startsWith("session:")) return hasGatewayScope(scopes, "sessions.read");
 	if (topic.startsWith("run:")) return hasGatewayScope(scopes, "agents.run");
+	if (topic.startsWith("side-chat:")) return hasGatewayScope(scopes, "agents.run");
 	if (topic.startsWith("workflow:")) return hasGatewayScope(scopes, "automations.read");
 	return false;
 }

package/dist/src/runtime-tools/manager.js

@@ -14,8 +14,8 @@ import { bundledPythonArchiveName, resolveOfflineBundleArtifact } from "./offlin
 import { normalizeRuntimeVersionRequest, parseRuntimeVersion, probeSystemRuntime, resolveInstallVersion, versionSatisfies } from "./probe.js";
 import { dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
-import { access, mkdir, realpath, rename, rm } from "node:fs/promises";
 import { EventEmitter } from "node:events";
+import { access, mkdir, realpath, rename, rm } from "node:fs/promises";
 //#region src/runtime-tools/manager.ts
 init_logger();
 const log = createLogger("RuntimeManager");

package/dist/src/session/index.js

@@ -1,5 +1,5 @@
-import { SessionStatus } from "./types.js";
 import { buildSessionContextForLlm, isTranscriptContextEntry, mergeLlmMessagesPreservingContextRows, transcriptRowsFromJsonArray } from "./session-context-for-llm.js";
+import { SessionStatus } from "./types.js";
 import { effectiveWorkspacePathForSession, normalizeWorkingDirectoryInput, projectWorkspacePath } from "./session-workspace.js";
 import { emitSessionTranscriptUpdate, onSessionTranscriptUpdate } from "./transcript-events.js";
 import { fallbackTitleFromMessages, generateSessionTitleFromMessages, getSessionTitleSource, isWebchatSessionKey, maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle, provisionalTitleFromUserText, sanitizeGeneratedSessionTitle, sanitizeSessionTitle, shouldAutoTitleSessionKey, shouldRefineSessionTitleWithLlm } from "./session-title.js";

package/dist/src/session/store.js

@@ -3,8 +3,8 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { requireXopcDatabase } from "../storage/sqlite/connection.js";
 import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import "./types.js";
 import { buildSessionContextForLlm, buildSessionDisplayMessages, isRuntimeOnlyTranscriptMessage, isTranscriptCompactionEntry, mergeLlmMessagesPreservingContextRows, transcriptRowsFromJsonArray } from "./session-context-for-llm.js";
+import "./types.js";
 import { init_agent_session_key, resolveAgentIdFromSessionKey } from "../routing/agent-session-key.js";
 import { estimateTokensFromMessages } from "../storage/sqlite/row-mappers.js";
 import { deleteSessionRecord, ensureSessionRecord, findSessionKeyBySessionId, getGlobalSessionStats, getSessionMetadata, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, resetSessionRecord } from "../storage/sqlite/session-repository.js";
@@ -13,6 +13,7 @@ import { getSessionConfig, setSessionConfig } from "../storage/sqlite/config-rep
 import "../storage/sqlite/index.js";
 import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { SessionCompactor } from "../agent/memory/compaction.js";
+import { resolveUserContextSessionAccess } from "../user-context/access-policy.js";
 import { readPostCompactionContext } from "../agent/reply/post-compaction-context.js";
 import { resolveCompactionPolicy } from "../agent/memory/compaction-policy.js";
 import { promoteCompactionLedger } from "../agent/memory/compaction-promotion.js";
@@ -464,6 +465,7 @@ var SessionStore = class {
 			})) throw new Error(`Session changed while compaction was running: ${key}`);
 			try {
 				const metadata = getSessionMetadata(key);
+				const access = resolveUserContextSessionAccess(this.options.config, key);
 				const promoted = promoteCompactionLedger({
 					sessionKey: key,
 					sessionId: expectedSnapshot.sessionId,
@@ -472,7 +474,8 @@ var SessionStore = class {
 					projectId: metadata?.projectId,
 					handover: result.handover,
 					audit: result.audit,
-					sourceEntries: expectedSnapshot.entries
+					sourceEntries: expectedSnapshot.entries,
+					writePolicy: access.knowledge && this.options.config.userContext.knowledgeMemory.sources.includes("session") ? this.options.config.userContext.knowledgeMemory.writePolicy : "deny"
 				});
 				log.info({
 					sessionKey: key,

package/dist/src/storage/sqlite/collaboration-rule-repository.d.ts

@@ -0,0 +1,19 @@
+import { type UserModelScope } from '../../user-model/domain.js';
+export interface CollaborationRule {
+    id: string;
+    category: 'communication' | 'execution' | 'boundary' | 'routine' | 'proactive';
+    status: 'active' | 'disabled' | 'archived';
+    priority: number;
+    scope: UserModelScope;
+    conditions: Record<string, unknown>;
+    statement: string;
+    revisionId: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export declare function getCollaborationRule(id: string): CollaborationRule | undefined;
+export declare function listCollaborationRules(principalId?: string): CollaborationRule[];
+export declare function createCollaborationRule(input: Pick<CollaborationRule, 'category' | 'priority' | 'scope' | 'conditions' | 'statement'> & {
+    status?: CollaborationRule['status'];
+}): CollaborationRule;
+export declare function setCollaborationRuleStatus(id: string, status: CollaborationRule['status']): CollaborationRule | undefined;

package/dist/src/storage/sqlite/collaboration-rule-repository.js

@@ -0,0 +1,54 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { USER_MODEL_PRINCIPAL_ID } from "../../user-model/domain.js";
+import { randomUUID } from "node:crypto";
+//#region src/storage/sqlite/collaboration-rule-repository.ts
+function fromRow(row) {
+	return {
+		id: row.rule_id,
+		category: row.category,
+		status: row.status,
+		priority: row.priority,
+		scope: {
+			type: row.scope_type,
+			...row.scope_id ? { id: 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 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 ? fromRow(row) : void 0;
+}
+function listCollaborationRules(principalId = USER_MODEL_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, r.updated_at DESC`).all(principalId).map(fromRow);
+}
+function createCollaborationRule(input) {
+	if (!input.statement.trim()) throw new Error("Collaboration rule statement is required.");
+	if (input.scope.type === "agent") throw new Error("Agent-scoped collaboration rules are not supported.");
+	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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, USER_MODEL_PRINCIPAL_ID, input.category, input.status ?? "active", 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 setCollaborationRuleStatus(id, status) {
+	return getSqliteDatabase().prepare(`UPDATE collaboration_rules SET status = ?, updated_at = ? WHERE rule_id = ?`).run(status, Date.now(), id).changes ? getCollaborationRule(id) : void 0;
+}
+//#endregion
+export { createCollaborationRule, getCollaborationRule, listCollaborationRules, setCollaborationRuleStatus };

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

@@ -1,6 +1,6 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { notifyUserContextChange } from "../../user-context/changes.js";
 import { sessionConfigRowToConfig } from "./row-mappers.js";
+import { notifyUserContextChange } from "../../user-context/changes.js";
 import { ensureSessionInTransaction } from "./session-repository.js";
 //#region src/storage/sqlite/config-repository.ts
 function readConfigRow(db, sessionKey) {

package/dist/src/storage/sqlite/connection-wait-repository.d.ts

@@ -0,0 +1,30 @@
+import type { ConnectionCheckpoint, ConnectionNeed, ConnectionWait } from '@xopcai/gateway-contract';
+import { type SessionInput } from './session-input-repository.js';
+export declare function onConnectionWaitChanged(listener: (sessionKey: string) => void): () => void;
+export declare function publishConnectionWait(sessionKey: string): void;
+export declare function getConnectionWait(id: string): ConnectionWait | undefined;
+export declare function getActiveConnectionWait(sessionKey: string): ConnectionWait | undefined;
+export declare function isConnectionSuspended(sessionKey: string, runId: string): boolean;
+export declare function updateConnectionWait(wait: ConnectionWait, expectedVersion: number): ConnectionWait;
+export declare function requireSessionConnection(input: {
+    sessionKey: string;
+    principalId: string;
+    agentId: string;
+    summary: string;
+    needs: ConnectionNeed[];
+    checkpoint?: Omit<ConnectionCheckpoint, 'entryId'>;
+}): {
+    status: 'connection_required' | 'skipped' | 'objective_conflict';
+    waitId?: string;
+};
+/** The input and the wait transition commit together, using the existing queue's unique key. */
+export declare function queueConnectionResolution(wait: ConnectionWait, resolution: 'continued' | 'skipped'): ConnectionWait;
+export declare function consumeConnectionResume(input: SessionInput): boolean;
+export declare function connectionBindings(sessionKey: string): ConnectionNeed[];
+export declare function connectionBinding(sessionKey: string, connectorId: string): string | undefined;
+/** New input wins over an outstanding auto-resume intent, including an already queued resume. */
+export declare function invalidateConnectionResumeIntent(sessionKey: string): void;
+export declare function reviseCurrentConnectionObjective(sessionKey: string, summary: string | undefined): void;
+export declare function cancelConnectionObjective(sessionKey: string): void;
+export declare function getConnectionResumeInput(sessionKey: string, runId: string): SessionInput | undefined;
+export declare function listConnectionWaitsToCheck(): ConnectionWait[];

package/dist/src/storage/sqlite/connection-wait-repository.js

@@ -0,0 +1,338 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { isXopcDatabaseOpen } from "./connection.js";
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { readCurrentSessionId } from "./session-instance-repository.js";
+import { bumpSessionInputRevision, getSessionInputById, getSessionInputState, insertSessionInput, setSessionInputStatus } from "./session-input-repository.js";
+import { TaskRunRepository } from "../../tasks/task-run-repository.js";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+//#region src/storage/sqlite/connection-wait-repository.ts
+init_logger();
+const log = createLogger("Connectors:Wait");
+const events = new EventEmitter();
+function onConnectionWaitChanged(listener) {
+	events.on("changed", listener);
+	return () => {
+		events.off("changed", listener);
+	};
+}
+function publishConnectionWait(sessionKey) {
+	events.emit("changed", sessionKey);
+}
+function getConnectionWait(id) {
+	if (!isXopcDatabaseOpen()) return void 0;
+	const row = getSqliteDatabase().prepare("SELECT data_json FROM session_connection_waits WHERE id = ?").get(id);
+	return row ? JSON.parse(row.data_json) : void 0;
+}
+function getActiveConnectionWait(sessionKey) {
+	if (!isXopcDatabaseOpen()) return void 0;
+	const db = getSqliteDatabase();
+	const row = db.prepare(`SELECT data_json FROM session_connection_waits WHERE session_key = ? AND session_id = ?
+    AND status IN ('open','queued')`).get(sessionKey, readCurrentSessionId(db, sessionKey) ?? "");
+	return row ? JSON.parse(row.data_json) : void 0;
+}
+function isConnectionSuspended(sessionKey, runId) {
+	const wait = getActiveConnectionWait(sessionKey);
+	return Boolean(wait && wait.originRunId === runId);
+}
+function updateConnectionWait(wait, expectedVersion) {
+	return runSqliteWriteTransaction((db) => {
+		if (readCurrentSessionId(db, wait.sessionKey) !== wait.sessionId) throw new Error("SESSION_CHANGED");
+		const next = {
+			...wait,
+			version: expectedVersion + 1,
+			updatedAt: Date.now()
+		};
+		if (!db.prepare(`UPDATE session_connection_waits SET status = ?, version = ?, data_json = ? WHERE id = ? AND version = ?`).run(next.status, next.version, JSON.stringify(next), next.id, expectedVersion).changes) throw new Error("WAIT_CHANGED");
+		bumpSessionInputRevision(db, wait.sessionKey);
+		return next;
+	});
+}
+function requireSessionConnection(input) {
+	return runSqliteWriteTransaction((db) => {
+		const sessionId = readCurrentSessionId(db, input.sessionKey);
+		const runtime = getSessionInputState(input.sessionKey);
+		const origin = runtime.activeInputId ? getSessionInputById(input.sessionKey, runtime.activeInputId) : void 0;
+		if (!sessionId || !origin || !runtime.activeRunId) throw new Error("Connection recovery requires a queued chat execution.");
+		const resumed = origin.payload ? getConnectionWait(origin.payload.waitId) : void 0;
+		if (resumed?.resolution === "skipped") return { status: "skipped" };
+		const active = getActiveConnectionWait(input.sessionKey);
+		if (active) {
+			if (active.originInputId !== origin.id && active.objectiveId !== resumed?.objectiveId) return {
+				status: "objective_conflict",
+				waitId: active.id
+			};
+			const needs = new Map(active.needs.map((need) => [need.key, need]));
+			for (const need of input.needs) {
+				const previous = needs.get(need.key);
+				needs.set(need.key, previous ? {
+					...previous,
+					capabilities: [...new Set([...previous.capabilities, ...need.capabilities])]
+				} : need);
+			}
+			if (JSON.stringify([...needs.values()]) !== JSON.stringify(active.needs)) updateConnectionWait({
+				...active,
+				needs: [...needs.values()]
+			}, active.version);
+			return {
+				status: "connection_required",
+				waitId: active.id
+			};
+		}
+		const lastEntry = db.prepare("SELECT entry_id FROM transcript_entries WHERE session_id = ? ORDER BY seq DESC LIMIT 1").get(sessionId);
+		const wait = {
+			...input,
+			needs: [...new Map(input.needs.map((need) => [need.key, need])).values()],
+			id: randomUUID(),
+			sessionId,
+			objectiveId: resumed?.objectiveId ?? origin.id,
+			objectiveRevision: (resumed?.objectiveRevision ?? 0) + 1,
+			objectiveUpdatedAt: resumed?.objectiveUpdatedAt ?? origin.createdAtMs,
+			originInputId: origin.id,
+			originRunId: runtime.activeRunId,
+			taskRunId: origin.taskRunId,
+			checkpoint: {
+				entryId: lastEntry?.entry_id,
+				completedSteps: input.checkpoint?.completedSteps ?? [],
+				pendingSteps: input.checkpoint?.pendingSteps ?? [input.summary],
+				timeRange: input.checkpoint?.timeRange ?? resumed?.checkpoint.timeRange
+			},
+			summary: resumed?.summary ?? origin.content,
+			status: "open",
+			version: 1,
+			createdAt: Date.now(),
+			updatedAt: Date.now()
+		};
+		db.prepare(`INSERT INTO session_connection_waits(id,principal_id,session_key,session_id,status,version,data_json) VALUES (?,?,?,?,?,?,?)`).run(wait.id, wait.principalId, wait.sessionKey, wait.sessionId, wait.status, wait.version, JSON.stringify(wait));
+		if (wait.taskRunId) {
+			const runs = new TaskRunRepository();
+			const run = runs.get(wait.taskRunId);
+			if (run) {
+				runs.createWait({
+					taskId: run.taskId,
+					taskRunId: run.id,
+					kind: "user_input",
+					reason: input.summary,
+					condition: {
+						type: "connection",
+						connectionWaitId: wait.id
+					}
+				});
+				runs.setStatus({
+					runId: run.id,
+					expectedVersion: run.version,
+					from: [run.status],
+					to: "waiting",
+					actor: { kind: "system" }
+				});
+			}
+		}
+		bumpSessionInputRevision(db, wait.sessionKey);
+		log.info({
+			sessionKey: wait.sessionKey,
+			waitId: wait.id,
+			objectiveRevision: wait.objectiveRevision,
+			runId: wait.originRunId,
+			phase: "waiting"
+		}, "Connection requirement saved");
+		return {
+			status: "connection_required",
+			waitId: wait.id
+		};
+	});
+}
+/** The input and the wait transition commit together, using the existing queue's unique key. */
+function queueConnectionResolution(wait, resolution) {
+	return runSqliteWriteTransaction(() => {
+		const current = getConnectionWait(wait.id);
+		if (!current || current.version !== wait.version || current.status !== "open") throw new Error("WAIT_CHANGED");
+		const origin = getSessionInputById(wait.sessionKey, wait.originInputId);
+		if (!origin) throw new Error("Original input is unavailable.");
+		const input = insertSessionInput({
+			id: randomUUID(),
+			sessionKey: wait.sessionKey,
+			expectedSessionId: wait.sessionId,
+			clientMessageId: `connection:${wait.id}:${wait.objectiveRevision}:${resolution}`,
+			requestedDelivery: "next",
+			effectiveDelivery: "next",
+			status: "queued",
+			content: resolution === "skipped" ? `The user skipped the requested connection. Continue this objective using only available information: ${wait.summary}. Do not request these connections again or claim to have read their data.` : `Recovery checkpoint: ${JSON.stringify(wait.checkpoint)}. The user chose to continue the request originally made at ${new Date(wait.objectiveUpdatedAt).toISOString()}: ${wait.summary}. Interpret relative dates against that original request time, unless the user explicitly changed them. The connection requirement has been checked. Search and describe tools again before using them. Use the explicitly selected account. Do not repeat already completed actions.`,
+			origin: {
+				type: "system",
+				source: "internal"
+			},
+			thinking: origin.thinking,
+			contextRefs: origin.contextRefs,
+			contextSnapshots: origin.contextSnapshots,
+			kind: "connection_resume",
+			taskRunId: wait.taskRunId,
+			payload: {
+				waitId: wait.id,
+				objectiveRevision: wait.objectiveRevision,
+				resolution
+			}
+		});
+		return updateConnectionWait({
+			...wait,
+			status: "queued",
+			resolution,
+			queuedInputId: input.id
+		}, wait.version);
+	});
+}
+function consumeConnectionResume(input) {
+	if (input.kind !== "connection_resume") return true;
+	return runSqliteWriteTransaction(() => {
+		const wait = input.payload ? getConnectionWait(input.payload.waitId) : void 0;
+		if (!wait || wait.status !== "queued" || wait.queuedInputId !== input.id || wait.objectiveRevision !== input.payload?.objectiveRevision) return false;
+		if (readCurrentSessionId(getSqliteDatabase(), input.sessionKey) !== wait.sessionId) return false;
+		if (wait.taskRunId) {
+			const runs = new TaskRunRepository();
+			const run = runs.get(wait.taskRunId);
+			if (!run || run.status !== "waiting") return false;
+			const taskWaits = runs.listActiveWaits(run.taskId);
+			if (taskWaits.some((item) => item.taskRunId === run.id && item.condition.connectionWaitId !== wait.id)) {
+				updateConnectionWait({
+					...wait,
+					status: "open",
+					intent: void 0,
+					queuedInputId: void 0,
+					objectiveRevision: wait.objectiveRevision + 1
+				}, wait.version);
+				return false;
+			}
+			for (const taskWait of taskWaits) if (taskWait.condition.connectionWaitId === wait.id) runs.resolveWait({
+				waitId: taskWait.id,
+				actor: { kind: "system" },
+				resolution: { connectionWaitId: wait.id }
+			});
+			runs.setStatus({
+				runId: run.id,
+				expectedVersion: run.version,
+				from: ["waiting"],
+				to: "running",
+				actor: { kind: "system" }
+			});
+		}
+		updateConnectionWait({
+			...wait,
+			status: "closed"
+		}, wait.version);
+		return true;
+	});
+}
+function connectionBindings(sessionKey) {
+	if (!isXopcDatabaseOpen()) return [];
+	const state = getSessionInputState(sessionKey);
+	const input = state.activeInputId ? getSessionInputById(sessionKey, state.activeInputId) : void 0;
+	return input?.payload ? getConnectionWait(input.payload.waitId)?.needs ?? [] : [];
+}
+function connectionBinding(sessionKey, connectorId) {
+	const matches = connectionBindings(sessionKey).filter((need) => need.connectorId === connectorId);
+	return matches.length === 1 ? matches[0].connectionId : void 0;
+}
+/** New input wins over an outstanding auto-resume intent, including an already queued resume. */
+function invalidateConnectionResumeIntent(sessionKey) {
+	const wait = getActiveConnectionWait(sessionKey);
+	if (!wait) return;
+	runSqliteWriteTransaction(() => {
+		if (wait.queuedInputId) setSessionInputStatus(wait.queuedInputId, "cancelled");
+		updateConnectionWait({
+			...wait,
+			status: "open",
+			intent: void 0,
+			queuedInputId: void 0,
+			objectiveRevision: wait.objectiveRevision + 1,
+			scopeConfirmedAt: void 0,
+			reviewRequired: true
+		}, wait.version);
+	});
+	publishConnectionWait(sessionKey);
+}
+function reviseCurrentConnectionObjective(sessionKey, summary) {
+	const wait = getActiveConnectionWait(sessionKey);
+	if (!wait) throw new Error("No connection objective is waiting.");
+	if (!summary) {
+		cancelConnectionObjective(sessionKey);
+		return;
+	}
+	runSqliteWriteTransaction(() => {
+		if (wait.queuedInputId) setSessionInputStatus(wait.queuedInputId, "cancelled");
+		updateConnectionWait({
+			...wait,
+			summary,
+			objectiveUpdatedAt: Date.now(),
+			checkpoint: {
+				...wait.checkpoint,
+				pendingSteps: [summary],
+				timeRange: void 0
+			},
+			status: "open",
+			resolution: void 0,
+			intent: void 0,
+			queuedInputId: void 0,
+			scopeConfirmedAt: void 0,
+			reviewRequired: true,
+			objectiveRevision: wait.objectiveRevision + 1
+		}, wait.version);
+	});
+	publishConnectionWait(sessionKey);
+}
+function cancelConnectionObjective(sessionKey) {
+	const wait = getActiveConnectionWait(sessionKey);
+	if (!wait) return;
+	runSqliteWriteTransaction(() => {
+		if (wait.queuedInputId) setSessionInputStatus(wait.queuedInputId, "cancelled");
+		if (wait.taskRunId) {
+			const runs = new TaskRunRepository();
+			const run = runs.get(wait.taskRunId);
+			if (run?.status === "waiting") {
+				for (const taskWait of runs.listActiveWaits(run.taskId)) if (taskWait.condition.connectionWaitId === wait.id) runs.resolveWait({
+					waitId: taskWait.id,
+					actor: { kind: "system" },
+					resolution: { cancelled: true }
+				});
+				runs.finalize({
+					runId: run.id,
+					expectedVersion: run.version,
+					receipt: {
+						status: "cancelled",
+						summary: "Connection objective cancelled",
+						changes: [],
+						evidence: [],
+						verification: {
+							status: "unverified",
+							checks: []
+						},
+						remainingWork: [],
+						needsUser: false,
+						completionVerdict: "not_achieved"
+					}
+				});
+			}
+		}
+		updateConnectionWait({
+			...wait,
+			status: "closed",
+			resolution: "cancelled",
+			intent: void 0
+		}, wait.version);
+	});
+	publishConnectionWait(sessionKey);
+}
+function getConnectionResumeInput(sessionKey, runId) {
+	if (!isXopcDatabaseOpen()) return void 0;
+	const state = getSessionInputState(sessionKey);
+	if (state.activeRunId !== runId || !state.activeInputId) return void 0;
+	const input = getSessionInputById(sessionKey, state.activeInputId);
+	return input?.kind === "connection_resume" ? input : void 0;
+}
+function listConnectionWaitsToCheck() {
+	if (!isXopcDatabaseOpen()) return [];
+	return getSqliteDatabase().prepare(`SELECT wait.data_json FROM session_connection_waits wait
+    JOIN sessions session ON session.session_id = wait.session_id
+    WHERE wait.status = 'open'`).all().map((row) => JSON.parse(row.data_json)).filter((wait) => wait.principalId === "local-owner" && wait.intent && wait.intent.validUntil > Date.now());
+}
+//#endregion
+export { cancelConnectionObjective, connectionBinding, connectionBindings, consumeConnectionResume, getActiveConnectionWait, getConnectionResumeInput, getConnectionWait, invalidateConnectionResumeIntent, isConnectionSuspended, listConnectionWaitsToCheck, onConnectionWaitChanged, publishConnectionWait, queueConnectionResolution, requireSessionConnection, reviseCurrentConnectionObjective, updateConnectionWait };

package/dist/src/storage/sqlite/connector-account-repository.js

@@ -59,7 +59,7 @@ function mergeAccountSourceData(db, connectorId, sourceAccountId, targetAccountI
   `).run(targetId, sourceId);
 	db.prepare("DELETE FROM knowledge_consumer_watermarks WHERE source_instance_id = ?").run(sourceId);
 	db.prepare(`
-    UPDATE memory_records
+    UPDATE knowledge_items
     SET source_json = json_set(source_json, '$.sourceInstanceId', ?)
     WHERE json_extract(source_json, '$.sourceInstanceId') = ?
   `).run(targetId, sourceId);

package/dist/src/storage/sqlite/context-evidence-repository.d.ts

@@ -0,0 +1,24 @@
+export interface ContextEvidence {
+    id: string;
+    sourceType: 'conversation' | 'connector' | 'user' | 'runtime';
+    sourceInstanceId?: string;
+    sourceRef: string;
+    sourceRunId?: string;
+    sourceItemId?: string;
+    sessionId?: string;
+    turnId?: string;
+    messageId?: string;
+    contentHash?: string;
+    retentionPolicy?: string;
+    processingPolicy?: 'local_only' | 'remote_allowed';
+    extractorId?: string;
+    extractorVersion?: string;
+    redactedExcerpt?: string;
+    trustLevel: 'owner' | 'trusted' | 'untrusted';
+    observedAt: number;
+    ingestedAt: number;
+    createdAt: number;
+}
+export declare function createContextEvidence(input: Omit<ContextEvidence, 'id' | 'ingestedAt' | 'createdAt'> & {
+    ingestedAt?: number;
+}, principalId?: string): ContextEvidence;