@xopcai/xopc 0.0.313 → 0.0.314

package/dist/packages/gateway-contract/src/extension-capabilities.js

@@ -0,0 +1,26 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
+//#region packages/gateway-contract/src/extension-capabilities.ts
+function extensionCapabilityPermissions(bindings) {
+	return bindings.map((binding) => `capability:${binding.id}`);
+}
+var ExtensionCapabilityBindingSchema, ExtensionCapabilityBindingsSchema;
+var init_extension_capabilities = __esmMin((() => {
+	ExtensionCapabilityBindingSchema = z.strictObject({
+		id: z.enum([
+			"xopc.notes.get",
+			"xopc.notes.list",
+			"xopc.tasks.get",
+			"xopc.tasks.list",
+			"xopc.notes.create",
+			"xopc.notes.update",
+			"xopc.notes.append"
+		]),
+		majorVersion: z.number().int().positive(),
+		descriptorDigest: z.string().regex(/^[a-f0-9]{64}$/)
+	});
+	ExtensionCapabilityBindingsSchema = z.array(ExtensionCapabilityBindingSchema).max(7).refine((bindings) => new Set(bindings.map((binding) => binding.id)).size === bindings.length, "Duplicate capability binding");
+}));
+//#endregion
+init_extension_capabilities();
+export { ExtensionCapabilityBindingSchema, ExtensionCapabilityBindingsSchema, extensionCapabilityPermissions, init_extension_capabilities };

package/dist/packages/gateway-contract/src/home.js

@@ -1,7 +1,7 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
 import { z } from "zod";
 //#region packages/gateway-contract/src/home.ts
-var HomeDecisionSchema, HomeActionSchema, HomeWorkbenchItemSchema, HomeRunningConversationSchema;
+var HomeDecisionSchema, HomeActionSchema, HomeWorkbenchItemSchema, HomeRunningConversationSchema, TaskValueMetricsSchema;
 var init_home = __esmMin((() => {
 	HomeDecisionSchema = z.object({
 		id: z.string(),
@@ -164,7 +164,7 @@ var init_home = __esmMin((() => {
 			suppressedAttentionCount: 0
 		})
 	});
-	z.object({
+	TaskValueMetricsSchema = z.object({
 		northStar: z.object({
 			weeklyTrustedProgress: z.number(),
 			weeklyActiveUsers: z.number(),
@@ -185,4 +185,4 @@ var init_home = __esmMin((() => {
 }));
 //#endregion
 init_home();
-export { HomeActionSchema, HomeDecisionSchema, HomeRunningConversationSchema, HomeWorkbenchItemSchema, init_home };
+export { HomeActionSchema, HomeDecisionSchema, HomeRunningConversationSchema, HomeWorkbenchItemSchema, TaskValueMetricsSchema, init_home };

package/dist/packages/gateway-contract/src/index.js

@@ -29,6 +29,10 @@ import { init_connection_waits } from "./connection-waits.js";
 import { init_clarifications } from "./clarifications.js";
 import { init_proactive } from "./proactive.js";
 import { init_discussions } from "./discussions.js";
+import { init_app_context } from "./app-context.js";
+import { init_scenes } from "./scenes.js";
+import { init_capabilities } from "./capabilities.js";
+import { init_extension_capabilities } from "./extension-capabilities.js";
 //#region packages/gateway-contract/src/index.ts
 var init_src = __esmMin((() => {
 	init_agent_stream();
@@ -61,6 +65,10 @@ var init_src = __esmMin((() => {
 	init_clarifications();
 	init_proactive();
 	init_discussions();
+	init_capabilities();
+	init_scenes();
+	init_app_context();
+	init_extension_capabilities();
 }));
 //#endregion
 init_src();

package/dist/packages/gateway-contract/src/product-delivery.js

@@ -7,7 +7,7 @@ function parseProductDeliveryEnvelope(value) {
 }
 function appendProductDeliveryText(text, delivery) {
 	if (!delivery) return text;
-	return `${text}${delivery.primary ? `\nOpen in xopc: [Open](${productReferenceDeepLink(delivery.primary)})` : ""}\n${PRODUCT_DELIVERY_TEXT_PREFIX}${encodeURIComponent(JSON.stringify(delivery))}`;
+	return `${text}${delivery.primary ? `\nOpen in xopc: [Open](${productReferenceDeepLink(delivery.primary)})` : delivery.presentation?.kind === "table" && delivery.presentation.items.length ? `\nOpen in xopc: ${delivery.presentation.items.map((item, index) => `[${index + 1}](${productReferenceDeepLink(item)})`).join(" · ")}` : ""}\n${PRODUCT_DELIVERY_TEXT_PREFIX}${encodeURIComponent(JSON.stringify(delivery))}`;
 }
 function productReferenceDeepLink(reference) {
 	return `xopc://open?${new URLSearchParams({
@@ -15,7 +15,7 @@ function productReferenceDeepLink(reference) {
 		id: reference.id
 	}).toString()}`;
 }
-var ProductReferenceKindSchema, ProductCapabilitySchema, ProductReferenceSchema, ProductDeliveryOperationSchema, ProductDeliveryEnvelopeSchema, PRODUCT_DELIVERY_TEXT_PREFIX;
+var ProductReferenceKindSchema, ProductCapabilitySchema, ProductReferenceSchema, ProductDeliveryOperationSchema, ProductDeliveryPresentationSchema, ProductDeliveryEnvelopeSchema, PRODUCT_DELIVERY_TEXT_PREFIX;
 var init_product_delivery = __esmMin((() => {
 	ProductReferenceKindSchema = z.enum([
 		"task",
@@ -60,14 +60,29 @@ var init_product_delivery = __esmMin((() => {
 		"completed",
 		"failed"
 	]);
+	ProductDeliveryPresentationSchema = z.discriminatedUnion("kind", [z.object({
+		kind: z.literal("table"),
+		items: z.array(ProductReferenceSchema).max(50),
+		truncated: z.boolean()
+	}), z.object({
+		kind: z.literal("diff"),
+		title: z.string().max(2e3),
+		truncated: z.boolean(),
+		edits: z.array(z.object({
+			from: z.number().int().nonnegative(),
+			to: z.number().int().nonnegative(),
+			text: z.string().max(16e3)
+		}).refine((edit) => edit.to >= edit.from, "Invalid replacement range")).max(20).refine((edits) => edits.reduce((total, edit) => total + edit.text.length, 0) <= 16e3, "Replacement text exceeds preview limit")
+	})]);
 	ProductDeliveryEnvelopeSchema = z.object({
 		version: z.literal(1),
 		operation: ProductDeliveryOperationSchema,
 		primary: ProductReferenceSchema.optional(),
-		related: z.array(ProductReferenceSchema).optional()
+		related: z.array(ProductReferenceSchema).optional(),
+		presentation: ProductDeliveryPresentationSchema.optional()
 	});
 	PRODUCT_DELIVERY_TEXT_PREFIX = "xopc-product-delivery:";
 }));
 //#endregion
 init_product_delivery();
-export { ProductCapabilitySchema, ProductDeliveryEnvelopeSchema, ProductDeliveryOperationSchema, ProductReferenceKindSchema, ProductReferenceSchema, appendProductDeliveryText, init_product_delivery, parseProductDeliveryEnvelope, productReferenceDeepLink };
+export { ProductCapabilitySchema, ProductDeliveryEnvelopeSchema, ProductDeliveryOperationSchema, ProductDeliveryPresentationSchema, ProductReferenceKindSchema, ProductReferenceSchema, appendProductDeliveryText, init_product_delivery, parseProductDeliveryEnvelope, productReferenceDeepLink };

package/dist/packages/gateway-contract/src/scenes.js

@@ -0,0 +1,199 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
+//#region packages/gateway-contract/src/scenes.ts
+var identifier, uniqueIds, sceneOutcomeKinds, activationStatuses, sceneScopeSchema, limitsSchema, sceneTemplateSchema, scenePermissionSchema, sceneNotesSchema, activationInputSchema, SceneActivationSchema, SceneConfigureSchema, SceneTransitionSchema, SceneWorkItemCreateSchema, SceneWorkItemUpdateSchema, SceneWorkItemSchema, hour, scenePreferencesSchema, preferenceFields, ScenePreferencePatchSchema, SceneFeedbackSchema, sceneScheduleSchema;
+var init_scenes = __esmMin((() => {
+	identifier = z.string().trim().min(1).max(200);
+	uniqueIds = z.array(identifier).max(100).refine((items) => new Set(items).size === items.length, "Duplicate identifiers");
+	sceneOutcomeKinds = [
+		"no_change",
+		"observation",
+		"artifact",
+		"decision",
+		"state_change",
+		"effect_proposal",
+		"receipt"
+	];
+	activationStatuses = [
+		"needs_setup",
+		"active",
+		"paused",
+		"completed",
+		"archived"
+	];
+	sceneScopeSchema = z.discriminatedUnion("kind", [
+		z.strictObject({ kind: z.literal("personal") }),
+		z.strictObject({
+			kind: z.literal("project"),
+			id: identifier
+		}),
+		z.strictObject({
+			kind: z.literal("conversation"),
+			id: identifier
+		}),
+		z.strictObject({
+			kind: z.literal("objects"),
+			ids: uniqueIds.refine((ids) => ids.length > 0)
+		})
+	]);
+	limitsSchema = z.strictObject({
+		timeoutSeconds: z.number().int().min(1).max(600),
+		maxIterations: z.number().int().min(1).max(30),
+		maxToolCalls: z.number().int().min(0).max(100),
+		maxOutputTokens: z.number().int().min(1).max(32768)
+	});
+	sceneTemplateSchema = z.strictObject({
+		schemaVersion: z.literal(1),
+		key: z.string().regex(/^[a-z][a-z0-9-]{0,79}$/),
+		version: z.string().regex(/^\d+\.\d+\.\d+$/),
+		title: z.string().trim().min(1).max(120),
+		description: z.string().trim().min(1).max(2e3),
+		goalMode: z.enum(["finite", "ongoing"]),
+		contextProviders: uniqueIds,
+		triggers: z.array(z.discriminatedUnion("type", [
+			z.strictObject({
+				id: identifier,
+				type: z.literal("manual")
+			}),
+			z.strictObject({
+				id: identifier,
+				type: z.literal("event"),
+				eventType: identifier
+			}),
+			z.strictObject({
+				id: identifier,
+				type: z.literal("schedule")
+			})
+		])).min(1).max(20).refine((items) => new Set(items.map((item) => item.id)).size === items.length, "Duplicate trigger IDs"),
+		execution: z.strictObject({
+			kind: z.literal("agent"),
+			instruction: z.string().trim().min(1).max(32e3),
+			limits: limitsSchema
+		}),
+		allowedOutcomeKinds: z.array(z.enum(sceneOutcomeKinds)).min(1),
+		allowedEffectHandlers: uniqueIds
+	});
+	scenePermissionSchema = z.strictObject({
+		accountIds: uniqueIds,
+		contextProviders: uniqueIds,
+		effectHandlers: uniqueIds
+	});
+	sceneNotesSchema = z.strictObject({
+		expectedRevision: z.number().int().nonnegative(),
+		content: z.string().trim().max(32e3),
+		validUntil: z.number().int().nonnegative().nullable().default(null)
+	});
+	activationInputSchema = z.strictObject({
+		templateKey: identifier,
+		templateVersion: identifier,
+		goal: z.string().trim().min(1).max(12e3),
+		scope: sceneScopeSchema,
+		permissions: scenePermissionSchema
+	});
+	SceneActivationSchema = activationInputSchema.extend({
+		id: identifier,
+		ownerId: identifier,
+		workspaceId: z.string().min(1),
+		status: z.enum(activationStatuses),
+		setupMissing: z.array(z.string()).optional(),
+		revision: z.number().int().positive()
+	});
+	SceneConfigureSchema = activationInputSchema.pick({
+		goal: true,
+		scope: true,
+		permissions: true
+	}).extend({ expectedRevision: z.number().int().positive() });
+	SceneTransitionSchema = z.strictObject({
+		expectedRevision: z.number().int().positive(),
+		status: z.enum(activationStatuses)
+	});
+	SceneWorkItemCreateSchema = z.strictObject({
+		subjectId: identifier,
+		accountId: identifier,
+		dueAt: z.number().int().nonnegative()
+	});
+	SceneWorkItemUpdateSchema = z.strictObject({
+		expectedRevision: z.number().int().positive(),
+		dueAt: z.number().int().nonnegative().optional(),
+		status: z.enum([
+			"watching",
+			"paused",
+			"completed"
+		]).optional()
+	}).refine((value) => value.dueAt !== void 0 || value.status !== void 0, "Work item update is empty");
+	SceneWorkItemSchema = SceneWorkItemCreateSchema.extend({
+		id: identifier,
+		activationId: identifier,
+		revision: z.number().int().positive(),
+		status: z.enum([
+			"watching",
+			"paused",
+			"completed"
+		])
+	});
+	hour = z.number().int().min(0).max(23);
+	scenePreferencesSchema = z.strictObject({
+		level: z.enum([
+			"quiet",
+			"balanced",
+			"active"
+		]).default("balanced"),
+		timezone: z.string().min(1).max(100).refine((value) => {
+			try {
+				new Intl.DateTimeFormat("en", { timeZone: value });
+				return true;
+			} catch {
+				return false;
+			}
+		}).default("Asia/Shanghai"),
+		quietStartHour: hour.default(22),
+		quietEndHour: hour.default(8),
+		dailyNotificationLimit: z.number().int().min(0).max(30).default(3),
+		digestEnabled: z.boolean().default(false),
+		digestHour: hour.default(18),
+		digestMinute: z.number().int().min(0).max(59).default(0),
+		preferredChannel: z.enum(["in_app", "browser"]).default("browser"),
+		suppressWhileViewing: z.boolean().default(true),
+		checksPaused: z.boolean().default(false),
+		checksPausedUntil: z.string().datetime({ offset: true }).nullable().default(null),
+		notificationsMuted: z.boolean().default(false)
+	});
+	preferenceFields = scenePreferencesSchema.shape;
+	ScenePreferencePatchSchema = z.strictObject({
+		expectedRevision: z.number().int().nonnegative(),
+		level: preferenceFields.level.removeDefault().optional(),
+		timezone: preferenceFields.timezone.removeDefault().optional(),
+		quietStartHour: preferenceFields.quietStartHour.removeDefault().optional(),
+		quietEndHour: preferenceFields.quietEndHour.removeDefault().optional(),
+		dailyNotificationLimit: preferenceFields.dailyNotificationLimit.removeDefault().optional(),
+		digestEnabled: preferenceFields.digestEnabled.removeDefault().optional(),
+		digestHour: preferenceFields.digestHour.removeDefault().optional(),
+		digestMinute: preferenceFields.digestMinute.removeDefault().optional(),
+		preferredChannel: preferenceFields.preferredChannel.removeDefault().optional(),
+		suppressWhileViewing: preferenceFields.suppressWhileViewing.removeDefault().optional(),
+		checksPaused: preferenceFields.checksPaused.removeDefault().optional(),
+		checksPausedUntil: preferenceFields.checksPausedUntil.removeDefault().optional(),
+		notificationsMuted: preferenceFields.notificationsMuted.removeDefault().optional()
+	});
+	SceneFeedbackSchema = z.strictObject({
+		expectedRevision: z.number().int().nonnegative(),
+		rating: z.enum(["useful", "not_useful"]),
+		note: z.string().trim().max(2e3).optional()
+	});
+	sceneScheduleSchema = z.strictObject({
+		weekdays: z.array(z.number().int().min(0).max(6)).min(1).max(7).refine((days) => new Set(days).size === days.length, "Duplicate weekdays"),
+		hour: z.number().int().min(0).max(23),
+		minute: z.number().int().min(0).max(59),
+		timeZone: z.string().trim().min(1).max(100).refine((timeZone) => {
+			try {
+				new Intl.DateTimeFormat("en", { timeZone });
+				return true;
+			} catch {
+				return false;
+			}
+		}, "Invalid time zone")
+	});
+}));
+//#endregion
+init_scenes();
+export { SceneActivationSchema, SceneConfigureSchema, SceneFeedbackSchema, ScenePreferencePatchSchema, SceneTransitionSchema, SceneWorkItemCreateSchema, SceneWorkItemSchema, SceneWorkItemUpdateSchema, activationInputSchema, activationStatuses, init_scenes, sceneNotesSchema, sceneOutcomeKinds, scenePermissionSchema, scenePreferencesSchema, sceneScheduleSchema, sceneScopeSchema, sceneTemplateSchema };

package/dist/packages/gateway-contract/src/task-runs.js

@@ -1,7 +1,7 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
 import { z } from "zod";
 //#region packages/gateway-contract/src/task-runs.ts
-var TaskExecutorKindSchema, TaskRunStatusSchema, TERMINAL_RUN_STATUSES, TaskRunSchema;
+var TaskExecutorKindSchema, TaskRunStatusSchema, TERMINAL_RUN_STATUSES, TaskRunSchema, TaskRunEventSchema;
 var init_task_runs = __esmMin((() => {
 	TaskExecutorKindSchema = z.enum([
 		"agent",
@@ -59,7 +59,11 @@ var init_task_runs = __esmMin((() => {
 			path: ["rootRunId"],
 			message: "A root run must reference itself"
 		});
-		if (run.status !== "queued" && (!run.contextSnapshotId || !run.policySnapshot)) context.addIssue({
+		if ((run.startedAt !== void 0 || [
+			"running",
+			"verifying",
+			"succeeded"
+		].includes(run.status)) && (!run.contextSnapshotId || !run.policySnapshot)) context.addIssue({
 			code: "custom",
 			path: ["contextSnapshotId"],
 			message: "A dispatched run requires context and policy snapshots"
@@ -70,7 +74,7 @@ var init_task_runs = __esmMin((() => {
 			message: "Only terminal runs have a completion timestamp"
 		});
 	});
-	z.object({
+	TaskRunEventSchema = z.object({
 		id: z.string(),
 		runId: z.string(),
 		sequence: z.number().int().positive(),
@@ -82,4 +86,4 @@ var init_task_runs = __esmMin((() => {
 }));
 //#endregion
 init_task_runs();
-export { TaskExecutorKindSchema, TaskRunSchema, TaskRunStatusSchema, init_task_runs };
+export { TaskExecutorKindSchema, TaskRunEventSchema, TaskRunSchema, TaskRunStatusSchema, init_task_runs };

package/dist/packages/gateway-contract/src/tasks.js

@@ -8,7 +8,7 @@ function verifiedTaskCriteria(receipt) {
 	const evidence = new Set(receipt?.evidence.filter((item) => item.strength === "verified").map((item) => item.title));
 	return new Set(receipt?.verification.checks.filter((check) => check.status === "passed" && check.evidenceTitles.some((title) => evidence.has(title))).map((check) => check.criterion));
 }
-var TaskPrioritySchema, TaskChangedFieldSchema, TaskAcceptancePolicySchema, ActorRefSchema, TaskContractSchema, TaskSchema, TaskContextRoleSchema, TaskContextEdgeSchema, TaskAuthorityGrantSchema, TaskDependencySummarySchema, TaskEvidenceSchema, TaskJudgmentSchema, TaskRunReceiptSchema, TaskExecutorSelectionSchema, TaskContractInputSchema, TaskContextInputSchema, TaskCreateRequestSchema, TaskPatchRequestSchema, TaskWaitInputSchema, TaskCommandSchema, TaskCommandRequestSchema, TaskDependencyUpdateRequestSchema, TaskBoardPositionRequestSchema, TaskConversationStateSchema, TaskSessionLinkSchema, TaskHandoffRequestSchema;
+var TaskPrioritySchema, TaskChangedFieldSchema, TaskAcceptancePolicySchema, ActorRefSchema, TaskContractSchema, TaskSchema, TaskContextRoleSchema, TaskContextEdgeSchema, TaskAuthorityGrantSchema, TaskDependencySummarySchema, TaskEvidenceSchema, TaskJudgmentSchema, TaskRunReceiptSchema, TaskExecutorSelectionSchema, TaskContractInputSchema, TaskContextInputSchema, TaskCreateRequestSchema, TaskPatchRequestSchema, TaskWaitInputSchema, TaskCommandSchema, TaskCommandRequestSchema, TaskDependencyUpdateRequestSchema, TaskBoardPositionRequestSchema, TaskListResponseSchema, TaskConversationStateSchema, TaskSessionLinkSchema, TaskHandoffRequestSchema, TaskDetailResponseSchema;
 var init_tasks = __esmMin((() => {
 	init_task_lifecycle();
 	init_task_runs();
@@ -36,6 +36,7 @@ var init_tasks = __esmMin((() => {
 		"context",
 		"runs",
 		"receipts",
+		"feedback",
 		"attention",
 		"conversation"
 	]);
@@ -380,7 +381,7 @@ var init_tasks = __esmMin((() => {
 		expectedVersion: z.number().int().positive(),
 		beforeTaskId: z.string().trim().min(1).nullable().optional()
 	}).strict();
-	z.object({
+	TaskListResponseSchema = z.object({
 		ok: z.literal(true),
 		items: z.array(z.object({
 			task: TaskSchema,
@@ -438,7 +439,7 @@ var init_tasks = __esmMin((() => {
 		activeConversationId: z.string(),
 		assignmentEpoch: z.number().int().positive()
 	});
-	z.object({
+	TaskDetailResponseSchema = z.object({
 		ok: z.literal(true),
 		task: TaskSchema,
 		operationalState: TaskOperationalStateSchema,
@@ -461,4 +462,4 @@ var init_tasks = __esmMin((() => {
 }));
 //#endregion
 init_tasks();
-export { ActorRefSchema, TaskAcceptancePolicySchema, TaskAuthorityGrantSchema, TaskBoardPositionRequestSchema, TaskChangedFieldSchema, TaskCommandRequestSchema, TaskCommandSchema, TaskContextEdgeSchema, TaskContextInputSchema, TaskContextRoleSchema, TaskContractInputSchema, TaskContractSchema, TaskConversationStateSchema, TaskCreateRequestSchema, TaskDependencySummarySchema, TaskDependencyUpdateRequestSchema, TaskEvidenceSchema, TaskExecutorSelectionSchema, TaskHandoffRequestSchema, TaskJudgmentSchema, TaskPatchRequestSchema, TaskPrioritySchema, TaskRunReceiptSchema, TaskSchema, TaskSessionLinkSchema, init_tasks, verifiedTaskCriteria };
+export { ActorRefSchema, TaskAcceptancePolicySchema, TaskAuthorityGrantSchema, TaskBoardPositionRequestSchema, TaskChangedFieldSchema, TaskCommandRequestSchema, TaskCommandSchema, TaskContextEdgeSchema, TaskContextInputSchema, TaskContextRoleSchema, TaskContractInputSchema, TaskContractSchema, TaskConversationStateSchema, TaskCreateRequestSchema, TaskDependencySummarySchema, TaskDependencyUpdateRequestSchema, TaskDetailResponseSchema, TaskEvidenceSchema, TaskExecutorSelectionSchema, TaskHandoffRequestSchema, TaskJudgmentSchema, TaskListResponseSchema, TaskPatchRequestSchema, TaskPrioritySchema, TaskRunReceiptSchema, TaskSchema, TaskSessionLinkSchema, init_tasks, verifiedTaskCriteria };

package/dist/packages/realtime-client/src/index.js

@@ -1,4 +1,4 @@
-import { REALTIME_CAPABILITIES, parseServerRealtimeMessage } from "../../realtime-protocol/src/index.js";
+import { REALTIME_CAPABILITIES, REALTIME_MAX_CLIENT_FRAME_BYTES, parseServerRealtimeMessage } from "../../realtime-protocol/src/index.js";
 //#region packages/realtime-client/src/index.ts
 var RealtimeConnectionError = class extends Error {
 	constructor(message, retryable) {
@@ -7,6 +7,14 @@ var RealtimeConnectionError = class extends Error {
 		this.name = "RealtimeConnectionError";
 	}
 };
+var RealtimeFrameTooLargeError = class extends Error {
+	constructor(bytes, maxBytes) {
+		super(`Realtime client frame is ${bytes} bytes; maximum is ${maxBytes} bytes`);
+		this.bytes = bytes;
+		this.maxBytes = maxBytes;
+		this.name = "RealtimeFrameTooLargeError";
+	}
+};
 function frameText(data) {
 	if (typeof data === "string") return data;
 	if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
@@ -227,8 +235,10 @@ var RealtimeClient = class {
 			if (cursor !== void 0 && message.payload.seq <= cursor) return;
 			this.options.onEvent?.(message.payload);
 			this.cursors.set(message.payload.topic, message.payload.seq);
-		} else if (message.kind === "realtime.subscribed") this.cursors.set(message.payload.topic, message.payload.cursor);
-		else if (message.kind === "realtime.gap") {
+		} else if (message.kind === "realtime.subscribed") {
+			this.cursors.set(message.payload.topic, message.payload.cursor);
+			this.options.onSubscribed?.(message.payload);
+		} else if (message.kind === "realtime.gap") {
 			this.cursors.set(message.payload.topic, message.payload.earliestSeq - 1);
 			return this.options.onGap?.(message.payload);
 		} else if (message.kind === "realtime.error") this.options.onStateChange?.("error", message.payload.message);
@@ -253,7 +263,10 @@ var RealtimeClient = class {
 	}
 	send(message) {
 		if (!this.socket || this.socket.readyState !== 1) return;
-		this.socket.send(JSON.stringify(message));
+		const data = JSON.stringify(message);
+		const bytes = new TextEncoder().encode(data).byteLength;
+		if (bytes > 262144) throw new RealtimeFrameTooLargeError(bytes, REALTIME_MAX_CLIENT_FRAME_BYTES);
+		this.socket.send(data);
 	}
 	scheduleReconnect(error) {
 		if (!this.shouldReconnect) return;

package/dist/src/agent/agent-manager.d.ts

@@ -96,6 +96,7 @@ export interface AgentManagerConfig {
     /** Gateway: exposes first-class xopc product objects for the `xopc_use` tool. */
     getNotesService?: () => NotesService | undefined;
     getProjectService?: () => ProjectService | undefined;
+    getWorkDiscovery?: () => import('../work-discovery/service.js').WorkDiscoveryService | undefined;
     getLocalAppService?: () => import('../local-apps/index.js').LocalAppService | undefined;
     dispatchTaskEvents?: () => void;
     dispatchTaskRuns?: () => void;

package/dist/src/agent/agent-manager.js

@@ -7,48 +7,48 @@ import { getInteractionState } from "../storage/sqlite/interaction-state-reposit
 import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
 import "../storage/sqlite/index.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
+import { applyConfigOverrides } from "../config/runtime-overrides.js";
 import { expandWorkspacePathString, init_workspace_path } from "../config/workspace-path.js";
 import { init_agent_scope, resolveAgentProfileDir } from "./agent-scope.js";
-import { init_paths, resolveBundledSkillsDir } from "../config/paths.js";
-import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { getConversationRouting } from "../storage/sqlite/conversation-repository.js";
 import { init_session_key } from "../routing/session-key.js";
+import { resolveEffectiveAgentProfile, resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
+import { init_paths, resolveBundledSkillsDir } from "../config/paths.js";
 import { init_sync_provider_auth, resolveProviderApiKeySync } from "../auth/sync-provider-auth.js";
+import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { getApiKeySync, getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
 import { createExtensionAwareStreamFn } from "../providers/extension-stream-bridge.js";
-import { loadSkillsLock } from "./skills/hub-lock.js";
-import { isUnderManagedSkillsDir } from "./skills/managed-store.js";
-import { resolveEffectiveAgentProfile, resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
-import { maybeRequestChannelExecApproval } from "../channels/exec-approval-runtime.js";
-import { applyConfigOverrides } from "../config/runtime-overrides.js";
-import { disposeAllSessionMcpRuntimes, retireSessionMcpRuntimeForConversationId } from "./mcp/bundle-mcp-runtime.js";
+import { extractTextContent } from "./context/workspace.js";
+import { buildExecutionScopeContextForPrompt } from "./context/execution-scope.js";
+import { clearBootstrapSnapshot } from "./bootstrap/bootstrap-cache.js";
+import { resolveBootstrapContextSync } from "./bootstrap/bootstrap-files.js";
+import { loadProjectAgentsContextFile } from "./bootstrap/project-agents-context.js";
+import { getEmbeddedExecutionRunId } from "./embedded/execution-context.js";
+import { parseExternalToolRef } from "./external-tools/refs.js";
 import { mcpToolPolicyId } from "./mcp/bundle-mcp-policy.js";
+import { disposeAllSessionMcpRuntimes, retireSessionMcpRuntimeForConversationId } from "./mcp/bundle-mcp-runtime.js";
 import { createSkillConfigManager, isSkillEnabled, resolveSkillConfig } from "./skills/config.js";
 import { isValidSkillEnvVarName } from "./skills/required-env-vars.js";
 import { resolveWorkspaceSkillsDir, resolveWorkspaceSkillsLockPath } from "./skills/workspace-skills-dir.js";
-import { ProjectTrustStore, hasTrustRequiringProjectResources } from "../project-trust/trust-store.js";
-import { parseExternalToolRef } from "./external-tools/refs.js";
-import { extractTextContent } from "./context/workspace.js";
-import { evaluateToolGate } from "./context/execution-context.js";
-import { resolveUserContextSessionAccess } from "../user-context/access-policy.js";
+import { loadSkillsLock } from "./skills/hub-lock.js";
+import { isUnderManagedSkillsDir } from "./skills/managed-store.js";
 import { evictAllEmbeddedSessionRunners, evictEmbeddedSessionRunner } from "./embedded/session-runner.js";
-import { getEmbeddedExecutionRunId } from "./embedded/execution-context.js";
 import { createAgentTurnPolicy } from "./orchestration/agent-turn-policy.js";
-import { buildExecutionScopeContextForPrompt } from "./context/execution-scope.js";
-import { clearBootstrapSnapshot } from "./bootstrap/bootstrap-cache.js";
-import { resolveBootstrapContextSync } from "./bootstrap/bootstrap-files.js";
-import { loadProjectAgentsContextFile } from "./bootstrap/project-agents-context.js";
+import { resolveUserContextSessionAccess } from "../user-context/access-policy.js";
 import { createAgentCapabilitySessionState, resolveAgentCapabilityCatalog } from "./capabilities/registry.js";
 import "./capabilities/index.js";
 import { sortToolsForPromptCache } from "./tools/cache-stability.js";
 import { AgentToolsFactory } from "./tools/factory.js";
 import "./mcp/bundle-mcp-tools.js";
 import { isMemorySubsystemEnabled } from "./memory/memory-config.js";
+import { evaluateToolGate } from "./context/execution-context.js";
 import { ExecutionContextCoordinator } from "./context/coordinator.js";
 import { WorkspaceRuntimeRegistry } from "./workspace-runtime/registry.js";
 import { runTurnUserModelCapture } from "./background-review/run-background-review.js";
 import { BackgroundReviewCoordinator } from "./background-review/coordinator.js";
+import { maybeRequestChannelExecApproval } from "../channels/exec-approval-runtime.js";
 import { SkillFilesystemWatcher } from "./skills/filesystem-watcher.js";
+import { ProjectTrustStore, hasTrustRequiringProjectResources } from "../project-trust/trust-store.js";
 import { basename, resolve, sep } from "node:path";
 import { createHash } from "node:crypto";
 import { Agent } from "@earendil-works/pi-agent-core";
@@ -267,6 +267,7 @@ var AgentManager = class {
 			emitBrowserEvent: this.config.emitBrowserEvent,
 			getNotesService: this.config.getNotesService,
 			getProjectService: this.config.getProjectService,
+			getWorkDiscovery: this.config.getWorkDiscovery,
 			getLocalAppService: this.config.getLocalAppService,
 			dispatchTaskEvents: this.config.dispatchTaskEvents,
 			dispatchTaskRuns: this.config.dispatchTaskRuns,

package/dist/src/agent/agent-scope.js

@@ -3,7 +3,7 @@ import { init_paths_state, resolveStateDir } from "../config/paths-state.js";
 import { expandWorkspacePathString, init_workspace_path } from "../config/workspace-path.js";
 import { init_workspace_defaults, resolveDefaultAgentWorkspaceDir } from "../config/workspace-defaults.js";
 import { basename, isAbsolute, join, relative, resolve } from "node:path";
-import fsSync from "node:fs";
+import fs from "node:fs";
 //#region src/agent/agent-scope.ts
 /**
 * Agent path and list resolution (config is the single source of truth).
@@ -135,7 +135,7 @@ function normalizePathForComparison(input) {
 	const resolved = resolve(resolveUserPath(input));
 	let normalized = resolved;
 	try {
-		normalized = fsSync.realpathSync.native(resolved);
+		normalized = fs.realpathSync.native(resolved);
 	} catch {}
 	if (process.platform === "win32") return normalized.toLowerCase();
 	return normalized;

package/dist/src/agent/background-review/run-background-review.js

@@ -4,17 +4,17 @@ import { finishContextExtractionRun } from "../../storage/sqlite/context-extract
 import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
 import { loadCompactionSourceSnapshot } from "../../storage/sqlite/transcript-repository.js";
 import "../../storage/sqlite/index.js";
+import { extractProfileAgentId } from "../../config/agent-profile.js";
 import { init_sync_provider_auth, resolveProviderApiKeySync } from "../../auth/sync-provider-auth.js";
 import { getApiKeySync, init_providers, resolveModel } from "../../providers/index.js";
 import { createExtensionAwareStreamFn } from "../../providers/extension-stream-bridge.js";
-import { extractProfileAgentId } from "../../config/agent-profile.js";
-import { listUserAssertions } from "../../user-model/repository.js";
-import { resolveModelIntentRef } from "../../config/agent-model-intents.js";
-import { claimRegisteredExtraction } from "../../user-context/extraction/registry.js";
 import { extractTextContent } from "../context/workspace.js";
+import { listUserAssertions } from "../../user-model/repository.js";
 import { readAgentMessageContent } from "../memory/agent-message-access.js";
 import { isAssistantTurnAborted, isAssistantTurnFailed } from "../orchestration/llm-turn-retry.js";
 import { resolveAgentTurnTimeoutMs, runAgentTurnWithTimeout } from "../orchestration/run-agent-turn-with-timeout.js";
+import { resolveModelIntentRef } from "../../config/agent-model-intents.js";
+import { claimRegisteredExtraction } from "../../user-context/extraction/registry.js";
 import { emptyUserModelCaptureResult, executeUserModelInterpretation } from "../../user-model/capture/executor.js";
 import { parseUserModelInterpretation } from "../../user-model/capture/semantic.js";
 import "../../user-model/capture/index.js";

package/dist/src/agent/child-agent-factory.d.ts

@@ -30,6 +30,8 @@ export interface DelegateChildProgressHooks {
     }) => void;
 }
 export interface DelegateChildHandleOptions {
+    /** Host-owned completion signal, e.g. a validated structured result. */
+    isComplete?: () => boolean;
     authorizeToolCall?: import('./orchestration/agent-turn-policy.js').AgentTurnPolicyOptions['authorizeToolCall'];
     workspace: string;
     goal: string;

package/dist/src/agent/child-agent-factory.js

@@ -39,6 +39,10 @@ function createDelegateChildHandle(options) {
 				maxToolFailures: 5,
 				authorizeToolCall: async (context, signal) => {
 					const { toolCall } = context;
+					if (options.isComplete?.()) return {
+						block: true,
+						reason: "The delegated result is already complete."
+					};
 					if (!allow.has(toolCall.name)) return {
 						block: true,
 						reason: "Tool is outside the delegated capability set."
@@ -64,6 +68,7 @@ function createDelegateChildHandle(options) {
 			});
 			const baseStop = policy.shouldStopAfterTurn;
 			policy.shouldStopAfterTurn = (context) => {
+				if (options.isComplete?.()) return true;
 				const stop = baseStop(context) || tokens >= 1e5;
 				if (stop) exhausted = true;
 				return stop;

package/dist/src/agent/coding/repository-instructions.js

@@ -1,5 +1,5 @@
-import { isDataBatchResult } from "../data-acquisition/render.js";
 import { validateDataBatch } from "../data-acquisition/schema.js";
+import { isDataBatchResult } from "../data-acquisition/render.js";
 import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";

package/dist/src/agent/commands/approved-verification.d.ts

@@ -0,0 +1,14 @@
+export declare class VerificationTerminationUnknownError extends Error {
+}
+/** Tests are executable repository content: always sandboxed, no host fallback. */
+export declare function verifyTaskWorkspace(input: {
+    workspace: string;
+    image: string;
+    command: string;
+    signal: AbortSignal;
+    guard: () => void;
+    executionId?: string;
+}): Promise<{
+    passed: boolean;
+    output: string;
+}>;