@agimon-ai/po-core 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/apiContracts.cjs

@@ -1,11 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let typebox = require("typebox");
 let typebox_value = require("typebox/value");
-let _earendil_works_pi_protocol = require("@earendil-works/pi-protocol");
-let _earendil_works_chord = require("@earendil-works/chord");
+let dist_interop_chord_mjs = require("../../dist/interop/chord.mjs");
 //#region src/schemas/apiContracts.ts
-const DOOM_API_CONTRACT_VERSION = 1;
-const DOOM_API_CONTRACT_FILE = "contracts.json";
+const PO_API_CONTRACT_VERSION = 1;
+const PO_API_CONTRACT_FILE = "contracts.json";
 const Schema = typebox.Type.Unsafe(typebox.Type.Union([typebox.Type.Boolean(), typebox.Type.Record(typebox.Type.String(), typebox.Type.Unknown())]));
 const Scope = typebox.Type.Union([
 	typebox.Type.Literal("global"),
@@ -20,7 +19,7 @@ const ResponseSchema = typebox.Type.Object({
 	events: typebox.Type.Optional(typebox.Type.Record(Named, Schema))
 });
 /** Data-only package entry. Schemas use JSON Schema draft-07, including TypeBox output; OpenAPI export translates tuple keywords. */
-const DoomApiContractSchema = typebox.Type.Object({
+const PoApiContractSchema = typebox.Type.Object({
 	version: typebox.Type.Literal(1),
 	protocols: typebox.Type.Optional(typebox.Type.Record(Named, Named)),
 	schemas: typebox.Type.Optional(typebox.Type.Record(Named, Schema)),
@@ -89,7 +88,7 @@ function defineApiContract(contract) {
 	return contract;
 }
 function parseApiContract(value) {
-	if (!(0, typebox_value.Check)(DoomApiContractSchema, value)) throw new Error("Invalid Po API contract");
+	if (!(0, typebox_value.Check)(PoApiContractSchema, value)) throw new Error("Invalid Po API contract");
 	const contract = value;
 	const ids = /* @__PURE__ */ new Set();
 	for (const entry of [...contract.http, ...contract.sockets]) {
@@ -117,7 +116,7 @@ function parseCompiledContracts(value) {
 			majorMode: Named,
 			layer: Named
 		}), { minItems: 1 }),
-		contract: typebox.Type.Optional(DoomApiContractSchema),
+		contract: typebox.Type.Optional(PoApiContractSchema),
 		problem: typebox.Type.Optional(Named),
 		module: typebox.Type.Optional(typebox.Type.String({ pattern: "^\\./[^\\\\%?#]+$" }))
 	});
@@ -425,19 +424,20 @@ function asyncApiSchemas(schemas) {
 /** Where a host mounts this package's API; the segment after /api/plugins/. */
 const API_BASE_PATH = "context";
 const ITEM_ROUTE = "/item";
+const CURRENT_ROUTE = "/current";
 //#endregion
 //#region src/schemas/httpApiContracts.ts
-const Text$2 = typebox.Type.String();
+const Text$3 = typebox.Type.String();
 const Optional$2 = typebox.Type.Optional;
-const Strings$1 = typebox.Type.Array(Text$2);
+const Strings$1 = typebox.Type.Array(Text$3);
 const Flag$2 = typebox.Type.Boolean();
 const NumberValue$2 = typebox.Type.Number();
 const ApiErrorSchema = typebox.Type.Object({
-	error: Text$2,
-	hash: Optional$2(Text$2)
+	error: Text$3,
+	hash: Optional$2(Text$3)
 });
 const ApiOkSchema = typebox.Type.Object({ ok: typebox.Type.Literal(true) });
-const Json$2 = typebox.Type.Unknown({ description: "Value whose schema is supplied by the selected runtime contribution." });
+const Json$4 = typebox.Type.Unknown({ description: "Value whose schema is supplied by the selected runtime contribution." });
 /** Common JSON response construction; status and payload remain explicit at the declaration. */
 function jsonApiResponses(schema, status = 200) {
 	return {
@@ -485,86 +485,86 @@ function jsonApiResponses(schema, status = 200) {
 	};
 }
 const WebCompositionSchema = typebox.Type.Object({
-	id: Text$2,
+	id: Text$3,
 	scope: typebox.Type.Union([
 		typebox.Type.Literal("global"),
 		typebox.Type.Literal("workspace"),
 		typebox.Type.Literal("session")
 	]),
 	revision: NumberValue$2,
-	manifestUrl: Text$2,
-	rawAssetBaseUrl: Text$2,
-	verifiedAssetBaseUrl: Text$2,
-	pluginEntries: typebox.Type.Array(typebox.Type.Tuple([Text$2, Text$2])),
+	manifestUrl: Text$3,
+	rawAssetBaseUrl: Text$3,
+	verifiedAssetBaseUrl: Text$3,
+	pluginEntries: typebox.Type.Array(typebox.Type.Tuple([Text$3, Text$3])),
 	assetPaths: Strings$1,
 	stylePaths: Strings$1,
 	channels: Strings$1
 });
 const NativeCompositionSchema = typebox.Type.Object({
-	id: Text$2,
+	id: Text$3,
 	scope: typebox.Type.Union([
 		typebox.Type.Literal("global"),
 		typebox.Type.Literal("workspace"),
 		typebox.Type.Literal("session")
 	]),
 	revision: NumberValue$2,
-	manifestUrl: Text$2,
-	rawAssetBaseUrl: Text$2,
-	entryPath: Text$2,
+	manifestUrl: Text$3,
+	rawAssetBaseUrl: Text$3,
+	entryPath: Text$3,
 	channels: Strings$1,
 	plugins: Strings$1
 });
 /** A configured template id and the mount whose compositions offer it. */
 const TemplateDecisionSchema = typebox.Type.Object({
-	id: Optional$2(Text$2),
+	id: Optional$2(Text$3),
 	mount: typebox.Type.Union([typebox.Type.Object({ scope: typebox.Type.Literal("global") }), typebox.Type.Object({
 		scope: typebox.Type.Literal("workspace"),
-		workspaceId: Text$2
+		workspaceId: Text$3
 	})])
 });
 const SessionSummarySchema = typebox.Type.Object({
-	id: Text$2,
-	workspaceId: Optional$2(Text$2),
+	id: Text$3,
+	workspaceId: Optional$2(Text$3),
 	webComposition: Optional$2(WebCompositionSchema),
 	nativeComposition: Optional$2(NativeCompositionSchema),
-	name: Text$2,
-	cwd: Text$2,
-	createdAt: Text$2,
-	updatedAt: Text$2,
+	name: Text$3,
+	cwd: Text$3,
+	createdAt: Text$3,
+	updatedAt: Text$3,
 	phase: typebox.Type.Union([
 		typebox.Type.Literal("idle"),
 		typebox.Type.Literal("turn"),
 		typebox.Type.Literal("compaction"),
 		typebox.Type.Literal("retry")
 	]),
-	phaseSince: Text$2,
+	phaseSince: Text$3,
 	attach: typebox.Type.Literal("attached"),
 	pendingMessageCount: NumberValue$2,
 	everPrompted: Flag$2,
 	awaitingInput: Flag$2,
-	lastSettledAt: Optional$2(Text$2),
+	lastSettledAt: Optional$2(Text$3),
 	git: Optional$2(typebox.Type.Object({
-		branch: Text$2,
+		branch: Text$3,
 		dirty: Flag$2
 	})),
 	profile: Optional$2(typebox.Type.Object({
-		name: Text$2,
-		displayName: Optional$2(Text$2),
-		iconVersion: Optional$2(Text$2)
+		name: Text$3,
+		displayName: Optional$2(Text$3),
+		iconVersion: Optional$2(Text$3)
 	})),
-	parentSessionId: Optional$2(Text$2),
-	sessionProvenance: Optional$2(Text$2),
+	parentSessionId: Optional$2(Text$3),
+	sessionProvenance: Optional$2(Text$3),
 	/** The line the session's extension published about background work it runs. */
 	activity: Optional$2(typebox.Type.Object({
-		label: Text$2,
+		label: Text$3,
 		attention: Optional$2(Flag$2),
-		since: Optional$2(Text$2)
+		since: Optional$2(Text$3)
 	})),
 	pendingSetups: Optional$2(typebox.Type.Array(typebox.Type.Object({
-		id: Text$2,
-		name: Text$2,
-		createdAt: Text$2,
-		cwd: Optional$2(Text$2),
+		id: Text$3,
+		name: Text$3,
+		createdAt: Text$3,
+		cwd: Optional$2(Text$3),
 		setupKind: Optional$2(typebox.Type.Union([typebox.Type.Literal("managed-worktree"), typebox.Type.Literal("existing-directory")])),
 		status: Optional$2(typebox.Type.Union([
 			typebox.Type.Literal("provisioning"),
@@ -573,48 +573,25 @@ const SessionSummarySchema = typebox.Type.Object({
 		])),
 		errorCode: Optional$2(typebox.Type.Union([typebox.Type.Literal("SESSION_WORKTREE_PROVISION_FAILED"), typebox.Type.Literal("SESSION_UNAVAILABLE")]))
 	}))),
+	groups: Optional$2(Strings$1),
+	backgroundWorkActive: Optional$2(Flag$2),
 	/** Present and true for a recorded session the server has not reopened yet. */
 	dormant: Optional$2(Flag$2)
 });
-const HubSnapshotFrameSchema = typebox.Type.Object({
-	type: typebox.Type.Literal("sessions_snapshot"),
-	sessions: typebox.Type.Array(SessionSummarySchema)
-});
-const HubUpsertFrameSchema = typebox.Type.Object({
-	type: typebox.Type.Literal("session_upsert"),
-	session: SessionSummarySchema
-});
-const HubRemovedFrameSchema = typebox.Type.Object({
-	type: typebox.Type.Literal("session_removed"),
-	sessionId: Text$2
-});
-const Workspace = typebox.Type.Object({
-	id: Text$2,
-	root: Text$2,
-	name: Optional$2(Text$2),
+const WorkspaceSchema = typebox.Type.Object({
+	id: Text$3,
+	root: Text$3,
+	name: Optional$2(Text$3),
 	available: Optional$2(Flag$2)
 });
-const WorkspaceSnapshotFrameSchema = typebox.Type.Object({
-	type: typebox.Type.Literal("workspaces_snapshot"),
-	workspaces: typebox.Type.Array(Workspace)
-});
-const WorkspaceUpsertFrameSchema = typebox.Type.Object({
-	type: typebox.Type.Literal("workspace_upsert"),
-	workspace: Workspace
-});
-const WorkspaceRemovedFrameSchema = typebox.Type.Object({
-	type: typebox.Type.Literal("workspace_removed"),
-	workspaceId: Text$2
-});
 const SavedSession = typebox.Type.Object({
-	id: Text$2,
-	name: Optional$2(Text$2),
-	firstMessage: Text$2,
-	createdAt: Text$2,
-	updatedAt: Text$2,
-	messageCount: NumberValue$2
+	id: Text$3,
+	name: Optional$2(Text$3),
+	firstMessage: Text$3,
+	createdAt: Text$3,
+	updatedAt: Text$3
 });
-const query = (name, schema = Text$2, required = false) => ({
+const query = (name, schema = Text$3, required = false) => ({
 	name,
 	in: "query",
 	required,
@@ -654,43 +631,44 @@ const headlessHttpContracts = [
 	host("compositions", "/api/compositions", "GET", typebox.Type.Object({
 		global: Optional$2(WebCompositionSchema),
 		nativeGlobal: Optional$2(NativeCompositionSchema),
-		publicKey: Optional$2(Text$2),
+		publicKey: Optional$2(Text$3),
 		shell: Optional$2(typebox.Type.Object({
-			publicKey: Text$2,
+			publicKey: Text$3,
 			revision: NumberValue$2
 		})),
 		template: Optional$2(TemplateDecisionSchema),
 		/** The phone app's `native.template` choice, resolved the same way. */
 		nativeTemplate: Optional$2(TemplateDecisionSchema),
 		workspaces: typebox.Type.Array(typebox.Type.Object({
-			id: Text$2,
-			root: Text$2,
+			id: Text$3,
+			root: Text$3,
 			webComposition: Optional$2(WebCompositionSchema),
 			nativeComposition: Optional$2(NativeCompositionSchema)
 		}))
 	})),
 	host("directories", "/api/directories", "GET", typebox.Type.Object({ directories: Strings$1 }), { parameters: [query("q")] }),
 	host("directories.children", "/api/directories/children", "GET", typebox.Type.Object({
-		path: Text$2,
-		parent: Optional$2(Text$2),
+		path: Text$3,
+		parent: Optional$2(Text$3),
 		directories: Strings$1
 	}), { parameters: [query("path")] }),
+	host("directories.po", "/api/directories/po", "GET", typebox.Type.Object({ directories: Strings$1 })),
 	host("sessions.list", "/api/workspaces/{workspaceId}/sessions", "GET", typebox.Type.Object({ sessions: typebox.Type.Array(SessionSummarySchema) })),
-	host("sessions.create", "/api/workspaces/{workspaceId}/sessions", "POST", typebox.Type.Object({ sessionId: Text$2 }), {
-		body: body(typebox.Type.Object({ name: Optional$2(Text$2) })),
-		responses: jsonApiResponses(typebox.Type.Object({ sessionId: Text$2 }), 201)
+	host("sessions.create", "/api/workspaces/{workspaceId}/sessions", "POST", typebox.Type.Object({ sessionId: Text$3 }), {
+		body: body(typebox.Type.Object({ name: Optional$2(Text$3) })),
+		responses: jsonApiResponses(typebox.Type.Object({ sessionId: Text$3 }), 201)
 	}),
 	host("sessions.get", "/api/workspaces/{workspaceId}/sessions/{sessionId}", "GET", SessionSummarySchema),
 	host("sessions.delete", "/api/workspaces/{workspaceId}/sessions/{sessionId}", "DELETE", ApiOkSchema),
 	host("sessions.history", "/api/workspaces/{workspaceId}/sessions/{sessionId}/history", "GET", typebox.Type.Object({ sessions: typebox.Type.Array(SavedSession) }), { availability: "Host provides sessionHistory" }),
 	host("sessions.restart", "/api/workspaces/{workspaceId}/sessions/{sessionId}/restart", "POST", ApiOkSchema, { availability: "Host provides restartSession" }),
 	host("sessions.revive", "/api/workspaces/{workspaceId}/sessions/{sessionId}/revive", "POST", ApiOkSchema, { availability: "Host provides reviveSession" }),
-	host("sessions.resume", "/api/workspaces/{workspaceId}/sessions/{sessionId}/resume", "POST", typebox.Type.Object({ sessionId: Text$2 }), {
+	host("sessions.resume", "/api/workspaces/{workspaceId}/sessions/{sessionId}/resume", "POST", typebox.Type.Object({ sessionId: Text$3 }), {
 		availability: "Host provides resumeSession",
 		body: body(typebox.Type.Object({ targetSessionId: typebox.Type.String({ pattern: "^[A-Za-z0-9_-]+$" }) }))
 	}),
 	host("sessions.file", "/api/workspaces/{workspaceId}/sessions/{sessionId}/file", "GET", Binary, {
-		parameters: [query("path", Text$2, true)],
+		parameters: [query("path", Text$3, true)],
 		responses: {
 			...jsonApiResponses(Binary),
 			"200": {
@@ -700,94 +678,65 @@ const headlessHttpContracts = [
 			}
 		}
 	}),
-	host("sessions.channels", "/api/workspaces/{workspaceId}/sessions/{sessionId}/channels", "GET", typebox.Type.Object({ channels: typebox.Type.Array(typebox.Type.Object({
-		type: Text$2,
-		sessionId: Text$2,
-		payload: Json$2
-	})) })),
-	host("sessions.channel.send", "/api/workspaces/{workspaceId}/sessions/{sessionId}/channel/{frameType}", "POST", ApiOkSchema, {
-		body: body(Json$2),
-		responses: jsonApiResponses(ApiOkSchema, 202),
-		description: "Deliver a payload to the selected channel contract identified by frameType."
-	}),
-	host("workspaces.list", "/api/workspaces", "GET", typebox.Type.Object({ workspaces: typebox.Type.Array(Workspace) })),
-	host("workspaces.admit", "/api/workspaces", "POST", typebox.Type.Object({ workspace: Workspace }), {
+	host("workspaces.list", "/api/workspaces", "GET", typebox.Type.Object({ workspaces: typebox.Type.Array(WorkspaceSchema) })),
+	host("workspaces.admit", "/api/workspaces", "POST", typebox.Type.Object({ workspace: WorkspaceSchema }), {
 		body: body(typebox.Type.Object({
-			root: Optional$2(Text$2),
-			name: Optional$2(Text$2)
+			root: Optional$2(Text$3),
+			name: Optional$2(Text$3)
 		})),
-		responses: jsonApiResponses(typebox.Type.Object({ workspace: Workspace }), 201)
+		responses: jsonApiResponses(typebox.Type.Object({ workspace: WorkspaceSchema }), 201)
 	}),
-	host("workspaces.get", "/api/workspaces/{workspaceId}", "GET", typebox.Type.Object({ workspace: Workspace })),
+	host("workspaces.get", "/api/workspaces/{workspaceId}", "GET", typebox.Type.Object({ workspace: WorkspaceSchema })),
 	host("workspaces.history", "/api/workspaces/{workspaceId}/history", "GET", typebox.Type.Object({ sessions: typebox.Type.Array(SavedSession) }), { availability: "Host provides workspaceHistory" }),
-	host("workspaces.resume", "/api/workspaces/{workspaceId}/resume", "POST", typebox.Type.Object({ sessionId: Text$2 }), {
+	host("workspaces.resume", "/api/workspaces/{workspaceId}/resume", "POST", typebox.Type.Object({ sessionId: Text$3 }), {
 		availability: "Host provides resumeWorkspaceSession",
 		body: body(typebox.Type.Object({ targetSessionId: typebox.Type.String({ pattern: "^[A-Za-z0-9_-]+$" }) }))
 	}),
-	host("workspaces.remove", "/api/workspaces/{workspaceId}", "DELETE", ApiOkSchema),
-	host("events", "/api/events", "GET", Text$2, { responses: {
-		"200": {
-			description: "SSE session and workspace snapshots, membership changes, and selected channel frames. Selected extension channel payloads are defined by the corresponding AsyncAPI channel operations.",
-			events: {
-				sessions_snapshot: HubSnapshotFrameSchema,
-				session_upsert: HubUpsertFrameSchema,
-				session_removed: HubRemovedFrameSchema,
-				workspaces_snapshot: WorkspaceSnapshotFrameSchema,
-				workspace_upsert: WorkspaceUpsertFrameSchema,
-				workspace_removed: WorkspaceRemovedFrameSchema
-			},
-			contentType: "text/event-stream",
-			schema: Text$2
-		},
-		"401": {
-			description: "Authentication required",
-			schema: ApiErrorSchema
-		}
-	} })
+	host("workspaces.remove", "/api/workspaces/{workspaceId}", "DELETE", ApiOkSchema)
 ];
 const AuthType = typebox.Type.Union([typebox.Type.Literal("api_key"), typebox.Type.Literal("oauth")]);
 const Provider = typebox.Type.Object({
-	id: Text$2,
-	name: Text$2,
+	id: Text$3,
+	name: Text$3,
 	methods: typebox.Type.Array(typebox.Type.Object({
 		type: AuthType,
-		label: Text$2
+		label: Text$3
 	})),
 	authenticated: Optional$2(typebox.Type.Object({
 		type: AuthType,
-		source: Optional$2(Text$2)
+		source: Optional$2(Text$3)
 	}))
 });
 const LoginEvent = typebox.Type.Union([
 	typebox.Type.Object({
 		type: typebox.Type.Literal("info"),
-		message: Text$2,
+		message: Text$3,
 		links: Optional$2(typebox.Type.Array(typebox.Type.Object({
-			url: Text$2,
-			label: Optional$2(Text$2)
+			url: Text$3,
+			label: Optional$2(Text$3)
 		})))
 	}),
 	typebox.Type.Object({
 		type: typebox.Type.Literal("auth_url"),
-		url: Text$2,
-		instructions: Optional$2(Text$2)
+		url: Text$3,
+		instructions: Optional$2(Text$3)
 	}),
 	typebox.Type.Object({
 		type: typebox.Type.Literal("device_code"),
-		userCode: Text$2,
-		verificationUri: Text$2,
+		userCode: Text$3,
+		verificationUri: Text$3,
 		intervalSeconds: Optional$2(NumberValue$2),
 		expiresInSeconds: Optional$2(NumberValue$2)
 	}),
 	typebox.Type.Object({
 		type: typebox.Type.Literal("progress"),
-		message: Text$2
+		message: Text$3
 	})
 ]);
 const LoginFlowSchema = typebox.Type.Object({
-	id: Text$2,
-	providerId: Text$2,
-	providerName: Text$2,
+	id: Text$3,
+	providerId: Text$3,
+	providerName: Text$3,
 	type: AuthType,
 	status: typebox.Type.Union([
 		typebox.Type.Literal("running"),
@@ -797,36 +746,36 @@ const LoginFlowSchema = typebox.Type.Object({
 	]),
 	events: typebox.Type.Array(LoginEvent),
 	prompt: Optional$2(typebox.Type.Object({
-		id: Text$2,
+		id: Text$3,
 		type: typebox.Type.Union([
 			typebox.Type.Literal("text"),
 			typebox.Type.Literal("secret"),
 			typebox.Type.Literal("select"),
 			typebox.Type.Literal("manual_code")
 		]),
-		message: Text$2,
-		placeholder: Optional$2(Text$2),
+		message: Text$3,
+		placeholder: Optional$2(Text$3),
 		options: Optional$2(typebox.Type.Array(typebox.Type.Object({
-			id: Text$2,
-			label: Text$2,
-			description: Optional$2(Text$2)
+			id: Text$3,
+			label: Text$3,
+			description: Optional$2(Text$3)
 		})))
 	})),
 	remote: Optional$2(Flag$2),
-	error: Optional$2(Text$2)
+	error: Optional$2(Text$3)
 });
 const Flow = typebox.Type.Object({ flow: LoginFlowSchema });
 const machineHttpContracts = [
 	host("providers.list", "/providers", "GET", typebox.Type.Object({ providers: typebox.Type.Array(Provider) })),
 	host("models.list", "/models", "GET", typebox.Type.Object({ models: typebox.Type.Array(typebox.Type.Object({
-		value: Text$2,
-		label: Text$2,
-		group: Text$2
+		value: Text$3,
+		label: Text$3,
+		group: Text$3
 	})) })),
 	host("providers.logout", "/providers/{providerId}", "DELETE", ApiOkSchema),
 	host("logins.create", "/logins", "POST", Flow, {
 		body: body(typebox.Type.Object({
-			providerId: Text$2,
+			providerId: Text$3,
 			type: AuthType
 		})),
 		responses: jsonApiResponses(Flow, 201)
@@ -834,8 +783,8 @@ const machineHttpContracts = [
 	host("logins.get", "/logins/{flowId}", "GET", Flow),
 	host("logins.cancel", "/logins/{flowId}", "DELETE", Flow),
 	host("logins.answer", "/logins/{flowId}/answer", "POST", Flow, { body: body(typebox.Type.Object({
-		promptId: Text$2,
-		value: Text$2
+		promptId: Text$3,
+		value: Text$3
 	})) })
 ].map((route) => ({
 	...route,
@@ -850,8 +799,8 @@ const Source = typebox.Type.Union([
 const Detail = typebox.Type.Union([
 	typebox.Type.Object({
 		itemKind: typebox.Type.Literal("tool"),
-		name: Text$2,
-		owner: Text$2,
+		name: Text$3,
+		owner: Text$3,
 		source: Source,
 		active: Flag$2,
 		tokens: typebox.Type.Object({
@@ -859,20 +808,20 @@ const Detail = typebox.Type.Union([
 			promptTokens: NumberValue$2,
 			totalTokens: NumberValue$2
 		}),
-		description: Optional$2(Text$2),
-		promptSnippet: Optional$2(Text$2),
+		description: Optional$2(Text$3),
+		promptSnippet: Optional$2(Text$3),
 		promptGuidelines: Optional$2(Strings$1),
-		parameters: Optional$2(Json$2)
+		parameters: Optional$2(Json$4)
 	}),
 	typebox.Type.Object({
 		itemKind: typebox.Type.Literal("skill"),
-		name: Text$2,
-		owner: Text$2,
+		name: Text$3,
+		owner: Text$3,
 		source: Source,
 		active: typebox.Type.Literal(true),
 		tokens: NumberValue$2,
-		description: Text$2,
-		filePath: Optional$2(Text$2),
+		description: Text$3,
+		filePath: Optional$2(Text$3),
 		modelInvocable: Flag$2
 	}),
 	typebox.Type.Object({
@@ -880,38 +829,81 @@ const Detail = typebox.Type.Union([
 		name: typebox.Type.Literal("system"),
 		tokens: NumberValue$2,
 		stage: typebox.Type.Union([typebox.Type.Literal("base"), typebox.Type.Literal("effective")]),
-		text: Text$2
+		text: Text$3
 	})
 ]);
-const sessionHttpContracts = [{
-	...host("context.item", ITEM_ROUTE, "GET", typebox.Type.Object({
-		revision: NumberValue$2,
-		item: Detail
-	}), { parameters: [query("kind", typebox.Type.Union([
-		typebox.Type.Literal("tool"),
-		typebox.Type.Literal("skill"),
-		typebox.Type.Literal("prompt")
-	]), true), query("name", Text$2, true)] }),
-	scope: "session",
-	basePath: API_BASE_PATH
-}, {
-	...host("files.complete", "/", "GET", typebox.Type.Object({ files: Strings$1 }), { parameters: [query("q", typebox.Type.String({ maxLength: 256 }))] }),
-	scope: "session",
-	basePath: "files"
-}];
+const sessionHttpContracts = [
+	{
+		...host("context.current", CURRENT_ROUTE, "GET", typebox.Type.Object({
+			version: typebox.Type.Literal(1),
+			revision: NumberValue$2,
+			selection: typebox.Type.Object({
+				majorMode: Text$3,
+				domains: Strings$1,
+				profile: Optional$2(Text$3)
+			}),
+			groups: typebox.Type.Array(typebox.Type.Object({
+				id: Text$3,
+				label: Text$3,
+				kind: typebox.Type.Union([
+					typebox.Type.Literal("major"),
+					typebox.Type.Literal("minor"),
+					typebox.Type.Literal("domain"),
+					typebox.Type.Literal("core")
+				]),
+				items: typebox.Type.Array(typebox.Type.Object({
+					name: Text$3,
+					itemKind: typebox.Type.Union([typebox.Type.Literal("tool"), typebox.Type.Literal("skill")]),
+					source: Source,
+					owner: Text$3,
+					tokens: NumberValue$2,
+					active: Flag$2
+				})),
+				tokens: NumberValue$2,
+				inactiveTokens: NumberValue$2
+			})),
+			totalTokens: NumberValue$2,
+			inactiveTokens: NumberValue$2,
+			systemPrompt: Optional$2(typebox.Type.Object({
+				tokens: NumberValue$2,
+				stage: typebox.Type.Union([typebox.Type.Literal("base"), typebox.Type.Literal("effective")])
+			})),
+			estimator: typebox.Type.Literal("gpt-tokenizer")
+		})),
+		scope: "session",
+		basePath: API_BASE_PATH
+	},
+	{
+		...host("context.item", ITEM_ROUTE, "GET", typebox.Type.Object({
+			revision: NumberValue$2,
+			item: Detail
+		}), { parameters: [query("kind", typebox.Type.Union([
+			typebox.Type.Literal("tool"),
+			typebox.Type.Literal("skill"),
+			typebox.Type.Literal("prompt")
+		]), true), query("name", Text$3, true)] }),
+		scope: "session",
+		basePath: API_BASE_PATH
+	},
+	{
+		...host("files.complete", "/", "GET", typebox.Type.Object({ files: Strings$1 }), { parameters: [query("q", typebox.Type.String({ maxLength: 256 }))] }),
+		scope: "session",
+		basePath: "files"
+	}
+];
 //#endregion
 //#region src/schemas/remoteApiContracts.ts
-const Text$1 = typebox.Type.String();
+const Text$2 = typebox.Type.String();
 const NumberValue$1 = typebox.Type.Number();
 const Optional$1 = typebox.Type.Optional;
 const Flag$1 = typebox.Type.Boolean();
-const JsonObject = typebox.Type.Record(Text$1, typebox.Type.Unknown({ description: "WebAuthn ceremony fields supplied and verified by the installed WebAuthn implementation." }));
+const JsonObject = typebox.Type.Record(Text$2, typebox.Type.Unknown({ description: "WebAuthn ceremony fields supplied and verified by the installed WebAuthn implementation." }));
 const Tunnel = typebox.Type.Union([typebox.Type.Object({ kind: typebox.Type.Literal("quick") }), typebox.Type.Object({
 	kind: typebox.Type.Literal("named"),
-	hostname: Text$1,
-	name: Optional$1(Text$1),
-	tokenFile: Optional$1(Text$1),
-	configFile: Optional$1(Text$1)
+	hostname: Text$2,
+	name: Optional$1(Text$2),
+	tokenFile: Optional$1(Text$2),
+	configFile: Optional$1(Text$2)
 })]);
 const Settings = typebox.Type.Object({
 	autoCloseEnabled: Flag$1,
@@ -922,7 +914,7 @@ const Settings = typebox.Type.Object({
 	tunnel: Tunnel,
 	sandbox: typebox.Type.Object({
 		enabled: Flag$1,
-		workspaces: typebox.Type.Array(Text$1)
+		workspaces: typebox.Type.Array(Text$2)
 	})
 });
 const State = typebox.Type.Object({
@@ -932,31 +924,31 @@ const State = typebox.Type.Object({
 		typebox.Type.Literal("on"),
 		typebox.Type.Literal("failed")
 	]),
-	publicUrl: Optional$1(Text$1),
-	startedAt: Optional$1(Text$1),
-	closesAt: Optional$1(Text$1),
-	error: Optional$1(Text$1),
+	publicUrl: Optional$1(Text$2),
+	startedAt: Optional$1(Text$2),
+	closesAt: Optional$1(Text$2),
+	error: Optional$1(Text$2),
 	devices: typebox.Type.Array(typebox.Type.Object({
-		id: Text$1,
-		label: Text$1,
-		userAgent: Text$1,
-		createdAt: Text$1,
-		lastSeenAt: Text$1,
+		id: Text$2,
+		label: Text$2,
+		userAgent: Text$2,
+		createdAt: Text$2,
+		lastSeenAt: Text$2,
 		self: Flag$1
 	})),
 	pending: typebox.Type.Array(typebox.Type.Object({
-		id: Text$1,
-		userAgent: Text$1,
-		edgeIp: Text$1,
-		createdAt: Text$1,
-		expiresAt: Text$1
+		id: Text$2,
+		userAgent: Text$2,
+		edgeIp: Text$2,
+		createdAt: Text$2,
+		expiresAt: Text$2
 	})),
 	trustedDevices: typebox.Type.Array(typebox.Type.Object({
-		id: Text$1,
-		label: Text$1,
+		id: Text$2,
+		label: Text$2,
 		platform: typebox.Type.Union([typebox.Type.Literal("ios"), typebox.Type.Literal("android")]),
-		createdAt: Text$1,
-		lastSeenAt: Text$1,
+		createdAt: Text$2,
+		lastSeenAt: Text$2,
 		self: Flag$1
 	})),
 	settings: Settings
@@ -966,45 +958,45 @@ const StateResponse = typebox.Type.Object({
 	handingOver: Optional$1(Flag$1)
 });
 const Trust = typebox.Type.Object({
-	publicKey: Text$1,
-	fingerprint: Text$1,
+	publicKey: Text$2,
+	fingerprint: Text$2,
 	revision: NumberValue$1
 });
 const Begun = typebox.Type.Object({
-	ceremonyId: Text$1,
+	ceremonyId: Text$2,
 	options: JsonObject
 });
 const DeviceKeyBegun = typebox.Type.Object({
-	ceremonyId: Text$1,
-	challenge: Text$1,
+	ceremonyId: Text$2,
+	challenge: Text$2,
 	kind: typebox.Type.Literal("device-key")
 });
 const ChannelKeys = typebox.Type.Object({
-	session: Text$1,
-	protocol: Text$1,
-	http: Text$1
+	session: Text$2,
+	protocol: Text$2,
+	http: Text$2
 });
 const Finish = typebox.Type.Object({
-	ceremonyId: Text$1,
+	ceremonyId: Text$2,
 	response: JsonObject
 });
 const SealedEnvelopeSchema = typebox.Type.Object({
 	v: typebox.Type.Literal(1),
-	n: Text$1,
-	c: Text$1
+	n: Text$2,
+	c: Text$2
 });
 const SealedHttpRequestSchema = typebox.Type.Object({
 	v: typebox.Type.Literal(1),
-	method: Text$1,
-	target: Text$1,
-	headers: typebox.Type.Array(typebox.Type.Tuple([Text$1, Text$1])),
-	body: Optional$1(Text$1)
+	method: Text$2,
+	target: Text$2,
+	headers: typebox.Type.Array(typebox.Type.Tuple([Text$2, Text$2])),
+	body: Optional$1(Text$2)
 });
 const SealedHttpResponseSchema = typebox.Type.Object({
 	v: typebox.Type.Literal(1),
 	status: NumberValue$1,
-	headers: typebox.Type.Array(typebox.Type.Tuple([Text$1, Text$1])),
-	body: Text$1
+	headers: typebox.Type.Array(typebox.Type.Tuple([Text$2, Text$2])),
+	body: Text$2
 });
 const route = (id, path, method, result, input, extra = {}) => ({
 	id: `remote.${id}`,
@@ -1046,16 +1038,16 @@ const direct = [
 	} }),
 	route("codes", "/codes", "POST", typebox.Type.Object({
 		...Trust.properties,
-		code: Text$1,
-		manualCode: Text$1,
-		pairUrl: Text$1,
-		expiresAt: Text$1
+		code: Text$2,
+		manualCode: Text$2,
+		pairUrl: Text$2,
+		expiresAt: Text$2
 	}), void 0, { responses: jsonApiResponses(typebox.Type.Object({
 		...Trust.properties,
-		code: Text$1,
-		manualCode: Text$1,
-		pairUrl: Text$1,
-		expiresAt: Text$1
+		code: Text$2,
+		manualCode: Text$2,
+		pairUrl: Text$2,
+		expiresAt: Text$2
 	}), 201) }),
 	route("approve", "/pairing/{id}/approve", "POST", StateResponse),
 	route("deny", "/pairing/{id}/deny", "POST", StateResponse),
@@ -1064,57 +1056,57 @@ const direct = [
 	route("passkeys", "/passkeys", "GET", typebox.Type.Object({
 		support: typebox.Type.Union([typebox.Type.Object({
 			supported: typebox.Type.Literal(true),
-			rpId: Text$1
+			rpId: Text$2
 		}), typebox.Type.Object({
 			supported: typebox.Type.Literal(false),
-			reason: Text$1
+			reason: Text$2
 		})]),
 		credentials: typebox.Type.Array(typebox.Type.Object({
-			id: Text$1,
-			label: Text$1,
-			createdAt: Text$1,
-			lastUsedAt: Text$1
+			id: Text$2,
+			label: Text$2,
+			createdAt: Text$2,
+			lastUsedAt: Text$2
 		}))
 	})),
 	route("passkeys.remove", "/passkeys/{id}", "DELETE", ApiOkSchema),
 	route("register.begin", "/passkeys/register/begin", "POST", Begun, void 0, { authentication: "device" }),
-	route("register.finish", "/passkeys/register/finish", "POST", typebox.Type.Object({ id: Text$1 }), Finish, { authentication: "device" }),
+	route("register.finish", "/passkeys/register/finish", "POST", typebox.Type.Object({ id: Text$2 }), Finish, { authentication: "device" }),
 	route("authenticate.begin", "/passkeys/authenticate/begin", "POST", Begun, void 0, { authentication: "none" }),
 	route("authenticate.finish", "/passkeys/authenticate/finish", "POST", typebox.Type.Object({
 		ok: typebox.Type.Literal(true),
-		hostPublicKey: Text$1
+		hostPublicKey: Text$2
 	}), Finish, { authentication: "none" }),
-	route("challenge", "/challenge", "POST", typebox.Type.Union([Begun, DeviceKeyBegun]), typebox.Type.Object({ action: Text$1 }), { authentication: "device" }),
-	route("trusted-devices.register", "/trusted-devices", "POST", typebox.Type.Object({ trustedDeviceId: Text$1 }), typebox.Type.Object({
-		identityPublicKey: Text$1,
-		stepUpPublicKey: Text$1,
-		label: Text$1,
+	route("challenge", "/challenge", "POST", typebox.Type.Union([Begun, DeviceKeyBegun]), typebox.Type.Object({ action: Text$2 }), { authentication: "device" }),
+	route("trusted-devices.register", "/trusted-devices", "POST", typebox.Type.Object({ trustedDeviceId: Text$2 }), typebox.Type.Object({
+		identityPublicKey: Text$2,
+		stepUpPublicKey: Text$2,
+		label: Text$2,
 		platform: typebox.Type.Union([typebox.Type.Literal("ios"), typebox.Type.Literal("android")]),
-		identityProof: Text$1,
-		stepUpProof: Text$1
+		identityProof: Text$2,
+		stepUpProof: Text$2
 	}), {
 		authentication: "device",
 		description: "Registers a native device from a sealed, QR-approved pairing session.",
-		responses: jsonApiResponses(typebox.Type.Object({ trustedDeviceId: Text$1 }), 201)
+		responses: jsonApiResponses(typebox.Type.Object({ trustedDeviceId: Text$2 }), 201)
 	}),
 	route("trusted-devices.revoke", "/trusted-devices/{id}", "DELETE", StateResponse, void 0, { description: "Revokes a trusted native device. Local callers, or sealed callers with verified step-up." }),
 	route("device-auth.challenge", "/device-auth/challenge", "POST", typebox.Type.Object({
-		challengeId: Text$1,
-		challenge: Text$1,
-		hostPublicKey: Text$1,
-		attestation: Text$1
+		challengeId: Text$2,
+		challenge: Text$2,
+		hostPublicKey: Text$2,
+		attestation: Text$2
 	}), typebox.Type.Object({
-		trustedDeviceId: Text$1,
-		nonce: Text$1
+		trustedDeviceId: Text$2,
+		nonce: Text$2
 	}), { authentication: "none" }),
 	route("device-auth.authenticate", "/device-auth/authenticate", "POST", typebox.Type.Object({ ok: typebox.Type.Literal(true) }), typebox.Type.Object({
-		challengeId: Text$1,
-		trustedDeviceId: Text$1,
-		signature: Text$1,
+		challengeId: Text$2,
+		trustedDeviceId: Text$2,
+		signature: Text$2,
 		channels: ChannelKeys
 	}), { authentication: "none" }),
 	route("channel", "/channel", "POST", ApiOkSchema, typebox.Type.Object({
-		clientPublicKey: Text$1,
+		clientPublicKey: Text$2,
 		scope: typebox.Type.Union([
 			typebox.Type.Literal("session"),
 			typebox.Type.Literal("protocol"),
@@ -1126,13 +1118,13 @@ const direct = [
 		description: "Sealed HTTP gateway. Decrypted requests/responses use the SealedHttpRequest and SealedHttpResponse envelopes."
 	}),
 	route("pair", "/pair", "POST", typebox.Type.Object({
-		requestId: Text$1,
+		requestId: Text$2,
 		status: typebox.Type.Literal("pending")
 	}), typebox.Type.Object({ code: typebox.Type.String({ minLength: 1 }) }), {
 		authentication: "none",
 		responses: {
 			...jsonApiResponses(typebox.Type.Object({
-				requestId: Text$1,
+				requestId: Text$2,
 				status: typebox.Type.Literal("pending")
 			}), 202),
 			"410": {
@@ -1150,26 +1142,26 @@ const direct = [
 			typebox.Type.Literal("consumed")
 		]),
 		bundleTrust: Optional$1(Trust),
-		hostPublicKey: Optional$1(Text$1)
+		hostPublicKey: Optional$1(Text$2)
 	}), void 0, {
 		authentication: "none",
 		parameters: [{
 			name: "request",
 			in: "query",
 			required: true,
-			schema: Text$1
+			schema: Text$2
 		}]
 	})
 ];
 const remoteHttpContracts = [
-	route("frontend", "/frontend", "POST", ApiOkSchema, typebox.Type.Object({ origin: Text$1 }), {
+	route("frontend", "/frontend", "POST", ApiOkSchema, typebox.Type.Object({ origin: Text$2 }), {
 		authentication: "owner",
 		availability: "Internal loopback frontend registration; blocked by the browser proxy.",
 		parameters: [{
 			name: "x-po-web-registration",
 			in: "header",
 			required: true,
-			schema: Text$1
+			schema: Text$2
 		}]
 	}),
 	...direct,
@@ -1192,15 +1184,15 @@ const remoteHttpContracts = [
 		responses: { "200": {
 			description: "Pairing page",
 			contentType: "text/html",
-			schema: Text$1
+			schema: Text$2
 		} }
 	}
 ];
 const Asset = typebox.Type.Object({
-	path: Text$1,
+	path: Text$2,
 	sha256: typebox.Type.String({ pattern: "^[a-f0-9]{64}$" }),
 	byteLength: typebox.Type.Integer({ minimum: 0 }),
-	contentType: Text$1
+	contentType: Text$2
 });
 const Signed = typebox.Type.Object({
 	manifest: typebox.Type.Object({
@@ -1209,8 +1201,8 @@ const Signed = typebox.Type.Object({
 		builtAt: NumberValue$1,
 		assets: typebox.Type.Array(Asset)
 	}),
-	signature: Text$1,
-	publicKey: Text$1
+	signature: Text$2,
+	publicKey: Text$2
 });
 const bundleHttpContracts = [...["/bundle-manifest.json", "/api/web-plugins/{id}/{revision}/manifest"].flatMap((path) => ["GET", "HEAD"].map((method) => ({
 	id: `bundle.${path}.${method}`,
@@ -1244,12 +1236,104 @@ const bundleHttpContracts = [...["/bundle-manifest.json", "/api/web-plugins/{id}
 	}
 })))];
 //#endregion
-//#region src/schemas/sessionProtocol.ts
-const DOOM_SESSION_SERVICE_ID = "po.session.v2";
-const DOOM_SESSION_MANAGEMENT_SERVICE_ID = "po.session-management.v1";
-(0, _earendil_works_chord.defineService)("po.hub.v1");
-(0, _earendil_works_chord.defineService)(DOOM_SESSION_SERVICE_ID);
-(0, _earendil_works_chord.defineService)(DOOM_SESSION_MANAGEMENT_SERVICE_ID);
+//#region src/schemas/protocolContracts.ts
+/** Name of the Po server host; every Po contract places its objects on it. */
+const PO_SERVER_HOST = "server";
+/** Chord method specs for a schema table, typed so contracts built from them stay nameable. */
+function chordMethods(schemas) {
+	return Object.fromEntries(Object.entries(schemas).map(([name, { args, result }]) => [name, result !== void 0 ? (0, dist_interop_chord_mjs.method)(args, result) : args !== void 0 ? (0, dist_interop_chord_mjs.method)(args) : (0, dist_interop_chord_mjs.method)()]));
+}
+//#endregion
+//#region src/schemas/protocolChannelsContract.ts
+const Json$3 = typebox.Type.Unsafe({});
+const ChannelFrameSchema = typebox.Type.Object({
+	type: typebox.Type.String({ minLength: 1 }),
+	payload: Json$3
+});
+/** Latest payload per extension channel frame type. */
+const PoChannelsStateSchema = typebox.Type.Record(typebox.Type.String(), Json$3);
+(0, dist_interop_chord_mjs.remote)("po.channels", {
+	version: 1,
+	host: (0, dist_interop_chord_mjs.hostNamed)(PO_SERVER_HOST),
+	input: typebox.Type.Object({ sessionId: typebox.Type.String({ minLength: 1 }) }),
+	variants: { default: {
+		state: { latest: PoChannelsStateSchema },
+		methods: chordMethods({ receive: { args: ChannelFrameSchema } })
+	} }
+});
+//#endregion
+//#region src/schemas/pluginProtocol.ts
+/** The address is always exact. A workspace call never resolves to a global service. */
+const PoPluginMountSchema = typebox.Type.Union([
+	typebox.Type.Object({ scope: typebox.Type.Literal("global") }, { additionalProperties: false }),
+	typebox.Type.Object({
+		scope: typebox.Type.Literal("workspace"),
+		workspaceId: typebox.Type.String({ minLength: 1 })
+	}, { additionalProperties: false }),
+	typebox.Type.Object({
+		scope: typebox.Type.Literal("session"),
+		sessionId: typebox.Type.String({ minLength: 1 })
+	}, { additionalProperties: false })
+]);
+const PoPluginCallSchema = typebox.Type.Object({
+	mount: PoPluginMountSchema,
+	service: typebox.Type.String({ minLength: 1 }),
+	method: typebox.Type.String({ minLength: 1 }),
+	input: typebox.Type.Unknown()
+}, { additionalProperties: false });
+//#endregion
+//#region src/schemas/protocolHubContract.ts
+const Text$1 = typebox.Type.String();
+const Json$2 = typebox.Type.Unsafe({});
+/** A live session frame every hub client needs (notification entries and agent dialogs) until it is acknowledged. */
+const HubNoticeSchema = typebox.Type.Object({
+	id: Text$1,
+	sessionId: Text$1,
+	frame: typebox.Type.Record(Text$1, Json$2)
+});
+const HubState = {
+	sessions: typebox.Type.Record(Text$1, SessionSummarySchema),
+	workspaces: typebox.Type.Record(Text$1, WorkspaceSchema),
+	pending: typebox.Type.Array(HubNoticeSchema)
+};
+const PoHubStateSchema = typebox.Type.Object(HubState);
+(0, dist_interop_chord_mjs.remote)("po.hub", {
+	version: 1,
+	host: (0, dist_interop_chord_mjs.hostNamed)(PO_SERVER_HOST),
+	input: typebox.Type.Object({}),
+	variants: { default: {
+		state: HubState,
+		methods: chordMethods({
+			readHome: {
+				args: typebox.Type.Object({
+					offset: typebox.Type.Optional(typebox.Type.Integer({ minimum: 0 })),
+					limit: typebox.Type.Optional(typebox.Type.Integer({ minimum: 1 })),
+					source: typebox.Type.Optional(Text$1),
+					workspaceId: typebox.Type.Optional(Text$1)
+				}),
+				result: typebox.Type.Unsafe({})
+			},
+			invoke: {
+				args: PoPluginCallSchema,
+				result: Json$2
+			},
+			ackNotice: { args: typebox.Type.Object({ id: Text$1 }) }
+		})
+	} }
+});
+//#endregion
+//#region src/schemas/protocolThreadContract.ts
+/** The thread's latest frame: `transcript_state` while its child runs, `transcript_ready` once it has finished. */
+const PoThreadFrameSchema = typebox.Type.Union([typebox.Type.Null(), typebox.Type.Intersect([typebox.Type.Object({ type: typebox.Type.String() }), typebox.Type.Record(typebox.Type.String(), typebox.Type.Unsafe({}))])]);
+(0, dist_interop_chord_mjs.remote)("po.thread", {
+	version: 1,
+	host: (0, dist_interop_chord_mjs.hostNamed)(PO_SERVER_HOST),
+	input: typebox.Type.Object({
+		sessionId: typebox.Type.String({ minLength: 1 }),
+		threadId: typebox.Type.String({ minLength: 1 })
+	}),
+	variants: { default: { state: { frame: PoThreadFrameSchema } } }
+});
 //#endregion
 //#region src/schemas/sessionApiContracts.ts
 const Text = typebox.Type.String();
@@ -1286,66 +1370,12 @@ const TextPart = typebox.Type.Object({
 	type: typebox.Type.Literal("text"),
 	text: Text
 });
-const Content = typebox.Type.Union([Image, TextPart]);
-const User = typebox.Type.Object({
-	id: Text,
-	role: typebox.Type.Literal("user"),
-	content: typebox.Type.Array(Content),
-	timestamp: NumberValue
+const ThinkingPart = typebox.Type.Object({
+	type: typebox.Type.Literal("thinking"),
+	thinking: Text,
+	redacted: Optional(typebox.Type.Literal(true))
 });
-const Transcript = typebox.Type.Union([
-	User,
-	typebox.Type.Object({
-		id: Text,
-		role: typebox.Type.Literal("assistant"),
-		content: typebox.Type.Array(typebox.Type.Union([
-			TextPart,
-			typebox.Type.Object({
-				type: typebox.Type.Literal("thinking"),
-				thinking: Text,
-				redacted: Optional(typebox.Type.Literal(true))
-			}),
-			typebox.Type.Object({
-				type: typebox.Type.Literal("toolCall"),
-				toolCallId: Text,
-				toolName: Text,
-				input: Json$1
-			})
-		])),
-		model: Model,
-		status: typebox.Type.Union([
-			typebox.Type.Literal("streaming"),
-			typebox.Type.Literal("complete"),
-			typebox.Type.Literal("aborted"),
-			typebox.Type.Literal("error")
-		]),
-		stopReason: Optional(typebox.Type.Union([
-			typebox.Type.Literal("stop"),
-			typebox.Type.Literal("length"),
-			typebox.Type.Literal("toolUse"),
-			typebox.Type.Literal("aborted"),
-			typebox.Type.Literal("error")
-		])),
-		errorMessage: Optional(Text),
-		timestamp: NumberValue
-	}),
-	typebox.Type.Object({
-		id: Text,
-		role: typebox.Type.Literal("tool"),
-		toolCallId: Text,
-		toolName: Text,
-		input: Json$1,
-		content: typebox.Type.Array(Content),
-		details: Optional(Json$1),
-		status: typebox.Type.Union([
-			typebox.Type.Literal("running"),
-			typebox.Type.Literal("complete"),
-			typebox.Type.Literal("error")
-		]),
-		isError: Flag,
-		timestamp: NumberValue
-	})
-]);
+const Content = typebox.Type.Union([Image, TextPart]);
 const Usage = typebox.Type.Object({
 	input: NumberValue,
 	output: NumberValue,
@@ -1379,152 +1409,20 @@ const Lifecycle = typebox.Type.Object({
 			typebox.Type.Literal("nextRun")
 		]),
 		scheduling: typebox.Type.Union([typebox.Type.Literal("automatic"), typebox.Type.Literal("held")]),
-		disposition: typebox.Type.Union([
-			typebox.Type.Literal("pending"),
-			typebox.Type.Literal("handoff"),
-			typebox.Type.Literal("uncertain")
-		])
+		disposition: typebox.Type.Union([typebox.Type.Literal("pending"), typebox.Type.Literal("handoff")])
 	}))
 });
 const Frame = typebox.Type.Intersect([typebox.Type.Object({ type: Text }), typebox.Type.Record(Text, Json$1)], { description: "Discriminated extension presentation frame; selected channel schemas describe package payloads." });
-const HubClientFrame = typebox.Type.Union([
-	typebox.Type.Object({
-		type: typebox.Type.Union([typebox.Type.Literal("subscribe"), typebox.Type.Literal("unsubscribe")]),
-		sessionId: Text
-	}),
-	typebox.Type.Object({
-		type: typebox.Type.Union([typebox.Type.Literal("subscribe_thread"), typebox.Type.Literal("unsubscribe_thread")]),
-		sessionId: Text,
-		threadId: Text
-	}),
-	typebox.Type.Object({
-		type: typebox.Type.String({ not: { enum: [
-			"subscribe",
-			"unsubscribe",
-			"subscribe_thread",
-			"unsubscribe_thread"
-		] } }),
-		sessionId: Text,
-		payload: Json$1
-	})
-]);
-const HubServerFrame = typebox.Type.Union([
-	HubSnapshotFrameSchema,
-	HubUpsertFrameSchema,
-	HubRemovedFrameSchema,
-	typebox.Type.Object({
-		type: typebox.Type.Literal("thread_frame"),
-		sessionId: Text,
-		threadId: Text,
-		frame: Frame
-	}),
-	typebox.Type.Object({
-		type: typebox.Type.Literal("thread_backlog"),
-		sessionId: Text,
-		threadId: Text,
-		frames: typebox.Type.Array(Frame)
-	}),
-	typebox.Type.Object({
-		type: typebox.Type.String({ not: { enum: [
-			"sessions_snapshot",
-			"session_upsert",
-			"session_removed",
-			"workspaces_snapshot",
-			"workspace_upsert",
-			"workspace_removed",
-			"thread_frame",
-			"thread_backlog"
-		] } }),
-		sessionId: Text,
-		payload: Json$1
-	})
-]);
 const ProtocolEvent = typebox.Type.Object({
 	sequence: NumberValue,
 	frame: Frame
 });
-const Update = typebox.Type.Union([
-	typebox.Type.Object({
-		sessionUpdate: typebox.Type.Union([
-			typebox.Type.Literal("user_message"),
-			typebox.Type.Literal("agent_message"),
-			typebox.Type.Literal("agent_thought")
-		]),
-		messageId: Text,
-		content: typebox.Type.Array(Content)
-	}),
-	typebox.Type.Object({
-		sessionUpdate: typebox.Type.Literal("tool_call_update"),
-		toolCallId: Text,
-		title: Optional(Text),
-		kind: Optional(Text),
-		status: Optional(typebox.Type.Union([
-			typebox.Type.Literal("pending"),
-			typebox.Type.Literal("in_progress"),
-			typebox.Type.Literal("completed"),
-			typebox.Type.Literal("failed"),
-			typebox.Type.Literal("cancelled")
-		])),
-		content: Optional(typebox.Type.Array(typebox.Type.Object({
-			type: typebox.Type.Literal("content"),
-			content: Content
-		}))),
-		rawInput: Optional(Json$1),
-		rawOutput: Optional(Json$1)
-	}),
-	typebox.Type.Object({
-		sessionUpdate: typebox.Type.Literal("state_update"),
-		state: typebox.Type.Union([
-			typebox.Type.Literal("running"),
-			typebox.Type.Literal("idle"),
-			typebox.Type.Literal("requires_action")
-		]),
-		stopReason: Optional(typebox.Type.Union([
-			typebox.Type.Literal("end_turn"),
-			typebox.Type.Literal("max_tokens"),
-			typebox.Type.Literal("max_turn_requests"),
-			typebox.Type.Literal("refusal"),
-			typebox.Type.Literal("cancelled"),
-			typebox.Type.Unsafe(typebox.Type.String({ pattern: "^_" }))
-		]))
-	})
-]);
 const SessionServiceStateSchema = typebox.Type.Object({
 	snapshot: typebox.Type.Object({
-		id: Text,
-		cwd: Text,
-		name: Optional(Text),
-		createdAt: NumberValue,
-		updatedAt: NumberValue,
-		phase: Phase,
-		model: Model,
-		thinkingLevel: Thinking,
 		fastMode: Flag,
-		attached: Flag,
 		locked: Flag,
-		revision: NumberValue,
-		queuedSteer: typebox.Type.Array(User),
-		queuedSteerCount: NumberValue,
 		lifecycle: Optional(Lifecycle)
 	}),
-	progress: typebox.Type.Union([typebox.Type.Null(), typebox.Type.Union([
-		typebox.Type.Object({
-			type: typebox.Type.Literal("item_started"),
-			item: Transcript
-		}),
-		typebox.Type.Object({
-			type: typebox.Type.Literal("item_updated"),
-			item: Transcript
-		}),
-		typebox.Type.Object({
-			type: typebox.Type.Literal("item_finished"),
-			item: Transcript
-		})
-	])]),
-	updates: Optional(typebox.Type.Array(typebox.Type.Object({
-		sequence: NumberValue,
-		update: Update
-	}))),
 	presentation: Optional(typebox.Type.Object({
 		revision: NumberValue,
 		dropped: NumberValue,
@@ -1532,17 +1430,35 @@ const SessionServiceStateSchema = typebox.Type.Object({
 		events: typebox.Type.Array(ProtocolEvent),
 		projections: typebox.Type.Array(ProtocolEvent)
 	})),
-	inFlight: Optional(typebox.Type.Array(Transcript))
+	live: Optional(typebox.Type.Object({
+		phase: Phase,
+		message: Optional(typebox.Type.Object({
+			role: typebox.Type.Literal("assistant"),
+			content: typebox.Type.Array(typebox.Type.Union([TextPart, ThinkingPart])),
+			model: Text,
+			timestamp: NumberValue
+		})),
+		tools: typebox.Type.Record(Text, typebox.Type.Object({
+			toolCallId: Text,
+			toolName: Text,
+			args: Json$1,
+			partialResult: Optional(typebox.Type.Object({
+				content: typebox.Type.Array(Content),
+				details: Optional(Json$1)
+			}))
+		}))
+	}))
 });
+/** Argument and result schemas of the `po.session` methods; the Chord contract and the API docs both read them. */
 const SessionMethodSchemas = {
 	readTranscriptPage: {
-		input: typebox.Type.Tuple([typebox.Type.Object({
+		args: typebox.Type.Object({
 			cursor: Optional(Text),
 			direction: Optional(typebox.Type.Union([typebox.Type.Literal("older"), typebox.Type.Literal("newer")])),
 			limit: Optional(NumberValue),
 			threadId: Optional(Text)
-		})]),
-		output: typebox.Type.Object({
+		}),
+		result: typebox.Type.Object({
 			entries: typebox.Type.Array(Json$1),
 			startCursor: typebox.Type.Union([Text, typebox.Type.Null()]),
 			endCursor: typebox.Type.Union([Text, typebox.Type.Null()]),
@@ -1550,29 +1466,28 @@ const SessionMethodSchemas = {
 			newerCursor: typebox.Type.Union([Text, typebox.Type.Null()]),
 			generation: NumberValue,
 			revision: NumberValue,
-			context: typebox.Type.Array(Json$1),
-			drafts: typebox.Type.Array(Transcript)
+			context: typebox.Type.Array(Json$1)
 		})
 	},
-	prompt: { input: typebox.Type.Tuple([typebox.Type.Union([Text, typebox.Type.Object({
+	prompt: { args: typebox.Type.Union([Text, typebox.Type.Object({
 		...Message.properties,
 		waitFor: Optional(typebox.Type.Union([typebox.Type.Literal("accepted"), typebox.Type.Literal("settled")]))
-	})])]) },
-	steer: { input: typebox.Type.Tuple([typebox.Type.Union([Text, Message])]) },
-	abort: { input: typebox.Type.Tuple([]) },
-	abortOperation: { input: typebox.Type.Tuple([typebox.Type.Object({ operationId: Text })]) },
-	setModel: { input: typebox.Type.Tuple([Model]) },
-	setThinking: { input: typebox.Type.Tuple([Thinking]) },
-	setFastMode: { input: typebox.Type.Tuple([Flag]) },
-	setAgentLock: { input: typebox.Type.Tuple([Flag]) },
-	followUp: { input: typebox.Type.Tuple([Message]) },
+	})]) },
+	steer: { args: typebox.Type.Union([Text, Message]) },
+	abort: {},
+	abortOperation: { args: typebox.Type.Object({ operationId: Text }) },
+	setModel: { args: Model },
+	setThinking: { args: Thinking },
+	setFastMode: { args: Flag },
+	setAgentLock: { args: Flag },
+	followUp: { args: Message },
 	enqueueAutomatic: {
-		input: typebox.Type.Tuple([Message]),
-		output: typebox.Type.Object({ id: Text })
+		args: Message,
+		result: typebox.Type.Object({ id: Text })
 	},
 	removeQueued: {
-		input: typebox.Type.Tuple([typebox.Type.Object({ id: Text })]),
-		output: typebox.Type.Union([
+		args: typebox.Type.Object({ id: Text }),
+		result: typebox.Type.Union([
 			typebox.Type.Literal("removed"),
 			typebox.Type.Literal("in_flight"),
 			typebox.Type.Literal("already_consumed"),
@@ -1580,34 +1495,31 @@ const SessionMethodSchemas = {
 		])
 	},
 	promoteQueued: {
-		input: typebox.Type.Tuple([typebox.Type.Object({
+		args: typebox.Type.Object({
 			id: Text,
 			operationId: Optional(Text)
-		})]),
-		output: typebox.Type.Union([
+		}),
+		result: typebox.Type.Union([
 			typebox.Type.Literal("promoted"),
 			typebox.Type.Literal("in_flight"),
 			typebox.Type.Literal("target_changed"),
 			typebox.Type.Literal("not_found")
 		])
 	},
-	resumeQueue: { input: typebox.Type.Tuple([]) },
-	clearQueue: {
-		input: typebox.Type.Tuple([]),
-		output: typebox.Type.Object({
-			steering: Strings,
-			followUp: Strings
-		})
-	},
+	resumeQueue: {},
+	clearQueue: { result: typebox.Type.Object({
+		steering: Strings,
+		followUp: Strings
+	}) },
 	rewind: {
-		input: typebox.Type.Tuple([typebox.Type.Object({
+		args: typebox.Type.Object({
 			itemId: Text,
 			summarize: Optional(Flag),
 			customInstructions: Optional(Text),
 			replaceInstructions: Optional(Flag),
 			label: Optional(Text)
-		})]),
-		output: typebox.Type.Object({
+		}),
+		result: typebox.Type.Object({
 			editorText: Optional(Text),
 			cancelled: Flag,
 			aborted: Optional(Flag),
@@ -1623,7 +1535,7 @@ const SessionMethodSchemas = {
 			}))
 		})
 	},
-	extensionUiResponse: { input: typebox.Type.Tuple([typebox.Type.Union([
+	extensionUiResponse: { args: typebox.Type.Union([
 		typebox.Type.Object({
 			id: Text,
 			value: Text
@@ -1636,201 +1548,128 @@ const SessionMethodSchemas = {
 			id: Text,
 			cancelled: typebox.Type.Literal(true)
 		})
-	])]) },
-	getState: {
-		input: typebox.Type.Tuple([]),
-		output: typebox.Type.Object({
-			model: Optional(Model),
-			thinkingLevel: Thinking,
-			fastMode: Flag,
-			isStreaming: Flag,
-			isCompacting: Flag,
-			steeringMode: typebox.Type.Union([typebox.Type.Literal("all"), typebox.Type.Literal("one-at-a-time")]),
-			followUpMode: typebox.Type.Union([typebox.Type.Literal("all"), typebox.Type.Literal("one-at-a-time")]),
-			sessionFile: Optional(Text),
-			sessionId: Text,
-			sessionName: Optional(Text),
-			autoCompactionEnabled: Flag,
-			messageCount: NumberValue,
-			pendingMessageCount: NumberValue,
-			operationId: Optional(Text),
-			executionStatus: Optional(typebox.Type.Union([typebox.Type.Literal("open"), typebox.Type.Literal("aborting")])),
-			queuePaused: Optional(Flag),
-			queueRevision: Optional(NumberValue)
-		})
-	},
-	getSessionStats: {
-		input: typebox.Type.Tuple([]),
-		output: typebox.Type.Object({
-			sessionFile: Optional(Text),
-			sessionId: Text,
-			totalMessages: NumberValue,
-			tokens: Usage,
-			cost: NumberValue,
-			contextUsage: Optional(typebox.Type.Object({
-				tokens: typebox.Type.Union([NumberValue, typebox.Type.Null()]),
-				contextWindow: NumberValue,
-				percent: typebox.Type.Union([NumberValue, typebox.Type.Null()])
-			}))
-		})
-	},
-	getCommands: {
-		input: typebox.Type.Tuple([]),
-		output: typebox.Type.Array(typebox.Type.Object({
-			name: Text,
-			description: Optional(Text),
-			source: typebox.Type.Union([
-				typebox.Type.Literal("extension"),
-				typebox.Type.Literal("prompt"),
-				typebox.Type.Literal("skill")
+	]) },
+	getState: { result: typebox.Type.Object({
+		model: Optional(Model),
+		thinkingLevel: Thinking,
+		fastMode: Flag,
+		agentLocked: Optional(Flag),
+		isStreaming: Flag,
+		isCompacting: Flag,
+		steeringMode: typebox.Type.Union([typebox.Type.Literal("all"), typebox.Type.Literal("one-at-a-time")]),
+		followUpMode: typebox.Type.Union([typebox.Type.Literal("all"), typebox.Type.Literal("one-at-a-time")]),
+		sessionId: Text,
+		sessionName: Optional(Text),
+		autoCompactionEnabled: Flag,
+		messageCount: NumberValue,
+		pendingMessageCount: NumberValue,
+		operationId: Optional(Text),
+		executionStatus: Optional(typebox.Type.Union([typebox.Type.Literal("open"), typebox.Type.Literal("aborting")])),
+		queuePaused: Optional(Flag),
+		queueRevision: Optional(NumberValue)
+	}) },
+	getSessionStats: { result: typebox.Type.Object({
+		sessionId: Text,
+		totalMessages: NumberValue,
+		tokens: Usage,
+		cost: NumberValue,
+		contextUsage: Optional(typebox.Type.Object({
+			tokens: typebox.Type.Union([NumberValue, typebox.Type.Null()]),
+			contextWindow: NumberValue,
+			percent: typebox.Type.Union([NumberValue, typebox.Type.Null()])
+		}))
+	}) },
+	getCommands: { result: typebox.Type.Array(typebox.Type.Object({
+		name: Text,
+		description: Optional(Text),
+		source: typebox.Type.Union([
+			typebox.Type.Literal("extension"),
+			typebox.Type.Literal("prompt"),
+			typebox.Type.Literal("skill")
+		]),
+		sourceInfo: Optional(typebox.Type.Object({
+			path: Text,
+			source: Text,
+			scope: typebox.Type.Union([
+				typebox.Type.Literal("user"),
+				typebox.Type.Literal("project"),
+				typebox.Type.Literal("temporary")
 			]),
-			sourceInfo: Optional(typebox.Type.Object({
-				path: Text,
-				source: Text,
-				scope: typebox.Type.Union([
-					typebox.Type.Literal("user"),
-					typebox.Type.Literal("project"),
-					typebox.Type.Literal("temporary")
-				]),
-				origin: typebox.Type.Union([typebox.Type.Literal("package"), typebox.Type.Literal("top-level")]),
-				baseDir: Optional(Text)
-			}))
+			origin: typebox.Type.Union([typebox.Type.Literal("package"), typebox.Type.Literal("top-level")]),
+			baseDir: Optional(Text)
 		}))
-	},
-	getAvailableModels: {
-		input: typebox.Type.Tuple([]),
-		output: typebox.Type.Array(Model)
-	},
-	getAvailableThinkingLevels: {
-		input: typebox.Type.Tuple([]),
-		output: typebox.Type.Array(Thinking)
-	},
+	})) },
+	getAvailableModels: { result: typebox.Type.Array(Model) },
+	getAvailableThinkingLevels: { result: typebox.Type.Array(Thinking) },
 	compact: {
-		input: typebox.Type.Tuple([typebox.Type.Object({ customInstructions: Optional(Text) })]),
-		output: Json$1
+		args: typebox.Type.Object({ customInstructions: Optional(Text) }),
+		result: Json$1
 	},
-	setName: { input: typebox.Type.Tuple([Text]) }
+	setName: { args: Text },
+	setGroups: { args: typebox.Type.Array(Text) }
 };
+/** The `po.session` methods as Chord specs. */
+const SessionMethods = chordMethods(SessionMethodSchemas);
 const ErrorSchema = typebox.Type.Object({
 	code: Text,
 	message: Text
 });
+const documented = (id, service, member, direction, input, description) => ({
+	id,
+	scope: service === "po.hub" ? "global" : "session",
+	service,
+	member,
+	direction,
+	kind: direction === "server-to-client" ? "state" : "method",
+	input,
+	...direction === "server-to-client" ? {} : { errors: ErrorSchema },
+	description
+});
 const sessionSocketContracts = [
-	...Object.entries(SessionMethodSchemas).map(([member, definition]) => ({
+	...Object.entries(SessionMethodSchemas).map(([member, { args, result }]) => ({
 		id: `session.${member}`,
 		scope: "session",
-		service: DOOM_SESSION_SERVICE_ID,
+		service: "po.session",
 		member,
 		direction: "client-to-server",
 		kind: "method",
-		description: `Session ${member}. Arguments exclude the process-local Chord Context. A void result is omitted from the successful Pi response.`,
-		...definition,
+		description: `Session ${member}. The Chord call carries the argument; a void result is null.`,
+		input: typebox.Type.Tuple(args === void 0 ? [] : [args]),
+		...result === void 0 ? {} : { output: result },
 		errors: ErrorSchema
 	})),
-	{
-		id: "session.state",
-		scope: "session",
-		service: DOOM_SESSION_SERVICE_ID,
-		member: "state",
-		direction: "server-to-client",
-		kind: "state",
-		input: SessionServiceStateSchema,
-		description: "Reconstructed session state after Chord snapshot/delta decoding."
-	},
-	{
-		id: "management.attach",
-		scope: "global",
-		service: DOOM_SESSION_MANAGEMENT_SERVICE_ID,
-		member: "attach",
-		direction: "client-to-server",
-		kind: "method",
-		input: typebox.Type.Tuple([Text]),
-		errors: ErrorSchema,
-		description: "Attach this presentation to a session. Pi publishes an out-of-band attachment update."
-	},
-	{
-		id: "management.detach",
-		scope: "global",
-		service: DOOM_SESSION_MANAGEMENT_SERVICE_ID,
-		member: "detach",
-		direction: "client-to-server",
-		kind: "method",
-		input: typebox.Type.Tuple([]),
-		errors: ErrorSchema,
-		description: "Detach this presentation from its selected session."
-	},
-	{
-		id: "hub.send",
-		scope: "global",
-		service: "po.hub.v1",
-		member: "send",
-		direction: "client-to-server",
-		kind: "method",
-		input: typebox.Type.Tuple([HubClientFrame]),
-		errors: ErrorSchema,
-		description: "Send a hub subscription, thread, history, or selected extension channel frame."
-	},
-	{
-		id: "hub.state",
-		scope: "global",
-		service: "po.hub.v1",
-		member: "state",
-		direction: "server-to-client",
-		kind: "state",
-		input: typebox.Type.Object({ events: typebox.Type.Array(typebox.Type.Object({
-			sequence: NumberValue,
-			frame: HubServerFrame
-		})) }),
-		description: "Reconstructed hub event replay window. Frame discriminators identify session and selected extension updates."
-	}
+	documented("session.state", "po.session", "state", "server-to-client", SessionServiceStateSchema, "The `state` member of `po.session`, reconstructed from Chord snapshot and delta frames."),
+	documented("hub.state", "po.hub", "state", "server-to-client", PoHubStateSchema, "Sessions and workspaces this connection may see, and notices it has not acknowledged."),
+	documented("thread.frame", "po.thread", "frame", "server-to-client", PoThreadFrameSchema, "The latest frame of one child thread: transcript_state while it runs, transcript_ready once finished."),
+	documented("channels.latest", "po.channels", "latest", "server-to-client", PoChannelsStateSchema, "The latest payload of each extension channel frame type for one session."),
+	documented("channels.receive", "po.channels", "receive", "client-to-server", typebox.Type.Tuple([ChannelFrameSchema]), "Send one extension channel frame to the session.")
 ];
 //#endregion
-//#region src/schemas/pluginProtocol.ts
-/** The address is always exact. A workspace call never resolves to a global service. */
-const DoomPluginMountSchema = typebox.Type.Union([
-	typebox.Type.Object({ scope: typebox.Type.Literal("global") }, { additionalProperties: false }),
-	typebox.Type.Object({
-		scope: typebox.Type.Literal("workspace"),
-		workspaceId: typebox.Type.String({ minLength: 1 })
-	}, { additionalProperties: false }),
-	typebox.Type.Object({
-		scope: typebox.Type.Literal("session"),
-		sessionId: typebox.Type.String({ minLength: 1 })
-	}, { additionalProperties: false })
-]);
-const DoomPluginCallSchema = typebox.Type.Object({
-	mount: DoomPluginMountSchema,
-	service: typebox.Type.String({ minLength: 1 }),
-	method: typebox.Type.String({ minLength: 1 }),
-	input: typebox.Type.Unknown()
-}, { additionalProperties: false });
-(0, _earendil_works_chord.defineService)("po.plugin.v1");
-//#endregion
 //#region src/schemas/transportApiContracts.ts
+/** The Chord release whose link frames this file describes (link protocol 4). */
+const CHORD_WIRE_VERSION = "1.3.0";
 const S = typebox.Type.String({ minLength: 1 });
-const Json = typebox.Type.Unknown({ description: "JSON value; its application shape is defined by the addressed service member." });
-const E = typebox.Type.Object({
-	code: S,
-	message: typebox.Type.String()
-}, { additionalProperties: false });
-const ServerId = typebox.Type.String({ pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" });
-const Address = typebox.Type.Object({
-	key: S,
-	generation: typebox.Type.Integer({ minimum: 1 })
-}, { additionalProperties: false });
-const Mode = typebox.Type.Union([typebox.Type.Literal("singleton"), typebox.Type.Literal("keyed")]);
-const SessionTarget = typebox.Type.Object({
-	serverId: ServerId,
-	sessionId: S,
-	attachmentId: S
-}, { additionalProperties: false });
-const Target = typebox.Type.Union([typebox.Type.Object({ serverId: ServerId }, { additionalProperties: false }), SessionTarget]);
-const ChordCallSchema = typebox.Type.Object({
-	serviceId: S,
-	member: S,
-	args: typebox.Type.Array(Json),
-	instance: typebox.Type.Optional(Address)
-}, { additionalProperties: false });
+const Json = typebox.Type.Unknown({ description: "JSON value; its application shape is defined by the addressed contract member." });
+const Id = typebox.Type.Integer({ minimum: 1 });
+const ErrorCode = typebox.Type.Union([
+	"aborted",
+	"contract_mismatch",
+	"forbidden",
+	"gone",
+	"invalid",
+	"not_in_variant",
+	"not_ready",
+	"released",
+	"superseded",
+	"unavailable",
+	"upgrade_conflict",
+	"upgrade_required"
+].map((code) => typebox.Type.Literal(code)));
+const WireError = typebox.Type.Object({
+	code: ErrorCode,
+	message: typebox.Type.String(),
+	reason: typebox.Type.Optional(typebox.Type.String())
+});
 const Segment = typebox.Type.Union([typebox.Type.String(), typebox.Type.Integer({ minimum: 0 })]);
 const Path = typebox.Type.Array(Segment);
 const PathRef = typebox.Type.Union([Path, typebox.Type.Integer({ minimum: 0 })]);
@@ -1871,173 +1710,158 @@ const ChordWireOpSchema = typebox.Type.Union([
 		Index,
 		typebox.Type.Array(Json)
 	]),
+	typebox.Type.Tuple([
+		typebox.Type.Literal("m"),
+		PathRef,
+		typebox.Type.Array(Index)
+	]),
+	typebox.Type.Tuple([typebox.Type.Literal("m"), typebox.Type.Array(Index)]),
 	typebox.Type.Tuple([
 		typebox.Type.Literal("#"),
 		Index,
 		Path
 	])
 ], { description: "Chord delta tuples. Path dictionary references and omitted paths depend on earlier operations in this subscription; decode with the Chord delta decoder." });
-const Instance = typebox.Type.Object({
-	instance: typebox.Type.Optional(Address),
-	members: typebox.Type.Array(typebox.Type.Union([typebox.Type.Object({
-		name: S,
-		kind: typebox.Type.Literal("method")
-	}), typebox.Type.Object({
-		name: S,
-		kind: typebox.Type.Literal("state"),
-		sequence: typebox.Type.Integer({ minimum: 0 }),
-		ops: typebox.Type.Array(ChordWireOpSchema)
-	})]))
+const Hello = (kind) => typebox.Type.Object({
+	t: typebox.Type.Literal("hello"),
+	protocol: typebox.Type.Optional(typebox.Type.Integer({ minimum: 1 })),
+	name: typebox.Type.String(),
+	kind,
+	codeVersion: typebox.Type.Integer({ minimum: 0 }),
+	acks: typebox.Type.Optional(typebox.Type.Boolean())
+});
+const Ack = typebox.Type.Object({
+	t: typebox.Type.Literal("ack"),
+	n: typebox.Type.Integer({ minimum: 1 })
 });
-const ChordSnapshotSchema = typebox.Type.Object({
-	serviceId: S,
-	mode: Mode,
-	instances: typebox.Type.Array(Instance)
+const Ping = typebox.Type.Object({
+	t: typebox.Type.Literal("ping"),
+	n: typebox.Type.Integer()
 });
-const ChordUpdateSchema = typebox.Type.Union([
+const Pong = typebox.Type.Object({
+	t: typebox.Type.Literal("pong"),
+	n: typebox.Type.Integer()
+});
+const Bye = typebox.Type.Object({
+	t: typebox.Type.Literal("bye"),
+	reason: typebox.Type.Optional(typebox.Type.String())
+});
+/** Frames a client (browser or native app) sends on its link. */
+const ChordClientFrameSchema = typebox.Type.Union([
+	Hello(typebox.Type.Literal("client")),
+	Ack,
 	typebox.Type.Object({
-		type: typebox.Type.Literal("state"),
-		instance: typebox.Type.Optional(Address),
-		member: S,
-		sequence: typebox.Type.Integer({ minimum: 1 }),
-		ops: typebox.Type.Array(ChordWireOpSchema)
+		t: typebox.Type.Literal("hold"),
+		id: Id,
+		at: typebox.Type.String(),
+		token: Json,
+		input: Json,
+		state: typebox.Type.Optional(typebox.Type.Literal(false)),
+		again: typebox.Type.Optional(typebox.Type.Literal(true))
 	}),
-	typebox.Type.Object({ type: typebox.Type.Literal("unavailable") }),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("replaced"),
-		snapshot: Instance
+		t: typebox.Type.Literal("release"),
+		id: Id
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("spawned"),
-		instance: Instance
+		t: typebox.Type.Literal("call"),
+		id: Id,
+		hold: Id,
+		member: S,
+		args: typebox.Type.Optional(Json)
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("closed"),
-		instance: Address
-	})
-]);
-const PiClientMessageSchema = typebox.Type.Union([
-	typebox.Type.Object({
-		type: typebox.Type.Literal("hello"),
-		version: typebox.Type.Integer({ minimum: 0 })
+		t: typebox.Type.Literal("cancel"),
+		id: Id
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("request"),
-		id: S,
-		target: Target,
-		call: ChordCallSchema
+		t: typebox.Type.Literal("sub"),
+		hold: Id
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("cancel"),
-		id: S,
-		target: Target
-	})
-]);
-const PiServerMessageSchema = typebox.Type.Union([
-	typebox.Type.Object({
-		type: typebox.Type.Literal("hello"),
-		version: typebox.Type.Literal(_earendil_works_pi_protocol.PROTOCOL_VERSION),
-		serverId: ServerId
+		t: typebox.Type.Literal("unsub"),
+		hold: Id
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("hello_error"),
-		error: E
+		t: typebox.Type.Literal("root_end"),
+		rootId: typebox.Type.String()
 	}),
+	Ping,
+	Pong,
+	Bye
+]);
+/** Frames the Po server sends to a client link. */
+const ChordServerFrameSchema = typebox.Type.Union([
+	Hello(typebox.Type.String()),
+	Ack,
 	typebox.Type.Object({
-		type: typebox.Type.Literal("response"),
-		id: S,
-		ok: typebox.Type.Literal(true),
-		result: typebox.Type.Optional(Json)
+		t: typebox.Type.Literal("shape"),
+		id: Id,
+		variant: typebox.Type.Optional(typebox.Type.String()),
+		members: typebox.Type.Array(typebox.Type.String()),
+		contract: typebox.Type.String(),
+		state: typebox.Type.Array(S)
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("response"),
-		id: S,
-		ok: typebox.Type.Literal(false),
-		error: E
+		t: typebox.Type.Literal("gone"),
+		id: Id,
+		error: WireError
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("service_update"),
-		subscriptionId: S,
-		update: ChordUpdateSchema
+		t: typebox.Type.Literal("result"),
+		id: Id,
+		value: typebox.Type.Optional(Json),
+		error: typebox.Type.Optional(WireError)
 	}),
 	typebox.Type.Object({
-		type: typebox.Type.Literal("attachment"),
-		attachment: typebox.Type.Union([SessionTarget, typebox.Type.Null()])
-	})
+		t: typebox.Type.Literal("state"),
+		hold: Id,
+		m: S,
+		as: typebox.Type.Union([
+			typebox.Type.Literal("snap"),
+			typebox.Type.Literal("reset"),
+			typebox.Type.Literal("ops"),
+			typebox.Type.Literal("error")
+		]),
+		value: typebox.Type.Optional(Json),
+		ops: typebox.Type.Optional(typebox.Type.Array(ChordWireOpSchema)),
+		error: typebox.Type.Optional(WireError)
+	}),
+	Ping,
+	Pong,
+	Bye
 ]);
 const transportSocketContracts = [
 	{
-		id: "pi.client",
+		id: "chord.client",
 		scope: "global",
-		service: "$pi",
+		service: "$chord",
 		member: "client",
 		direction: "client-to-server",
 		kind: "channel",
-		input: PiClientMessageSchema,
-		description: `Pi protocol ${_earendil_works_pi_protocol.PROTOCOL_VERSION} decoded client envelope. Encode with the public Pi codec and framing functions, then seal for WebSocket delivery.`
+		input: ChordClientFrameSchema,
+		description: `Chord ${CHORD_WIRE_VERSION} link frame, one JSON text message each, sealed for remote delivery. Hold \`po.hub\` ({}) and \`po.session\` ({ sessionId }) at host \`server\`.`
 	},
 	{
-		id: "pi.server",
+		id: "chord.server",
 		scope: "global",
-		service: "$pi",
+		service: "$chord",
 		member: "server",
 		direction: "server-to-client",
 		kind: "channel",
-		input: PiServerMessageSchema,
-		description: "Pi decoded server envelope. Responses correlate by id; service updates correlate by subscriptionId."
-	},
-	{
-		id: "chord.catalogue",
-		scope: "global",
-		service: "$chord.service",
-		member: "catalogue",
-		direction: "client-to-server",
-		kind: "method",
-		input: typebox.Type.Tuple([]),
-		output: typebox.Type.Array(typebox.Type.Object({
-			serviceId: S,
-			mode: Mode
-		})),
-		errors: E,
-		description: "Discover services at the selected Pi target."
-	},
-	{
-		id: "chord.subscribe",
-		scope: "global",
-		service: "$chord.service",
-		member: "subscribe",
-		direction: "client-to-server",
-		kind: "method",
-		input: typebox.Type.Tuple([
-			S,
-			S,
-			Mode
-		]),
-		output: ChordSnapshotSchema,
-		errors: E,
-		description: "Subscribe with [subscriptionId, serviceId, mode]; subsequent Pi service_update messages contain Chord deltas."
-	},
-	{
-		id: "chord.unsubscribe",
-		scope: "global",
-		service: "$chord.service",
-		member: "unsubscribe",
-		direction: "client-to-server",
-		kind: "method",
-		input: typebox.Type.Tuple([S]),
-		errors: E,
-		description: "Unsubscribe by subscriptionId."
+		input: ChordServerFrameSchema,
+		description: "Chord link frame. Results correlate by call id; state frames by hold id and member."
 	},
 	{
 		id: "plugin.invoke",
 		scope: "global",
-		service: "po.plugin.v1",
+		service: "po.hub",
 		member: "invoke",
 		direction: "client-to-server",
 		kind: "method",
-		input: typebox.Type.Tuple([DoomPluginCallSchema]),
+		input: PoPluginCallSchema,
 		output: Json,
-		errors: E,
+		errors: WireError,
 		description: "Invoke the selected scoped plugin method. Its declaration supplies input and output shapes."
 	}
 ];
@@ -2051,8 +1875,7 @@ const builtinApiContract = defineApiContract({
 		SealedHttpResponse: SealedHttpResponseSchema
 	},
 	protocols: {
-		pi: String(_earendil_works_pi_protocol.PROTOCOL_VERSION),
-		chord: "1.0.0",
+		chord: CHORD_WIRE_VERSION,
 		sealed: "1"
 	},
 	http: [
@@ -2072,16 +1895,14 @@ const builtinApiContract = defineApiContract({
 //#endregion
 exports.ApiErrorSchema = ApiErrorSchema;
 exports.ApiOkSchema = ApiOkSchema;
-exports.ChordCallSchema = ChordCallSchema;
-exports.ChordSnapshotSchema = ChordSnapshotSchema;
-exports.ChordUpdateSchema = ChordUpdateSchema;
+exports.CHORD_WIRE_VERSION = CHORD_WIRE_VERSION;
+exports.ChordClientFrameSchema = ChordClientFrameSchema;
+exports.ChordServerFrameSchema = ChordServerFrameSchema;
 exports.ChordWireOpSchema = ChordWireOpSchema;
-exports.DOOM_API_CONTRACT_FILE = DOOM_API_CONTRACT_FILE;
-exports.DOOM_API_CONTRACT_VERSION = DOOM_API_CONTRACT_VERSION;
-exports.DoomApiContractSchema = DoomApiContractSchema;
-exports.PiClientMessageSchema = PiClientMessageSchema;
-exports.PiServerMessageSchema = PiServerMessageSchema;
-exports.SessionMethodSchemas = SessionMethodSchemas;
+exports.PO_API_CONTRACT_FILE = PO_API_CONTRACT_FILE;
+exports.PO_API_CONTRACT_VERSION = PO_API_CONTRACT_VERSION;
+exports.PoApiContractSchema = PoApiContractSchema;
+exports.SessionMethods = SessionMethods;
 exports.SessionServiceStateSchema = SessionServiceStateSchema;
 exports.builtinApiContract = builtinApiContract;
 exports.canonicalContractJson = canonicalContractJson;