@xopcai/xopc 0.0.312 → 0.0.314

package/dist/src/scenes/taskFollowUp/workspaceFingerprint.d.ts

@@ -0,0 +1,2 @@
+/** Bind verification to tracked and non-ignored files without executing repository code. */
+export declare function workspaceFingerprint(workspace: string): Promise<string>;

package/dist/src/scenes/taskFollowUp/workspaceFingerprint.js

@@ -0,0 +1,46 @@
+import { runGit } from "../../execution-environments/git.js";
+import { resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { lstat, readFile, readlink } from "node:fs/promises";
+//#region src/scenes/taskFollowUp/workspaceFingerprint.ts
+/** Bind verification to tracked and non-ignored files without executing repository code. */
+async function workspaceFingerprint(workspace) {
+	const hash = createHash("sha256");
+	hash.update(await runGit(workspace, ["rev-parse", "HEAD"]));
+	hash.update(await runGit(workspace, [
+		"symbolic-ref",
+		"--quiet",
+		"HEAD"
+	]));
+	const paths = [...new Set((await runGit(workspace, [
+		"ls-files",
+		"-z",
+		"--cached",
+		"--others",
+		"--exclude-standard"
+	])).split("\0").filter(Boolean))].sort();
+	if (paths.length > 2e4) throw new Error("Workspace verification file budget exceeded");
+	let bytes = 0;
+	for (const path of paths) {
+		const file = resolve(workspace, path);
+		hash.update(JSON.stringify(path));
+		const stat = await lstat(file).catch((error) => {
+			if (error.code === "ENOENT") return void 0;
+			throw error;
+		});
+		if (!stat) {
+			hash.update("deleted");
+			continue;
+		}
+		hash.update(String(stat.mode));
+		if (stat.isSymbolicLink()) hash.update(await readlink(file));
+		else if (stat.isFile()) {
+			bytes += stat.size;
+			if (bytes > 256 * 1024 * 1024) throw new Error("Workspace verification size budget exceeded");
+			hash.update(await readFile(file));
+		} else throw new Error("Submodules and special files require a separate verification workspace");
+	}
+	return hash.digest("hex");
+}
+//#endregion
+export { workspaceFingerprint };

package/dist/src/scenes/templates.d.ts

@@ -27,7 +27,7 @@ export declare const mailFollowUpTemplate: {
             maxOutputTokens: number;
         };
     };
-    allowedOutcomeKinds: ("artifact" | "receipt" | "decision" | "observation" | "no_change" | "state_change" | "effect_proposal")[];
+    allowedOutcomeKinds: ("artifact" | "receipt" | "decision" | "no_change" | "observation" | "state_change" | "effect_proposal")[];
     allowedEffectHandlers: string[];
 };
 export declare const familyPlanTemplate: {
@@ -59,6 +59,6 @@ export declare const familyPlanTemplate: {
             maxOutputTokens: number;
         };
     };
-    allowedOutcomeKinds: ("artifact" | "receipt" | "decision" | "observation" | "no_change" | "state_change" | "effect_proposal")[];
+    allowedOutcomeKinds: ("artifact" | "receipt" | "decision" | "no_change" | "observation" | "state_change" | "effect_proposal")[];
     allowedEffectHandlers: string[];
 };

package/dist/src/scenes/templates.js

@@ -1,4 +1,4 @@
-import { sceneTemplateSchema } from "./contracts.js";
+import { sceneTemplateSchema } from "../../packages/gateway-contract/src/scenes.js";
 //#region src/scenes/templates.ts
 const mailFollowUpTemplate = sceneTemplateSchema.parse({
 	schemaVersion: 1,

package/dist/src/session/session-find.d.ts

@@ -0,0 +1,17 @@
+type FindableMessage = {
+    role: string;
+    content: string | unknown[];
+    displayIndex?: number;
+};
+export type SessionFindMatch = {
+    displayIndex: number;
+    occurrence: number;
+};
+export type SessionFindResult = {
+    query: string;
+    total: number;
+    truncated: boolean;
+    matches: SessionFindMatch[];
+};
+export declare function findSessionMessages(messages: readonly FindableMessage[], rawQuery: string, limit?: number): SessionFindResult;
+export {};

package/dist/src/session/session-find.js

@@ -0,0 +1,56 @@
+import { markdownToIR } from "../markdown/ir.js";
+//#region src/session/session-find.ts
+function searchableMessageText(message) {
+	if (message.role !== "user" && message.role !== "assistant") return "";
+	if (typeof message.content === "string") return markdownToIR(message.content, { tableMode: "bullets" }).text;
+	return message.content.flatMap((block) => {
+		if (!block || typeof block !== "object") return [];
+		const value = block;
+		return value.type === "text" && value.presentation !== "pending" && value.presentation !== "narration" && typeof value.text === "string" ? [markdownToIR(value.text, { tableMode: "bullets" }).text] : [];
+	}).join("\n");
+}
+function countLiteralMatches(text, query) {
+	const haystack = text.toLowerCase();
+	const needle = query.toLowerCase();
+	let count = 0;
+	let from = 0;
+	while (from <= haystack.length - needle.length) {
+		const index = haystack.indexOf(needle, from);
+		if (index < 0) break;
+		count += 1;
+		from = index + needle.length;
+	}
+	return count;
+}
+function findSessionMessages(messages, rawQuery, limit = 1e3) {
+	const query = rawQuery.trim();
+	const cappedLimit = Math.min(1e3, Math.max(1, Math.trunc(limit)));
+	if (!query) return {
+		query,
+		total: 0,
+		truncated: false,
+		matches: []
+	};
+	const matches = [];
+	const occurrencesByDisplayIndex = /* @__PURE__ */ new Map();
+	let total = 0;
+	messages.forEach((message, messageIndex) => {
+		const displayIndex = Number.isInteger(message.displayIndex) && message.displayIndex >= 0 ? message.displayIndex : messageIndex;
+		const count = countLiteralMatches(searchableMessageText(message), query);
+		const occurrenceOffset = occurrencesByDisplayIndex.get(displayIndex) ?? 0;
+		total += count;
+		for (let occurrence = 0; occurrence < count && matches.length < cappedLimit; occurrence += 1) matches.push({
+			displayIndex,
+			occurrence: occurrenceOffset + occurrence
+		});
+		occurrencesByDisplayIndex.set(displayIndex, occurrenceOffset + count);
+	});
+	return {
+		query,
+		total,
+		truncated: total > matches.length,
+		matches
+	};
+}
+//#endregion
+export { findSessionMessages };

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

@@ -10,6 +10,7 @@ import type { SessionMetadata, SessionDetail, SessionListQuery, PaginatedResult,
 import { SessionStatus } from './types.js';
 import type { Message } from './types.js';
 import type { SessionTranscriptUpdate } from './transcript-events.js';
+import { type SessionFindResult } from './session-find.js';
 export interface SessionStoreOptions {
     config: Config;
 }
@@ -43,6 +44,8 @@ export declare class SessionStore {
     private compactor;
     private compactionHooks;
     private readonly compactionTails;
+    private compactionCheckpoint;
+    private clearCompactionCheckpoint;
     constructor(options: SessionStoreOptions, windowConfig?: Partial<WindowConfig>, compactionConfig?: Partial<CompactionConfig>);
     /** Refresh policy for subsequent compactions without changing an in-flight request. */
     updateConfig(config: Config): void;
@@ -176,6 +179,7 @@ export declare class SessionStore {
     }): Promise<AgentMessage[]>;
     estimateTokenUsage(_key: string, messages: AgentMessage[]): Promise<number>;
     searchInSession(key: string, keyword: string): Promise<Message[]>;
+    findInSession(key: string, query: string, limit?: number): Promise<SessionFindResult | null>;
     recallSession(key: string, query: string, options?: {
         limit?: number;
         beforeSeq?: number;

package/dist/src/session/store.js

@@ -13,6 +13,7 @@ import { getSessionConfig, setSessionConfig } from "../storage/sqlite/config-rep
 import "../storage/sqlite/index.js";
 import { init_agent_session_key, resolveAgentIdFromConversationId } from "../routing/agent-session-key.js";
 import { resolveEffectiveAgentProfile } from "../config/agent-profile.js";
+import { DurableState } from "../storage/sqlite/durable-state.js";
 import { transcriptRowsToClientHistory } from "./client-history.js";
 import { SessionCompactor } from "../agent/memory/compaction.js";
 import { resolveCompactionPolicy } from "../agent/memory/compaction-policy.js";
@@ -23,6 +24,7 @@ import { SlidingWindow } from "../agent/memory/window.js";
 import { isAppendOnlyLlmTranscriptMessage } from "./transcript-stats.js";
 import { backfillStructuredTurnOutcomes } from "./turn-outcome-projector.js";
 import { computeTranscriptUserRoundDeleteRange } from "./user-round-delete.js";
+import { findSessionMessages } from "./session-find.js";
 //#region src/session/store.ts
 init_paths_state();
 init_agent_session_key();
@@ -45,6 +47,27 @@ var SessionStore = class {
 	compactor;
 	compactionHooks = {};
 	compactionTails = /* @__PURE__ */ new Map();
+	compactionCheckpoint(key) {
+		const state = new DurableState("session-compaction-progress", key);
+		return {
+			load: () => state.get("active"),
+			save: (checkpoint) => state.set("active", checkpoint),
+			clear: () => {
+				state.delete("active");
+			}
+		};
+	}
+	clearCompactionCheckpoint(key, checkpoint = this.compactionCheckpoint(key)) {
+		try {
+			checkpoint.clear();
+		} catch (err) {
+			log.warn({
+				err,
+				conversationId: key,
+				phase: "checkpoint_clear"
+			}, "Compaction checkpoint cleanup failed");
+		}
+	}
 	constructor(options, windowConfig, compactionConfig) {
 		this.options = options;
 		this.window = new SlidingWindow(windowConfig);
@@ -276,10 +299,13 @@ var SessionStore = class {
 		return this.runStoreMutation(async () => {
 			requireXopcDatabase();
 			const task = resetSessionRecord(key, this.resolveWorkspaceCwd(key));
-			if (task) log.info({
-				key,
-				...task
-			}, "Session reset");
+			if (task) {
+				this.clearCompactionCheckpoint(key);
+				log.info({
+					key,
+					...task
+				}, "Session reset");
+			}
 			return task;
 		});
 	}
@@ -287,7 +313,10 @@ var SessionStore = class {
 		return this.runStoreMutation(async () => {
 			requireXopcDatabase();
 			const ok = deleteSessionRecord(key);
-			if (ok) log.info({ key }, "Session deleted");
+			if (ok) {
+				this.clearCompactionCheckpoint(key);
+				log.info({ key }, "Session deleted");
+			}
 			return ok;
 		});
 	}
@@ -538,20 +567,23 @@ var SessionStore = class {
 				messageCount: messages.length,
 				tokenCount
 			});
+			const checkpoint = executionOptions?.checkpoint ?? this.compactionCheckpoint(key);
 			const result = await this.compactor.compact(snapshot.entries, model, instructions, force, {
 				...executionOptions,
-				conversationId: key
+				conversationId: key,
+				checkpoint
 			});
 			executionOptions?.signal?.throwIfAborted();
 			if (result.compacted) {
 				const compacted = await this.applyCompaction(key, result, snapshot);
+				this.clearCompactionCheckpoint(key, checkpoint);
 				await this.runCompactionHook("after", {
 					conversationId: key,
 					messageCount: compacted.length,
 					tokenCount: result.tokensAfter,
 					compactedCount: Math.max(0, Math.min(messages.length, result.firstKeptIndex))
 				});
-			}
+			} else this.clearCompactionCheckpoint(key, checkpoint);
 			return result;
 		});
 	}
@@ -593,6 +625,10 @@ var SessionStore = class {
 		const q = keyword.toLowerCase();
 		return this.convertMessages(messages.filter((m) => this.extractTextContent(this.messageContent(m)).toLowerCase().includes(q)));
 	}
+	async findInSession(key, query, limit) {
+		if (!await this.getMetadata(key)) return null;
+		return findSessionMessages(transcriptRowsToClientHistory(await this.loadTranscriptRows(key)), query, limit);
+	}
 	recallSession(key, query, options) {
 		requireXopcDatabase();
 		return searchSessionTranscript(key, query, options);

package/dist/src/share/note-share-revocation.d.ts

@@ -0,0 +1,3 @@
+/** SQLite-only revocation for compound note deletion transactions. */
+export declare function revokeNoteShareRecords(noteId: string): string[];
+export declare function canRemoveRevokedNoteShareArtifact(id: string): boolean;

package/dist/src/share/note-share-revocation.js

@@ -0,0 +1,26 @@
+import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { DurableState } from "../storage/sqlite/durable-state.js";
+//#region src/share/note-share-revocation.ts
+init_transaction();
+/** SQLite-only revocation for compound note deletion transactions. */
+function revokeNoteShareRecords(noteId) {
+	return runSqliteWriteTransaction(() => {
+		const shares = new DurableState("shares");
+		const revoked = [];
+		for (const record of shares.values()) {
+			if (record.kind !== "note" || record.sourceNoteId !== noteId || record.revoked) continue;
+			shares.set(record.id, {
+				...record,
+				revoked: true
+			});
+			revoked.push(record.id);
+		}
+		return revoked;
+	});
+}
+function canRemoveRevokedNoteShareArtifact(id) {
+	const record = new DurableState("shares").get(id);
+	return !record || record.kind === "note" && record.revoked;
+}
+//#endregion
+export { canRemoveRevokedNoteShareArtifact, revokeNoteShareRecords };

package/dist/src/storage/sqlite/migrations/190_scene_development.sql

@@ -0,0 +1,37 @@
+-- Scene-specific source and delivery metadata; Task and TaskRun remain authoritative.
+CREATE TABLE scene_development_bindings (
+  activation_id TEXT PRIMARY KEY REFERENCES scene_activations(id) ON DELETE CASCADE,
+  task_id TEXT NOT NULL UNIQUE REFERENCES tasks(task_id) ON DELETE CASCADE,
+  source_key TEXT NOT NULL UNIQUE,
+  input_json TEXT NOT NULL CHECK(json_valid(input_json)),
+  environment_id TEXT REFERENCES execution_environments(environment_id),
+  resource_operation_id TEXT,
+  observed_revision INTEGER NOT NULL DEFAULT 0,
+  delivered_revision INTEGER NOT NULL DEFAULT 0,
+  delivered_decisions_hash TEXT NOT NULL DEFAULT '',
+  applied_revision INTEGER NOT NULL DEFAULT 0,
+  executing_run_id TEXT REFERENCES task_runs(run_id),
+  last_error TEXT,
+  next_poll_at INTEGER NOT NULL DEFAULT 0,
+  failures INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL
+);
+CREATE TABLE scene_development_revisions (
+  activation_id TEXT NOT NULL REFERENCES scene_development_bindings(activation_id) ON DELETE CASCADE,
+  revision INTEGER NOT NULL,
+  source_hash TEXT NOT NULL,
+  content TEXT NOT NULL,
+  observed_at INTEGER NOT NULL,
+  PRIMARY KEY(activation_id, revision)
+);
+CREATE INDEX scene_development_poll ON scene_development_bindings(next_poll_at);
+CREATE TABLE scene_development_branch_links (
+  owner_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  project_id TEXT NOT NULL REFERENCES projects(project_id) ON DELETE CASCADE,
+  branch_ref TEXT NOT NULL,
+  task_id TEXT NOT NULL REFERENCES tasks(task_id) ON DELETE CASCADE,
+  confirmed_sha TEXT NOT NULL,
+  confirmed_at INTEGER NOT NULL,
+  PRIMARY KEY(owner_id, workspace_id, project_id, branch_ref)
+);

package/dist/src/storage/sqlite/migrations/191_scene_task_follow_up.sql

@@ -0,0 +1,27 @@
+-- Preserve experimental records and resources without automatically widening authority.
+ALTER TABLE scene_development_bindings RENAME TO scene_task_bindings;
+ALTER TABLE scene_development_revisions RENAME TO scene_task_revisions;
+ALTER TABLE scene_development_branch_links RENAME TO scene_task_branch_links;
+ALTER TABLE scene_task_bindings RENAME COLUMN applied_revision TO processed_revision;
+ALTER TABLE scene_task_bindings ADD COLUMN continuation_attempts INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE scene_task_bindings ADD COLUMN continuation_requested INTEGER NOT NULL DEFAULT 0;
+UPDATE scene_task_bindings SET input_json = json_patch(json_object(
+  'source', json_object('provider', 'slack_thread', 'reference', json_extract(input_json, '$.thread')),
+  'goal', json_extract(input_json, '$.goal'),
+  'instruction', 'Follow the delegated goal using current discussion. Do not publish, commit, push, merge or deploy.',
+  'projectId', json_extract(input_json, '$.projectId'),
+  'resource', 'worktree',
+  'capabilities', json(CASE WHEN json_extract(input_json, '$.mode') = 'code'
+    THEN CASE WHEN json_extract(input_json, '$.verificationCommand') IS NOT NULL
+      THEN '["workspace.read","workspace.write","verification.run"]' ELSE '["workspace.read","workspace.write"]' END
+    ELSE '["workspace.read"]' END)
+), json_object('sourceUrl', json_extract(input_json, '$.sourceUrl'), 'verificationCommand',
+  CASE WHEN json_extract(input_json, '$.mode') = 'code' THEN json_extract(input_json, '$.verificationCommand') ELSE NULL END)),
+  last_error = 'Configuration migrated. Review permissions and resume explicitly.', next_poll_at = 0;
+-- Original verified receipts remain authoritative; processed is not a verification claim.
+UPDATE scene_activations SET status = CASE WHEN status = 'archived' THEN status ELSE 'paused' END,
+  revision = revision + 1,
+  permissions_json = json_set(permissions_json, '$.contextProviders', json('["connected_source"]'),
+    '$.effectHandlers', json((SELECT json_group_array(value) FROM scene_task_bindings b,
+      json_each(b.input_json, '$.capabilities') WHERE b.activation_id = scene_activations.id AND value <> 'workspace.read')))
+WHERE id IN (SELECT activation_id FROM scene_task_bindings);

package/dist/src/storage/sqlite/migrations/192_capability_operations.sql

@@ -0,0 +1,20 @@
+CREATE TABLE capability_operations (
+  operation_id TEXT PRIMARY KEY,
+  principal_id TEXT NOT NULL,
+  capability_id TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  request_digest TEXT NOT NULL,
+  descriptor_digest TEXT NOT NULL,
+  result_json TEXT NOT NULL CHECK (json_valid(result_json)),
+  created_at INTEGER NOT NULL,
+  UNIQUE(principal_id, capability_id, idempotency_key)
+);
+
+CREATE TABLE capability_invocations (
+  invocation_id TEXT PRIMARY KEY,
+  operation_id TEXT NOT NULL REFERENCES capability_operations(operation_id) ON DELETE CASCADE,
+  surface TEXT NOT NULL,
+  replayed INTEGER NOT NULL CHECK (replayed IN (0, 1)),
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX capability_invocations_operation ON capability_invocations(operation_id, created_at);

package/dist/src/storage/sqlite/migrations/193_note_file_cleanup.sql

@@ -0,0 +1,8 @@
+CREATE TABLE note_file_cleanup (
+  note_id TEXT NOT NULL,
+  relative_path TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  attempts INTEGER NOT NULL DEFAULT 0,
+  next_attempt_at INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (note_id, relative_path)
+);

package/dist/src/storage/sqlite/migrations/194_capability_external_outcomes.sql

@@ -0,0 +1,11 @@
+ALTER TABLE capability_operations ADD COLUMN state TEXT NOT NULL DEFAULT 'succeeded'
+  CHECK (state IN ('running', 'succeeded', 'failed', 'unknown'));
+ALTER TABLE capability_operations ADD COLUMN generation INTEGER NOT NULL DEFAULT 1;
+ALTER TABLE capability_operations ADD COLUMN recovery_mode TEXT NOT NULL DEFAULT 'atomic'
+  CHECK (recovery_mode IN ('atomic', 'manual', 'provider-idempotent'));
+ALTER TABLE capability_operations ADD COLUMN lease_expires_at INTEGER;
+ALTER TABLE capability_operations ADD COLUMN evidence_json TEXT CHECK (evidence_json IS NULL OR json_valid(evidence_json));
+ALTER TABLE capability_invocations ADD COLUMN state TEXT NOT NULL DEFAULT 'succeeded'
+  CHECK (state IN ('running', 'succeeded', 'failed', 'unknown'));
+ALTER TABLE capability_invocations ADD COLUMN finished_at INTEGER;
+ALTER TABLE domain_outbox ADD COLUMN operation_id TEXT;

package/dist/src/storage/sqlite/migrations/195_automation_deleted_revisions.sql

@@ -0,0 +1,4 @@
+CREATE TABLE automation_deleted_revisions (
+  automation_id TEXT PRIMARY KEY,
+  revision INTEGER NOT NULL CHECK (revision >= 0)
+);

package/dist/src/storage/sqlite/migrations/196_automation_run_requests.sql

@@ -0,0 +1,23 @@
+CREATE TABLE automation_run_requests (
+  run_id TEXT PRIMARY KEY,
+  automation_json TEXT NOT NULL CHECK (json_valid(automation_json))
+);
+
+-- Freeze the configuration previously used to resume pre-upgrade queued runs.
+-- Remove only top-level optional fields; merge-patch would erase null workflow inputs.
+INSERT INTO automation_run_requests (run_id, automation_json)
+SELECT r.run_id, json_remove(json_object(
+  'id', a.automation_id, 'name', r.automation_name, 'description', a.description,
+  'projectId', a.project_id, 'enabled', json(CASE WHEN a.enabled = 1 THEN 'true' ELSE 'false' END),
+  'trigger', json(r.trigger_snapshot_json), 'action', json(r.action_snapshot_json),
+  'safety', json(a.safety_json), 'conversationMode', a.conversation_mode,
+  'notificationPolicy', a.notification_policy, 'completionWebhookUrl', a.completion_webhook_url,
+  'reliability', json(a.reliability_json), 'state', json(a.state_json),
+  'createdAtMs', a.created_at_ms, 'updatedAtMs', a.updated_at_ms
+),
+  CASE WHEN a.description IS NULL THEN '$.description' ELSE '$.__absent' END,
+  CASE WHEN a.project_id IS NULL THEN '$.projectId' ELSE '$.__absent' END,
+  CASE WHEN a.safety_json IS NULL THEN '$.safety' ELSE '$.__absent' END,
+  CASE WHEN a.completion_webhook_url IS NULL THEN '$.completionWebhookUrl' ELSE '$.__absent' END,
+  CASE WHEN a.reliability_json IS NULL THEN '$.reliability' ELSE '$.__absent' END
+) FROM automation_runs r JOIN automations a ON a.automation_id = r.automation_id WHERE r.status = 'queued';

package/dist/src/storage/sqlite/migrations/197_note_deletion_cleanup.sql

@@ -0,0 +1,8 @@
+CREATE TABLE note_deletion_cleanup (
+  kind TEXT NOT NULL CHECK(kind IN ('media', 'share')),
+  object_id TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  attempts INTEGER NOT NULL DEFAULT 0,
+  next_attempt_at INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY(kind, object_id)
+);

package/dist/src/storage/sqlite/migrations/198_project_workspace_creation.sql

@@ -0,0 +1,7 @@
+CREATE TABLE project_workspace_creation (
+  project_id TEXT PRIMARY KEY REFERENCES projects(project_id) ON DELETE CASCADE,
+  workspace_root TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  attempts INTEGER NOT NULL DEFAULT 0,
+  next_attempt_at INTEGER NOT NULL DEFAULT 0
+);