@xopcai/xopc 0.0.170 → 0.0.172

package/dist/src/session/store.d.ts

@@ -1,22 +1,39 @@
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
+import type { Api, Model } from '@earendil-works/pi-ai/compat';
 import type { Config } from '../config/schema.js';
-import { type CompactionConfig, type CompactionResult } from '../agent/memory/compaction.js';
+import { type CompactionConfig, type CompactionExecutionOptions, type CompactionResult } from '../agent/memory/compaction.js';
 import { type WindowConfig } from '../agent/memory/window.js';
 import { type SessionMetadataSeed } from '../storage/sqlite/index.js';
 import type { XopcSessionTranscriptV1 } from './transcript-format.js';
 import { type TranscriptStoredRow, type XopcTranscriptContextEntry } from './session-context-for-llm.js';
-import type { SessionMetadata, SessionDetail, SessionListQuery, PaginatedResult, GlobalSessionStats, ExportFormat, CompactionCheckpointSummary, CompactionCheckpointDetail } from './types.js';
+import type { SessionMetadata, SessionDetail, SessionListQuery, PaginatedResult, GlobalSessionStats, ExportFormat, CompactionBoundarySummary } from './types.js';
 import { SessionStatus } from './types.js';
 import type { Message } from './types.js';
 import type { SessionTranscriptUpdate } from './transcript-events.js';
 export interface SessionStoreOptions {
     config: Config;
 }
+export interface SessionCompactionHooks {
+    before?: (event: {
+        sessionKey: string;
+        messageCount: number;
+        tokenCount: number;
+    }) => Promise<void> | void;
+    after?: (event: {
+        sessionKey: string;
+        messageCount: number;
+        tokenCount: number;
+        compactedCount: number;
+    }) => Promise<void> | void;
+}
 export declare class SessionStore {
     private options;
     private window;
     private compactor;
+    private compactionHooks;
     constructor(options: SessionStoreOptions, windowConfig?: Partial<WindowConfig>, compactionConfig?: Partial<CompactionConfig>);
+    setCompactionHooks(hooks: SessionCompactionHooks): void;
+    private runCompactionHook;
     private resolveWorkspaceCwd;
     private runStoreMutation;
     initialize(): Promise<void>;
@@ -110,6 +127,11 @@ export declare class SessionStore {
     saveMessages(key: string, messages: AgentMessage[], options?: {
         metadata?: SessionMetadataSeed;
     }): Promise<void>;
+    deleteUserRound(key: string, userRoundIndex: number): Promise<{
+        deleted: number;
+        removedMessages: AgentMessage[];
+        remainingMessages: AgentMessage[];
+    } | null>;
     getWindowStats(messages: AgentMessage[]): {
         total: number;
         system: number;
@@ -118,31 +140,16 @@ export declare class SessionStore {
         tool: number;
         needsTrim: boolean;
     };
-    needsCompaction(key: string, messages: AgentMessage[], contextWindow: number): {
-        needed: boolean;
-        reason: string;
-        usagePercent?: number;
-    };
-    prepareCompaction(key: string, messages: AgentMessage[], contextWindow: number): {
-        needsCompaction: boolean;
-        messages: AgentMessage[];
-        stats: {
-            needed: boolean;
-            reason: string;
-            usagePercent?: number;
-        };
-    };
     applyCompaction(key: string, messages: AgentMessage[], result: CompactionResult): Promise<AgentMessage[]>;
-    compact(key: string, messages: AgentMessage[], contextWindow: number, instructions?: string, force?: boolean): Promise<CompactionResult>;
+    compact(key: string, messages: AgentMessage[], model: Model<Api>, instructions?: string, force?: boolean, executionOptions?: CompactionExecutionOptions): Promise<CompactionResult>;
     getCompactionStats(key: string): Promise<{
         compactionCount: number;
         totalTokensBefore: number;
         totalTokensAfter: number;
-        lastCompactionAt: any;
+        lastCompactionAt: string;
     }>;
-    listCompactionCheckpoints(key: string): Promise<CompactionCheckpointSummary[]>;
-    getCompactionCheckpointDetail(key: string, checkpointId: string): Promise<CompactionCheckpointDetail | null>;
-    restoreCompactionCheckpoint(key: string, checkpointId: string): Promise<void>;
+    listCompactionBoundaries(key: string): Promise<CompactionBoundarySummary[]>;
+    restoreBeforeCompactionBoundary(key: string, compactionId: string): Promise<void>;
     deleteSession(key: string): Promise<boolean>;
     load(key: string, options?: {
         fromArchive?: boolean;
@@ -169,9 +176,7 @@ export declare class SessionStore {
     estimateTokens(messages: AgentMessage[]): number;
     private loadDisplayMessages;
     private paginateDisplayMessages;
-    private displayMessageIdentity;
     private messageContent;
-    private isCompactionSummaryMessage;
     private extractTextContent;
     private injectPostCompactionContext;
     private convertMessages;

package/dist/src/session/store.js

@@ -3,18 +3,19 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { requireXopcDatabase } from "../storage/sqlite/connection.js";
 import "./types.js";
-import { buildSessionContextForLlm, buildSessionDisplayMessages, mergeLlmMessagesPreservingContextRows, transcriptRowsFromJsonArray } from "./session-context-for-llm.js";
+import { buildSessionContextForLlm, buildSessionDisplayMessages, isRuntimeOnlyTranscriptMessage, isTranscriptCompactionEntry, mergeLlmMessagesPreservingContextRows, transcriptRowsFromJsonArray } from "./session-context-for-llm.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";
-import { appendTranscriptEntry, captureCompactionCheckpoint, getCompactionCheckpointDetail, listCompactionCheckpoints, loadCheckpointRows, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRowsForSession, paginateTranscriptMessages, replaceTranscriptRows, restoreCompactionCheckpoint } from "../storage/sqlite/transcript-repository.js";
+import { appendCompactionBoundary, appendTranscriptEntry, listCompactionBoundaries, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRowsForSession, paginateTranscriptMessages, replaceTranscriptRows, restoreBeforeCompactionBoundary } from "../storage/sqlite/transcript-repository.js";
 import "../storage/sqlite/index.js";
 import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { readPostCompactionContext } from "../agent/reply/post-compaction-context.js";
 import { SessionCompactor } from "../agent/memory/compaction.js";
+import { resolveCompactionPolicy } from "../agent/memory/compaction-policy.js";
 import { SlidingWindow } from "../agent/memory/window.js";
-import { normalizeCompactionCheckpointId } from "./compaction-checkpoints.js";
 import { isAppendOnlyLlmTranscriptMessage } from "./transcript-stats.js";
 import { transcriptRowsToClientHistory } from "./client-history.js";
+import { computeTranscriptUserRoundDeleteRange } from "./user-round-delete.js";
 //#region src/session/store.ts
 init_paths_state();
 init_logger();
@@ -23,11 +24,30 @@ const INDEX_VERSION = "1.0";
 var SessionStore = class {
 	window;
 	compactor;
+	compactionHooks = {};
 	constructor(options, windowConfig, compactionConfig) {
 		this.options = options;
 		this.window = new SlidingWindow(windowConfig);
 		this.compactor = new SessionCompactor(compactionConfig);
 	}
+	setCompactionHooks(hooks) {
+		this.compactionHooks = hooks;
+	}
+	async runCompactionHook(phase, event) {
+		try {
+			if (phase === "before") await this.compactionHooks.before?.(event);
+			else await this.compactionHooks.after?.({
+				...event,
+				compactedCount: event.compactedCount ?? 0
+			});
+		} catch (err) {
+			log.warn({
+				err,
+				phase,
+				sessionKey: event.sessionKey
+			}, `Session compaction ${phase} hook failed`);
+		}
+	}
 	resolveWorkspaceCwd(sessionKey) {
 		return resolveEffectiveAgentProfileForSession(this.options.config, sessionKey).resolvedWorkspacePath;
 	}
@@ -94,8 +114,7 @@ var SessionStore = class {
 				limit,
 				offset: hasBeforeCursor ? void 0 : offset,
 				beforeIndex: hasBeforeCursor ? parsedBefore : void 0,
-				includeContext: true,
-				includeArchived: true
+				includeContext: true
 			});
 			const messages = transcriptRowsToClientHistory(page.rows);
 			const endIndex = hasBeforeCursor ? Math.min(page.total, Math.max(0, parsedBefore)) : Math.max(0, page.total - offset);
@@ -242,16 +261,19 @@ var SessionStore = class {
 		if (!metadata?.sessionId) return null;
 		const rows = await this.loadTranscriptRows(key);
 		const compactions = [];
-		for (const row of rows) if (row.type === "compaction") {
-			const c = row;
-			compactions.push({
-				at: c.at ?? (/* @__PURE__ */ new Date()).toISOString(),
-				summary: c.summary ?? "",
-				firstKeptIndex: Number(c.firstKeptIndex ?? 0),
-				tokensBefore: c.tokensBefore ?? 0,
-				tokensAfter: c.tokensAfter ?? 0
-			});
-		}
+		for (const row of rows) if (isTranscriptCompactionEntry(row)) compactions.push({
+			at: row.at,
+			baseSeq: row.baseSeq,
+			plannerVersion: row.plannerVersion,
+			summaryModelRef: row.summaryModelRef,
+			qualityAudit: row.qualityAudit,
+			summary: row.summary,
+			messages: row.messages,
+			firstKeptIndex: row.firstKeptIndex,
+			tokensBefore: row.tokensBefore,
+			tokensAfter: row.tokensAfter,
+			restoredFromCompactionId: row.restoredFromCompactionId
+		});
 		return {
 			type: "xopc_session_transcript",
 			version: 1,
@@ -346,34 +368,42 @@ var SessionStore = class {
 			replaceTranscriptRows(key, mergeLlmMessagesPreservingContextRows(await this.loadTranscriptRows(key), messages));
 		});
 	}
+	async deleteUserRound(key, userRoundIndex) {
+		return this.runStoreMutation(async () => {
+			requireXopcDatabase();
+			const canonicalRows = (await this.loadTranscriptRows(key)).filter((row) => !isTranscriptCompactionEntry(row) && !isRuntimeOnlyTranscriptMessage(row));
+			const range = computeTranscriptUserRoundDeleteRange(canonicalRows, userRoundIndex);
+			if (!range) return null;
+			const removedRows = canonicalRows.slice(range.startIndex, range.startIndex + range.count);
+			const remainingRows = canonicalRows.slice(0, range.startIndex).concat(canonicalRows.slice(range.startIndex + range.count));
+			const removedMessages = buildSessionDisplayMessages(removedRows);
+			const remainingMessages = buildSessionDisplayMessages(remainingRows);
+			replaceTranscriptRows(key, remainingRows);
+			return {
+				deleted: removedMessages.length,
+				removedMessages,
+				remainingMessages
+			};
+		});
+	}
 	getWindowStats(messages) {
 		return this.window.getStats(messages);
 	}
-	needsCompaction(key, messages, contextWindow) {
-		return this.compactor.needsCompaction(messages, contextWindow);
-	}
-	prepareCompaction(key, messages, contextWindow) {
-		const result = this.compactor.needsCompaction(messages, contextWindow);
-		return {
-			needsCompaction: result.needed,
-			messages,
-			stats: result
-		};
-	}
 	async applyCompaction(key, messages, result) {
 		const compacted = this.compactor.applyCompaction(messages, result);
 		return this.runStoreMutation(async () => {
-			const merged = mergeLlmMessagesPreservingContextRows(await this.loadTranscriptRows(key), compacted);
-			captureCompactionCheckpoint(key);
-			replaceTranscriptRows(key, merged, { appendCompaction: {
+			appendCompactionBoundary(key, {
+				type: "compaction",
 				at: (/* @__PURE__ */ new Date()).toISOString(),
+				plannerVersion: result.plannerVersion ?? 2,
+				summaryModelRef: result.summaryModelRef ?? "unknown",
+				qualityAudit: result.qualityAudit ?? "disabled",
 				summary: result.summary,
+				messages: compacted,
 				firstKeptIndex: result.firstKeptIndex,
 				tokensBefore: result.tokensBefore,
 				tokensAfter: result.tokensAfter
-			} });
-			const metadata = await this.getMetadata(key);
-			if (metadata) await this.updateMetadata(key, { compactedCount: metadata.compactedCount + 1 });
+			});
 			log.info({
 				key,
 				tokensBefore: result.tokensBefore,
@@ -384,37 +414,44 @@ var SessionStore = class {
 			return compacted;
 		});
 	}
-	async compact(key, messages, contextWindow, instructions, force) {
-		const result = await this.compactor.compact(messages, instructions, force);
-		if (result.compacted) await this.applyCompaction(key, messages, result);
+	async compact(key, messages, model, instructions, force, executionOptions) {
+		const tokenCount = this.estimateTokens(messages);
+		await this.runCompactionHook("before", {
+			sessionKey: key,
+			messageCount: messages.length,
+			tokenCount
+		});
+		const result = await this.compactor.compact(messages, model, instructions, force, executionOptions);
+		if (result.compacted) {
+			const compacted = await this.applyCompaction(key, messages, result);
+			await this.runCompactionHook("after", {
+				sessionKey: key,
+				messageCount: compacted.length,
+				tokenCount: result.tokensAfter,
+				compactedCount: Math.max(0, Math.min(messages.length, result.firstKeptIndex))
+			});
+		}
 		return result;
 	}
 	async getCompactionStats(key) {
-		const metadata = await this.getMetadata(key);
-		if (!metadata) return;
+		if (!await this.getMetadata(key)) return void 0;
+		const boundaries = listCompactionBoundaries(key);
 		return {
-			compactionCount: metadata.compactedCount,
-			totalTokensBefore: 0,
-			totalTokensAfter: 0,
-			lastCompactionAt: void 0
+			compactionCount: boundaries.length,
+			totalTokensBefore: boundaries.reduce((sum, boundary) => sum + boundary.tokensBefore, 0),
+			totalTokensAfter: boundaries.reduce((sum, boundary) => sum + boundary.tokensAfter, 0),
+			lastCompactionAt: boundaries[0]?.createdAt
 		};
 	}
-	async listCompactionCheckpoints(key) {
-		requireXopcDatabase();
-		return listCompactionCheckpoints(key);
-	}
-	async getCompactionCheckpointDetail(key, checkpointId) {
+	async listCompactionBoundaries(key) {
 		requireXopcDatabase();
-		const id = normalizeCompactionCheckpointId(checkpointId);
-		if (!id) return null;
-		return getCompactionCheckpointDetail(key, id);
+		return listCompactionBoundaries(key);
 	}
-	async restoreCompactionCheckpoint(key, checkpointId) {
+	async restoreBeforeCompactionBoundary(key, compactionId) {
 		return this.runStoreMutation(async () => {
 			requireXopcDatabase();
-			const id = normalizeCompactionCheckpointId(checkpointId);
-			if (!id) throw new Error(`Invalid checkpoint id: ${checkpointId}`);
-			restoreCompactionCheckpoint(key, id);
+			if (!compactionId.trim()) throw new Error("compactionId is required");
+			restoreBeforeCompactionBoundary(key, compactionId);
 		});
 	}
 	async deleteSession(key) {
@@ -553,20 +590,7 @@ var SessionStore = class {
 	}
 	async loadDisplayMessages(key) {
 		requireXopcDatabase();
-		const checkpoints = listCompactionCheckpoints(key);
-		const rowSets = [];
-		for (const checkpoint of [...checkpoints].reverse()) rowSets.push(loadCheckpointRows(key, checkpoint.id));
-		rowSets.push(await this.loadTranscriptRows(key));
-		const messages = [];
-		const seen = /* @__PURE__ */ new Set();
-		for (const rows of rowSets) for (const message of buildSessionDisplayMessages(rows)) {
-			if (this.isCompactionSummaryMessage(message)) continue;
-			const identity = this.displayMessageIdentity(message);
-			if (seen.has(identity)) continue;
-			seen.add(identity);
-			messages.push(message);
-		}
-		return messages;
+		return buildSessionDisplayMessages(await this.loadTranscriptRows(key));
 	}
 	paginateDisplayMessages(messages, options = {}) {
 		const total = messages.length;
@@ -588,24 +612,9 @@ var SessionStore = class {
 			endIndex
 		};
 	}
-	displayMessageIdentity(message) {
-		const record = message;
-		return JSON.stringify({
-			role: message.role,
-			timestamp: record.timestamp,
-			toolCallId: record.toolCallId ?? record.tool_call_id,
-			toolName: record.toolName,
-			content: this.messageContent(message)
-		});
-	}
 	messageContent(msg) {
 		return msg.content;
 	}
-	isCompactionSummaryMessage(msg) {
-		if (msg.role !== "user") return false;
-		const text = this.extractTextContent(this.messageContent(msg)).trim();
-		return /^\[Previous conversation summary\]/i.test(text);
-	}
 	extractTextContent(content) {
 		if (typeof content === "string") return content;
 		if (Array.isArray(content)) {
@@ -621,9 +630,11 @@ var SessionStore = class {
 		return "";
 	}
 	async injectPostCompactionContext(key) {
+		const policy = resolveCompactionPolicy(this.options.config);
 		const contextText = readPostCompactionContext({
 			cfg: this.options.config,
-			sessionKey: key
+			sessionKey: key,
+			sectionNames: policy.postCompactionSections
 		});
 		if (!contextText?.trim()) return;
 		try {

package/dist/src/session/transcript-format.d.ts

@@ -1,17 +1,11 @@
 /**
  * API-level transcript summary types (authoritative storage is SQLite `transcript_entries`).
  */
-import type { TranscriptStoredRow } from './session-context-for-llm.js';
+import type { TranscriptStoredRow, XopcTranscriptCompactionEntry } from './session-context-for-llm.js';
 export declare const XOPC_SESSION_TRANSCRIPT_TYPE: "xopc_session_transcript";
 export declare const CURRENT_SESSION_TRANSCRIPT_VERSION = 1;
 /** Record appended when context compaction runs (mirrors pi `CompactionEntry` audit fields). */
-export interface TranscriptCompactionRecord {
-    at: string;
-    summary: string;
-    firstKeptIndex: number;
-    tokensBefore: number;
-    tokensAfter: number;
-}
+export type TranscriptCompactionRecord = Omit<XopcTranscriptCompactionEntry, 'type'>;
 /** Synthetic document shape returned by {@link SessionStore.loadTranscriptDocument} for API parity. */
 export interface XopcSessionTranscriptV1 {
     type: typeof XOPC_SESSION_TRANSCRIPT_TYPE;

package/dist/src/session/types.d.ts

@@ -179,12 +179,14 @@ export interface SessionExport {
     /** Full on-disk rows (LLM + `kind: 'context'`) for audit / round-trip. */
     transcriptRows: TranscriptStoredRow[];
 }
-/** On-disk pre-compaction snapshot (OpenClaw-style checkpoint list). */
-export interface CompactionCheckpointSummary {
+/** Append-only context boundary produced by compaction or logical restoration. */
+export interface CompactionBoundarySummary {
     id: string;
-    sizeBytes: number;
-    modifiedAt: string;
-}
-export interface CompactionCheckpointDetail extends CompactionCheckpointSummary {
+    seq: number;
+    createdAt: string;
     messageCount: number;
+    tokensBefore: number;
+    tokensAfter: number;
+    summaryPreview: string;
+    restoredFromCompactionId?: string;
 }

package/dist/src/session/user-round-delete.d.ts

@@ -1,9 +1,6 @@
-import type { AgentMessage } from '@earendil-works/pi-agent-core';
-/**
- * LLM transcript range for one user turn: the user row plus every following
- * assistant / tool / toolResult row until the next user (or EOF).
- */
-export declare function computeUserRoundDeleteRange(messages: readonly AgentMessage[], userRoundIndex: number): {
+import { type TranscriptStoredRow } from './session-context-for-llm.js';
+/** Raw transcript range for one UI-visible user turn. */
+export declare function computeTranscriptUserRoundDeleteRange(rows: readonly TranscriptStoredRow[], userRoundIndex: number): {
     startIndex: number;
     count: number;
 } | null;

package/dist/src/session/user-round-delete.js

@@ -1,33 +1,29 @@
+import { isTranscriptCustomMessageEntry } from "./session-context-for-llm.js";
 //#region src/session/user-round-delete.ts
-function isUserRole(role) {
-	return role === "user";
+function isVisibleUserRow(row) {
+	if (isTranscriptCustomMessageEntry(row)) return row.display !== false;
+	return row.role === "user";
 }
-/**
-* LLM transcript range for one user turn: the user row plus every following
-* assistant / tool / toolResult row until the next user (or EOF).
-*/
-function computeUserRoundDeleteRange(messages, userRoundIndex) {
-	if (userRoundIndex < 0 || messages.length === 0) return null;
+/** Raw transcript range for one UI-visible user turn. */
+function computeTranscriptUserRoundDeleteRange(rows, userRoundIndex) {
+	if (!Number.isInteger(userRoundIndex) || userRoundIndex < 0 || rows.length === 0) return null;
 	let userCount = 0;
 	let startIndex = -1;
-	for (let i = 0; i < messages.length; i++) {
-		if (!isUserRole(String(messages[i]?.role ?? ""))) continue;
+	for (let index = 0; index < rows.length; index += 1) {
+		if (!isVisibleUserRow(rows[index])) continue;
 		if (userCount === userRoundIndex) {
-			startIndex = i;
+			startIndex = index;
 			break;
 		}
 		userCount += 1;
 	}
 	if (startIndex < 0) return null;
 	let end = startIndex + 1;
-	while (end < messages.length) {
-		if (isUserRole(String(messages[end]?.role ?? ""))) break;
-		end += 1;
-	}
+	while (end < rows.length && !isVisibleUserRow(rows[end])) end += 1;
 	return {
 		startIndex,
 		count: end - startIndex
 	};
 }
 //#endregion
-export { computeUserRoundDeleteRange };
+export { computeTranscriptUserRoundDeleteRange };

package/dist/src/storage/sqlite/connector-learning-repository.d.ts

@@ -0,0 +1,47 @@
+export type ConnectorLearningMode = 'bootstrap' | 'incremental';
+export type ConnectorLearningStatus = 'queued' | 'running' | 'completed' | 'failed' | 'paused';
+export type ConnectorLearningPhase = 'queued' | 'fetching' | 'indexing' | 'deriving' | 'completed';
+export type ConnectorLearningJob = {
+    id: string;
+    idempotencyKey: string;
+    connectorId: string;
+    connectionId: string;
+    sourceInstanceId: string;
+    agentId: string;
+    mode: ConnectorLearningMode;
+    status: ConnectorLearningStatus;
+    phase: ConnectorLearningPhase;
+    itemsDiscovered: number;
+    itemsIndexed: number;
+    candidatesCreated: number;
+    attemptCount: number;
+    error?: string;
+    nextRunAt?: string;
+    startedAt?: string;
+    finishedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export declare function enqueueConnectorLearningJob(input: {
+    connectorId: string;
+    connectionId: string;
+    sourceInstanceId: string;
+    agentId: string;
+    mode: ConnectorLearningMode;
+    idempotencyKey: string;
+    nextRunAt?: number;
+    nowMs?: number;
+}): ConnectorLearningJob;
+export declare function claimNextConnectorLearningJob(nowMs?: number): ConnectorLearningJob | null;
+export declare function recoverStaleConnectorLearningJobs(staleBeforeMs: number, nowMs?: number): number;
+export declare function setConnectorLearningPaused(connectionId: string, paused: boolean, nowMs?: number): number;
+export declare function updateConnectorLearningJob(id: string, patch: Partial<Pick<ConnectorLearningJob, 'status' | 'phase' | 'itemsDiscovered' | 'itemsIndexed' | 'candidatesCreated' | 'error'>> & {
+    nextRunAt?: number | null;
+    finished?: boolean;
+    nowMs?: number;
+}): ConnectorLearningJob;
+export declare function listConnectorLearningJobs(options?: {
+    sourceInstanceId?: string;
+    connectionId?: string;
+    limit?: number;
+}): ConnectorLearningJob[];

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

@@ -0,0 +1,110 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/storage/sqlite/connector-learning-repository.ts
+function iso(value) {
+	return value == null ? void 0 : new Date(value).toISOString();
+}
+function fromRow(row) {
+	return {
+		id: row.job_id,
+		idempotencyKey: row.idempotency_key,
+		connectorId: row.connector_id,
+		connectionId: row.connection_id,
+		sourceInstanceId: row.source_instance_id,
+		agentId: row.agent_id,
+		mode: row.mode,
+		status: row.status,
+		phase: row.phase,
+		itemsDiscovered: row.items_discovered,
+		itemsIndexed: row.items_indexed,
+		candidatesCreated: row.candidates_created,
+		attemptCount: row.attempt_count,
+		...row.error ? { error: row.error } : {},
+		...iso(row.next_run_at) ? { nextRunAt: iso(row.next_run_at) } : {},
+		...iso(row.started_at) ? { startedAt: iso(row.started_at) } : {},
+		...iso(row.finished_at) ? { finishedAt: iso(row.finished_at) } : {},
+		createdAt: new Date(row.created_at).toISOString(),
+		updatedAt: new Date(row.updated_at).toISOString()
+	};
+}
+function enqueueConnectorLearningJob(input) {
+	const now = input.nowMs ?? Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO connector_learning_jobs (
+        job_id, idempotency_key, connector_id, connection_id, source_instance_id,
+        agent_id, mode, status, phase, next_run_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 'queued', 'queued', ?, ?, ?)
+      ON CONFLICT(idempotency_key) DO NOTHING`).run(randomUUID(), input.idempotencyKey, input.connectorId, input.connectionId, input.sourceInstanceId, input.agentId, input.mode, input.nextRunAt ?? now, now, now);
+	});
+	return fromRow(getSqliteDatabase().prepare("SELECT * FROM connector_learning_jobs WHERE idempotency_key = ?").get(input.idempotencyKey));
+}
+function claimNextConnectorLearningJob(nowMs = Date.now()) {
+	return runSqliteWriteTransaction((db) => {
+		const row = db.prepare(`SELECT * FROM connector_learning_jobs
+       WHERE status IN ('queued', 'failed') AND attempt_count < 5 AND COALESCE(next_run_at, 0) <= ?
+       ORDER BY next_run_at ASC, created_at ASC LIMIT 1`).get(nowMs);
+		if (!row) return null;
+		if (db.prepare(`UPDATE connector_learning_jobs SET
+        status = 'running', phase = 'fetching', attempt_count = attempt_count + 1,
+        error = NULL, started_at = COALESCE(started_at, ?), updated_at = ?
+       WHERE job_id = ? AND status IN ('queued', 'failed')`).run(nowMs, nowMs, row.job_id).changes !== 1) return null;
+		return fromRow(db.prepare("SELECT * FROM connector_learning_jobs WHERE job_id = ?").get(row.job_id));
+	});
+}
+function recoverStaleConnectorLearningJobs(staleBeforeMs, nowMs = Date.now()) {
+	return runSqliteWriteTransaction((db) => Number(db.prepare(`UPDATE connector_learning_jobs SET
+      status = CASE WHEN attempt_count >= 5 THEN 'paused' ELSE 'failed' END,
+      error = 'Interrupted while learning; queued for recovery.',
+      next_run_at = CASE WHEN attempt_count >= 5 THEN NULL ELSE ? END,
+      finished_at = ?, updated_at = ?
+     WHERE status = 'running' AND updated_at < ?`).run(nowMs, nowMs, nowMs, staleBeforeMs).changes));
+}
+function setConnectorLearningPaused(connectionId, paused, nowMs = Date.now()) {
+	return runSqliteWriteTransaction((db) => Number(db.prepare(paused ? `UPDATE connector_learning_jobs SET status = 'paused', next_run_at = NULL, updated_at = ?
+         WHERE connection_id = ? AND status IN ('queued', 'failed', 'running')` : `UPDATE connector_learning_jobs SET status = 'queued', next_run_at = ?, updated_at = ?
+         WHERE connection_id = ? AND status = 'paused'`).run(...paused ? [nowMs, connectionId] : [
+		nowMs,
+		nowMs,
+		connectionId
+	]).changes));
+}
+function updateConnectorLearningJob(id, patch) {
+	const now = patch.nowMs ?? Date.now();
+	const fields = ["updated_at = ?"];
+	const values = [now];
+	const add = (column, value) => {
+		if (value === void 0) return;
+		fields.push(`${column} = ?`);
+		values.push(value);
+	};
+	add("status", patch.status);
+	add("phase", patch.phase);
+	add("items_discovered", patch.itemsDiscovered);
+	add("items_indexed", patch.itemsIndexed);
+	add("candidates_created", patch.candidatesCreated);
+	add("error", patch.error);
+	add("next_run_at", patch.nextRunAt);
+	if (patch.finished) add("finished_at", now);
+	values.push(id);
+	getSqliteDatabase().prepare(`UPDATE connector_learning_jobs SET ${fields.join(", ")} WHERE job_id = ?`).run(...values);
+	const row = getSqliteDatabase().prepare("SELECT * FROM connector_learning_jobs WHERE job_id = ?").get(id);
+	if (!row) throw new Error(`Connector learning job not found: ${id}`);
+	return fromRow(row);
+}
+function listConnectorLearningJobs(options = {}) {
+	const clauses = [];
+	const values = [];
+	if (options.sourceInstanceId) {
+		clauses.push("source_instance_id = ?");
+		values.push(options.sourceInstanceId);
+	}
+	if (options.connectionId) {
+		clauses.push("connection_id = ?");
+		values.push(options.connectionId);
+	}
+	const limit = Math.max(1, Math.min(options.limit ?? 100, 500));
+	return getSqliteDatabase().prepare(`SELECT * FROM connector_learning_jobs ${clauses.length ? `WHERE ${clauses.join(" AND ")}` : ""}
+     ORDER BY created_at DESC LIMIT ?`).all(...values, limit).map(fromRow);
+}
+//#endregion
+export { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnectorLearningJobs, recoverStaleConnectorLearningJobs, setConnectorLearningPaused, updateConnectorLearningJob };