@pstdio/pocketcoder-sdk 0.6.0 → 0.7.0

package/dist/index.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { createHash } from "node:crypto";
+import { posix } from "node:path";
 import { isIP } from "node:net";
 //#region ../contracts/src/attachments/attachment.ts
 const ATTACHMENT_MAX_FILE_BYTES = 26214400;
@@ -93,14 +95,160 @@ const AttachmentResolvedPayload = z.object({
 	missing_id: z.uuid().optional()
 });
 //#endregion
+//#region ../contracts/src/common/canonical.ts
+function canonicalJson(value) {
+	return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+	if (Array.isArray(value)) return value.map(sortValue);
+	if (value !== null && typeof value === "object") {
+		const out = {};
+		for (const key of Object.keys(value).sort()) {
+			const v = value[key];
+			if (v !== void 0) out[key] = sortValue(v);
+		}
+		return out;
+	}
+	return value;
+}
+function sha256Hex(input) {
+	return createHash("sha256").update(input).digest("hex");
+}
+function digestOf(value) {
+	return `sha256:${sha256Hex(canonicalJson(value))}`;
+}
+//#endregion
+//#region ../contracts/src/templates/workload-capabilities.ts
+const WorkloadDigestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const WorkloadImageSchema = z.string().regex(/^[^\s@]+@sha256:[0-9a-f]{64}$/);
+const WorkloadNameSchema = z.string().regex(/^[a-z][a-z0-9-]{0,62}$/);
+const WorkloadBoundSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const WorkloadCapabilitySchema = z.enum([
+	"ready-without-task",
+	"live-inputs",
+	"immutable-inputs",
+	"serial-operations",
+	"retained-exports",
+	"explicit-start",
+	"exact-exit",
+	"targeted-cancel",
+	"stop-before-export",
+	"request-lookup",
+	"deduplicated-accept",
+	"explicit-publication",
+	"workspace-services",
+	"revocable-preview-grants",
+	"workspace-cancel",
+	"unknown-outcome"
+]);
+const WorkloadProfileSchema = z.enum([
+	"finite-process",
+	"cloud-interactive",
+	"service"
+]);
+const common$1 = [
+	"ready-without-task",
+	"live-inputs",
+	"immutable-inputs",
+	"serial-operations",
+	"retained-exports"
+];
+[...common$1], [...common$1];
+const WorkloadLimitsSchema = z.strictObject({
+	deadlineSeconds: WorkloadBoundSchema,
+	finalizationSeconds: WorkloadBoundSchema,
+	inputFileBytes: WorkloadBoundSchema,
+	stagedInputBytes: WorkloadBoundSchema,
+	inputFiles: WorkloadBoundSchema,
+	inFlightTransfers: WorkloadBoundSchema,
+	exportBytes: WorkloadBoundSchema,
+	exportFiles: WorkloadBoundSchema,
+	unreferencedInputRetentionSeconds: WorkloadBoundSchema,
+	exportRetentionSeconds: WorkloadBoundSchema
+}).superRefine((limits, ctx) => {
+	for (const [smaller, larger] of [["inputFileBytes", "stagedInputBytes"], ["finalizationSeconds", "deadlineSeconds"]]) if (limits[smaller] > limits[larger]) ctx.addIssue({
+		code: "custom",
+		path: [smaller],
+		message: `${smaller} must not exceed ${larger}`
+	});
+});
+const WorkloadRuntimePinSchema = z.strictObject({
+	digest: WorkloadDigestSchema,
+	protocol: z.literal("pocketcoder.workload/v1")
+});
+const InstalledWorkloadSchema = z.strictObject({
+	workspaceId: z.uuid(),
+	incarnationId: z.string().min(1).max(256),
+	templateDigest: WorkloadDigestSchema,
+	image: WorkloadImageSchema,
+	runtime: WorkloadRuntimePinSchema,
+	storage: z.strictObject({
+		identity: z.string().min(1).max(256),
+		profile: z.enum(["controller-readonly/v1", "shared-writer-readonly/v1"])
+	}),
+	capabilities: z.array(WorkloadCapabilitySchema),
+	adapters: z.record(WorkloadNameSchema, z.strictObject({
+		kind: z.enum([
+			"process",
+			"service",
+			"pi",
+			"agentapi"
+		]),
+		digest: WorkloadDigestSchema,
+		protocol: z.string().min(1).max(128),
+		capabilities: z.array(WorkloadCapabilitySchema)
+	}))
+});
+//#endregion
+//#region ../contracts/src/attachments/input-reference.ts
+const InputObjectReferenceSchema = z.strictObject({
+	workspaceId: z.uuid(),
+	fileId: z.uuid(),
+	objectVersion: WorkloadDigestSchema,
+	name: z.string().min(1).max(255),
+	mediaType: AttachmentMediaTypeSchema,
+	sizeBytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+	digest: WorkloadDigestSchema,
+	visibility: z.enum([
+		"ready",
+		"unavailable",
+		"expired"
+	])
+});
+const AcceptedInputManifestSchema = z.strictObject({
+	workspaceId: z.uuid(),
+	incarnationId: z.string().min(1).max(256),
+	digest: WorkloadDigestSchema,
+	objects: z.array(InputObjectReferenceSchema)
+}).superRefine((manifest, ctx) => {
+	const { digest, ...contents } = manifest;
+	if (digest !== digestOf(contents)) ctx.addIssue({
+		code: "custom",
+		path: ["digest"],
+		message: "input manifest digest does not match its objects"
+	});
+	const ids = /* @__PURE__ */ new Set();
+	for (const [index, object] of manifest.objects.entries()) {
+		if (object.workspaceId !== manifest.workspaceId || object.visibility !== "ready" || ids.has(object.fileId)) ctx.addIssue({
+			code: "custom",
+			path: ["objects", index],
+			message: "accepted inputs must be unique, ready and workspace-scoped"
+		});
+		ids.add(object.fileId);
+	}
+});
+//#endregion
 //#region ../contracts/src/common/scopes.ts
 const SCOPES = [
 	"templates:read",
+	"templates:write",
+	"secrets:write",
 	"workspaces:create",
 	"workspaces:read",
 	"workspaces:cancel",
 	"workspaces:purge",
 	"workspaces:recover",
+	"principals:admin",
 	"keys:read",
 	"keys:write",
 	"workspaces:preserve",
@@ -109,8 +257,12 @@ const SCOPES = [
 	"checkpoints:delete",
 	"outputs:read",
 	"conversations:read",
+	"conversations:write",
 	"conversations:delete",
 	"services:relay",
+	"previews:open",
+	"display:view",
+	"display:control",
 	"attachments:write",
 	"logs:read",
 	"network:read",
@@ -121,13 +273,20 @@ const SCOPES = [
 z.strictObject({
 	request_id: z.string().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/),
 	scopes: z.array(z.enum(SCOPES)).min(1).max(SCOPES.length),
+	templates: z.array(z.string().min(1).max(128)).max(100).optional(),
+	managed_principal_ids: z.array(z.uuid()).max(100).optional(),
 	expires_at: z.iso.datetime()
-});
+}).pick({
+	request_id: true,
+	expires_at: true
+}).partial({ expires_at: true });
 const KeyResourceSchema = z.object({
 	id: z.uuid(),
 	principal_id: z.uuid(),
 	scopes: z.array(z.string()),
 	effective_scopes: z.array(z.string()),
+	templates: z.array(z.string()).nullable(),
+	effective_templates: z.array(z.string()),
 	managed_principal_ids: z.array(z.uuid()),
 	issuance_request_id: z.string().nullable(),
 	created_at: z.iso.datetime(),
@@ -143,12 +302,265 @@ const KeyListResponseSchema = z.object({
 	items: z.array(KeyResourceSchema),
 	next_cursor: z.uuid().nullable()
 });
+const ExpiringKeySchema = KeyResourceSchema.extend({ principal_name: z.string() });
+const ExpiringKeyListResponseSchema = z.object({ items: z.array(ExpiringKeySchema) });
+//#endregion
+//#region ../contracts/src/auth/principals.ts
+const PrincipalGrantsSchema = z.strictObject({
+	scopes: z.array(z.enum(SCOPES)).max(SCOPES.length),
+	templates: z.array(z.string().min(1).max(128)).max(100)
+});
+PrincipalGrantsSchema.extend({ name: z.string().min(1).max(128) });
+const PrincipalResourceSchema = z.object({
+	id: z.uuid(),
+	name: z.string(),
+	scopes: z.array(z.string()),
+	templates: z.array(z.string()),
+	disabled_at: z.iso.datetime().nullable(),
+	created_at: z.iso.datetime()
+});
+const PrincipalListResponseSchema = z.object({ items: z.array(PrincipalResourceSchema) });
+PrincipalGrantsSchema.partial().extend({ disabled: z.boolean().optional() }).refine((value) => Object.keys(value).length > 0, { message: "Provide a grant or disabled status." });
 //#endregion
 //#region ../contracts/src/common/duration.ts
 const DURATION_RE = /^(\d+)(ms|s|m|h)$/;
+const UNIT_MS = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5
+};
 function isDuration(value) {
 	return DURATION_RE.test(value);
 }
+function parseDurationMs(value) {
+	const match = DURATION_RE.exec(value);
+	if (!match) throw new Error(`invalid duration: ${value}`);
+	const amount = Number(match[1]);
+	const unit = UNIT_MS[match[2]];
+	if (unit === void 0) throw new Error(`invalid duration unit: ${value}`);
+	return amount * unit;
+}
+//#endregion
+//#region ../contracts/src/persistence/artifacts.ts
+const SEGMENT = /^(?!\.\.?$)[A-Za-z0-9._-]{1,128}$/;
+const PrivateArtifactSchema = z.object({
+	name: z.string().regex(/^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/),
+	mount: z.string().regex(/^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/),
+	pattern: z.string().max(512).refine((pattern) => {
+		const segments = pattern.split("/");
+		return segments.every((segment) => segment === "*" || SEGMENT.test(segment)) && segments.filter((segment) => segment === "*").length <= 1;
+	}, "pattern must be relative path segments with at most one * segment"),
+	maxBytes: z.number().int().positive().max(67108864).default(8388608)
+});
+//#endregion
+//#region ../contracts/src/persistence/persistence.ts
+const DurationValueSchema = z.string().refine(isDuration, { message: "expected a duration like 15s, 20m, or 2h" });
+const LAUNCH_MODES = ["create", "restore"];
+const CONVERSATION_RESTORE_CAPABILITIES = [
+	"supported",
+	"filesystem_only",
+	"unknown"
+];
+const SourceDescriptorSchema = z.object({
+	kind: z.literal("git"),
+	repository: z.string().min(1).max(64).regex(/^[a-z0-9]([a-z0-9._-]{0,62}[a-z0-9])?$/),
+	revision: z.string().min(1).max(256).refine((value) => !value.startsWith("-") && !value.startsWith("/") && !value.endsWith("/") && !value.endsWith(".") && !value.endsWith(".lock") && value !== "@" && !value.includes("..") && !value.includes("//") && !value.includes("@{") && !/[~^:?*[\]\\\s]/u.test(value) && [...value].every((character) => {
+		const code = character.codePointAt(0) ?? 0;
+		return code >= 32 && code !== 127;
+	}), { message: "revision is not a safe branch, tag, or commit name" })
+});
+const ResolvedSourceSchema = z.object({
+	kind: z.literal("git"),
+	repository: z.string().min(1).max(64),
+	requested_revision: z.string().min(1).max(256),
+	resolved_commit: z.string().regex(/^[0-9a-f]{40,64}$/)
+});
+const PersistenceMountSchema = z.object({
+	name: z.string().min(1).max(64).regex(/^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/),
+	target: z.string().min(1),
+	maxBytes: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+	maxFiles: z.number().int().positive().max(1e7)
+});
+const CheckpointPolicySchema = z.object({
+	onIdle: z.enum(["preserve", "destroy"]).default("destroy"),
+	onDeadline: z.enum(["preserve", "destroy"]).default("destroy"),
+	onCleanExit: z.enum(["preserve", "destroy"]).default("destroy"),
+	onFailure: z.enum([
+		"preserve",
+		"retain-for-recovery",
+		"destroy"
+	]).default("destroy"),
+	retention: DurationValueSchema.default("168h")
+});
+const PersistenceSpecSchema = z.object({
+	mounts: z.array(PersistenceMountSchema).max(16).default([]),
+	conversationRestore: z.enum(CONVERSATION_RESTORE_CAPABILITIES).default("filesystem_only"),
+	conversationRetention: DurationValueSchema.default("168h"),
+	sessionCompatibility: z.string().min(1).max(128).optional(),
+	checkpoint: CheckpointPolicySchema.prefault({}),
+	artifacts: z.array(PrivateArtifactSchema).max(16).optional()
+});
+const OutputDeclarationSchema = z.discriminatedUnion("type", [
+	z.object({ type: z.literal("gitSha") }),
+	z.object({
+		type: z.literal("string"),
+		maxLength: z.number().int().positive().max(4096).default(512)
+	}),
+	z.object({
+		type: z.literal("httpsUrl"),
+		maxLength: z.number().int().positive().max(4096).default(2048)
+	})
+]);
+const CHECKPOINT_STATES = [
+	"creating",
+	"ready",
+	"failed",
+	"deleting",
+	"deleted"
+];
+const OPERATION_KINDS = [
+	"preserve",
+	"restore",
+	"verify",
+	"delete",
+	"purge"
+];
+const OPERATION_STATES = [
+	"pending",
+	"running",
+	"succeeded",
+	"failed"
+];
+const CheckpointResourceSchema = z.object({
+	id: z.uuid(),
+	workspace_id: z.uuid(),
+	state: z.enum(CHECKPOINT_STATES),
+	reason_code: z.string().nullable(),
+	template: z.object({
+		name: z.string(),
+		version: z.string(),
+		digest: z.string()
+	}),
+	manifest_digest: z.string().nullable(),
+	logical_bytes: z.number().int().nonnegative().nullable(),
+	stored_bytes: z.number().int().nonnegative().nullable(),
+	file_count: z.number().int().nonnegative().nullable(),
+	mounts: z.array(z.string()),
+	conversation_restore: z.enum(CONVERSATION_RESTORE_CAPABILITIES),
+	label: z.string().nullable(),
+	created_at: z.iso.datetime(),
+	ready_at: z.iso.datetime().nullable(),
+	expires_at: z.iso.datetime().nullable()
+});
+const OperationResourceSchema = z.object({
+	id: z.uuid(),
+	kind: z.enum(OPERATION_KINDS),
+	state: z.enum(OPERATION_STATES),
+	workspace_id: z.uuid().nullable(),
+	checkpoint_id: z.uuid().nullable(),
+	result_workspace_id: z.uuid().nullable(),
+	reason_code: z.string().nullable(),
+	created_at: z.iso.datetime(),
+	updated_at: z.iso.datetime(),
+	completed_at: z.iso.datetime().nullable()
+});
+z.object({
+	retention: DurationValueSchema.optional(),
+	label: z.string().min(1).max(128).optional()
+});
+z.object({
+	external_id: z.string().min(1).max(256),
+	metadata: z.record(z.string().max(64), z.string().max(512)).optional(),
+	launch_input: z.record(z.string(), z.unknown()).optional()
+});
+const CheckpointManifestEntrySchema = z.object({
+	path: z.string(),
+	kind: z.enum([
+		"directory",
+		"file",
+		"symlink"
+	]),
+	mode: z.number().int().nonnegative(),
+	uid: z.number().int().nonnegative(),
+	gid: z.number().int().nonnegative(),
+	mtime_ns: z.string().regex(/^\d+$/),
+	size: z.number().int().nonnegative(),
+	digest: z.string().optional(),
+	link_target: z.string().optional()
+});
+z.object({
+	format: z.literal("pocketcoder-checkpoint/v1"),
+	checkpoint_id: z.uuid(),
+	template_digest: z.string(),
+	mounts: z.array(z.object({
+		name: z.string(),
+		entries: z.array(CheckpointManifestEntrySchema)
+	})),
+	logical_bytes: z.number().int().nonnegative(),
+	file_count: z.number().int().nonnegative()
+});
+//#endregion
+//#region ../contracts/src/checkpoints/archive-format.ts
+const CHECKPOINT_ARCHIVE_FORMAT = "pocketcoder-checkpoint-tar/v1";
+const count = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const digest$1 = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+const mount = z.strictObject({
+	name: PersistenceMountSchema.shape.name,
+	logical_bytes: count,
+	file_count: count
+});
+const mounts = z.array(mount).max(16).refine((items) => new Set(items.map((item) => item.name)).size === items.length);
+const CheckpointArchiveHeaderSchema = z.strictObject({
+	format: z.literal(CHECKPOINT_ARCHIVE_FORMAT),
+	checkpoint_id: z.uuid(),
+	workspace_id: z.uuid(),
+	template_digest: digest$1,
+	mounts
+});
+function validUnicode(value) {
+	return Buffer.from(value).toString("utf8") === value;
+}
+function safeCheckpointPath(value) {
+	return validUnicode(value) && value === value.normalize("NFC") && !value.includes("\0") && !value.includes("\\") && value.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+function safeCheckpointLink(path, target) {
+	if (!target || !validUnicode(target) || target.startsWith("/") || target.includes("\0") || target.includes("\\")) return false;
+	const resolved = posix.normalize(posix.join(posix.dirname(path), target));
+	return resolved !== ".." && !resolved.startsWith("../") && !posix.isAbsolute(resolved);
+}
+const common = {
+	mount: z.number().int().min(0).max(15),
+	path: z.string().refine(safeCheckpointPath),
+	mode: z.number().int().min(0).max(511),
+	mtime_ns: z.string().regex(/^(0|[1-9]\d*)$/)
+};
+z.discriminatedUnion("kind", [
+	z.strictObject({
+		...common,
+		kind: z.literal("directory"),
+		size: z.literal(0)
+	}),
+	z.strictObject({
+		...common,
+		kind: z.literal("file"),
+		size: count,
+		digest: digest$1
+	}),
+	z.strictObject({
+		...common,
+		kind: z.literal("symlink"),
+		mode: z.literal(511),
+		size: count,
+		digest: digest$1,
+		link_target: z.string()
+	}).refine((entry) => safeCheckpointLink(entry.path, entry.link_target) && entry.size === Buffer.byteLength(entry.link_target) && entry.digest === `sha256:${sha256Hex(entry.link_target)}`)
+]);
+z.strictObject({
+	mounts,
+	manifest_digest: digest$1,
+	content_digest: digest$1
+});
 //#endregion
 //#region ../contracts/src/common/errors.ts
 const ERROR_CODES = {
@@ -156,13 +568,16 @@ const ERROR_CODES = {
 	"auth.missing_scope": 403,
 	"auth.disabled_principal": 403,
 	"principal.not_found": 404,
+	"principal.name_conflict": 409,
 	"key.not_found": 404,
+	"request.body_too_large": 413,
 	"validation.invalid": 400,
 	"idempotency.conflict": 409,
 	"capacity.queue_full": 429,
 	"capacity.waiters_full": 429,
 	"template.not_found": 404,
 	"template.version_not_found": 404,
+	"template.version_immutable": 409,
 	"template.not_authorized": 403,
 	"workspace.not_found": 404,
 	"workspace.external_id_conflict": 409,
@@ -177,6 +592,10 @@ const ERROR_CODES = {
 	"workspace.persistence_not_enabled": 409,
 	"workspace.preserving": 409,
 	"checkpoint.not_found": 404,
+	"checkpoint.unsupported": 409,
+	"artifact.not_found": 404,
+	"artifact.workspace_active": 409,
+	"artifact.too_large": 413,
 	"checkpoint.not_ready": 409,
 	"checkpoint.none_ready": 409,
 	"checkpoint.corrupt": 409,
@@ -186,24 +605,35 @@ const ERROR_CODES = {
 	"restore.image_unavailable": 409,
 	"restore.incompatible": 409,
 	"resume.unsupported": 409,
+	"conversation.not_found": 404,
 	"conversation.expired": 410,
 	"conversation.deleted": 410,
 	"operation.conflict": 409,
 	"source.not_allowed": 422,
 	"source.invalid_revision": 422,
 	"secret.unavailable": 503,
+	"secret.not_found": 404,
 	"storage.capacity_exhausted": 507,
 	"relay.body_too_large": 413,
 	"relay.route_not_allowed": 422,
 	"relay.streaming_unsupported": 409,
 	"relay.deadline_exceeded": 504,
 	"relay.upstream_error": 502,
+	"agent.interrupt_unsupported": 409,
 	"attachment.invalid": 400,
 	"attachment.too_large": 413,
 	"attachment.not_found": 404,
 	"attachment.conflict": 409,
 	"attachment.unsupported": 409,
 	"attachment.interrupted": 503,
+	"maintenance.active": 503,
+	"maintenance.timeout": 503,
+	"backup.failed": 409,
+	"journal.pending": 503,
+	"account.purged": 409,
+	"account.purge_pending": 503,
+	"recovery.required": 503,
+	"recovery.failed": 409,
 	"internal.error": 500
 };
 const errorCodes = Object.keys(ERROR_CODES);
@@ -214,6 +644,9 @@ const ErrorEnvelopeSchema = z.object({ error: z.object({
 	details: z.record(z.string(), z.unknown()).optional()
 }) });
 //#endregion
+//#region ../contracts/src/common/json-value.ts
+const JsonValueSchema = z.json();
+//#endregion
 //#region ../contracts/src/common/pagination.ts
 const CursorSchema = z.string().min(1).max(2048);
 function CursorPageSchema(item) {
@@ -229,6 +662,77 @@ function CursorQuerySchema(maxLimit, defaultLimit) {
 	});
 }
 //#endregion
+//#region ../contracts/src/conversations/facts.ts
+const ProducerCodeSchema = z.string().regex(/^[a-z][a-z0-9_]{0,63}$/);
+const ConversationFactSchema = z.discriminatedUnion("type", [
+	z.object({ type: z.literal("intermediate") }),
+	z.object({ type: z.literal("final_response") }),
+	z.object({ type: z.literal("tool_only") }),
+	z.object({
+		type: z.literal("activity_started"),
+		activity_id: z.uuid(),
+		kind: z.enum([
+			"tool",
+			"attachment",
+			"workspace",
+			"retrieval"
+		]),
+		label: z.string().min(1).max(160),
+		started_at: z.iso.datetime().nullable(),
+		action: ProducerCodeSchema.optional(),
+		subject: ProducerCodeSchema.optional()
+	}),
+	z.object({
+		type: z.literal("activity_finished"),
+		activity_id: z.uuid(),
+		ended_at: z.iso.datetime().nullable(),
+		outcome: z.enum([
+			"completed",
+			"failed",
+			"interrupted",
+			"canceled"
+		])
+	}),
+	z.object({
+		type: z.literal("turn_terminal"),
+		outcome: z.enum([
+			"completed",
+			"failed",
+			"interrupted",
+			"canceled",
+			"lost"
+		]),
+		reason: ProducerCodeSchema.optional()
+	})
+]);
+//#endregion
+//#region ../contracts/src/conversations/identity.ts
+const ConversationRequestIdentitySchema = z.object({
+	schema: z.literal("pocketcoder.conversation/v2"),
+	authority: z.enum(["external", "generic"]),
+	conversation_id: z.uuid(),
+	request_id: z.uuid(),
+	turn_id: z.uuid(),
+	request_fingerprint: z.string().regex(/^[0-9a-f]{64}$/)
+});
+const ConversationRequestReceiptSchema = z.object({
+	kind: z.enum(["accepted", "replayed"]),
+	identity: ConversationRequestIdentitySchema,
+	accepted_at: z.iso.datetime()
+});
+const ConversationMessageIdentitySchema = ConversationRequestIdentitySchema.extend({
+	event_id: z.uuid(),
+	message_id: z.string().min(1).max(256),
+	sequence: z.number().int().nonnegative(),
+	revision: z.number().int().positive(),
+	fact: ConversationFactSchema.optional()
+});
+const ConversationProtocolSupportSchema = z.object({
+	schema: z.literal("pocketcoder.conversation/v2"),
+	request_identity_authorities: z.array(z.enum(["external", "generic"])),
+	producer_capabilities: z.null()
+});
+//#endregion
 //#region ../contracts/src/conversations/conversation.ts
 const CONVERSATION_ROLES = [
 	"user",
@@ -242,14 +746,21 @@ const ConversationMessageInputSchema = z.object({
 	role: z.enum(CONVERSATION_ROLES),
 	content: z.string().max(262144),
 	occurred_at: z.iso.datetime(),
-	metadata: ConversationMetadataSchema.default({})
+	metadata: ConversationMetadataSchema.default({}),
+	identity: ConversationMessageIdentitySchema.nullable().optional()
+});
+const ConversationMessageResourceSchema = ConversationMessageInputSchema.extend({
+	seq: z.number().int().positive(),
+	identity: ConversationMessageIdentitySchema.nullable().default(null)
 });
-const ConversationMessageResourceSchema = ConversationMessageInputSchema.extend({ seq: z.number().int().positive() });
 CursorQuerySchema(200, 100);
-const ConversationPageSchema = CursorPageSchema(ConversationMessageResourceSchema).extend({ retention: z.object({
-	status: z.literal("retained"),
-	expires_at: z.iso.datetime().nullable()
-}) });
+const ConversationPageSchema = CursorPageSchema(ConversationMessageResourceSchema).extend({
+	protocol: ConversationProtocolSupportSchema.nullable().default(null),
+	retention: z.object({
+		status: z.literal("retained"),
+		expires_at: z.iso.datetime().nullable()
+	})
+});
 const ConversationResumeOutcomeSchema = z.object({
 	status: z.literal("supported"),
 	reason: z.null(),
@@ -257,6 +768,160 @@ const ConversationResumeOutcomeSchema = z.object({
 	checkpoint_id: z.uuid()
 });
 //#endregion
+//#region ../contracts/src/conversations/document.ts
+const CONVERSATION_RECORD_STATUSES = [
+	"completed",
+	"failed",
+	"interrupted",
+	"canceled",
+	"lost",
+	"message",
+	"legacy"
+];
+const ConversationActivitySchema = z.object({
+	activity_id: z.uuid(),
+	kind: z.string(),
+	label: z.string(),
+	action: z.string().nullable(),
+	subject: z.string().nullable(),
+	started_at: z.iso.datetime().nullable(),
+	ended_at: z.iso.datetime().nullable(),
+	outcome: z.string().nullable()
+});
+z.object({
+	schema: z.literal("pocketcoder.conversation-record/v1"),
+	turn_id: z.uuid().nullable(),
+	request: ConversationRequestIdentitySchema.nullable(),
+	status: z.enum(CONVERSATION_RECORD_STATUSES),
+	reason: z.string().nullable(),
+	messages: z.array(ConversationMessageResourceSchema),
+	activities: z.array(ConversationActivitySchema),
+	final_response: z.string().nullable(),
+	started_at: z.iso.datetime().nullable(),
+	ended_at: z.iso.datetime().nullable()
+});
+const ConversationSummarySchema = z.object({
+	conversation_id: z.uuid().nullable(),
+	workspace_id: z.uuid(),
+	legacy: z.boolean(),
+	status: z.enum([
+		"retained",
+		"deleted",
+		"expired"
+	]),
+	message_count: z.number().int().nonnegative(),
+	turn_count: z.number().int().nonnegative(),
+	last_activity_at: z.iso.datetime(),
+	expires_at: z.iso.datetime().nullable()
+});
+const ConversationListSchema = z.object({ items: z.array(ConversationSummarySchema) });
+const ConversationDocumentPageSchema = CursorPageSchema(ConversationMessageResourceSchema).extend({
+	conversation: ConversationSummarySchema,
+	protocol: ConversationProtocolSupportSchema
+});
+const ConversationLiveEventSchema = z.discriminatedUnion("type", [z.object({
+	type: z.literal("turn"),
+	conversation_id: z.uuid(),
+	turn_id: z.uuid(),
+	messages: z.array(ConversationMessageResourceSchema.omit({ seq: true }))
+}), z.object({
+	type: z.literal("committed"),
+	conversation_id: z.uuid().nullable(),
+	turn_id: z.uuid().nullable(),
+	status: z.enum(CONVERSATION_RECORD_STATUSES),
+	last_seq: z.number().int().nonnegative()
+})]);
+//#endregion
+//#region ../contracts/src/previews/view-session.ts
+const HttpsOriginSchema = z.string().refine((value) => {
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" && url.origin === value && !url.username && !url.password;
+	} catch {
+		return false;
+	}
+}, "An exact HTTPS origin is required.");
+const ViewSessionSchema = z.discriminatedUnion("mode", [
+	z.strictObject({ mode: z.literal("local") }),
+	z.strictObject({ mode: z.literal("top_level") }),
+	z.strictObject({
+		mode: z.literal("embedded"),
+		parentOrigin: HttpsOriginSchema
+	})
+]);
+z.strictObject({ session: ViewSessionSchema.default({ mode: "local" }) });
+//#endregion
+//#region ../contracts/src/displays/display.ts
+const DisplaySchema = z.strictObject({ mode: z.enum(["desktop", "browser"]) });
+z.strictObject({
+	control: z.boolean().default(false),
+	session: ViewSessionSchema.default({ mode: "local" })
+});
+const BROWSER_WIDTH = 1280;
+const coordinate = (max) => z.number().int().min(0).max(max - 1);
+const url = z.string().max(2048).refine((value) => {
+	try {
+		const parsed = new URL(value);
+		return ["http:", "https:"].includes(parsed.protocol) && !parsed.username && !parsed.password;
+	} catch {
+		return false;
+	}
+}, "Browser navigation requires an HTTP or HTTPS URL without credentials.");
+z.discriminatedUnion("action", [
+	z.strictObject({
+		action: z.literal("navigate"),
+		url
+	}),
+	z.strictObject({
+		action: z.literal("click"),
+		x: coordinate(BROWSER_WIDTH),
+		y: coordinate(800)
+	}),
+	z.strictObject({
+		action: z.literal("text"),
+		text: z.string().min(1).max(1024)
+	}),
+	z.strictObject({
+		action: z.literal("key"),
+		key: z.enum([
+			"Enter",
+			"Tab",
+			"Backspace",
+			"Delete",
+			"Escape",
+			"ArrowLeft",
+			"ArrowRight",
+			"ArrowUp",
+			"ArrowDown",
+			"Home",
+			"End",
+			"PageUp",
+			"PageDown"
+		])
+	}),
+	z.strictObject({
+		action: z.literal("scroll"),
+		x: coordinate(BROWSER_WIDTH),
+		y: coordinate(800),
+		deltaY: z.number().int().min(-1e3).max(1e3)
+	})
+]);
+const ScreenshotResourceSchema = z.strictObject({
+	kind: z.literal("screenshot"),
+	id: z.uuid(),
+	workspace_id: z.uuid(),
+	content_type: z.literal("image/png"),
+	bytes: z.number().int().min(1).max(4 * 1024 ** 2),
+	digest: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+	expires_at: z.iso.datetime()
+});
+const ScreenshotCapturePayload = z.strictObject({
+	output_id: z.uuid(),
+	credential: z.string().min(32).max(128),
+	url: z.url(),
+	expires_at: z.iso.datetime()
+});
+//#endregion
 //#region ../contracts/src/network/network.ts
 const DOMAIN_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
 function isDomain(value) {
@@ -289,173 +954,175 @@ const NETWORK_STATES = [
 const NetworkEventInputSchema = z.object({
 	source_seq: z.number().int().positive(),
 	occurred_at: z.iso.datetime(),
-	decision: z.enum(["allow", "deny"]),
-	transport: z.enum(["http", "https"]),
-	host: z.string().min(1).max(253),
-	port: z.number().int().min(1).max(65535),
-	method: z.string().max(32).nullable().default(null),
-	path: z.string().max(2048).refine((path) => !path.includes("?") && !path.includes("#"), "path cannot contain query or fragment").nullable().default(null),
-	matched_rule: z.string().max(512).nullable().default(null),
-	reason: z.string().min(1).max(128)
-});
-z.object({
-	source_session_id: z.uuid(),
-	events: z.array(NetworkEventInputSchema).min(1).max(100)
-});
-const NetworkEventSchema = NetworkEventInputSchema.omit({ source_seq: true }).extend({
-	seq: z.number().int().positive(),
-	workspace_id: z.uuid(),
-	source_session_id: z.uuid(),
-	source_seq: z.number().int().positive()
-});
-CursorQuerySchema(200, 100);
-const NetworkEventPageSchema = CursorPageSchema(NetworkEventSchema);
-//#endregion
-//#region ../contracts/src/persistence/persistence.ts
-const DurationValueSchema = z.string().refine(isDuration, { message: "expected a duration like 15s, 20m, or 2h" });
-const LAUNCH_MODES = ["create", "restore"];
-const CONVERSATION_RESTORE_CAPABILITIES = [
-	"supported",
-	"filesystem_only",
-	"unknown"
-];
-const SourceDescriptorSchema = z.object({
-	kind: z.literal("git"),
-	repository: z.string().min(1).max(64).regex(/^[a-z0-9]([a-z0-9._-]{0,62}[a-z0-9])?$/),
-	revision: z.string().min(1).max(256).refine((value) => !value.startsWith("-") && !value.startsWith("/") && !value.endsWith("/") && !value.endsWith(".") && !value.endsWith(".lock") && value !== "@" && !value.includes("..") && !value.includes("//") && !value.includes("@{") && !/[~^:?*[\]\\\s]/u.test(value) && [...value].every((character) => {
-		const code = character.codePointAt(0) ?? 0;
-		return code >= 32 && code !== 127;
-	}), { message: "revision is not a safe branch, tag, or commit name" })
-});
-const ResolvedSourceSchema = z.object({
-	kind: z.literal("git"),
-	repository: z.string().min(1).max(64),
-	requested_revision: z.string().min(1).max(256),
-	resolved_commit: z.string().regex(/^[0-9a-f]{40,64}$/)
-});
-const PersistenceMountSchema = z.object({
-	name: z.string().min(1).max(64).regex(/^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/),
-	target: z.string().min(1),
-	maxBytes: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-	maxFiles: z.number().int().positive().max(1e7)
-});
-const CheckpointPolicySchema = z.object({
-	onIdle: z.enum(["preserve", "destroy"]).default("destroy"),
-	onDeadline: z.enum(["preserve", "destroy"]).default("destroy"),
-	onCleanExit: z.enum(["preserve", "destroy"]).default("destroy"),
-	onFailure: z.enum([
-		"preserve",
-		"retain-for-recovery",
-		"destroy"
-	]).default("destroy"),
-	retention: DurationValueSchema.default("168h")
-});
-const PersistenceSpecSchema = z.object({
-	mounts: z.array(PersistenceMountSchema).max(16).default([]),
-	conversationRestore: z.enum(CONVERSATION_RESTORE_CAPABILITIES).default("filesystem_only"),
-	conversationRetention: DurationValueSchema.default("168h"),
-	sessionCompatibility: z.string().min(1).max(128).optional(),
-	checkpoint: CheckpointPolicySchema.prefault({})
-});
-const OutputDeclarationSchema = z.discriminatedUnion("type", [
-	z.object({ type: z.literal("gitSha") }),
-	z.object({
-		type: z.literal("string"),
-		maxLength: z.number().int().positive().max(4096).default(512)
-	}),
-	z.object({
-		type: z.literal("httpsUrl"),
-		maxLength: z.number().int().positive().max(4096).default(2048)
-	})
-]);
-const CHECKPOINT_STATES = [
-	"creating",
-	"ready",
-	"failed",
-	"deleting",
-	"deleted"
-];
-const OPERATION_KINDS = [
-	"preserve",
-	"restore",
-	"verify",
-	"delete",
-	"purge"
-];
-const OPERATION_STATES = [
-	"pending",
-	"running",
-	"succeeded",
-	"failed"
-];
-const CheckpointResourceSchema = z.object({
-	id: z.uuid(),
-	workspace_id: z.uuid(),
-	state: z.enum(CHECKPOINT_STATES),
-	reason_code: z.string().nullable(),
-	template: z.object({
-		name: z.string(),
-		version: z.string(),
-		digest: z.string()
-	}),
-	manifest_digest: z.string().nullable(),
-	logical_bytes: z.number().int().nonnegative().nullable(),
-	stored_bytes: z.number().int().nonnegative().nullable(),
-	file_count: z.number().int().nonnegative().nullable(),
-	mounts: z.array(z.string()),
-	conversation_restore: z.enum(CONVERSATION_RESTORE_CAPABILITIES),
-	label: z.string().nullable(),
-	created_at: z.iso.datetime(),
-	ready_at: z.iso.datetime().nullable(),
-	expires_at: z.iso.datetime().nullable()
-});
-const OperationResourceSchema = z.object({
-	id: z.uuid(),
-	kind: z.enum(OPERATION_KINDS),
-	state: z.enum(OPERATION_STATES),
-	workspace_id: z.uuid().nullable(),
-	checkpoint_id: z.uuid().nullable(),
-	result_workspace_id: z.uuid().nullable(),
-	reason_code: z.string().nullable(),
-	created_at: z.iso.datetime(),
-	updated_at: z.iso.datetime(),
-	completed_at: z.iso.datetime().nullable()
+	decision: z.enum(["allow", "deny"]),
+	transport: z.enum(["http", "https"]),
+	host: z.string().min(1).max(253),
+	port: z.number().int().min(1).max(65535),
+	method: z.string().max(32).nullable().default(null),
+	path: z.string().max(2048).refine((path) => !path.includes("?") && !path.includes("#"), "path cannot contain query or fragment").nullable().default(null),
+	matched_rule: z.string().max(512).nullable().default(null),
+	reason: z.string().min(1).max(128)
 });
 z.object({
-	retention: DurationValueSchema.optional(),
-	label: z.string().min(1).max(128).optional()
+	source_session_id: z.uuid(),
+	events: z.array(NetworkEventInputSchema).min(1).max(100)
 });
-z.object({
-	external_id: z.string().min(1).max(256),
-	metadata: z.record(z.string().max(64), z.string().max(512)).optional(),
-	launch_input: z.record(z.string(), z.unknown()).optional()
+const NetworkEventSchema = NetworkEventInputSchema.omit({ source_seq: true }).extend({
+	seq: z.number().int().positive(),
+	workspace_id: z.uuid(),
+	source_session_id: z.uuid(),
+	source_seq: z.number().int().positive()
 });
-const CheckpointManifestEntrySchema = z.object({
-	path: z.string(),
-	kind: z.enum([
-		"directory",
-		"file",
-		"symlink"
+CursorQuerySchema(200, 100);
+const NetworkEventPageSchema = CursorPageSchema(NetworkEventSchema);
+//#endregion
+//#region ../contracts/src/workspaces/workload-operation.ts
+const WorkloadExecutionReferenceSchema = z.strictObject({
+	workspaceId: z.uuid(),
+	incarnationId: z.string().min(1).max(256),
+	owner: z.enum(["process", "conversation-request"]),
+	requestId: z.uuid()
+});
+const WorkloadAcceptanceSchema = z.strictObject({
+	execution: WorkloadExecutionReferenceSchema,
+	callerPrincipalId: z.uuid(),
+	templateDigest: WorkloadDigestSchema,
+	adapterDigest: WorkloadDigestSchema,
+	operation: WorkloadNameSchema,
+	input: z.record(z.string(), JsonValueSchema),
+	inputs: AcceptedInputManifestSchema,
+	bindingSetDigest: WorkloadDigestSchema,
+	fingerprint: WorkloadDigestSchema
+}).superRefine((value, ctx) => {
+	const { fingerprint, ...facts } = value;
+	if (fingerprint !== digestOf(facts)) ctx.addIssue({
+		code: "custom",
+		path: ["fingerprint"],
+		message: "acceptance fingerprint does not match its facts"
+	});
+	if (value.inputs.workspaceId !== value.execution.workspaceId || value.inputs.incarnationId !== value.execution.incarnationId) ctx.addIssue({
+		code: "custom",
+		path: ["inputs"],
+		message: "accepted input identity must match the execution"
+	});
+});
+const WorkloadCancelSchema = z.strictObject({
+	execution: WorkloadExecutionReferenceSchema,
+	cancelId: z.uuid(),
+	scope: z.enum(["operation", "workspace"])
+});
+//#endregion
+//#region ../contracts/src/outputs/export-reference.ts
+const ExportObjectReferenceSchema = z.strictObject({
+	objectId: z.uuid(),
+	objectVersion: WorkloadDigestSchema,
+	name: z.string().min(1).max(255),
+	sizeBytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+	mediaType: AttachmentMediaTypeSchema,
+	digest: WorkloadDigestSchema
+});
+z.strictObject({
+	exportId: z.uuid(),
+	execution: WorkloadExecutionReferenceSchema,
+	manifestDigest: WorkloadDigestSchema,
+	completeness: z.enum([
+		"complete",
+		"partial",
+		"lost"
 	]),
-	mode: z.number().int().nonnegative(),
-	uid: z.number().int().nonnegative(),
-	gid: z.number().int().nonnegative(),
-	mtime_ns: z.string().regex(/^\d+$/),
-	size: z.number().int().nonnegative(),
-	digest: z.string().optional(),
-	link_target: z.string().optional()
+	publication: z.enum([
+		"published",
+		"unavailable",
+		"expired"
+	]),
+	objects: z.array(ExportObjectReferenceSchema),
+	errors: z.array(z.string().min(1).max(512)),
+	publishedAt: z.iso.datetime(),
+	expiresAt: z.iso.datetime()
+}).superRefine((value, ctx) => {
+	const { execution, objects, completeness, errors } = value;
+	if (value.manifestDigest !== digestOf({
+		execution,
+		objects,
+		completeness,
+		errors
+	})) ctx.addIssue({
+		code: "custom",
+		path: ["manifestDigest"],
+		message: "export digest does not match its frozen manifest"
+	});
+	if (Date.parse(value.expiresAt) <= Date.parse(value.publishedAt)) ctx.addIssue({
+		code: "custom",
+		path: ["expiresAt"],
+		message: "export retention must be positive"
+	});
+	const ids = value.objects.map((object) => object.objectId);
+	if (new Set(ids).size !== ids.length) ctx.addIssue({
+		code: "custom",
+		path: ["objects"],
+		message: "export object IDs must be unique"
+	});
 });
-z.object({
-	format: z.literal("pocketcoder-checkpoint/v1"),
-	checkpoint_id: z.uuid(),
-	template_digest: z.string(),
-	mounts: z.array(z.object({
-		name: z.string(),
-		entries: z.array(CheckpointManifestEntrySchema)
-	})),
-	logical_bytes: z.number().int().nonnegative(),
-	file_count: z.number().int().nonnegative()
+//#endregion
+//#region ../contracts/src/previews/preview.ts
+const PreviewNameSchema = z.string().regex(/^[a-z][a-z0-9-]{0,19}$/).refine((name) => !(/* @__PURE__ */ new Set([
+	"display",
+	"control",
+	"agent",
+	"supervisor",
+	"vnc",
+	"cdp"
+])).has(name) && !name.startsWith("pc-"), "reserved preview name");
+const RESERVED_PORTS = /* @__PURE__ */ new Set([
+	3284,
+	5900,
+	5901,
+	6080,
+	9222,
+	9229
+]);
+const PreviewSchema = z.strictObject({ port: z.number().int().min(1024).max(65535).refine((port) => !RESERVED_PORTS.has(port), "reserved port") });
+const PreviewsSchema = z.record(PreviewNameSchema, PreviewSchema).refine((previews) => Object.keys(previews).length <= 16, "at most 16 previews");
+const PreviewOpenResponseSchema = z.object({
+	url: z.url(),
+	expires_at: z.iso.datetime()
 });
+const PreviewListSchema = z.array(z.object({
+	name: PreviewNameSchema,
+	port: z.number().int()
+}));
+const PreviewSocketPayload = z.discriminatedUnion("op", [
+	z.object({
+		op: z.literal("open"),
+		request_id: z.uuid(),
+		name: z.union([PreviewNameSchema, z.literal("display")]),
+		path: z.string().max(8192),
+		origin: z.url(),
+		cookie: z.string().max(8192).optional(),
+		protocols: z.array(z.string().max(128)).max(16)
+	}),
+	z.object({
+		op: z.literal("ready"),
+		request_id: z.uuid(),
+		protocol: z.string().max(128)
+	}),
+	z.object({
+		op: z.literal("data"),
+		request_id: z.uuid(),
+		seq: z.number().int().nonnegative(),
+		binary: z.boolean(),
+		content_b64: z.string().max(87384)
+	}),
+	z.object({
+		op: z.literal("ack"),
+		request_id: z.uuid(),
+		seq: z.number().int().nonnegative()
+	}),
+	z.object({
+		op: z.literal("close"),
+		request_id: z.uuid()
+	})
+]);
 //#endregion
 //#region ../contracts/src/workspaces/workspace.ts
 const WORKSPACE_STATES = [
@@ -479,6 +1146,15 @@ const TERMINAL_STATES = [
 	"preserved"
 ];
 const REASON_CODES = [
+	...[
+		"admission_global_capacity",
+		"admission_principal_capacity",
+		"admission_template_capacity",
+		"admission_policy_global_capacity",
+		"admission_actor_capacity",
+		"admission_denied",
+		"admission_unavailable"
+	],
 	"child_exit_success",
 	"child_exit_failure",
 	"setup_failed",
@@ -513,6 +1189,7 @@ const AGENT_STATES = [
 	"running",
 	"stable"
 ];
+const AgentInterruptResponseSchema = z.object({ status: z.enum(["requested", "idle"]) });
 z.object({
 	external_id: z.string().min(1).max(256),
 	template: z.object({
@@ -528,10 +1205,15 @@ const TemplateRefSchema = z.object({
 	version: z.string(),
 	digest: z.string()
 });
+const AgentMetadataSchema = z.object({
+	type: z.string(),
+	model: z.string().min(1).max(255).nullable()
+});
 const WorkspaceResourceSchema = z.object({
 	id: z.uuid(),
 	external_id: z.string(),
 	template: TemplateRefSchema,
+	agent: AgentMetadataSchema.nullable(),
 	state: z.enum(WORKSPACE_STATES),
 	reason_code: z.enum(REASON_CODES).nullable(),
 	agent_state: z.enum(AGENT_STATES),
@@ -585,19 +1267,21 @@ z.object({
 	limit: z.coerce.number().int().positive().max(200).default(50),
 	cursor: z.string().optional()
 });
-//#endregion
-//#region ../contracts/src/protocol/api.ts
-const TemplatePageSchema = CursorPageSchema(z.object({
+const TemplateListItemSchema = z.object({
 	name: z.string(),
 	version: z.string(),
 	digest: z.string(),
+	agent: AgentMetadataSchema.nullable(),
 	description: z.string().optional(),
 	status: z.enum([
 		"active",
 		"available",
 		"retired"
 	])
-}));
+});
+//#endregion
+//#region ../contracts/src/protocol/api.ts
+const TemplatePageSchema = CursorPageSchema(TemplateListItemSchema);
 CursorQuerySchema(200, 100);
 const CheckpointPageSchema = CursorPageSchema(CheckpointResourceSchema);
 CursorQuerySchema(200, 50).extend({ state: z.enum(CHECKPOINT_STATES).optional() });
@@ -687,6 +1371,52 @@ const LogChunkSchema = z.object({
 });
 CursorQuerySchema(1e3, 200);
 const LogPageSchema = CursorPageSchema(LogChunkSchema);
+const SecretTypeSchema = z.enum([
+	"setup-issuer",
+	"runtime-issuer",
+	"registry"
+]);
+const SecretNameSchema = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/);
+z.object({ name: SecretNameSchema });
+const issuerUrl = z.url().refine((value) => {
+	if (!URL.canParse(value)) return false;
+	const url = new URL(value);
+	return url.protocol === "https:" && !url.username && !url.password && !url.search && !url.hash;
+});
+const IssuerConfigSchema = z.strictObject({
+	url: issuerUrl,
+	authorization: z.string().min(1).max(16384),
+	policy: z.record(z.string(), z.json()).meta({
+		type: "object",
+		additionalProperties: true
+	})
+});
+const RegistryConfigSchema = z.strictObject({
+	server: z.string().max(255).regex(/^[A-Za-z0-9.-]+(?::[0-9]{1,5})?$/),
+	username: z.string().min(1).max(1024),
+	password: z.string().min(1).max(16384)
+});
+z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("setup-issuer"),
+		value: IssuerConfigSchema
+	}),
+	z.strictObject({
+		type: z.literal("runtime-issuer"),
+		value: IssuerConfigSchema
+	}),
+	z.strictObject({
+		type: z.literal("registry"),
+		value: RegistryConfigSchema
+	})
+]);
+const SecretResourceSchema = z.strictObject({
+	name: SecretNameSchema,
+	type: SecretTypeSchema,
+	updated_at: z.iso.datetime(),
+	retired_at: z.iso.datetime().nullable()
+});
+const SecretListSchema = z.strictObject({ items: z.array(SecretResourceSchema) });
 //#endregion
 //#region ../contracts/src/templates/template-constants.ts
 function isAbsolutePath(value) {
@@ -695,7 +1425,7 @@ function isAbsolutePath(value) {
 const SECRET_ENV_PATTERN = /(SECRET|TOKEN|PASSWORD|PASSWD|API_?KEY|PRIVATE_?KEY|CREDENTIAL)/i;
 const SECRET_REFERENCE_PREFIX = "secretRef:";
 //#endregion
-//#region ../contracts/src/templates/template-schema.ts
+//#region ../contracts/src/templates/template-alpha-schema.ts
 const NAME_RE = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
 const SEMVER_RE = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/;
 const IMAGE_DIGEST_RE = /^[^\s@]+@sha256:[0-9a-f]{64}$/;
@@ -722,10 +1452,12 @@ const HarnessSchema = z.object({
 	cwd: z.string().refine(isAbsolutePath, "expected an absolute path").optional()
 });
 const AgentSchema = HarnessSchema.extend({
+	model: z.string().min(1).max(255).optional().describe("Display metadata only; does not configure the agent model."),
 	type: z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/).default("custom"),
 	transport: z.enum(["pty", "acp"]).default("pty"),
 	termWidth: z.number().int().min(10).max(65535).optional(),
-	stateFile: z.string().refine(isAbsolutePath, "expected an absolute path").optional()
+	stateFile: z.string().refine(isAbsolutePath, "expected an absolute path").optional(),
+	interruptKeys: z.string().min(1).max(16).optional()
 });
 const TerminalSchema = z.object({
 	command: CommandSchema,
@@ -808,6 +1540,7 @@ const CheckpointHookSchema = z.object({
 const TemplateSpecSchema = z.object({
 	version: z.string().regex(SEMVER_RE),
 	image: z.string().regex(IMAGE_DIGEST_RE, { message: "image must be digest-pinned (repo@sha256:<64 hex>)" }),
+	imagePullSecret: z.string().refine((value) => value.startsWith("secretRef:") && SecretNameSchema.safeParse(value.slice(10)).success, "imagePullSecret must name a stored secret").optional(),
 	command: CommandSchema.default([
 		"/usr/local/bin/pocketcoder-supervisor",
 		"supervise",
@@ -818,6 +1551,8 @@ const TemplateSpecSchema = z.object({
 	agent: AgentSchema.optional(),
 	harness: HarnessSchema.optional(),
 	terminal: TerminalSchema.optional(),
+	previews: PreviewsSchema.optional(),
+	display: DisplaySchema.optional(),
 	env: EnvSchema.default({}),
 	resources: ResourcesSchema,
 	timeouts: TimeoutsSchema.prefault({}),
@@ -840,7 +1575,11 @@ const TemplateSpecSchema = z.object({
 		message: "either agent or harness is required"
 	});
 	if (!spec.agent) return;
-	if (spec.agent.transport === "acp") for (const field of ["termWidth", "stateFile"]) {
+	if (spec.agent.transport === "acp") for (const field of [
+		"termWidth",
+		"stateFile",
+		"interruptKeys"
+	]) {
 		if (spec.agent[field] === void 0) continue;
 		ctx.addIssue({
 			code: "custom",
@@ -876,7 +1615,7 @@ const TemplateSpecSchema = z.object({
 	};
 });
 const TemplateManifestBaseSchema = z.object({
-	apiVersion: z.literal("pocketcoder.dev/v1alpha1"),
+	apiVersion: z.literal("pocketcoder.dev/v1alpha1", { error: "unsupported template format for the alpha runtime; canonical workloads require an installed workload runtime" }),
 	kind: z.literal("Template"),
 	metadata: z.object({
 		name: z.string().regex(NAME_RE),
@@ -885,61 +1624,105 @@ const TemplateManifestBaseSchema = z.object({
 	spec: TemplateSpecSchema
 });
 //#endregion
-//#region ../contracts/src/templates/template-runtime.ts
-const LEGACY_AGENTAPI_SERVICE = ServiceSchema.parse({
-	baseUrl: "http://127.0.0.1:3284",
-	routes: [
-		{
-			method: "GET",
-			path: "/status"
-		},
-		{
-			method: "GET",
-			path: "/messages",
-			query: ["after"]
-		},
-		{
-			method: "POST",
-			path: "/message"
-		}
-	]
+//#region ../contracts/src/workspaces/finite-process.ts
+const ProcessReferenceSchema = WorkloadExecutionReferenceSchema.extend({ owner: z.literal("process") });
+const FiniteProcessFactSchema = z.strictObject({
+	execution: ProcessReferenceSchema,
+	fingerprint: WorkloadDigestSchema,
+	phase: z.enum([
+		"claimed",
+		"running",
+		"exited",
+		"lost"
+	]),
+	processGroupId: z.number().int().positive().nullable(),
+	claimedAt: z.iso.datetime(),
+	startedAt: z.iso.datetime().nullable(),
+	endedAt: z.iso.datetime().nullable(),
+	exitCode: z.number().int().nullable(),
+	signal: z.string().min(1).nullable()
+}).superRefine((fact, ctx) => {
+	if ((fact.phase === "exited" || fact.phase === "lost") !== (fact.endedAt !== null)) ctx.addIssue({
+		code: "custom",
+		message: "terminal facts require an end time"
+	});
+	if (fact.phase === "exited" && fact.exitCode === null === (fact.signal === null)) ctx.addIssue({
+		code: "custom",
+		message: "exit requires exactly one observed code or signal"
+	});
+	if (fact.phase !== "exited" && (fact.exitCode !== null || fact.signal !== null)) ctx.addIssue({
+		code: "custom",
+		message: "unobserved exits cannot have a code or signal"
+	});
+	if (fact.phase === "running" && (!fact.processGroupId || !fact.startedAt)) ctx.addIssue({
+		code: "custom",
+		message: "running facts require an owned process group and start time"
+	});
 });
-const AGENTAPI_SERVICE = ServiceSchema.parse({
-	...LEGACY_AGENTAPI_SERVICE,
-	routes: [...LEGACY_AGENTAPI_SERVICE.routes, {
-		method: "GET",
-		path: "/events",
-		responseMode: "stream",
-		maxResponseBytes: 4194304,
-		deadlineSeconds: 300
-	}]
+const WaitingRuntimeSpecSchema = z.strictObject({
+	incarnationId: z.string().min(1).max(256),
+	profile: WorkloadProfileSchema,
+	operations: z.record(z.string(), HarnessSchema),
+	infrastructure: z.record(z.string(), HarnessSchema)
+});
+const ProcessStartPayload = z.strictObject({
+	execution: ProcessReferenceSchema,
+	fingerprint: WorkloadDigestSchema,
+	input: z.record(z.string(), JsonValueSchema).default({}),
+	inputDirectory: z.string().min(1).optional(),
+	operation: z.string().min(1).max(64)
+});
+const ProcessTargetPayload = z.strictObject({ execution: ProcessReferenceSchema });
+const ProcessCancelPayload = ProcessTargetPayload.extend({
+	cancelId: z.uuid(),
+	signal: z.enum(["SIGTERM", "SIGKILL"]),
+	deadlineAt: z.iso.datetime()
+});
+const ProcessCancelResultPayload = ProcessTargetPayload.extend({
+	cancelId: z.uuid(),
+	status: z.enum([
+		"canceled",
+		"requested",
+		"terminal"
+	])
+});
+//#endregion
+//#region ../contracts/src/secrets/credential-slot.ts
+const CredentialSlotSchema = z.strictObject({
+	policyRef: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._/-]{0,254}$/).refine((value) => !value.includes("..")),
+	policyVersion: z.string().min(1).max(128),
+	binding: z.enum(["fixed-scope", "post-create-grant"]),
+	delivery: z.literal("workspace-expiring-file"),
+	maxLeaseSeconds: z.number().int().positive().max(Number.MAX_SAFE_INTEGER)
+});
+//#endregion
+//#region ../contracts/src/templates/workload-input-schema.ts
+const WorkloadInputPropertySchema = z.lazy(() => z.discriminatedUnion("type", [
+	z.strictObject({ type: z.enum([
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"null"
+	]) }),
+	z.strictObject({
+		type: z.literal("array"),
+		items: WorkloadInputPropertySchema
+	}),
+	WorkloadInputSchema
+]));
+const WorkloadInputSchema = z.strictObject({
+	type: z.literal("object"),
+	properties: z.record(z.string(), WorkloadInputPropertySchema),
+	required: z.array(z.string()).default([]),
+	additionalProperties: z.literal(false)
+}).superRefine((schema, ctx) => {
+	if (new Set(schema.required).size !== schema.required.length || schema.required.some((name) => !Object.hasOwn(schema.properties, name))) ctx.addIssue({
+		code: "custom",
+		path: ["required"],
+		message: "required input properties must be declared and unique"
+	});
 });
-function isAgentApiNative(spec) {
-	return "agent" in spec && spec.agent !== void 0;
-}
-function agentApiHarness(spec) {
-	if (!isAgentApiNative(spec)) return spec.harness;
-	return {
-		command: [
-			"/usr/local/bin/agentapi",
-			"server",
-			"--type",
-			spec.agent.type,
-			...spec.agent.transport === "acp" ? ["--experimental-acp"] : [],
-			...spec.agent.termWidth === void 0 ? [] : ["--term-width", String(spec.agent.termWidth)],
-			...spec.agent.stateFile === void 0 ? [] : ["--state-file", spec.agent.stateFile],
-			"--port",
-			"3284",
-			"--",
-			...spec.agent.command
-		],
-		env: spec.agent.env,
-		...spec.agent.cwd ? { cwd: spec.agent.cwd } : {}
-	};
-}
-function templateServices(spec) {
-	return isAgentApiNative(spec) ? { agent: AGENTAPI_SERVICE } : spec.services;
-}
 //#endregion
 //#region ../contracts/src/templates/template-validation.ts
 function envSources(spec) {
@@ -987,7 +1770,7 @@ function validateNetworkEnvironment(spec, ctx) {
 		});
 	}
 }
-function validateServices(spec, ctx) {
+function validateServices$1(spec, ctx) {
 	for (const [serviceName, service] of Object.entries(templateServices(spec))) {
 		if (!isLoopbackBaseUrl(service.baseUrl)) ctx.addIssue({
 			code: "custom",
@@ -1130,7 +1913,7 @@ const FORBIDDEN_PERSISTENCE_ROOTS = [
 function pathContains(parent, child) {
 	return child === parent || child.startsWith(`${parent}/`);
 }
-function validatePersistence(spec, ctx) {
+function validateTemplatePersistence(spec, ctx) {
 	const seenNames = /* @__PURE__ */ new Set();
 	const mounts = spec.persistence.mounts;
 	for (const [index, mount] of mounts.entries()) validatePersistenceMount(spec, mounts, mount, index, seenNames, ctx);
@@ -1147,7 +1930,7 @@ function validatePersistence(spec, ctx) {
 	});
 }
 function validateAgentStateFile(spec, mounts, ctx) {
-	if (!isAgentApiNative(spec)) return;
+	if (!spec.agent) return;
 	const stateFile = spec.agent.stateFile;
 	const normalized = stateFile !== void 0 && isNormalizedFilesystemPath(stateFile);
 	if (stateFile !== void 0 && !normalized) ctx.addIssue({
@@ -1227,59 +2010,477 @@ function validateMountOverlap(mounts, mount, index, path, ctx) {
 		});
 	}
 }
-function validateMemoryPathOverlap(spec, mount, path, ctx) {
-	for (const memoryPath of spec.security.writableMemoryPaths) {
-		if (!pathContains(memoryPath, mount.target) && !pathContains(mount.target, memoryPath)) continue;
-		ctx.addIssue({
-			code: "custom",
-			path,
-			message: `target overlaps writableMemoryPath ${memoryPath}`
-		});
+function validateMemoryPathOverlap(spec, mount, path, ctx) {
+	for (const memoryPath of spec.security.writableMemoryPaths) {
+		if (!pathContains(memoryPath, mount.target) && !pathContains(mount.target, memoryPath)) continue;
+		ctx.addIssue({
+			code: "custom",
+			path,
+			message: `target overlaps writableMemoryPath ${memoryPath}`
+		});
+	}
+}
+function validateSourceMount(spec, mounts, ctx) {
+	if (!spec.source) return;
+	if (mounts.find((mount) => mount.name === spec.source?.destinationMount)) return;
+	ctx.addIssue({
+		code: "custom",
+		path: [
+			"spec",
+			"source",
+			"destinationMount"
+		],
+		message: "source destinationMount must name a persistence mount"
+	});
+}
+function isNormalizedFilesystemPath(path) {
+	if (!isAbsolutePath(path) || path === "/") return false;
+	if (path.endsWith("/") || path.includes("//") || path.includes("\\") || path.includes(",")) return false;
+	if ([...path].some((character) => {
+		const code = character.codePointAt(0) ?? 0;
+		return code < 32 || code === 127;
+	})) return false;
+	return !path.split("/").some((part) => part === "." || part === "..");
+}
+function isNormalizedPath(path) {
+	if (!path.startsWith("/")) return false;
+	if (path.includes("..") || path.includes("//")) return false;
+	if (/[?#\s]/.test(path)) return false;
+	if (/%2e|%2f|%5c/i.test(path)) return false;
+	if ([...path].some((character) => character.charCodeAt(0) <= 31)) return false;
+	return true;
+}
+function validateTemplateSpec(spec, ctx) {
+	validateServices$1(spec, ctx);
+	validatePreviews(spec, ctx);
+	validateEnvironment(spec, ctx);
+	validateOutputs(spec, ctx);
+	validateWritableMemoryPaths(spec, ctx);
+	validateTemplatePersistence(spec, ctx);
+	validateNetworkEnvironment(spec, ctx);
+	validateTerminal(spec, ctx);
+}
+function validatePreviews(spec, ctx) {
+	const servicePorts = new Set(Object.values(templateServices(spec)).filter((service) => isLoopbackBaseUrl(service.baseUrl)).map((service) => {
+		const url = new URL(service.baseUrl);
+		return Number(url.port || 80);
+	}));
+	for (const [name, preview] of Object.entries(spec.previews ?? {})) if (servicePorts.has(preview.port)) ctx.addIssue({
+		code: "custom",
+		path: [
+			"spec",
+			"previews",
+			name,
+			"port"
+		],
+		message: "preview port is reserved by a template service"
+	});
+}
+//#endregion
+//#region ../contracts/src/templates/workload-validation.ts
+function isWorkloadPath(path) {
+	return path.startsWith("/") && !/[\\,\s]/.test(path) && !path.includes("//") && !path.endsWith("/") && ![...path].some((character) => {
+		const code = character.charCodeAt(0);
+		return code < 32 || code === 127;
+	}) && !path.split("/").some((part) => part === "." || part === "..");
+}
+function overlaps(left, right) {
+	return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+function validateProfile(spec, issue) {
+	const operations = Object.values(spec.operations);
+	if (operations.length === 0 && spec.profile !== "service") issue(["operations"], "at least one operation is required");
+	if (spec.profile === "service" && Object.keys(spec.services).length === 0) issue(["services"], "service profile requires declared transport");
+	if (spec.profile === "finite-process" && (operations.length !== 1 || !Object.hasOwn(spec.adapters, operations[0]?.adapter ?? "") || spec.adapters[operations[0]?.adapter ?? ""]?.kind !== "process")) issue(["operations"], "finite-process requires one process operation");
+}
+function validateSecurity(spec, issue) {
+	if (!spec.security.readOnlyRoot || !spec.security.dropCapabilities.includes("ALL")) issue(["security"], "workload profiles require a read-only root and all capabilities dropped");
+	for (const path of spec.security.writableMemoryPaths) if (!isWorkloadPath(path) || [
+		"/run/pocketcoder",
+		"/proc",
+		"/sys",
+		"/dev"
+	].some((root) => overlaps(path, root))) issue(["security", "writableMemoryPaths"], "writable path overlaps protected storage or is not normalized");
+}
+function validateAdapters(spec, issue) {
+	for (const [name, adapter] of Object.entries(spec.adapters)) {
+		const path = ["adapters", name];
+		if (adapter.kind === "service") {
+			if (!adapter.service || !Object.hasOwn(spec.services, adapter.service) || adapter.command) issue(path, "service adapters require a declared service and no process command");
+		} else if (!adapter.command || adapter.service) issue(path, "process, Pi and AgentAPI adapters require a command and no service reference");
+	}
+}
+function validateProcessEnvironment(spec, issue) {
+	const processes = [
+		...spec.lifecycle?.checkpointHook ? [{
+			path: ["lifecycle", "checkpointHook"],
+			process: spec.lifecycle.checkpointHook
+		}] : [],
+		...Object.entries(spec.adapters).map(([name, adapter]) => ({
+			path: ["adapters", name],
+			process: adapter
+		})),
+		...Object.entries(spec.services).flatMap(([name, service]) => service.process ? [{
+			path: [
+				"services",
+				name,
+				"process"
+			],
+			process: service.process
+		}] : [])
+	];
+	for (const { path, process } of processes) {
+		if (process.cwd && process.cwd !== "/" && !isWorkloadPath(process.cwd)) issue(path, "cwd must be normalized");
+		validateEnv(spec, process.env, path, issue);
+	}
+}
+function validateEnv(spec, env, path, issue) {
+	for (const [key, value] of Object.entries(env)) {
+		if (value.startsWith("credentialSlot:")) {
+			if (!Object.hasOwn(spec.credentialSlots, value.slice(15))) issue([
+				...path,
+				"env",
+				key
+			], "unknown credential slot");
+		} else if (SECRET_ENV_PATTERN.test(key) && value !== "" || value.startsWith("secretRef:")) issue([
+			...path,
+			"env",
+			key
+		], "runtime credentials require a credentialSlot: reference");
+		if (spec.network.mode === "restricted" && /^(http_proxy|https_proxy|all_proxy|no_proxy)$/i.test(key)) issue([
+			...path,
+			"env",
+			key
+		], "proxy variables are reserved by restricted networking");
+	}
+}
+function validateOperations(spec, issue) {
+	for (const [name, operation] of Object.entries(spec.operations)) {
+		const adapter = Object.hasOwn(spec.adapters, operation.adapter) ? spec.adapters[operation.adapter] : void 0;
+		if (!adapter) issue([
+			"operations",
+			name,
+			"adapter"
+		], "operation must name a pinned adapter");
+		if (spec.profile === "cloud-interactive" && adapter?.kind === "process") issue(["operations", name], "cloud-interactive requires request-aware adapters");
+		for (const root of operation.outputRoots) if (!isWorkloadPath(root) || [
+			"/run",
+			"/proc",
+			"/sys",
+			"/dev"
+		].some((path) => overlaps(path, root))) issue([
+			"operations",
+			name,
+			"outputRoots"
+		], "output roots must be normalized and outside protected storage");
+	}
+}
+function serviceUrl(value) {
+	try {
+		return new URL(value);
+	} catch {
+		return null;
+	}
+}
+function isLoopbackService(url) {
+	return url.protocol === "http:" && [
+		"127.0.0.1",
+		"localhost",
+		"[::1]"
+	].includes(url.hostname) && !url.username && !url.password && url.pathname === "/" && !url.search && !url.hash;
+}
+function validateServices(spec, issue) {
+	for (const [name, service] of Object.entries(spec.services)) {
+		const url = serviceUrl(service.baseUrl);
+		if (!url || !isLoopbackService(url)) {
+			issue(["services", name], "service must use loopback HTTP without credentials or a path");
+			continue;
+		}
+		const routes = /* @__PURE__ */ new Set();
+		if (!isNormalizedPath(service.healthPath)) issue([
+			"services",
+			name,
+			"healthPath"
+		], "health path must be normalized");
+		for (const route of service.routes) {
+			const key = `${route.method} ${route.path}`;
+			if (!isNormalizedPath(route.path) || routes.has(key)) issue([
+				"services",
+				name,
+				"routes"
+			], "routes must be normalized and unique");
+			routes.add(key);
+		}
+		for (const [previewName, preview] of Object.entries(spec.previews)) if (preview.port === Number(url.port || 80)) issue(["previews", previewName], "preview port is reserved by a service");
 	}
 }
-function validateSourceMount(spec, mounts, ctx) {
-	if (!spec.source) return;
-	if (mounts.find((mount) => mount.name === spec.source?.destinationMount)) return;
-	ctx.addIssue({
+function validateWorkloadTemplate(manifest, ctx) {
+	const spec = manifest.spec;
+	const issue = (path, message) => ctx.addIssue({
 		code: "custom",
-		path: [
-			"spec",
-			"source",
-			"destinationMount"
-		],
-		message: "source destinationMount must name a persistence mount"
+		path: ["spec", ...path],
+		message
 	});
+	validateTemplatePersistence({
+		security: spec.security,
+		source: null,
+		persistence: spec.lifecycle?.persistence ?? PersistenceSpecSchema.parse({})
+	}, ctx);
+	const timeouts = spec.lifecycle?.timeouts;
+	if (timeouts && (parseDurationMs(timeouts.maxAge) > spec.limits.deadlineSeconds * 1e3 || parseDurationMs(timeouts.terminateGrace) > spec.limits.finalizationSeconds * 1e3)) issue(["lifecycle", "timeouts"], "Lifecycle timeouts exceed the workload limits.");
+	validateProfile(spec, issue);
+	validateSecurity(spec, issue);
+	validateAdapters(spec, issue);
+	validateProcessEnvironment(spec, issue);
+	validateOperations(spec, issue);
+	validateServices(spec, issue);
+	for (const [name, slot] of Object.entries(spec.credentialSlots)) if (slot.maxLeaseSeconds > spec.limits.deadlineSeconds) issue(["credentialSlots", name], "credential lifetime exceeds the workspace deadline");
 }
-function isNormalizedFilesystemPath(path) {
-	if (!isAbsolutePath(path) || path === "/") return false;
-	if (path.endsWith("/") || path.includes("//") || path.includes("\\") || path.includes(",")) return false;
-	if ([...path].some((character) => {
-		const code = character.codePointAt(0) ?? 0;
-		return code < 32 || code === 127;
-	})) return false;
-	return !path.split("/").some((part) => part === "." || part === "..");
+//#endregion
+//#region ../contracts/src/templates/workload-template.ts
+const WorkloadAdapterSchema = z.strictObject({
+	kind: z.enum([
+		"process",
+		"service",
+		"pi",
+		"agentapi"
+	]),
+	digest: WorkloadDigestSchema,
+	protocol: z.string().min(1).max(128),
+	command: HarnessSchema.shape.command.optional(),
+	cwd: HarnessSchema.shape.cwd,
+	env: HarnessSchema.shape.env,
+	service: WorkloadNameSchema.optional()
+});
+const WorkloadOperationSchema = z.strictObject({
+	adapter: WorkloadNameSchema,
+	inputSchema: WorkloadInputSchema,
+	requiredCapabilities: z.array(WorkloadCapabilitySchema),
+	outputRoots: z.array(z.string()).max(16)
+});
+const WorkloadTemplateSchema = z.strictObject({
+	apiVersion: z.literal("pocketcoder.dev/v1"),
+	kind: z.literal("Template"),
+	metadata: z.strictObject({
+		name: WorkloadNameSchema,
+		description: z.string().max(512).optional()
+	}),
+	spec: z.strictObject({
+		version: z.string().regex(/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/),
+		image: WorkloadImageSchema,
+		runtime: WorkloadRuntimePinSchema,
+		profile: WorkloadProfileSchema,
+		adapters: z.record(WorkloadNameSchema, WorkloadAdapterSchema),
+		operations: z.record(WorkloadNameSchema, WorkloadOperationSchema),
+		services: z.record(WorkloadNameSchema, ServiceSchema.extend({ process: HarnessSchema.strict().optional() }).strict()),
+		previews: PreviewsSchema,
+		credentialSlots: z.record(WorkloadNameSchema, CredentialSlotSchema),
+		resources: ResourcesSchema.strict(),
+		network: NetworkPolicySchema,
+		security: SecuritySchema.strict(),
+		limits: WorkloadLimitsSchema,
+		lifecycle: z.strictObject({
+			persistence: PersistenceSpecSchema.prefault({}),
+			checkpointHook: CheckpointHookSchema.optional(),
+			timeouts: TimeoutsSchema.optional(),
+			maxLaunchInputBytes: z.number().int().positive().max(1048576).default(65536)
+		}).optional()
+	})
+}).superRefine(validateWorkloadTemplate);
+const WorkloadTemplateSnapshotSchema = z.strictObject({
+	format: z.literal("pocketcoder.dev/v1"),
+	name: WorkloadNameSchema,
+	version: z.string(),
+	digest: WorkloadDigestSchema,
+	manifest: WorkloadTemplateSchema
+}).superRefine((snapshot, ctx) => {
+	if (snapshot.name !== snapshot.manifest.metadata.name || snapshot.version !== snapshot.manifest.spec.version || snapshot.digest !== digestOf(snapshot.manifest)) ctx.addIssue({
+		code: "custom",
+		message: "snapshot identity does not match its immutable manifest"
+	});
+});
+//#endregion
+//#region ../contracts/src/templates/template-runtime.ts
+const LEGACY_AGENTAPI_SERVICE = ServiceSchema.parse({
+	baseUrl: "http://127.0.0.1:3284",
+	routes: [
+		{
+			method: "GET",
+			path: "/status"
+		},
+		{
+			method: "GET",
+			path: "/messages",
+			query: ["after"]
+		},
+		{
+			method: "POST",
+			path: "/message"
+		}
+	]
+});
+const AGENTAPI_SERVICE = ServiceSchema.parse({
+	...LEGACY_AGENTAPI_SERVICE,
+	routes: [...LEGACY_AGENTAPI_SERVICE.routes, {
+		method: "GET",
+		path: "/events",
+		responseMode: "stream",
+		maxResponseBytes: 4194304,
+		deadlineSeconds: 300
+	}]
+});
+function isAgentApiNative(spec) {
+	return "agent" in spec && spec.agent !== void 0;
 }
-function isNormalizedPath(path) {
-	if (!path.startsWith("/")) return false;
-	if (path.includes("..") || path.includes("//")) return false;
-	if (/[?#\s]/.test(path)) return false;
-	if (/%2e|%2f|%5c/i.test(path)) return false;
-	if ([...path].some((character) => character.charCodeAt(0) <= 31)) return false;
-	return true;
+function agentApiHarness(spec) {
+	if (!isAgentApiNative(spec)) {
+		if (!spec.harness) throw new Error("A workload infrastructure process is not an alpha harness.");
+		return spec.harness;
+	}
+	return {
+		command: [
+			"/usr/local/bin/agentapi",
+			"server",
+			"--type",
+			spec.agent.type,
+			...spec.agent.transport === "acp" ? ["--experimental-acp"] : [],
+			...spec.agent.termWidth === void 0 ? [] : ["--term-width", String(spec.agent.termWidth)],
+			...spec.agent.stateFile === void 0 ? [] : ["--state-file", spec.agent.stateFile],
+			"--port",
+			"3284",
+			"--",
+			...spec.agent.command
+		],
+		env: spec.agent.env,
+		...spec.agent.cwd ? { cwd: spec.agent.cwd } : {}
+	};
 }
-function validateTemplateSpec(spec, ctx) {
-	validateServices(spec, ctx);
-	validateEnvironment(spec, ctx);
-	validateOutputs(spec, ctx);
-	validateWritableMemoryPaths(spec, ctx);
-	validatePersistence(spec, ctx);
-	validateNetworkEnvironment(spec, ctx);
-	validateTerminal(spec, ctx);
+function templateServices(spec) {
+	return isAgentApiNative(spec) ? { agent: AGENTAPI_SERVICE } : spec.services ?? {};
 }
-TemplateManifestBaseSchema.superRefine((manifest, ctx) => {
+z.object({
+	name: z.string(),
+	version: z.string(),
+	digest: WorkloadDigestSchema,
+	spec: TemplateSpecSchema
+});
+//#endregion
+//#region ../contracts/src/templates/template.ts
+const TemplateManifestSchema = TemplateManifestBaseSchema.superRefine((manifest, ctx) => {
 	validateTemplateSpec(manifest.spec, ctx);
 });
 //#endregion
+//#region ../contracts/src/protocol/protocol-checkpoint.ts
+const bytes = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+const PrepareCheckpointArchivePayload = z.object({
+	operation_id: z.uuid(),
+	checkpoint_id: z.uuid(),
+	deadline_ms: bytes,
+	mounts: z.array(PersistenceMountSchema).max(16),
+	max_archive_bytes: bytes,
+	max_index_bytes: bytes,
+	max_queue_bytes: bytes
+});
+const CheckpointPreparedPayload = z.object({
+	operation_id: z.uuid(),
+	checkpoint_id: z.uuid(),
+	header: CheckpointArchiveHeaderSchema,
+	archive_bytes: bytes
+}).refine((value) => value.header.checkpoint_id === value.checkpoint_id, "Checkpoint declaration identity differs.");
+const grant = z.object({
+	operation_id: z.uuid(),
+	transfer_id: z.uuid(),
+	checkpoint_id: z.uuid(),
+	credential: z.string().min(1).max(4096),
+	url: z.url(),
+	expires_at: z.iso.datetime()
+});
+const CheckpointUploadPayload = grant;
+const RestoreTransferSpecSchema = grant.extend({
+	source: z.object({
+		checkpoint_id: z.uuid(),
+		workspace_id: z.uuid(),
+		template_digest: digest,
+		archive_digest: digest
+	}),
+	mounts: z.array(PersistenceMountSchema).max(16),
+	max_archive_bytes: bytes,
+	max_index_bytes: bytes,
+	max_ledger_bytes: bytes
+}).refine((value) => value.source.checkpoint_id === value.checkpoint_id, "Restore source identity differs.");
+const CheckpointInstalledPayload = z.object({
+	operation_id: z.uuid(),
+	transfer_id: z.uuid(),
+	checkpoint_id: z.uuid(),
+	archive_digest: digest,
+	phase: z.enum(["installed", "failed"])
+});
+const CheckpointUploadStatusPayload = z.object({
+	operation_id: z.uuid(),
+	transfer_id: z.uuid(),
+	checkpoint_id: z.uuid(),
+	phase: z.enum(["uploaded", "failed"])
+});
+//#endregion
+//#region ../contracts/src/protocol/protocol-exec.ts
+const SOURCE_CREDENTIAL_MAX_BYTES = 65536;
+const RestoreModeSchema = z.enum(["provider_installed", "controller_archive"]);
+const ExecSpecSchema = z.object({
+	agentapi_native: z.boolean().default(false),
+	setup: z.array(SetupStepSchema),
+	harness: HarnessSchema.nullable(),
+	workload: WaitingRuntimeSpecSchema.optional(),
+	env: z.record(z.string(), z.string()),
+	services: z.record(z.string(), ServiceSchema),
+	previews: PreviewsSchema.optional(),
+	display: DisplaySchema.optional(),
+	terminal: z.object({
+		command: z.array(z.string().min(1)).min(1),
+		cwd: z.string().optional(),
+		env: z.record(z.string(), z.string()),
+		max_sessions: z.number().int().min(1).max(8),
+		idle_timeout_seconds: z.number().int().positive(),
+		replay_buffer_bytes: z.number().int().positive()
+	}).nullable().default(null),
+	timeouts: TimeoutsSchema,
+	security: z.object({ writable_memory_paths: z.array(z.string()) }).default({ writable_memory_paths: [] }),
+	network: z.discriminatedUnion("mode", [z.object({ mode: z.literal("unrestricted") }), z.object({
+		mode: z.literal("restricted"),
+		proxy_url: z.url(),
+		health_url: z.url()
+	})]).default({ mode: "unrestricted" }),
+	launch_mode: z.enum(LAUNCH_MODES).default("create"),
+	source: SourceDescriptorSchema.extend({
+		url: z.url(),
+		destination: z.string(),
+		max_bytes: z.number().int().positive().optional(),
+		max_files: z.number().int().positive().optional(),
+		credential_expires_at: z.iso.datetime().nullable().default(null),
+		credential: z.string().min(1).max(SOURCE_CREDENTIAL_MAX_BYTES).refine((value) => !value.includes("\0"), "credential must not contain NUL bytes").nullable().default(null)
+	}).nullable().default(null),
+	restore: z.object({
+		mode: RestoreModeSchema,
+		checkpoint_id: z.uuid(),
+		origin_workspace_id: z.uuid(),
+		transfer: RestoreTransferSpecSchema.nullable().default(null)
+	}).nullable().default(null),
+	persistence: z.object({
+		mounts: z.array(z.object({
+			name: z.string(),
+			target: z.string()
+		})),
+		conversation_restore: z.enum(CONVERSATION_RESTORE_CAPABILITIES)
+	}),
+	checkpoint_hook: z.object({
+		command: z.array(z.string().min(1)).min(1),
+		timeout_seconds: z.number().int().positive(),
+		env: z.record(z.string(), z.string()),
+		cwd: z.string().optional()
+	}).nullable(),
+	outputs: z.record(z.string(), z.unknown())
+});
+//#endregion
 //#region ../contracts/src/terminals/terminal.ts
 const TERMINAL_CHUNK_BYTES = 32768;
 const TERMINAL_REPLAY_BUFFER_BYTES = 65536;
@@ -1394,11 +2595,34 @@ const TerminalSessionSchema = z.object({
 CursorQuerySchema(200, 50);
 const TerminalSessionPageSchema = CursorPageSchema(TerminalSessionSchema);
 //#endregion
+//#region ../contracts/src/protocol/protocol-credentials.ts
+const WorkspaceCredentialSchema = z.object({
+	lease_id: z.uuid(),
+	path: z.string().regex(/^\/run\/pocketcoder\/secrets\/leases\/[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/),
+	credential: z.string().min(1).max(SOURCE_CREDENTIAL_MAX_BYTES).refine((value) => !value.includes("\0")),
+	expires_at: z.iso.datetime(),
+	purpose: z.enum(["setup-issuer", "runtime-issuer"])
+});
+const CredentialRenewPayload = z.object({
+	lease_id: z.uuid(),
+	request_id: z.uuid()
+});
+const CredentialRenewedPayload = z.object({
+	previous_lease_id: z.uuid(),
+	request_id: z.uuid(),
+	credential: WorkspaceCredentialSchema
+});
+const CredentialInstalledPayload = z.object({
+	previous_lease_id: z.uuid(),
+	lease_id: z.uuid()
+});
+//#endregion
 //#region ../contracts/src/protocol/protocol-stream.ts
 const ProxyStreamStartPayload = z.object({
 	request_id: z.uuid(),
 	status: z.number().int().min(100).max(599),
-	headers: z.record(z.string(), z.string())
+	headers: z.record(z.string(), z.string()),
+	cookies: z.array(z.string().max(4096)).max(16).optional()
 });
 const ProxyStreamChunkPayload = z.object({
 	request_id: z.uuid(),
@@ -1466,7 +2690,6 @@ z.object({
 	type: z.literal("lease_assignment"),
 	input: ProviderInputSchema
 });
-const SOURCE_CREDENTIAL_MAX_BYTES = 65536;
 const EnvelopeBase = z.object({
 	v: z.union([
 		z.literal(1),
@@ -1474,7 +2697,14 @@ const EnvelopeBase = z.object({
 		z.literal(3),
 		z.literal(4),
 		z.literal(5),
-		z.literal(6)
+		z.literal(6),
+		z.literal(7),
+		z.literal(8),
+		z.literal(9),
+		z.literal(10),
+		z.literal(11),
+		z.literal(12),
+		z.literal(13)
 	]),
 	workspace_id: z.uuid(),
 	connection_id: z.uuid(),
@@ -1496,6 +2726,7 @@ const HeartbeatPayload = z.object({
 	child: z.enum([
 		"starting",
 		"setup",
+		"waiting",
 		"running",
 		"exited",
 		"terminating"
@@ -1510,6 +2741,7 @@ const ProcessStatePayload = z.object({
 	phase: z.enum([
 		"starting",
 		"setup",
+		"waiting",
 		"running",
 		"exited",
 		"terminating"
@@ -1591,6 +2823,38 @@ const RestoreStatusPayload = z.object({
 });
 const ConversationMessagePayload = ConversationMessageInputSchema;
 z.discriminatedUnion("type", [
+	EnvelopeBase.extend({
+		type: z.literal("runtime_ready"),
+		payload: z.object({ incarnationId: z.string().min(1) })
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("finite_process"),
+		payload: FiniteProcessFactSchema
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("process_absent"),
+		payload: ProcessTargetPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("process_cancel_result"),
+		payload: ProcessCancelResultPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("preview_socket"),
+		payload: PreviewSocketPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("credential_renew"),
+		payload: CredentialRenewPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("credential_installed"),
+		payload: CredentialInstalledPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("setup_complete"),
+		payload: z.object({ request_id: z.uuid() })
+	}),
 	EnvelopeBase.extend({
 		type: z.literal("registered"),
 		payload: RegisteredPayload
@@ -1660,77 +2924,44 @@ z.discriminatedUnion("type", [
 		payload: CheckpointStatusPayload
 	}),
 	EnvelopeBase.extend({
-		type: z.literal("output_published"),
-		payload: OutputPublishedPayload
-	}),
-	EnvelopeBase.extend({
-		type: z.literal("restore_status"),
-		payload: RestoreStatusPayload
+		type: z.literal("checkpoint_prepared"),
+		payload: CheckpointPreparedPayload
 	}),
 	EnvelopeBase.extend({
-		type: z.literal("conversation_message"),
-		payload: ConversationMessagePayload
+		type: z.literal("checkpoint_installed"),
+		payload: CheckpointInstalledPayload
 	}),
 	EnvelopeBase.extend({
-		type: z.literal("attachment_ack"),
-		payload: AttachmentAckPayload
+		type: z.literal("checkpoint_upload_status"),
+		payload: CheckpointUploadStatusPayload
 	}),
 	EnvelopeBase.extend({
-		type: z.literal("attachment_result"),
-		payload: AttachmentResultPayload
+		type: z.literal("output_published"),
+		payload: OutputPublishedPayload
 	}),
-	EnvelopeBase.extend({
-		type: z.literal("attachment_resolved"),
-		payload: AttachmentResolvedPayload
-	})
-]);
-const ExecSpecSchema = z.object({
-	agentapi_native: z.boolean().default(false),
-	setup: z.array(SetupStepSchema),
-	harness: HarnessSchema,
-	env: z.record(z.string(), z.string()),
-	services: z.record(z.string(), ServiceSchema),
-	terminal: z.object({
-		command: z.array(z.string().min(1)).min(1),
-		cwd: z.string().optional(),
-		env: z.record(z.string(), z.string()),
-		max_sessions: z.number().int().min(1).max(8),
-		idle_timeout_seconds: z.number().int().positive(),
-		replay_buffer_bytes: z.number().int().positive()
-	}).nullable().default(null),
-	timeouts: TimeoutsSchema,
-	security: z.object({ writable_memory_paths: z.array(z.string()) }).default({ writable_memory_paths: [] }),
-	network: z.discriminatedUnion("mode", [z.object({ mode: z.literal("unrestricted") }), z.object({
-		mode: z.literal("restricted"),
-		proxy_url: z.url(),
-		health_url: z.url()
-	})]).default({ mode: "unrestricted" }),
-	launch_mode: z.enum(LAUNCH_MODES).default("create"),
-	source: SourceDescriptorSchema.extend({
-		url: z.url(),
-		destination: z.string(),
-		credential: z.string().min(1).max(SOURCE_CREDENTIAL_MAX_BYTES).refine((value) => !value.includes("\0"), "credential must not contain NUL bytes").nullable().default(null)
-	}).nullable().default(null),
-	restore: z.object({
-		checkpoint_id: z.uuid(),
-		origin_workspace_id: z.uuid()
-	}).nullable().default(null),
-	persistence: z.object({
-		mounts: z.array(z.object({
-			name: z.string(),
-			target: z.string()
-		})),
-		conversation_restore: z.enum(CONVERSATION_RESTORE_CAPABILITIES)
+	EnvelopeBase.extend({
+		type: z.literal("restore_status"),
+		payload: RestoreStatusPayload
 	}),
-	checkpoint_hook: z.object({
-		command: z.array(z.string().min(1)).min(1),
-		timeout_seconds: z.number().int().positive(),
-		env: z.record(z.string(), z.string()),
-		cwd: z.string().optional()
-	}).nullable(),
-	outputs: z.record(z.string(), z.unknown())
-});
+	EnvelopeBase.extend({
+		type: z.literal("conversation_message"),
+		payload: ConversationMessagePayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("attachment_ack"),
+		payload: AttachmentAckPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("attachment_result"),
+		payload: AttachmentResultPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("attachment_resolved"),
+		payload: AttachmentResolvedPayload
+	})
+]);
 const RegisteredAckPayload = z.object({
+	credentials: z.array(WorkspaceCredentialSchema).max(64).default([]),
 	epoch: z.number().int().positive(),
 	reconnect_credential: z.string().optional(),
 	limits: z.object({
@@ -1749,7 +2980,9 @@ const ProxyRequestPayload = z.object({
 		"POST",
 		"PUT",
 		"PATCH",
-		"DELETE"
+		"DELETE",
+		"HEAD",
+		"OPTIONS"
 	]),
 	path: z.string(),
 	query: z.record(z.string(), z.string()).default({}),
@@ -1765,6 +2998,42 @@ const PrepareCheckpointPayload = z.object({
 	deadline_ms: z.number().int().positive()
 });
 z.discriminatedUnion("type", [
+	EnvelopeBase.extend({
+		type: z.literal("process_start"),
+		payload: ProcessStartPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("process_lookup"),
+		payload: ProcessTargetPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("process_cancel"),
+		payload: ProcessCancelPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("process_ack"),
+		payload: ProcessTargetPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("screenshot_capture"),
+		payload: ScreenshotCapturePayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("preview_socket"),
+		payload: PreviewSocketPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("credential_renewed"),
+		payload: CredentialRenewedPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("credential_installed_ack"),
+		payload: CredentialInstalledPayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("setup_complete_ack"),
+		payload: z.object({ request_id: z.uuid() })
+	}),
 	EnvelopeBase.extend({
 		type: z.literal("registered_ack"),
 		payload: RegisteredAckPayload
@@ -1813,6 +3082,14 @@ z.discriminatedUnion("type", [
 		type: z.literal("prepare_checkpoint"),
 		payload: PrepareCheckpointPayload
 	}),
+	EnvelopeBase.extend({
+		type: z.literal("prepare_checkpoint_archive"),
+		payload: PrepareCheckpointArchivePayload
+	}),
+	EnvelopeBase.extend({
+		type: z.literal("checkpoint_upload"),
+		payload: CheckpointUploadPayload
+	}),
 	EnvelopeBase.extend({
 		type: z.literal("attachment_start"),
 		payload: AttachmentStartPayload
@@ -1835,6 +3112,107 @@ z.discriminatedUnion("type", [
 	})
 ]);
 //#endregion
+//#region ../contracts/src/recovery/account-purge.ts
+const Digest = z.string().regex(/^[a-f0-9]{64}$/);
+const AccountPurgeIntentSchema = z.strictObject({
+	format: z.literal("pocketcoder-account-purge/v1"),
+	accountId: z.uuid(),
+	operationId: z.uuid(),
+	createRequestDigest: Digest,
+	purgeRequestDigest: Digest,
+	admittedAt: z.iso.datetime()
+});
+z.strictObject({
+	format: z.literal("pocketcoder-account-purge-completion/v1"),
+	intent: AccountPurgeIntentSchema,
+	completedAt: z.iso.datetime()
+});
+//#endregion
+//#region ../contracts/src/recovery/source-writer.ts
+const fileIdentity = z.strictObject({
+	device: z.string().regex(/^\d+$/).max(20),
+	inode: z.string().regex(/^[1-9]\d*$/).max(20)
+});
+z.strictObject({
+	format: z.literal("pocketcoder-source-writer/v1"),
+	directory: z.string().startsWith("/").max(4096),
+	root: fileIdentity,
+	lock: fileIdentity
+});
+z.strictObject({ manifest: z.union([TemplateManifestSchema, WorkloadTemplateSchema]) });
+z.object({
+	name: z.string().regex(/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/),
+	version: z.string().min(1).max(256)
+});
+z.strictObject({
+	workspaceId: z.uuid(),
+	incarnationId: z.string().min(1).max(256),
+	profiles: z.array(WorkloadProfileSchema),
+	storageProfiles: z.array(z.enum(["controller-readonly/v1", "shared-writer-readonly/v1"])),
+	ceilings: WorkloadLimitsSchema,
+	now: z.iso.datetime(),
+	expiresAt: z.iso.datetime(),
+	installed: InstalledWorkloadSchema.optional()
+});
+//#endregion
+//#region ../contracts/src/workspaces/execution-dispatch.ts
+const ExecutionPhaseSchema = z.enum([
+	"accepted",
+	"dispatching",
+	"running",
+	"terminal",
+	"canceled",
+	"unknown",
+	"lost"
+]);
+z.strictObject({
+	acceptance: WorkloadAcceptanceSchema,
+	conversationIdentity: ConversationRequestIdentitySchema.nullable(),
+	outcome: JsonValueSchema.nullable(),
+	acceptedAt: z.iso.datetime(),
+	dispatchClaimedAt: z.iso.datetime().nullable(),
+	phase: ExecutionPhaseSchema,
+	cancel: z.strictObject({
+		cancelId: z.uuid(),
+		requestedAt: z.iso.datetime()
+	}).nullable(),
+	settledAt: z.iso.datetime().nullable(),
+	acknowledgedAt: z.iso.datetime().nullable(),
+	finalizedAt: z.iso.datetime().nullable()
+});
+z.strictObject({
+	acceptance: WorkloadAcceptanceSchema,
+	conversationIdentity: ConversationRequestIdentitySchema.optional()
+}).refine(({ acceptance, conversationIdentity }) => acceptance.execution.owner !== "conversation-request" || conversationIdentity !== void 0, {
+	path: ["conversationIdentity"],
+	message: "Conversation execution requires a conversation identity."
+});
+WorkloadCancelSchema.refine((cancel) => cancel.scope === "operation", { message: "Use workspace release for workspace cancellation" });
+z.strictObject({
+	workspaceId: z.uuid(),
+	callerPrincipalId: z.uuid(),
+	incarnationId: z.string().min(1),
+	template: WorkloadTemplateSnapshotSchema,
+	producer: InstalledWorkloadSchema,
+	readyAt: z.iso.datetime().nullable(),
+	endedAt: z.iso.datetime().nullable()
+});
+z.discriminatedUnion("phase", [z.strictObject({
+	execution: WorkloadExecutionReferenceSchema,
+	phase: z.literal("absent")
+}), z.strictObject({
+	execution: WorkloadExecutionReferenceSchema,
+	fingerprint: WorkloadDigestSchema,
+	phase: z.enum([
+		"accepted",
+		"running",
+		"terminal",
+		"canceled"
+	]),
+	outcome: JsonValueSchema.nullable()
+})]);
+WorkloadCancelSchema.extend({ fingerprint: WorkloadDigestSchema });
+//#endregion
 //#region src/resources/admin/admin.ts
 var AdministrationApi = class {
 	transport;
@@ -1912,44 +3290,8 @@ function responseError(response, body) {
 	});
 }
 //#endregion
-//#region src/resources/attachments/attachments.ts
+//#region src/resources/agent/agent.ts
 const DEFAULT_READY_TIMEOUT_MS = 12e4;
-function contentDisposition(name) {
-	const clean = name.replace(/[\r\n]/g, "");
-	if (/^[ -~]*$/.test(clean)) return `attachment; filename="${clean.replace(/(["\\])/g, "\\$1")}"`;
-	return `attachment; filename*=UTF-8''${encodeURIComponent(clean)}`;
-}
-function progressStream(body, total, onProgress) {
-	const source = new Response(body).body ?? new ReadableStream({ start: (c) => c.close() });
-	let uploaded = 0;
-	return source.pipeThrough(new TransformStream({ transform(chunk, controller) {
-		uploaded += chunk.byteLength;
-		controller.enqueue(chunk);
-		onProgress(Math.min(uploaded, total), total);
-	} }));
-}
-var AttachmentsApi = class {
-	transport;
-	constructor(transport) {
-		this.transport = transport;
-	}
-	async upload(workspaceId, input) {
-		const id = (input.id ?? crypto.randomUUID()).toLowerCase();
-		const body = input.onProgress ? progressStream(input.body, input.sizeBytes, input.onProgress) : input.body;
-		const init = {
-			method: "PUT",
-			...input.signal ? { signal: input.signal } : {},
-			headers: {
-				"content-type": input.mediaType ?? "application/octet-stream",
-				"content-disposition": contentDisposition(input.name),
-				"content-length": String(input.sizeBytes)
-			},
-			body,
-			...body instanceof ReadableStream ? { duplex: "half" } : {}
-		};
-		return await this.transport.request(`/v1/workspaces/${encodeURIComponent(workspaceId)}/attachments/${id}`, AttachmentDescriptorSchema, init);
-	}
-};
 var AgentApi = class {
 	transport;
 	workspaces;
@@ -1983,6 +3325,58 @@ var AgentApi = class {
 		}
 		throw responseError(response, body);
 	}
+	interrupt(workspaceId, options = {}) {
+		return this.transport.request(`/v1/workspaces/${encodeURIComponent(workspaceId)}/agent/interrupt`, AgentInterruptResponseSchema, {
+			method: "POST",
+			signal: options.signal
+		});
+	}
+};
+//#endregion
+//#region src/resources/attachments/attachments.ts
+function contentDisposition(name) {
+	const clean = name.replace(/[\r\n]/g, "");
+	if (/^[ -~]*$/.test(clean)) return `attachment; filename="${clean.replace(/(["\\])/g, "\\$1")}"`;
+	return `attachment; filename*=UTF-8''${encodeURIComponent(clean)}`;
+}
+function progressStream(body, total, onProgress) {
+	const source = new Response(body).body ?? new ReadableStream({ start: (c) => c.close() });
+	let uploaded = 0;
+	return source.pipeThrough(new TransformStream({ transform(chunk, controller) {
+		uploaded += chunk.byteLength;
+		controller.enqueue(chunk);
+		onProgress(Math.min(uploaded, total), total);
+	} }));
+}
+var AttachmentsApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	async upload(workspaceId, input) {
+		const id = (input.id ?? crypto.randomUUID()).toLowerCase();
+		let sha256 = input.sha256;
+		if (!sha256) {
+			if (input.body instanceof ReadableStream) throw new Error("Stream uploads require sha256 before body consumption.");
+			const digest = await crypto.subtle.digest("SHA-256", await new Response(input.body).arrayBuffer());
+			sha256 = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+		}
+		if (!/^[0-9a-f]{64}$/.test(sha256)) throw new Error("sha256 must be 64 lowercase hexadecimal characters.");
+		const body = input.onProgress ? progressStream(input.body, input.sizeBytes, input.onProgress) : input.body;
+		const init = {
+			method: "PUT",
+			...input.signal ? { signal: input.signal } : {},
+			headers: {
+				"content-type": input.mediaType ?? "application/octet-stream",
+				"content-disposition": contentDisposition(input.name),
+				"content-length": String(input.sizeBytes),
+				"x-content-sha256": sha256
+			},
+			body,
+			...body instanceof ReadableStream ? { duplex: "half" } : {}
+		};
+		return await this.transport.request(`/v1/workspaces/${encodeURIComponent(workspaceId)}/attachments/${id}`, InputObjectReferenceSchema, init);
+	}
 };
 //#endregion
 //#region src/transport/common.ts
@@ -2047,16 +3441,72 @@ var OperationsApi = class {
 };
 //#endregion
 //#region src/resources/conversations/conversations.ts
+function workspacePath(id) {
+	return `/v1/workspaces/${encodeURIComponent(id)}`;
+}
+async function* liveEvents(body) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	for await (const chunk of body) {
+		buffer += decoder.decode(chunk, { stream: true });
+		let end = buffer.indexOf("\n\n");
+		while (end !== -1) {
+			const block = buffer.slice(0, end);
+			buffer = buffer.slice(end + 2);
+			const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+			const event = data ? ConversationLiveEventSchema.safeParse(JSON.parse(data)) : null;
+			if (event?.success) yield event.data;
+			end = buffer.indexOf("\n\n");
+		}
+	}
+}
 var ConversationsApi = class {
 	transport;
 	constructor(transport) {
 		this.transport = transport;
 	}
 	async list(id, query = {}, options = {}) {
-		return page(await this.transport.request(`/v1/workspaces/${encodeURIComponent(id)}/conversation?${queryString({
+		const body = await this.transport.request(`${workspacePath(id)}/conversation?${queryString({
+			cursor: query.cursor,
+			limit: query.limit ?? 100
+		})}`, ConversationPageSchema, options);
+		return {
+			...page(body),
+			protocol: body.protocol,
+			retention: body.retention
+		};
+	}
+	async acceptRequest(id, identity, options = {}) {
+		return this.transport.request(`${workspacePath(id)}/conversation/requests`, ConversationRequestReceiptSchema, {
+			...options,
+			method: "POST",
+			body: JSON.stringify(identity)
+		});
+	}
+	async listConversations(id, options = {}) {
+		return (await this.transport.request(`${workspacePath(id)}/conversations`, ConversationListSchema, options)).items;
+	}
+	async read(id, conversationId, query = {}, options = {}) {
+		const body = await this.transport.request(`${workspacePath(id)}/conversations/${encodeURIComponent(conversationId)}?${queryString({
 			cursor: query.cursor,
 			limit: query.limit ?? 100
-		})}`, ConversationPageSchema, options));
+		})}`, ConversationDocumentPageSchema, options);
+		return {
+			...page(body),
+			conversation: body.conversation,
+			protocol: body.protocol
+		};
+	}
+	async delete(id, conversationId, options = {}) {
+		await this.transport.request(`${workspacePath(id)}/conversations/${encodeURIComponent(conversationId)}`, z.undefined(), {
+			...options,
+			method: "DELETE"
+		});
+	}
+	async *live(id, options = {}) {
+		const path = options.conversationId ? `${workspacePath(id)}/conversations/${encodeURIComponent(options.conversationId)}/live` : `${workspacePath(id)}/conversation/live`;
+		const response = await this.transport.stream(path, options.signal);
+		if (response.body) yield* liveEvents(response.body);
 	}
 };
 //#endregion
@@ -2088,8 +3538,40 @@ var NetworkEventsApi = class extends WorkspaceCursorApi {
 	}
 };
 var OutputsApi = class extends WorkspaceCursorApi {
+	binaryTransport;
+	async download(workspaceId, outputId, options = {}) {
+		const response = await this.binaryTransport.raw(`/v1/workspaces/${encodeURIComponent(workspaceId)}/outputs/${encodeURIComponent(outputId)}/content`, options);
+		if (!response.ok) throw responseError(response, await response.json());
+		return response;
+	}
 	constructor(transport) {
 		super(transport, "outputs", OutputPageSchema);
+		this.binaryTransport = transport;
+	}
+};
+//#endregion
+//#region src/resources/displays/displays.ts
+var DisplaysApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	capture(workspaceId, options = {}) {
+		return this.transport.request(`/v1/workspaces/${encodeURIComponent(workspaceId)}/display/screenshot`, ScreenshotResourceSchema, {
+			method: "POST",
+			body: "{}",
+			signal: options.signal
+		});
+	}
+	open(workspaceId, control = false, options = {}) {
+		return this.transport.request(`/v1/workspaces/${encodeURIComponent(workspaceId)}/display`, PreviewOpenResponseSchema, {
+			method: "POST",
+			body: JSON.stringify({
+				control,
+				session: options.session ?? { mode: "local" }
+			}),
+			signal: options.signal
+		});
 	}
 };
 //#endregion
@@ -2117,6 +3599,9 @@ var KeysApi = class {
 			cursor = page.next_cursor ?? void 0;
 		} while (cursor);
 	}
+	expiring(query = {}, options = {}) {
+		return this.transport.request(`/v1/keys/expiring?${queryString({ within_hours: query.withinHours })}`, ExpiringKeyListResponseSchema, options);
+	}
 	issue(principalId, input, options = {}) {
 		return this.transport.request(`/v1/principals/${encodeURIComponent(principalId)}/keys`, KeyIssueResponseSchema, {
 			method: "POST",
@@ -2124,6 +3609,13 @@ var KeysApi = class {
 			signal: options.signal
 		});
 	}
+	rotate(principalId, keyId, input, options = {}) {
+		return this.transport.request(`/v1/principals/${encodeURIComponent(principalId)}/keys/${encodeURIComponent(keyId)}/rotate`, KeyIssueResponseSchema, {
+			method: "POST",
+			body: JSON.stringify(input),
+			signal: options.signal
+		});
+	}
 	revoke(principalId, keyId, options = {}) {
 		return this.transport.request(`/v1/principals/${encodeURIComponent(principalId)}/keys/${encodeURIComponent(keyId)}`, z.object({ revoked: z.literal(true) }), {
 			method: "DELETE",
@@ -2155,6 +3647,76 @@ var RecoveryApi = class {
 	}
 };
 //#endregion
+//#region src/resources/previews/previews.ts
+var PreviewsApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	list(workspaceId, options = {}) {
+		return this.transport.request(`/v1/workspaces/${encodeURIComponent(workspaceId)}/previews`, PreviewListSchema, options);
+	}
+	open(workspaceId, name, options = {}) {
+		return this.transport.request(`/v1/workspaces/${encodeURIComponent(workspaceId)}/previews/${encodeURIComponent(name)}`, PreviewOpenResponseSchema, {
+			method: "POST",
+			body: JSON.stringify({ session: options.session ?? { mode: "local" } }),
+			signal: options.signal
+		});
+	}
+};
+//#endregion
+//#region src/resources/principals/principals.ts
+var PrincipalsApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	list(options = {}) {
+		return this.transport.request("/v1/principals", PrincipalListResponseSchema, options);
+	}
+	get(principalId, options = {}) {
+		return this.transport.request(`/v1/principals/${encodeURIComponent(principalId)}`, PrincipalResourceSchema, options);
+	}
+	create(input, options = {}) {
+		return this.transport.request("/v1/principals", PrincipalResourceSchema, {
+			method: "POST",
+			body: JSON.stringify(input),
+			signal: options.signal
+		});
+	}
+	update(principalId, input, options = {}) {
+		return this.transport.request(`/v1/principals/${encodeURIComponent(principalId)}`, PrincipalResourceSchema, {
+			method: "PATCH",
+			body: JSON.stringify(input),
+			signal: options.signal
+		});
+	}
+};
+//#endregion
+//#region src/resources/secrets/secrets.ts
+var SecretsApi = class {
+	transport;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	async put(name, input, options = {}) {
+		return this.transport.request(`/v1/secrets/${encodeURIComponent(name)}`, SecretResourceSchema, {
+			...options,
+			method: "PUT",
+			body: JSON.stringify(input)
+		});
+	}
+	async list(options = {}) {
+		return (await this.transport.request("/v1/secrets", SecretListSchema, options)).items;
+	}
+	async retire(name, options = {}) {
+		return this.transport.request(`/v1/secrets/${encodeURIComponent(name)}`, SecretResourceSchema, {
+			...options,
+			method: "DELETE"
+		});
+	}
+};
+//#endregion
 //#region src/resources/templates/templates.ts
 var TemplatesApi = class {
 	transport;
@@ -2168,7 +3730,27 @@ var TemplatesApi = class {
 		})}`, TemplatePageSchema, options));
 	}
 	async list(options = {}) {
-		return (await this.page({}, options)).items;
+		const items = [];
+		let cursor;
+		do {
+			const result = await this.page({ cursor }, options);
+			items.push(...result.items);
+			cursor = result.nextCursor ?? void 0;
+		} while (cursor);
+		return items;
+	}
+	async publish(manifest, options = {}) {
+		return this.transport.request("/v1/templates", TemplateListItemSchema, {
+			...options,
+			method: "POST",
+			body: JSON.stringify({ manifest })
+		});
+	}
+	async retire(name, version, options = {}) {
+		return this.transport.request(`/v1/templates/${encodeURIComponent(name)}/${encodeURIComponent(version)}`, TemplateListItemSchema, {
+			...options,
+			method: "DELETE"
+		});
 	}
 };
 //#endregion
@@ -2432,6 +4014,20 @@ var PocketCoderTransport = class {
 			await delay(100 * 2 ** attempt, signal);
 		}
 	}
+	async stream(path, signal) {
+		const response = await this.fetchImpl(`${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`, {
+			headers: {
+				authorization: `Bearer ${this.apiKey}`,
+				accept: "text/event-stream"
+			},
+			...signal ? { signal } : {}
+		});
+		if (!response.ok) {
+			const text = await response.text();
+			throw responseError(response, text ? JSON.parse(text) : void 0);
+		}
+		return response;
+	}
 	async request(path, schema, init = {}) {
 		const response = await this.raw(path, init);
 		const text = await response.text();
@@ -2496,8 +4092,11 @@ async function delay(milliseconds, signal) {
 //#region src/client.ts
 var PocketCoderClient = class {
 	transport;
+	secrets;
 	templates;
 	workspaces;
+	previews;
+	displays;
 	attachments;
 	agent;
 	conversations;
@@ -2508,12 +4107,16 @@ var PocketCoderClient = class {
 	outputs;
 	administration;
 	terminals;
+	principals;
 	keys;
 	recovery;
 	constructor(config, fetchImpl = fetch) {
 		this.transport = new PocketCoderTransport(config, fetchImpl);
+		this.secrets = new SecretsApi(this.transport);
 		this.templates = new TemplatesApi(this.transport);
 		this.workspaces = new WorkspacesApi(this.transport);
+		this.previews = new PreviewsApi(this.transport);
+		this.displays = new DisplaysApi(this.transport);
 		this.attachments = new AttachmentsApi(this.transport);
 		this.agent = new AgentApi(this.transport, this.workspaces);
 		this.conversations = new ConversationsApi(this.transport);
@@ -2524,6 +4127,7 @@ var PocketCoderClient = class {
 		this.outputs = new OutputsApi(this.transport);
 		this.administration = new AdministrationApi(this.transport);
 		this.terminals = new TerminalsApi(this.transport);
+		this.principals = new PrincipalsApi(this.transport);
 		this.keys = new KeysApi(this.transport);
 		this.recovery = new RecoveryApi(this.transport);
 	}
@@ -2676,4 +4280,4 @@ var WorkspaceTurnResolver = class {
 	}
 };
 //#endregion
-export { AdministrationApi, AgentApi, AgentNotReadyError, AttachmentsApi, CheckpointsApi, ConversationGoneError, ConversationsApi, KeysApi, LogsApi, NetworkEventsApi, OperationsApi, OutputsApi, PocketCoderClient, PocketCoderError, RecoveryApi, TERMINAL_WORKSPACE_STATES, TemplatesApi, TerminalConnection, TerminalsApi, WorkspaceTerminalError, WorkspaceTurnResolutionError, WorkspaceTurnResolver, WorkspacesApi, isPocketCoderErrorCode, splitAttachmentManifest };
+export { AdministrationApi, AgentApi, AgentNotReadyError, AttachmentsApi, CheckpointsApi, ConversationGoneError, ConversationsApi, KeysApi, LogsApi, NetworkEventsApi, OperationsApi, OutputsApi, PocketCoderClient, PocketCoderError, PrincipalsApi, RecoveryApi, SecretsApi, TERMINAL_WORKSPACE_STATES, TemplatesApi, TerminalConnection, TerminalsApi, WorkspaceTerminalError, WorkspaceTurnResolutionError, WorkspaceTurnResolver, WorkspacesApi, isPocketCoderErrorCode, splitAttachmentManifest };