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

package/dist/apiContracts.mjs

@@ -1,10 +1,9 @@
 import { Type } from "typebox";
 import { Check } from "typebox/value";
-import { PROTOCOL_VERSION } from "@earendil-works/pi-protocol";
-import { defineService } from "@earendil-works/chord";
+import { hostNamed, method, remote } from "@earendil-works/chord";
 //#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 = Type.Unsafe(Type.Union([Type.Boolean(), Type.Record(Type.String(), Type.Unknown())]));
 const Scope = Type.Union([
 	Type.Literal("global"),
@@ -19,7 +18,7 @@ const ResponseSchema = Type.Object({
 	events: Type.Optional(Type.Record(Named, Schema))
 });
 /** Data-only package entry. Schemas use JSON Schema draft-07, including TypeBox output; OpenAPI export translates tuple keywords. */
-const DoomApiContractSchema = Type.Object({
+const PoApiContractSchema = Type.Object({
 	version: Type.Literal(1),
 	protocols: Type.Optional(Type.Record(Named, Named)),
 	schemas: Type.Optional(Type.Record(Named, Schema)),
@@ -88,7 +87,7 @@ function defineApiContract(contract) {
 	return contract;
 }
 function parseApiContract(value) {
-	if (!Check(DoomApiContractSchema, value)) throw new Error("Invalid Po API contract");
+	if (!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]) {
@@ -116,7 +115,7 @@ function parseCompiledContracts(value) {
 			majorMode: Named,
 			layer: Named
 		}), { minItems: 1 }),
-		contract: Type.Optional(DoomApiContractSchema),
+		contract: Type.Optional(PoApiContractSchema),
 		problem: Type.Optional(Named),
 		module: Type.Optional(Type.String({ pattern: "^\\./[^\\\\%?#]+$" }))
 	});
@@ -424,19 +423,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 = Type.String();
+const Text$3 = Type.String();
 const Optional$2 = Type.Optional;
-const Strings$1 = Type.Array(Text$2);
+const Strings$1 = Type.Array(Text$3);
 const Flag$2 = Type.Boolean();
 const NumberValue$2 = Type.Number();
 const ApiErrorSchema = Type.Object({
-	error: Text$2,
-	hash: Optional$2(Text$2)
+	error: Text$3,
+	hash: Optional$2(Text$3)
 });
 const ApiOkSchema = Type.Object({ ok: Type.Literal(true) });
-const Json$2 = Type.Unknown({ description: "Value whose schema is supplied by the selected runtime contribution." });
+const Json$4 = 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 {
@@ -484,86 +484,86 @@ function jsonApiResponses(schema, status = 200) {
 	};
 }
 const WebCompositionSchema = Type.Object({
-	id: Text$2,
+	id: Text$3,
 	scope: Type.Union([
 		Type.Literal("global"),
 		Type.Literal("workspace"),
 		Type.Literal("session")
 	]),
 	revision: NumberValue$2,
-	manifestUrl: Text$2,
-	rawAssetBaseUrl: Text$2,
-	verifiedAssetBaseUrl: Text$2,
-	pluginEntries: Type.Array(Type.Tuple([Text$2, Text$2])),
+	manifestUrl: Text$3,
+	rawAssetBaseUrl: Text$3,
+	verifiedAssetBaseUrl: Text$3,
+	pluginEntries: Type.Array(Type.Tuple([Text$3, Text$3])),
 	assetPaths: Strings$1,
 	stylePaths: Strings$1,
 	channels: Strings$1
 });
 const NativeCompositionSchema = Type.Object({
-	id: Text$2,
+	id: Text$3,
 	scope: Type.Union([
 		Type.Literal("global"),
 		Type.Literal("workspace"),
 		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 = Type.Object({
-	id: Optional$2(Text$2),
+	id: Optional$2(Text$3),
 	mount: Type.Union([Type.Object({ scope: Type.Literal("global") }), Type.Object({
 		scope: Type.Literal("workspace"),
-		workspaceId: Text$2
+		workspaceId: Text$3
 	})])
 });
 const SessionSummarySchema = 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: Type.Union([
 		Type.Literal("idle"),
 		Type.Literal("turn"),
 		Type.Literal("compaction"),
 		Type.Literal("retry")
 	]),
-	phaseSince: Text$2,
+	phaseSince: Text$3,
 	attach: 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(Type.Object({
-		branch: Text$2,
+		branch: Text$3,
 		dirty: Flag$2
 	})),
 	profile: Optional$2(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(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(Type.Array(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(Type.Union([Type.Literal("managed-worktree"), Type.Literal("existing-directory")])),
 		status: Optional$2(Type.Union([
 			Type.Literal("provisioning"),
@@ -572,48 +572,25 @@ const SessionSummarySchema = Type.Object({
 		])),
 		errorCode: Optional$2(Type.Union([Type.Literal("SESSION_WORKTREE_PROVISION_FAILED"), 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 = Type.Object({
-	type: Type.Literal("sessions_snapshot"),
-	sessions: Type.Array(SessionSummarySchema)
-});
-const HubUpsertFrameSchema = Type.Object({
-	type: Type.Literal("session_upsert"),
-	session: SessionSummarySchema
-});
-const HubRemovedFrameSchema = Type.Object({
-	type: Type.Literal("session_removed"),
-	sessionId: Text$2
-});
-const Workspace = Type.Object({
-	id: Text$2,
-	root: Text$2,
-	name: Optional$2(Text$2),
+const WorkspaceSchema = Type.Object({
+	id: Text$3,
+	root: Text$3,
+	name: Optional$2(Text$3),
 	available: Optional$2(Flag$2)
 });
-const WorkspaceSnapshotFrameSchema = Type.Object({
-	type: Type.Literal("workspaces_snapshot"),
-	workspaces: Type.Array(Workspace)
-});
-const WorkspaceUpsertFrameSchema = Type.Object({
-	type: Type.Literal("workspace_upsert"),
-	workspace: Workspace
-});
-const WorkspaceRemovedFrameSchema = Type.Object({
-	type: Type.Literal("workspace_removed"),
-	workspaceId: Text$2
-});
 const SavedSession = 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,
@@ -653,43 +630,44 @@ const headlessHttpContracts = [
 	host("compositions", "/api/compositions", "GET", Type.Object({
 		global: Optional$2(WebCompositionSchema),
 		nativeGlobal: Optional$2(NativeCompositionSchema),
-		publicKey: Optional$2(Text$2),
+		publicKey: Optional$2(Text$3),
 		shell: Optional$2(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: Type.Array(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", Type.Object({ directories: Strings$1 }), { parameters: [query("q")] }),
 	host("directories.children", "/api/directories/children", "GET", 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", Type.Object({ directories: Strings$1 })),
 	host("sessions.list", "/api/workspaces/{workspaceId}/sessions", "GET", Type.Object({ sessions: Type.Array(SessionSummarySchema) })),
-	host("sessions.create", "/api/workspaces/{workspaceId}/sessions", "POST", Type.Object({ sessionId: Text$2 }), {
-		body: body(Type.Object({ name: Optional$2(Text$2) })),
-		responses: jsonApiResponses(Type.Object({ sessionId: Text$2 }), 201)
+	host("sessions.create", "/api/workspaces/{workspaceId}/sessions", "POST", Type.Object({ sessionId: Text$3 }), {
+		body: body(Type.Object({ name: Optional$2(Text$3) })),
+		responses: jsonApiResponses(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", Type.Object({ sessions: 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", Type.Object({ sessionId: Text$2 }), {
+	host("sessions.resume", "/api/workspaces/{workspaceId}/sessions/{sessionId}/resume", "POST", Type.Object({ sessionId: Text$3 }), {
 		availability: "Host provides resumeSession",
 		body: body(Type.Object({ targetSessionId: 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": {
@@ -699,94 +677,65 @@ const headlessHttpContracts = [
 			}
 		}
 	}),
-	host("sessions.channels", "/api/workspaces/{workspaceId}/sessions/{sessionId}/channels", "GET", Type.Object({ channels: Type.Array(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", Type.Object({ workspaces: Type.Array(Workspace) })),
-	host("workspaces.admit", "/api/workspaces", "POST", Type.Object({ workspace: Workspace }), {
+	host("workspaces.list", "/api/workspaces", "GET", Type.Object({ workspaces: Type.Array(WorkspaceSchema) })),
+	host("workspaces.admit", "/api/workspaces", "POST", Type.Object({ workspace: WorkspaceSchema }), {
 		body: body(Type.Object({
-			root: Optional$2(Text$2),
-			name: Optional$2(Text$2)
+			root: Optional$2(Text$3),
+			name: Optional$2(Text$3)
 		})),
-		responses: jsonApiResponses(Type.Object({ workspace: Workspace }), 201)
+		responses: jsonApiResponses(Type.Object({ workspace: WorkspaceSchema }), 201)
 	}),
-	host("workspaces.get", "/api/workspaces/{workspaceId}", "GET", Type.Object({ workspace: Workspace })),
+	host("workspaces.get", "/api/workspaces/{workspaceId}", "GET", Type.Object({ workspace: WorkspaceSchema })),
 	host("workspaces.history", "/api/workspaces/{workspaceId}/history", "GET", Type.Object({ sessions: Type.Array(SavedSession) }), { availability: "Host provides workspaceHistory" }),
-	host("workspaces.resume", "/api/workspaces/{workspaceId}/resume", "POST", Type.Object({ sessionId: Text$2 }), {
+	host("workspaces.resume", "/api/workspaces/{workspaceId}/resume", "POST", Type.Object({ sessionId: Text$3 }), {
 		availability: "Host provides resumeWorkspaceSession",
 		body: body(Type.Object({ targetSessionId: 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 = Type.Union([Type.Literal("api_key"), Type.Literal("oauth")]);
 const Provider = Type.Object({
-	id: Text$2,
-	name: Text$2,
+	id: Text$3,
+	name: Text$3,
 	methods: Type.Array(Type.Object({
 		type: AuthType,
-		label: Text$2
+		label: Text$3
 	})),
 	authenticated: Optional$2(Type.Object({
 		type: AuthType,
-		source: Optional$2(Text$2)
+		source: Optional$2(Text$3)
 	}))
 });
 const LoginEvent = Type.Union([
 	Type.Object({
 		type: Type.Literal("info"),
-		message: Text$2,
+		message: Text$3,
 		links: Optional$2(Type.Array(Type.Object({
-			url: Text$2,
-			label: Optional$2(Text$2)
+			url: Text$3,
+			label: Optional$2(Text$3)
 		})))
 	}),
 	Type.Object({
 		type: Type.Literal("auth_url"),
-		url: Text$2,
-		instructions: Optional$2(Text$2)
+		url: Text$3,
+		instructions: Optional$2(Text$3)
 	}),
 	Type.Object({
 		type: 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)
 	}),
 	Type.Object({
 		type: Type.Literal("progress"),
-		message: Text$2
+		message: Text$3
 	})
 ]);
 const LoginFlowSchema = Type.Object({
-	id: Text$2,
-	providerId: Text$2,
-	providerName: Text$2,
+	id: Text$3,
+	providerId: Text$3,
+	providerName: Text$3,
 	type: AuthType,
 	status: Type.Union([
 		Type.Literal("running"),
@@ -796,36 +745,36 @@ const LoginFlowSchema = Type.Object({
 	]),
 	events: Type.Array(LoginEvent),
 	prompt: Optional$2(Type.Object({
-		id: Text$2,
+		id: Text$3,
 		type: Type.Union([
 			Type.Literal("text"),
 			Type.Literal("secret"),
 			Type.Literal("select"),
 			Type.Literal("manual_code")
 		]),
-		message: Text$2,
-		placeholder: Optional$2(Text$2),
+		message: Text$3,
+		placeholder: Optional$2(Text$3),
 		options: Optional$2(Type.Array(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 = Type.Object({ flow: LoginFlowSchema });
 const machineHttpContracts = [
 	host("providers.list", "/providers", "GET", Type.Object({ providers: Type.Array(Provider) })),
 	host("models.list", "/models", "GET", Type.Object({ models: Type.Array(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(Type.Object({
-			providerId: Text$2,
+			providerId: Text$3,
 			type: AuthType
 		})),
 		responses: jsonApiResponses(Flow, 201)
@@ -833,8 +782,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(Type.Object({
-		promptId: Text$2,
-		value: Text$2
+		promptId: Text$3,
+		value: Text$3
 	})) })
 ].map((route) => ({
 	...route,
@@ -849,8 +798,8 @@ const Source = Type.Union([
 const Detail = Type.Union([
 	Type.Object({
 		itemKind: Type.Literal("tool"),
-		name: Text$2,
-		owner: Text$2,
+		name: Text$3,
+		owner: Text$3,
 		source: Source,
 		active: Flag$2,
 		tokens: Type.Object({
@@ -858,20 +807,20 @@ const Detail = 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)
 	}),
 	Type.Object({
 		itemKind: Type.Literal("skill"),
-		name: Text$2,
-		owner: Text$2,
+		name: Text$3,
+		owner: Text$3,
 		source: Source,
 		active: 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
 	}),
 	Type.Object({
@@ -879,38 +828,81 @@ const Detail = Type.Union([
 		name: Type.Literal("system"),
 		tokens: NumberValue$2,
 		stage: Type.Union([Type.Literal("base"), Type.Literal("effective")]),
-		text: Text$2
+		text: Text$3
 	})
 ]);
-const sessionHttpContracts = [{
-	...host("context.item", ITEM_ROUTE, "GET", Type.Object({
-		revision: NumberValue$2,
-		item: Detail
-	}), { parameters: [query("kind", Type.Union([
-		Type.Literal("tool"),
-		Type.Literal("skill"),
-		Type.Literal("prompt")
-	]), true), query("name", Text$2, true)] }),
-	scope: "session",
-	basePath: API_BASE_PATH
-}, {
-	...host("files.complete", "/", "GET", Type.Object({ files: Strings$1 }), { parameters: [query("q", Type.String({ maxLength: 256 }))] }),
-	scope: "session",
-	basePath: "files"
-}];
+const sessionHttpContracts = [
+	{
+		...host("context.current", CURRENT_ROUTE, "GET", Type.Object({
+			version: Type.Literal(1),
+			revision: NumberValue$2,
+			selection: Type.Object({
+				majorMode: Text$3,
+				domains: Strings$1,
+				profile: Optional$2(Text$3)
+			}),
+			groups: Type.Array(Type.Object({
+				id: Text$3,
+				label: Text$3,
+				kind: Type.Union([
+					Type.Literal("major"),
+					Type.Literal("minor"),
+					Type.Literal("domain"),
+					Type.Literal("core")
+				]),
+				items: Type.Array(Type.Object({
+					name: Text$3,
+					itemKind: Type.Union([Type.Literal("tool"), 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(Type.Object({
+				tokens: NumberValue$2,
+				stage: Type.Union([Type.Literal("base"), Type.Literal("effective")])
+			})),
+			estimator: Type.Literal("gpt-tokenizer")
+		})),
+		scope: "session",
+		basePath: API_BASE_PATH
+	},
+	{
+		...host("context.item", ITEM_ROUTE, "GET", Type.Object({
+			revision: NumberValue$2,
+			item: Detail
+		}), { parameters: [query("kind", Type.Union([
+			Type.Literal("tool"),
+			Type.Literal("skill"),
+			Type.Literal("prompt")
+		]), true), query("name", Text$3, true)] }),
+		scope: "session",
+		basePath: API_BASE_PATH
+	},
+	{
+		...host("files.complete", "/", "GET", Type.Object({ files: Strings$1 }), { parameters: [query("q", Type.String({ maxLength: 256 }))] }),
+		scope: "session",
+		basePath: "files"
+	}
+];
 //#endregion
 //#region src/schemas/remoteApiContracts.ts
-const Text$1 = Type.String();
+const Text$2 = Type.String();
 const NumberValue$1 = Type.Number();
 const Optional$1 = Type.Optional;
 const Flag$1 = Type.Boolean();
-const JsonObject = Type.Record(Text$1, Type.Unknown({ description: "WebAuthn ceremony fields supplied and verified by the installed WebAuthn implementation." }));
+const JsonObject = Type.Record(Text$2, Type.Unknown({ description: "WebAuthn ceremony fields supplied and verified by the installed WebAuthn implementation." }));
 const Tunnel = Type.Union([Type.Object({ kind: Type.Literal("quick") }), Type.Object({
 	kind: 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 = Type.Object({
 	autoCloseEnabled: Flag$1,
@@ -921,7 +913,7 @@ const Settings = Type.Object({
 	tunnel: Tunnel,
 	sandbox: Type.Object({
 		enabled: Flag$1,
-		workspaces: Type.Array(Text$1)
+		workspaces: Type.Array(Text$2)
 	})
 });
 const State = Type.Object({
@@ -931,31 +923,31 @@ const State = Type.Object({
 		Type.Literal("on"),
 		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: Type.Array(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: Type.Array(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: Type.Array(Type.Object({
-		id: Text$1,
-		label: Text$1,
+		id: Text$2,
+		label: Text$2,
 		platform: Type.Union([Type.Literal("ios"), Type.Literal("android")]),
-		createdAt: Text$1,
-		lastSeenAt: Text$1,
+		createdAt: Text$2,
+		lastSeenAt: Text$2,
 		self: Flag$1
 	})),
 	settings: Settings
@@ -965,45 +957,45 @@ const StateResponse = Type.Object({
 	handingOver: Optional$1(Flag$1)
 });
 const Trust = Type.Object({
-	publicKey: Text$1,
-	fingerprint: Text$1,
+	publicKey: Text$2,
+	fingerprint: Text$2,
 	revision: NumberValue$1
 });
 const Begun = Type.Object({
-	ceremonyId: Text$1,
+	ceremonyId: Text$2,
 	options: JsonObject
 });
 const DeviceKeyBegun = Type.Object({
-	ceremonyId: Text$1,
-	challenge: Text$1,
+	ceremonyId: Text$2,
+	challenge: Text$2,
 	kind: Type.Literal("device-key")
 });
 const ChannelKeys = Type.Object({
-	session: Text$1,
-	protocol: Text$1,
-	http: Text$1
+	session: Text$2,
+	protocol: Text$2,
+	http: Text$2
 });
 const Finish = Type.Object({
-	ceremonyId: Text$1,
+	ceremonyId: Text$2,
 	response: JsonObject
 });
 const SealedEnvelopeSchema = Type.Object({
 	v: Type.Literal(1),
-	n: Text$1,
-	c: Text$1
+	n: Text$2,
+	c: Text$2
 });
 const SealedHttpRequestSchema = Type.Object({
 	v: Type.Literal(1),
-	method: Text$1,
-	target: Text$1,
-	headers: Type.Array(Type.Tuple([Text$1, Text$1])),
-	body: Optional$1(Text$1)
+	method: Text$2,
+	target: Text$2,
+	headers: Type.Array(Type.Tuple([Text$2, Text$2])),
+	body: Optional$1(Text$2)
 });
 const SealedHttpResponseSchema = Type.Object({
 	v: Type.Literal(1),
 	status: NumberValue$1,
-	headers: Type.Array(Type.Tuple([Text$1, Text$1])),
-	body: Text$1
+	headers: Type.Array(Type.Tuple([Text$2, Text$2])),
+	body: Text$2
 });
 const route = (id, path, method, result, input, extra = {}) => ({
 	id: `remote.${id}`,
@@ -1045,16 +1037,16 @@ const direct = [
 	} }),
 	route("codes", "/codes", "POST", 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(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),
@@ -1063,57 +1055,57 @@ const direct = [
 	route("passkeys", "/passkeys", "GET", Type.Object({
 		support: Type.Union([Type.Object({
 			supported: Type.Literal(true),
-			rpId: Text$1
+			rpId: Text$2
 		}), Type.Object({
 			supported: Type.Literal(false),
-			reason: Text$1
+			reason: Text$2
 		})]),
 		credentials: Type.Array(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", Type.Object({ id: Text$1 }), Finish, { authentication: "device" }),
+	route("register.finish", "/passkeys/register/finish", "POST", 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", Type.Object({
 		ok: Type.Literal(true),
-		hostPublicKey: Text$1
+		hostPublicKey: Text$2
 	}), Finish, { authentication: "none" }),
-	route("challenge", "/challenge", "POST", Type.Union([Begun, DeviceKeyBegun]), Type.Object({ action: Text$1 }), { authentication: "device" }),
-	route("trusted-devices.register", "/trusted-devices", "POST", Type.Object({ trustedDeviceId: Text$1 }), Type.Object({
-		identityPublicKey: Text$1,
-		stepUpPublicKey: Text$1,
-		label: Text$1,
+	route("challenge", "/challenge", "POST", Type.Union([Begun, DeviceKeyBegun]), Type.Object({ action: Text$2 }), { authentication: "device" }),
+	route("trusted-devices.register", "/trusted-devices", "POST", Type.Object({ trustedDeviceId: Text$2 }), Type.Object({
+		identityPublicKey: Text$2,
+		stepUpPublicKey: Text$2,
+		label: Text$2,
 		platform: Type.Union([Type.Literal("ios"), 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(Type.Object({ trustedDeviceId: Text$1 }), 201)
+		responses: jsonApiResponses(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", 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
 	}), Type.Object({
-		trustedDeviceId: Text$1,
-		nonce: Text$1
+		trustedDeviceId: Text$2,
+		nonce: Text$2
 	}), { authentication: "none" }),
 	route("device-auth.authenticate", "/device-auth/authenticate", "POST", Type.Object({ ok: Type.Literal(true) }), 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, Type.Object({
-		clientPublicKey: Text$1,
+		clientPublicKey: Text$2,
 		scope: Type.Union([
 			Type.Literal("session"),
 			Type.Literal("protocol"),
@@ -1125,13 +1117,13 @@ const direct = [
 		description: "Sealed HTTP gateway. Decrypted requests/responses use the SealedHttpRequest and SealedHttpResponse envelopes."
 	}),
 	route("pair", "/pair", "POST", Type.Object({
-		requestId: Text$1,
+		requestId: Text$2,
 		status: Type.Literal("pending")
 	}), Type.Object({ code: Type.String({ minLength: 1 }) }), {
 		authentication: "none",
 		responses: {
 			...jsonApiResponses(Type.Object({
-				requestId: Text$1,
+				requestId: Text$2,
 				status: Type.Literal("pending")
 			}), 202),
 			"410": {
@@ -1149,26 +1141,26 @@ const direct = [
 			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, Type.Object({ origin: Text$1 }), {
+	route("frontend", "/frontend", "POST", ApiOkSchema, 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,
@@ -1191,15 +1183,15 @@ const remoteHttpContracts = [
 		responses: { "200": {
 			description: "Pairing page",
 			contentType: "text/html",
-			schema: Text$1
+			schema: Text$2
 		} }
 	}
 ];
 const Asset = Type.Object({
-	path: Text$1,
+	path: Text$2,
 	sha256: Type.String({ pattern: "^[a-f0-9]{64}$" }),
 	byteLength: Type.Integer({ minimum: 0 }),
-	contentType: Text$1
+	contentType: Text$2
 });
 const Signed = Type.Object({
 	manifest: Type.Object({
@@ -1208,8 +1200,8 @@ const Signed = Type.Object({
 		builtAt: NumberValue$1,
 		assets: 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}`,
@@ -1243,12 +1235,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";
-defineService("po.hub.v1");
-defineService(DOOM_SESSION_SERVICE_ID);
-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 ? method(args, result) : args !== void 0 ? method(args) : method()]));
+}
+//#endregion
+//#region src/schemas/protocolChannelsContract.ts
+const Json$3 = Type.Unsafe({});
+const ChannelFrameSchema = Type.Object({
+	type: Type.String({ minLength: 1 }),
+	payload: Json$3
+});
+/** Latest payload per extension channel frame type. */
+const PoChannelsStateSchema = Type.Record(Type.String(), Json$3);
+remote("po.channels", {
+	version: 1,
+	host: hostNamed(PO_SERVER_HOST),
+	input: Type.Object({ sessionId: 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 = Type.Union([
+	Type.Object({ scope: Type.Literal("global") }, { additionalProperties: false }),
+	Type.Object({
+		scope: Type.Literal("workspace"),
+		workspaceId: Type.String({ minLength: 1 })
+	}, { additionalProperties: false }),
+	Type.Object({
+		scope: Type.Literal("session"),
+		sessionId: Type.String({ minLength: 1 })
+	}, { additionalProperties: false })
+]);
+const PoPluginCallSchema = Type.Object({
+	mount: PoPluginMountSchema,
+	service: Type.String({ minLength: 1 }),
+	method: Type.String({ minLength: 1 }),
+	input: Type.Unknown()
+}, { additionalProperties: false });
+//#endregion
+//#region src/schemas/protocolHubContract.ts
+const Text$1 = Type.String();
+const Json$2 = Type.Unsafe({});
+/** A live session frame every hub client needs (notification entries and agent dialogs) until it is acknowledged. */
+const HubNoticeSchema = Type.Object({
+	id: Text$1,
+	sessionId: Text$1,
+	frame: Type.Record(Text$1, Json$2)
+});
+const HubState = {
+	sessions: Type.Record(Text$1, SessionSummarySchema),
+	workspaces: Type.Record(Text$1, WorkspaceSchema),
+	pending: Type.Array(HubNoticeSchema)
+};
+const PoHubStateSchema = Type.Object(HubState);
+remote("po.hub", {
+	version: 1,
+	host: hostNamed(PO_SERVER_HOST),
+	input: Type.Object({}),
+	variants: { default: {
+		state: HubState,
+		methods: chordMethods({
+			readHome: {
+				args: Type.Object({
+					offset: Type.Optional(Type.Integer({ minimum: 0 })),
+					limit: Type.Optional(Type.Integer({ minimum: 1 })),
+					source: Type.Optional(Text$1),
+					workspaceId: Type.Optional(Text$1)
+				}),
+				result: Type.Unsafe({})
+			},
+			invoke: {
+				args: PoPluginCallSchema,
+				result: Json$2
+			},
+			ackNotice: { args: 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 = Type.Union([Type.Null(), Type.Intersect([Type.Object({ type: Type.String() }), Type.Record(Type.String(), Type.Unsafe({}))])]);
+remote("po.thread", {
+	version: 1,
+	host: hostNamed(PO_SERVER_HOST),
+	input: Type.Object({
+		sessionId: Type.String({ minLength: 1 }),
+		threadId: Type.String({ minLength: 1 })
+	}),
+	variants: { default: { state: { frame: PoThreadFrameSchema } } }
+});
 //#endregion
 //#region src/schemas/sessionApiContracts.ts
 const Text = Type.String();
@@ -1285,66 +1369,12 @@ const TextPart = Type.Object({
 	type: Type.Literal("text"),
 	text: Text
 });
-const Content = Type.Union([Image, TextPart]);
-const User = Type.Object({
-	id: Text,
-	role: Type.Literal("user"),
-	content: Type.Array(Content),
-	timestamp: NumberValue
+const ThinkingPart = Type.Object({
+	type: Type.Literal("thinking"),
+	thinking: Text,
+	redacted: Optional(Type.Literal(true))
 });
-const Transcript = Type.Union([
-	User,
-	Type.Object({
-		id: Text,
-		role: Type.Literal("assistant"),
-		content: Type.Array(Type.Union([
-			TextPart,
-			Type.Object({
-				type: Type.Literal("thinking"),
-				thinking: Text,
-				redacted: Optional(Type.Literal(true))
-			}),
-			Type.Object({
-				type: Type.Literal("toolCall"),
-				toolCallId: Text,
-				toolName: Text,
-				input: Json$1
-			})
-		])),
-		model: Model,
-		status: Type.Union([
-			Type.Literal("streaming"),
-			Type.Literal("complete"),
-			Type.Literal("aborted"),
-			Type.Literal("error")
-		]),
-		stopReason: Optional(Type.Union([
-			Type.Literal("stop"),
-			Type.Literal("length"),
-			Type.Literal("toolUse"),
-			Type.Literal("aborted"),
-			Type.Literal("error")
-		])),
-		errorMessage: Optional(Text),
-		timestamp: NumberValue
-	}),
-	Type.Object({
-		id: Text,
-		role: Type.Literal("tool"),
-		toolCallId: Text,
-		toolName: Text,
-		input: Json$1,
-		content: Type.Array(Content),
-		details: Optional(Json$1),
-		status: Type.Union([
-			Type.Literal("running"),
-			Type.Literal("complete"),
-			Type.Literal("error")
-		]),
-		isError: Flag,
-		timestamp: NumberValue
-	})
-]);
+const Content = Type.Union([Image, TextPart]);
 const Usage = Type.Object({
 	input: NumberValue,
 	output: NumberValue,
@@ -1378,152 +1408,20 @@ const Lifecycle = Type.Object({
 			Type.Literal("nextRun")
 		]),
 		scheduling: Type.Union([Type.Literal("automatic"), Type.Literal("held")]),
-		disposition: Type.Union([
-			Type.Literal("pending"),
-			Type.Literal("handoff"),
-			Type.Literal("uncertain")
-		])
+		disposition: Type.Union([Type.Literal("pending"), Type.Literal("handoff")])
 	}))
 });
 const Frame = Type.Intersect([Type.Object({ type: Text }), Type.Record(Text, Json$1)], { description: "Discriminated extension presentation frame; selected channel schemas describe package payloads." });
-const HubClientFrame = Type.Union([
-	Type.Object({
-		type: Type.Union([Type.Literal("subscribe"), Type.Literal("unsubscribe")]),
-		sessionId: Text
-	}),
-	Type.Object({
-		type: Type.Union([Type.Literal("subscribe_thread"), Type.Literal("unsubscribe_thread")]),
-		sessionId: Text,
-		threadId: Text
-	}),
-	Type.Object({
-		type: Type.String({ not: { enum: [
-			"subscribe",
-			"unsubscribe",
-			"subscribe_thread",
-			"unsubscribe_thread"
-		] } }),
-		sessionId: Text,
-		payload: Json$1
-	})
-]);
-const HubServerFrame = Type.Union([
-	HubSnapshotFrameSchema,
-	HubUpsertFrameSchema,
-	HubRemovedFrameSchema,
-	Type.Object({
-		type: Type.Literal("thread_frame"),
-		sessionId: Text,
-		threadId: Text,
-		frame: Frame
-	}),
-	Type.Object({
-		type: Type.Literal("thread_backlog"),
-		sessionId: Text,
-		threadId: Text,
-		frames: Type.Array(Frame)
-	}),
-	Type.Object({
-		type: 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 = Type.Object({
 	sequence: NumberValue,
 	frame: Frame
 });
-const Update = Type.Union([
-	Type.Object({
-		sessionUpdate: Type.Union([
-			Type.Literal("user_message"),
-			Type.Literal("agent_message"),
-			Type.Literal("agent_thought")
-		]),
-		messageId: Text,
-		content: Type.Array(Content)
-	}),
-	Type.Object({
-		sessionUpdate: Type.Literal("tool_call_update"),
-		toolCallId: Text,
-		title: Optional(Text),
-		kind: Optional(Text),
-		status: Optional(Type.Union([
-			Type.Literal("pending"),
-			Type.Literal("in_progress"),
-			Type.Literal("completed"),
-			Type.Literal("failed"),
-			Type.Literal("cancelled")
-		])),
-		content: Optional(Type.Array(Type.Object({
-			type: Type.Literal("content"),
-			content: Content
-		}))),
-		rawInput: Optional(Json$1),
-		rawOutput: Optional(Json$1)
-	}),
-	Type.Object({
-		sessionUpdate: Type.Literal("state_update"),
-		state: Type.Union([
-			Type.Literal("running"),
-			Type.Literal("idle"),
-			Type.Literal("requires_action")
-		]),
-		stopReason: Optional(Type.Union([
-			Type.Literal("end_turn"),
-			Type.Literal("max_tokens"),
-			Type.Literal("max_turn_requests"),
-			Type.Literal("refusal"),
-			Type.Literal("cancelled"),
-			Type.Unsafe(Type.String({ pattern: "^_" }))
-		]))
-	})
-]);
 const SessionServiceStateSchema = Type.Object({
 	snapshot: 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: Type.Array(User),
-		queuedSteerCount: NumberValue,
 		lifecycle: Optional(Lifecycle)
 	}),
-	progress: Type.Union([Type.Null(), Type.Union([
-		Type.Object({
-			type: Type.Literal("item_started"),
-			item: Transcript
-		}),
-		Type.Object({
-			type: Type.Literal("item_updated"),
-			item: Transcript
-		}),
-		Type.Object({
-			type: Type.Literal("item_finished"),
-			item: Transcript
-		})
-	])]),
-	updates: Optional(Type.Array(Type.Object({
-		sequence: NumberValue,
-		update: Update
-	}))),
 	presentation: Optional(Type.Object({
 		revision: NumberValue,
 		dropped: NumberValue,
@@ -1531,17 +1429,35 @@ const SessionServiceStateSchema = Type.Object({
 		events: Type.Array(ProtocolEvent),
 		projections: Type.Array(ProtocolEvent)
 	})),
-	inFlight: Optional(Type.Array(Transcript))
+	live: Optional(Type.Object({
+		phase: Phase,
+		message: Optional(Type.Object({
+			role: Type.Literal("assistant"),
+			content: Type.Array(Type.Union([TextPart, ThinkingPart])),
+			model: Text,
+			timestamp: NumberValue
+		})),
+		tools: Type.Record(Text, Type.Object({
+			toolCallId: Text,
+			toolName: Text,
+			args: Json$1,
+			partialResult: Optional(Type.Object({
+				content: 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: Type.Tuple([Type.Object({
+		args: Type.Object({
 			cursor: Optional(Text),
 			direction: Optional(Type.Union([Type.Literal("older"), Type.Literal("newer")])),
 			limit: Optional(NumberValue),
 			threadId: Optional(Text)
-		})]),
-		output: Type.Object({
+		}),
+		result: Type.Object({
 			entries: Type.Array(Json$1),
 			startCursor: Type.Union([Text, Type.Null()]),
 			endCursor: Type.Union([Text, Type.Null()]),
@@ -1549,29 +1465,28 @@ const SessionMethodSchemas = {
 			newerCursor: Type.Union([Text, Type.Null()]),
 			generation: NumberValue,
 			revision: NumberValue,
-			context: Type.Array(Json$1),
-			drafts: Type.Array(Transcript)
+			context: Type.Array(Json$1)
 		})
 	},
-	prompt: { input: Type.Tuple([Type.Union([Text, Type.Object({
+	prompt: { args: Type.Union([Text, Type.Object({
 		...Message.properties,
 		waitFor: Optional(Type.Union([Type.Literal("accepted"), Type.Literal("settled")]))
-	})])]) },
-	steer: { input: Type.Tuple([Type.Union([Text, Message])]) },
-	abort: { input: Type.Tuple([]) },
-	abortOperation: { input: Type.Tuple([Type.Object({ operationId: Text })]) },
-	setModel: { input: Type.Tuple([Model]) },
-	setThinking: { input: Type.Tuple([Thinking]) },
-	setFastMode: { input: Type.Tuple([Flag]) },
-	setAgentLock: { input: Type.Tuple([Flag]) },
-	followUp: { input: Type.Tuple([Message]) },
+	})]) },
+	steer: { args: Type.Union([Text, Message]) },
+	abort: {},
+	abortOperation: { args: Type.Object({ operationId: Text }) },
+	setModel: { args: Model },
+	setThinking: { args: Thinking },
+	setFastMode: { args: Flag },
+	setAgentLock: { args: Flag },
+	followUp: { args: Message },
 	enqueueAutomatic: {
-		input: Type.Tuple([Message]),
-		output: Type.Object({ id: Text })
+		args: Message,
+		result: Type.Object({ id: Text })
 	},
 	removeQueued: {
-		input: Type.Tuple([Type.Object({ id: Text })]),
-		output: Type.Union([
+		args: Type.Object({ id: Text }),
+		result: Type.Union([
 			Type.Literal("removed"),
 			Type.Literal("in_flight"),
 			Type.Literal("already_consumed"),
@@ -1579,34 +1494,31 @@ const SessionMethodSchemas = {
 		])
 	},
 	promoteQueued: {
-		input: Type.Tuple([Type.Object({
+		args: Type.Object({
 			id: Text,
 			operationId: Optional(Text)
-		})]),
-		output: Type.Union([
+		}),
+		result: Type.Union([
 			Type.Literal("promoted"),
 			Type.Literal("in_flight"),
 			Type.Literal("target_changed"),
 			Type.Literal("not_found")
 		])
 	},
-	resumeQueue: { input: Type.Tuple([]) },
-	clearQueue: {
-		input: Type.Tuple([]),
-		output: Type.Object({
-			steering: Strings,
-			followUp: Strings
-		})
-	},
+	resumeQueue: {},
+	clearQueue: { result: Type.Object({
+		steering: Strings,
+		followUp: Strings
+	}) },
 	rewind: {
-		input: Type.Tuple([Type.Object({
+		args: Type.Object({
 			itemId: Text,
 			summarize: Optional(Flag),
 			customInstructions: Optional(Text),
 			replaceInstructions: Optional(Flag),
 			label: Optional(Text)
-		})]),
-		output: Type.Object({
+		}),
+		result: Type.Object({
 			editorText: Optional(Text),
 			cancelled: Flag,
 			aborted: Optional(Flag),
@@ -1622,7 +1534,7 @@ const SessionMethodSchemas = {
 			}))
 		})
 	},
-	extensionUiResponse: { input: Type.Tuple([Type.Union([
+	extensionUiResponse: { args: Type.Union([
 		Type.Object({
 			id: Text,
 			value: Text
@@ -1635,201 +1547,128 @@ const SessionMethodSchemas = {
 			id: Text,
 			cancelled: Type.Literal(true)
 		})
-	])]) },
-	getState: {
-		input: Type.Tuple([]),
-		output: Type.Object({
-			model: Optional(Model),
-			thinkingLevel: Thinking,
-			fastMode: Flag,
-			isStreaming: Flag,
-			isCompacting: Flag,
-			steeringMode: Type.Union([Type.Literal("all"), Type.Literal("one-at-a-time")]),
-			followUpMode: Type.Union([Type.Literal("all"), 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(Type.Union([Type.Literal("open"), Type.Literal("aborting")])),
-			queuePaused: Optional(Flag),
-			queueRevision: Optional(NumberValue)
-		})
-	},
-	getSessionStats: {
-		input: Type.Tuple([]),
-		output: Type.Object({
-			sessionFile: Optional(Text),
-			sessionId: Text,
-			totalMessages: NumberValue,
-			tokens: Usage,
-			cost: NumberValue,
-			contextUsage: Optional(Type.Object({
-				tokens: Type.Union([NumberValue, Type.Null()]),
-				contextWindow: NumberValue,
-				percent: Type.Union([NumberValue, Type.Null()])
-			}))
-		})
-	},
-	getCommands: {
-		input: Type.Tuple([]),
-		output: Type.Array(Type.Object({
-			name: Text,
-			description: Optional(Text),
-			source: Type.Union([
-				Type.Literal("extension"),
-				Type.Literal("prompt"),
-				Type.Literal("skill")
+	]) },
+	getState: { result: Type.Object({
+		model: Optional(Model),
+		thinkingLevel: Thinking,
+		fastMode: Flag,
+		agentLocked: Optional(Flag),
+		isStreaming: Flag,
+		isCompacting: Flag,
+		steeringMode: Type.Union([Type.Literal("all"), Type.Literal("one-at-a-time")]),
+		followUpMode: Type.Union([Type.Literal("all"), Type.Literal("one-at-a-time")]),
+		sessionId: Text,
+		sessionName: Optional(Text),
+		autoCompactionEnabled: Flag,
+		messageCount: NumberValue,
+		pendingMessageCount: NumberValue,
+		operationId: Optional(Text),
+		executionStatus: Optional(Type.Union([Type.Literal("open"), Type.Literal("aborting")])),
+		queuePaused: Optional(Flag),
+		queueRevision: Optional(NumberValue)
+	}) },
+	getSessionStats: { result: Type.Object({
+		sessionId: Text,
+		totalMessages: NumberValue,
+		tokens: Usage,
+		cost: NumberValue,
+		contextUsage: Optional(Type.Object({
+			tokens: Type.Union([NumberValue, Type.Null()]),
+			contextWindow: NumberValue,
+			percent: Type.Union([NumberValue, Type.Null()])
+		}))
+	}) },
+	getCommands: { result: Type.Array(Type.Object({
+		name: Text,
+		description: Optional(Text),
+		source: Type.Union([
+			Type.Literal("extension"),
+			Type.Literal("prompt"),
+			Type.Literal("skill")
+		]),
+		sourceInfo: Optional(Type.Object({
+			path: Text,
+			source: Text,
+			scope: Type.Union([
+				Type.Literal("user"),
+				Type.Literal("project"),
+				Type.Literal("temporary")
 			]),
-			sourceInfo: Optional(Type.Object({
-				path: Text,
-				source: Text,
-				scope: Type.Union([
-					Type.Literal("user"),
-					Type.Literal("project"),
-					Type.Literal("temporary")
-				]),
-				origin: Type.Union([Type.Literal("package"), Type.Literal("top-level")]),
-				baseDir: Optional(Text)
-			}))
+			origin: Type.Union([Type.Literal("package"), Type.Literal("top-level")]),
+			baseDir: Optional(Text)
 		}))
-	},
-	getAvailableModels: {
-		input: Type.Tuple([]),
-		output: Type.Array(Model)
-	},
-	getAvailableThinkingLevels: {
-		input: Type.Tuple([]),
-		output: Type.Array(Thinking)
-	},
+	})) },
+	getAvailableModels: { result: Type.Array(Model) },
+	getAvailableThinkingLevels: { result: Type.Array(Thinking) },
 	compact: {
-		input: Type.Tuple([Type.Object({ customInstructions: Optional(Text) })]),
-		output: Json$1
+		args: Type.Object({ customInstructions: Optional(Text) }),
+		result: Json$1
 	},
-	setName: { input: Type.Tuple([Text]) }
+	setName: { args: Text },
+	setGroups: { args: Type.Array(Text) }
 };
+/** The `po.session` methods as Chord specs. */
+const SessionMethods = chordMethods(SessionMethodSchemas);
 const ErrorSchema = 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: 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: 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: 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: 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: Type.Object({ events: Type.Array(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", 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 = Type.Union([
-	Type.Object({ scope: Type.Literal("global") }, { additionalProperties: false }),
-	Type.Object({
-		scope: Type.Literal("workspace"),
-		workspaceId: Type.String({ minLength: 1 })
-	}, { additionalProperties: false }),
-	Type.Object({
-		scope: Type.Literal("session"),
-		sessionId: Type.String({ minLength: 1 })
-	}, { additionalProperties: false })
-]);
-const DoomPluginCallSchema = Type.Object({
-	mount: DoomPluginMountSchema,
-	service: Type.String({ minLength: 1 }),
-	method: Type.String({ minLength: 1 }),
-	input: Type.Unknown()
-}, { additionalProperties: false });
-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 = Type.String({ minLength: 1 });
-const Json = Type.Unknown({ description: "JSON value; its application shape is defined by the addressed service member." });
-const E = Type.Object({
-	code: S,
-	message: Type.String()
-}, { additionalProperties: false });
-const ServerId = 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 = Type.Object({
-	key: S,
-	generation: Type.Integer({ minimum: 1 })
-}, { additionalProperties: false });
-const Mode = Type.Union([Type.Literal("singleton"), Type.Literal("keyed")]);
-const SessionTarget = Type.Object({
-	serverId: ServerId,
-	sessionId: S,
-	attachmentId: S
-}, { additionalProperties: false });
-const Target = Type.Union([Type.Object({ serverId: ServerId }, { additionalProperties: false }), SessionTarget]);
-const ChordCallSchema = Type.Object({
-	serviceId: S,
-	member: S,
-	args: Type.Array(Json),
-	instance: Type.Optional(Address)
-}, { additionalProperties: false });
+const Json = Type.Unknown({ description: "JSON value; its application shape is defined by the addressed contract member." });
+const Id = Type.Integer({ minimum: 1 });
+const ErrorCode = Type.Union([
+	"aborted",
+	"contract_mismatch",
+	"forbidden",
+	"gone",
+	"invalid",
+	"not_in_variant",
+	"not_ready",
+	"released",
+	"superseded",
+	"unavailable",
+	"upgrade_conflict",
+	"upgrade_required"
+].map((code) => Type.Literal(code)));
+const WireError = Type.Object({
+	code: ErrorCode,
+	message: Type.String(),
+	reason: Type.Optional(Type.String())
+});
 const Segment = Type.Union([Type.String(), Type.Integer({ minimum: 0 })]);
 const Path = Type.Array(Segment);
 const PathRef = Type.Union([Path, Type.Integer({ minimum: 0 })]);
@@ -1870,173 +1709,158 @@ const ChordWireOpSchema = Type.Union([
 		Index,
 		Type.Array(Json)
 	]),
+	Type.Tuple([
+		Type.Literal("m"),
+		PathRef,
+		Type.Array(Index)
+	]),
+	Type.Tuple([Type.Literal("m"), Type.Array(Index)]),
 	Type.Tuple([
 		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 = Type.Object({
-	instance: Type.Optional(Address),
-	members: Type.Array(Type.Union([Type.Object({
-		name: S,
-		kind: Type.Literal("method")
-	}), Type.Object({
-		name: S,
-		kind: Type.Literal("state"),
-		sequence: Type.Integer({ minimum: 0 }),
-		ops: Type.Array(ChordWireOpSchema)
-	})]))
+const Hello = (kind) => Type.Object({
+	t: Type.Literal("hello"),
+	protocol: Type.Optional(Type.Integer({ minimum: 1 })),
+	name: Type.String(),
+	kind,
+	codeVersion: Type.Integer({ minimum: 0 }),
+	acks: Type.Optional(Type.Boolean())
+});
+const Ack = Type.Object({
+	t: Type.Literal("ack"),
+	n: Type.Integer({ minimum: 1 })
 });
-const ChordSnapshotSchema = Type.Object({
-	serviceId: S,
-	mode: Mode,
-	instances: Type.Array(Instance)
+const Ping = Type.Object({
+	t: Type.Literal("ping"),
+	n: Type.Integer()
 });
-const ChordUpdateSchema = Type.Union([
+const Pong = Type.Object({
+	t: Type.Literal("pong"),
+	n: Type.Integer()
+});
+const Bye = Type.Object({
+	t: Type.Literal("bye"),
+	reason: Type.Optional(Type.String())
+});
+/** Frames a client (browser or native app) sends on its link. */
+const ChordClientFrameSchema = Type.Union([
+	Hello(Type.Literal("client")),
+	Ack,
 	Type.Object({
-		type: Type.Literal("state"),
-		instance: Type.Optional(Address),
-		member: S,
-		sequence: Type.Integer({ minimum: 1 }),
-		ops: Type.Array(ChordWireOpSchema)
+		t: Type.Literal("hold"),
+		id: Id,
+		at: Type.String(),
+		token: Json,
+		input: Json,
+		state: Type.Optional(Type.Literal(false)),
+		again: Type.Optional(Type.Literal(true))
 	}),
-	Type.Object({ type: Type.Literal("unavailable") }),
 	Type.Object({
-		type: Type.Literal("replaced"),
-		snapshot: Instance
+		t: Type.Literal("release"),
+		id: Id
 	}),
 	Type.Object({
-		type: Type.Literal("spawned"),
-		instance: Instance
+		t: Type.Literal("call"),
+		id: Id,
+		hold: Id,
+		member: S,
+		args: Type.Optional(Json)
 	}),
 	Type.Object({
-		type: Type.Literal("closed"),
-		instance: Address
-	})
-]);
-const PiClientMessageSchema = Type.Union([
-	Type.Object({
-		type: Type.Literal("hello"),
-		version: Type.Integer({ minimum: 0 })
+		t: Type.Literal("cancel"),
+		id: Id
 	}),
 	Type.Object({
-		type: Type.Literal("request"),
-		id: S,
-		target: Target,
-		call: ChordCallSchema
+		t: Type.Literal("sub"),
+		hold: Id
 	}),
 	Type.Object({
-		type: Type.Literal("cancel"),
-		id: S,
-		target: Target
-	})
-]);
-const PiServerMessageSchema = Type.Union([
-	Type.Object({
-		type: Type.Literal("hello"),
-		version: Type.Literal(PROTOCOL_VERSION),
-		serverId: ServerId
+		t: Type.Literal("unsub"),
+		hold: Id
 	}),
 	Type.Object({
-		type: Type.Literal("hello_error"),
-		error: E
+		t: Type.Literal("root_end"),
+		rootId: Type.String()
 	}),
+	Ping,
+	Pong,
+	Bye
+]);
+/** Frames the Po server sends to a client link. */
+const ChordServerFrameSchema = Type.Union([
+	Hello(Type.String()),
+	Ack,
 	Type.Object({
-		type: Type.Literal("response"),
-		id: S,
-		ok: Type.Literal(true),
-		result: Type.Optional(Json)
+		t: Type.Literal("shape"),
+		id: Id,
+		variant: Type.Optional(Type.String()),
+		members: Type.Array(Type.String()),
+		contract: Type.String(),
+		state: Type.Array(S)
 	}),
 	Type.Object({
-		type: Type.Literal("response"),
-		id: S,
-		ok: Type.Literal(false),
-		error: E
+		t: Type.Literal("gone"),
+		id: Id,
+		error: WireError
 	}),
 	Type.Object({
-		type: Type.Literal("service_update"),
-		subscriptionId: S,
-		update: ChordUpdateSchema
+		t: Type.Literal("result"),
+		id: Id,
+		value: Type.Optional(Json),
+		error: Type.Optional(WireError)
 	}),
 	Type.Object({
-		type: Type.Literal("attachment"),
-		attachment: Type.Union([SessionTarget, Type.Null()])
-	})
+		t: Type.Literal("state"),
+		hold: Id,
+		m: S,
+		as: Type.Union([
+			Type.Literal("snap"),
+			Type.Literal("reset"),
+			Type.Literal("ops"),
+			Type.Literal("error")
+		]),
+		value: Type.Optional(Json),
+		ops: Type.Optional(Type.Array(ChordWireOpSchema)),
+		error: 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 ${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: Type.Tuple([]),
-		output: Type.Array(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: 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: 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: 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."
 	}
 ];
@@ -2050,8 +1874,7 @@ const builtinApiContract = defineApiContract({
 		SealedHttpResponse: SealedHttpResponseSchema
 	},
 	protocols: {
-		pi: String(PROTOCOL_VERSION),
-		chord: "1.0.0",
+		chord: CHORD_WIRE_VERSION,
 		sealed: "1"
 	},
 	http: [
@@ -2069,6 +1892,6 @@ const builtinApiContract = defineApiContract({
 	]
 });
 //#endregion
-export { ApiErrorSchema, ApiOkSchema, ChordCallSchema, ChordSnapshotSchema, ChordUpdateSchema, ChordWireOpSchema, DOOM_API_CONTRACT_FILE, DOOM_API_CONTRACT_VERSION, DoomApiContractSchema, PiClientMessageSchema, PiServerMessageSchema, SessionMethodSchemas, SessionServiceStateSchema, builtinApiContract, canonicalContractJson, createApiDocuments, defineApiContract, jsonApiResponses, parseApiContract, parseCompiledContracts };
+export { ApiErrorSchema, ApiOkSchema, CHORD_WIRE_VERSION, ChordClientFrameSchema, ChordServerFrameSchema, ChordWireOpSchema, PO_API_CONTRACT_FILE, PO_API_CONTRACT_VERSION, PoApiContractSchema, SessionMethods, SessionServiceStateSchema, builtinApiContract, canonicalContractJson, createApiDocuments, defineApiContract, jsonApiResponses, parseApiContract, parseCompiledContracts };
 
 //# sourceMappingURL=apiContracts.mjs.map