@chainingintention/pi-web-cn 2.202610.5 → 2.202611.1

package/dist/pi-packages/scheduled-tasks/extensions/index.js

@@ -0,0 +1,710 @@
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+// src/shared/thinkingLevels.ts
+/**
+* Known levels in increasing intensity, derived from pi's `ThinkingLevel` union.
+* The `satisfies` clause makes this fail to compile if pi removes or renames a
+* level; thinkingLevels.test.ts adds a compile-time check for additions too. When
+* either breaks, update this list and give the new level a label/description
+* where thinking levels are presented.
+*/
+var KNOWN_THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+function isKnownThinkingLevel(value) {
+	return KNOWN_THINKING_LEVELS.some((level) => level === value);
+}
+Object.freeze({
+	pluginId: "pi-web.host",
+	id: "catalog",
+	version: 1,
+	parse: snapshotCatalog
+});
+function snapshotCatalog(value) {
+	const catalog = record(value);
+	if (catalog["version"] !== 1) throw invalid$1();
+	const projects = methods(catalog["projects"]);
+	const workspaces = methods(catalog["workspaces"]);
+	const sessions = methods(catalog["sessions"]);
+	return Object.freeze({
+		version: 1,
+		projects: Object.freeze({
+			list: async (options) => array(await projects.list(options), snapshotProject),
+			get: async (projectId, options) => {
+				const id = text(projectId);
+				const result = snapshotProject(await projects.get(id, options));
+				if (result.id !== id) throw invalid$1();
+				return result;
+			}
+		}),
+		workspaces: Object.freeze({
+			list: async (projectId, options) => {
+				const id = text(projectId);
+				return array(await workspaces.list(id, options), (row) => workspaceFor(row, id));
+			},
+			get: async (selection, options) => {
+				const requested = snapshotSelection$1(selection);
+				const result = workspaceFor(await workspaces.get(requested, options), requested.projectId);
+				if (result.id !== requested.workspaceId) throw invalid$1();
+				return result;
+			}
+		}),
+		sessions: Object.freeze({
+			list: async (selection, options) => array(await sessions.list(snapshotSelection$1(selection), options), snapshotSession),
+			get: async (selection, options) => {
+				const requested = snapshotSelection$1(selection, true);
+				const result = snapshotSession(await sessions.get(requested, options));
+				if (result.id !== requested.sessionId) throw invalid$1();
+				return result;
+			}
+		})
+	});
+}
+function methods(value) {
+	const owner = record(value);
+	const list = owner["list"];
+	const get = owner["get"];
+	if (typeof list !== "function" || typeof get !== "function") throw invalid$1();
+	return {
+		list: (...args) => Promise.resolve(Reflect.apply(list, owner, args)),
+		get: (...args) => Promise.resolve(Reflect.apply(get, owner, args))
+	};
+}
+function snapshotProject(value) {
+	const row = record(value);
+	return Object.freeze({
+		id: text(row["id"]),
+		name: text(row["name"]),
+		path: text(row["path"])
+	});
+}
+function workspaceFor(value, projectId) {
+	const row = record(value);
+	if (row["projectId"] !== projectId || typeof row["isMain"] !== "boolean") throw invalid$1();
+	let provider;
+	if (row["provider"] !== void 0) {
+		const source = record(row["provider"]);
+		const capabilities = record(source["capabilities"]);
+		if (typeof capabilities["remove"] !== "boolean") throw invalid$1();
+		provider = Object.freeze({
+			pluginId: text(source["pluginId"]),
+			capabilities: Object.freeze({ remove: capabilities["remove"] }),
+			...source["metadata"] === void 0 ? {} : { metadata: jsonObject(source["metadata"]) }
+		});
+	}
+	const removal = row["removal"] === void 0 ? void 0 : record(row["removal"]);
+	return Object.freeze({
+		id: text(row["id"]),
+		projectId,
+		path: text(row["path"]),
+		label: text(row["label"]),
+		isMain: row["isMain"],
+		...provider === void 0 ? {} : { provider },
+		...removal === void 0 ? {} : { removal: Object.freeze({
+			actionLabel: text(removal["actionLabel"]),
+			confirmation: text(removal["confirmation"])
+		}) }
+	});
+}
+function snapshotSession(value) {
+	const row = record(value);
+	const runtime = row["runtime"];
+	if (typeof row["archived"] !== "boolean" || runtime !== "not-hosted" && runtime !== "idle" && runtime !== "busy") throw invalid$1();
+	let metadata;
+	if (row["metadata"] !== void 0) metadata = Object.freeze(Object.fromEntries(Object.entries(record(row["metadata"])).map(([key, data]) => [key, jsonObject(data)])));
+	if (row["name"] !== void 0 && typeof row["name"] !== "string") throw invalid$1();
+	if (typeof row["pinned"] !== "boolean") throw invalid$1();
+	const created = nullableTimestamp(row["created"]);
+	const modified = nullableTimestamp(row["modified"]);
+	const archivedAt = nullableTimestamp(row["archivedAt"]);
+	if (archivedAt !== null && !row["archived"]) throw invalid$1();
+	return Object.freeze({
+		id: text(row["id"]),
+		cwd: text(row["cwd"]),
+		archived: row["archived"],
+		runtime,
+		created,
+		modified,
+		archivedAt,
+		pinned: row["pinned"],
+		...row["name"] === void 0 ? {} : { name: row["name"] },
+		...metadata === void 0 ? {} : { metadata }
+	});
+}
+function nullableTimestamp(value) {
+	if (value === null) return null;
+	if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) throw invalid$1();
+	return value;
+}
+function snapshotSelection$1(value, session = false) {
+	const row = record(value);
+	const keys = session ? [
+		"projectId",
+		"workspaceId",
+		"sessionId"
+	] : ["projectId", "workspaceId"];
+	if (Reflect.ownKeys(row).some((key) => typeof key !== "string" || !keys.includes(key))) throw invalid$1();
+	return Object.freeze({
+		projectId: text(row["projectId"]),
+		workspaceId: text(row["workspaceId"]),
+		...session ? { sessionId: text(row["sessionId"]) } : {}
+	});
+}
+function array(value, snapshot) {
+	if (!Array.isArray(value)) throw invalid$1();
+	return Object.freeze(value.map(snapshot));
+}
+function record(value) {
+	if (!isRecord(value)) throw invalid$1();
+	return value;
+}
+function isRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function text(value) {
+	if (typeof value !== "string" || value.trim() === "") throw invalid$1();
+	return value;
+}
+function jsonObject(value, ancestors = /* @__PURE__ */ new Set()) {
+	const source = record(value);
+	if (ancestors.has(source)) throw invalid$1();
+	ancestors.add(source);
+	const result = Object.freeze(Object.fromEntries(Object.entries(source).map(([key, data]) => [key, json(data, ancestors)])));
+	ancestors.delete(source);
+	return result;
+}
+function json(value, ancestors) {
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return value;
+	if (Array.isArray(value)) {
+		if (ancestors.has(value)) throw invalid$1();
+		ancestors.add(value);
+		const result = Object.freeze(value.map((item) => json(item, ancestors)));
+		ancestors.delete(value);
+		return result;
+	}
+	return jsonObject(value, ancestors);
+}
+function invalid$1() {
+	return /* @__PURE__ */ new Error("Invalid PI WEB host catalog capability v1 data");
+}
+Object.freeze({
+	pluginId: "pi-web.host",
+	id: "session-lifecycle",
+	version: 1,
+	parse: snapshotLifecycle
+});
+function snapshotLifecycle(value) {
+	if (typeof value !== "object" || value === null || !("version" in value) || value.version !== 1) throw invalid();
+	const owner = value;
+	const method = (name) => {
+		const fn = Reflect.get(owner, name);
+		if (typeof fn !== "function") throw invalid();
+		return async (selection, options) => {
+			const result = Reflect.apply(fn, owner, [snapshotSelection(selection), options]);
+			return await Promise.resolve(result);
+		};
+	};
+	const get = method("get");
+	const mutation = (name) => {
+		const invoke = method(name);
+		return async (selection, options) => {
+			await invoke(selection, options);
+		};
+	};
+	return Object.freeze({
+		version: 1,
+		get: async (selection, options) => {
+			const requested = snapshotSelection(selection);
+			const result = await get(requested, options);
+			if (typeof result !== "object" || result === null || !("sessionId" in result) || result.sessionId !== requested.sessionId || !("pinned" in result) || typeof result.pinned !== "boolean" || !("archived" in result) || typeof result.archived !== "boolean") throw invalid();
+			return Object.freeze({
+				sessionId: requested.sessionId,
+				pinned: result.pinned,
+				archived: result.archived
+			});
+		},
+		pin: mutation("pin"),
+		unpin: mutation("unpin"),
+		archive: mutation("archive"),
+		restore: mutation("restore"),
+		delete: mutation("delete")
+	});
+}
+function snapshotSelection(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalid();
+	const keys = [
+		"projectId",
+		"workspaceId",
+		"sessionId"
+	];
+	if (Reflect.ownKeys(value).some((key) => typeof key !== "string" || !keys.some((allowed) => key === allowed))) throw invalid();
+	const text = (key) => {
+		const field = Reflect.get(value, key);
+		if (typeof field !== "string" || field.trim() === "" || field.length > 512) throw invalid();
+		return field;
+	};
+	return Object.freeze({
+		projectId: text("projectId"),
+		workspaceId: text("workspaceId"),
+		sessionId: text("sessionId")
+	});
+}
+function invalid() {
+	return /* @__PURE__ */ new Error("Invalid PI WEB host session lifecycle capability v1 data");
+}
+// src/server-plugin-api.ts
+/** Discover this package's local v5 backend on a hosted pi.events bus.
+* Throws synchronously outside PI WEB or when the paired backend is unavailable.
+* Extensions are trusted in-process code, not a sandbox.
+*/
+function createCompanionBackend(events, pluginId) {
+	let backend;
+	let failure;
+	events.emit("pi-web:companion-backend:discover", {
+		pluginId,
+		accept: (discover) => {
+			try {
+				backend = discover();
+			} catch (error) {
+				failure = error instanceof Error ? error : new Error(String(error));
+			}
+		}
+	});
+	if (failure !== void 0) throw failure;
+	if (backend === void 0) throw new Error("Companion backend discovery requires a hosted PI WEB event bus");
+	return backend;
+}
+Object.freeze({
+	pluginId: "pi-web.host",
+	id: "workspaces",
+	version: 1,
+	parse: snapshotPiWebHostWorkspacesV1
+});
+Object.freeze({
+	pluginId: "pi-web.host",
+	id: "pi-sessions",
+	version: 1,
+	parse: snapshotPiWebHostPiSessionsV1
+});
+Object.freeze({
+	pluginId: "pi-web.host",
+	id: "pi-session-events",
+	version: 1,
+	parse: snapshotPiWebHostPiSessionEventsV1
+});
+function snapshotPiWebHostWorkspacesV1(value) {
+	if (typeof value !== "object" || value === null) throw invalidPiWebHostWorkspaces();
+	const version = Reflect.get(value, "version");
+	const resolve = Reflect.get(value, "resolve");
+	if (version !== 1 || typeof resolve !== "function") throw invalidPiWebHostWorkspaces();
+	return Object.freeze({
+		version: 1,
+		resolve: async (selection) => {
+			const requested = snapshotPiWebHostWorkspaceSelection(selection);
+			return snapshotPiWebHostWorkspaceAuthority(await Reflect.apply(resolve, value, [requested]), requested);
+		}
+	});
+}
+function snapshotPiWebHostPiSessionEventsV1(value) {
+	if (typeof value !== "object" || value === null) throw new Error("Invalid PI session events capability");
+	const connect = Reflect.get(value, "connect");
+	if (Reflect.get(value, "version") !== 1 || typeof connect !== "function") throw new Error("Invalid PI session events capability");
+	return Object.freeze({
+		version: 1,
+		connect: async (selection) => {
+			const workspace = snapshotPiWebHostWorkspaceSelection({
+				projectId: selection.projectId,
+				workspaceId: selection.workspaceId
+			});
+			const sessionId = selection.sessionId;
+			if (typeof sessionId !== "string" || sessionId.trim() === "" || sessionId.length > 512) throw new Error("Invalid hosted session id");
+			const connection = await Reflect.apply(connect, value, [{
+				...workspace,
+				sessionId
+			}]);
+			if (typeof connection !== "object" || connection === null) throw new Error("Invalid PI session events connection");
+			const signal = Reflect.get(connection, "signal");
+			const on = Reflect.get(connection, "on");
+			const emit = Reflect.get(connection, "emit");
+			const close = Reflect.get(connection, "close");
+			if (!(signal instanceof AbortSignal) || typeof on !== "function" || typeof emit !== "function" || typeof close !== "function") throw new Error("Invalid PI session events connection");
+			return Object.freeze({
+				signal,
+				on: (channel, handler) => {
+					const unsubscribe = Reflect.apply(on, connection, [channel, handler]);
+					if (typeof unsubscribe !== "function") throw new Error("Invalid PI event unsubscribe function");
+					return () => {
+						Reflect.apply(unsubscribe, void 0, []);
+					};
+				},
+				emit: (channel, data) => {
+					Reflect.apply(emit, connection, [channel, data]);
+				},
+				close: () => {
+					Reflect.apply(close, connection, []);
+				}
+			});
+		}
+	});
+}
+function snapshotPiWebHostPiSessionsV1(value) {
+	if (typeof value !== "object" || value === null) throw invalidPiWebHostPiSessions();
+	const version = Reflect.get(value, "version");
+	const run = Reflect.get(value, "run");
+	const create = Reflect.get(value, "create");
+	if (version !== 1 || typeof run !== "function" || typeof create !== "function") throw invalidPiWebHostPiSessions();
+	return Object.freeze({
+		version: 1,
+		create: async (input) => {
+			const requested = snapshotPiWebHostWorkspaceSelection(input);
+			const result = await Reflect.apply(create, value, [requested]);
+			if (!isPublicJsonObject(result)) throw new Error("PI WEB host PI sessions capability v1 must return a created session object");
+			const sessionId = requiredBoundedPiSessionString(Reflect.get(result, "sessionId"), "returned sessionId", 512);
+			return Object.freeze({ sessionId });
+		},
+		run: async (input) => {
+			const requested = snapshotPiWebHostPiSessionRunInput(input);
+			return snapshotPiWebHostPiSessionRun(await Reflect.apply(run, value, [requested]));
+		}
+	});
+}
+function snapshotPiWebHostPiSessionRunInput(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host PI sessions capability v1 run input must be an object");
+	const supportedKeys = /* @__PURE__ */ new Set([
+		"projectId",
+		"workspaceId",
+		"prompt",
+		"model",
+		"thinkingLevel"
+	]);
+	for (const key of Reflect.ownKeys(value)) if (typeof key !== "string" || !supportedKeys.has(key)) throw new Error(`Unsupported PI WEB host PI sessions capability v1 run input field: ${String(key)}`);
+	if (!Object.hasOwn(value, "projectId") || !Object.hasOwn(value, "workspaceId") || !Object.hasOwn(value, "prompt")) throw new Error("PI WEB host PI sessions capability v1 run input must contain projectId, workspaceId, and prompt");
+	const projectId = requiredBoundedPiSessionString(Reflect.get(value, "projectId"), "projectId", 512);
+	const workspaceId = requiredBoundedPiSessionString(Reflect.get(value, "workspaceId"), "workspaceId", 512);
+	const prompt = requiredBoundedPiSessionUtf8String(Reflect.get(value, "prompt"), "prompt", 65536);
+	const settings = snapshotPiSessionSettings(value);
+	return Object.freeze({
+		projectId,
+		workspaceId,
+		prompt,
+		...settings
+	});
+}
+function snapshotPiWebHostPiSessionRun(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host PI sessions capability v1 must return a run object");
+	const sessionId = requiredBoundedPiSessionString(Reflect.get(value, "sessionId"), "returned sessionId", 512);
+	const completionValue = Reflect.get(value, "completion");
+	if (!isPromiseLike(completionValue)) throw new Error("PI WEB host PI sessions capability v1 run must expose completion");
+	const completion = Promise.resolve(completionValue).then(snapshotPiWebHostPiSessionRunCompletion);
+	return Object.freeze({
+		sessionId,
+		completion,
+		...snapshotPiSessionSettings(value)
+	});
+}
+function snapshotPiSessionSettings(value) {
+	const modelValue = Reflect.get(value, "model");
+	const thinkingValue = Reflect.get(value, "thinkingLevel");
+	const model = modelValue === void 0 ? void 0 : requiredBoundedPiSessionString(modelValue, "model", 512);
+	if (thinkingValue !== void 0 && (typeof thinkingValue !== "string" || !isKnownThinkingLevel(thinkingValue))) throw new Error("Invalid PI WEB host PI sessions thinkingLevel");
+	return {
+		...model === void 0 ? {} : { model },
+		...thinkingValue === void 0 ? {} : { thinkingLevel: thinkingValue }
+	};
+}
+function snapshotPiWebHostPiSessionRunCompletion(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host PI sessions capability v1 completion must be an object");
+	const status = Reflect.get(value, "status");
+	if (status === "completed" || status === "cancelled") return Object.freeze({ status });
+	if (status !== "failed") throw new Error("PI WEB host PI sessions capability v1 completion status is invalid");
+	const error = requiredBoundedPiSessionUtf8String(Reflect.get(value, "error"), "completion error", 4096);
+	return Object.freeze({
+		status,
+		error
+	});
+}
+function snapshotPiWebHostWorkspaceSelection(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host workspaces capability v1 selection must be an object");
+	const supportedKeys = /* @__PURE__ */ new Set(["projectId", "workspaceId"]);
+	for (const key of Reflect.ownKeys(value)) if (typeof key !== "string" || !supportedKeys.has(key)) throw new Error(`Unsupported PI WEB host workspaces capability v1 selection field: ${String(key)}`);
+	if (!Object.hasOwn(value, "projectId") || !Object.hasOwn(value, "workspaceId")) throw new Error("PI WEB host workspaces capability v1 selection must contain projectId and workspaceId");
+	const projectId = requiredPublicString(Reflect.get(value, "projectId"), "selection projectId");
+	const workspaceId = requiredPublicString(Reflect.get(value, "workspaceId"), "selection workspaceId");
+	return Object.freeze({
+		projectId,
+		workspaceId
+	});
+}
+function snapshotPiWebHostWorkspaceAuthority(value, requested) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host workspaces capability v1 must return an authority object");
+	const project = snapshotPiWebHostProject(Reflect.get(value, "project"));
+	const workspace = snapshotPiWebHostWorkspace(Reflect.get(value, "workspace"));
+	if (workspace.projectId !== project.id) throw new Error("PI WEB host workspaces capability v1 returned mismatched project and workspace scopes");
+	if (project.id !== requested.projectId || workspace.id !== requested.workspaceId) throw new Error("PI WEB host workspaces capability v1 returned authority outside the requested selection");
+	return Object.freeze({
+		project,
+		workspace
+	});
+}
+function snapshotPiWebHostProject(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host workspaces capability v1 project must be an object");
+	const id = requiredPublicString(Reflect.get(value, "id"), "project id");
+	const name = requiredPublicString(Reflect.get(value, "name"), "project name");
+	const path = requiredPublicString(Reflect.get(value, "path"), "project path");
+	return Object.freeze({
+		id,
+		name,
+		path
+	});
+}
+function snapshotPiWebHostWorkspace(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host workspaces capability v1 workspace must be an object");
+	const id = requiredPublicString(Reflect.get(value, "id"), "workspace id");
+	const projectId = requiredPublicString(Reflect.get(value, "projectId"), "workspace projectId");
+	const path = requiredPublicString(Reflect.get(value, "path"), "workspace path");
+	const label = requiredPublicString(Reflect.get(value, "label"), "workspace label");
+	const isMain = Reflect.get(value, "isMain");
+	if (typeof isMain !== "boolean") throw new Error("PI WEB host workspaces capability v1 workspace isMain must be a boolean");
+	const providerValue = Reflect.get(value, "provider");
+	const provider = providerValue === void 0 ? void 0 : snapshotPiWebHostWorkspaceProvider(providerValue);
+	return Object.freeze({
+		id,
+		projectId,
+		path,
+		label,
+		isMain,
+		...provider === void 0 ? {} : { provider }
+	});
+}
+function snapshotPiWebHostWorkspaceProvider(value) {
+	if (!isPublicJsonObject(value)) throw new Error("PI WEB host workspaces capability v1 workspace provider must be an object");
+	const pluginId = requiredPublicString(Reflect.get(value, "pluginId"), "workspace provider pluginId");
+	const capabilitiesValue = Reflect.get(value, "capabilities");
+	if (!isPublicJsonObject(capabilitiesValue)) throw new Error("PI WEB host workspaces capability v1 workspace provider capabilities are invalid");
+	const remove = Reflect.get(capabilitiesValue, "remove");
+	if (typeof remove !== "boolean") throw new Error("PI WEB host workspaces capability v1 workspace provider capabilities are invalid");
+	const capabilities = Object.freeze({ remove });
+	const metadataValue = Reflect.get(value, "metadata");
+	const metadata = metadataValue === void 0 ? void 0 : clonePublicJsonObject(metadataValue, "workspace provider metadata");
+	return Object.freeze({
+		pluginId,
+		capabilities,
+		...metadata === void 0 ? {} : { metadata }
+	});
+}
+function clonePublicJsonObject(value, label) {
+	if (!isPublicJsonObject(value)) throw new Error(`PI WEB host workspaces capability v1 ${label} must be a JSON object`);
+	return clonePublicJsonRecord(value, /* @__PURE__ */ new Set(), label);
+}
+function clonePublicJsonRecord(value, ancestors, label) {
+	if (ancestors.has(value)) throw new Error(`PI WEB host workspaces capability v1 ${label} must not contain cycles`);
+	ancestors.add(value);
+	try {
+		const output = {};
+		for (const key of Object.keys(value)) Object.defineProperty(output, key, {
+			value: clonePublicJsonValue(value[key], ancestors, label),
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+		return Object.freeze(output);
+	} finally {
+		ancestors.delete(value);
+	}
+}
+function clonePublicJsonValue(value, ancestors, label) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error(`PI WEB host workspaces capability v1 ${label} must contain only finite JSON numbers`);
+		return value;
+	}
+	if (Array.isArray(value)) {
+		if (ancestors.has(value)) throw new Error(`PI WEB host workspaces capability v1 ${label} must not contain cycles`);
+		ancestors.add(value);
+		try {
+			const output = [];
+			for (let index = 0; index < value.length; index += 1) {
+				if (!Object.hasOwn(value, index)) throw new Error(`PI WEB host workspaces capability v1 ${label} must not contain sparse arrays`);
+				output.push(clonePublicJsonValue(value[index], ancestors, label));
+			}
+			return Object.freeze(output);
+		} finally {
+			ancestors.delete(value);
+		}
+	}
+	if (isPublicJsonObject(value)) return clonePublicJsonRecord(value, ancestors, label);
+	throw new Error(`PI WEB host workspaces capability v1 ${label} must contain only JSON values`);
+}
+function requiredPublicString(value, label) {
+	if (typeof value !== "string" || value === "") throw new Error(`PI WEB host workspaces capability v1 ${label} must be a non-empty string`);
+	return value;
+}
+function requiredBoundedPiSessionString(value, label, maxLength) {
+	if (typeof value !== "string" || value === "") throw new Error(`PI WEB host PI sessions capability v1 ${label} must be a non-empty string`);
+	if (value.length > maxLength) throw new Error(`PI WEB host PI sessions capability v1 ${label} must be at most ${String(maxLength)} characters`);
+	return value;
+}
+function requiredBoundedPiSessionUtf8String(value, label, maxBytes) {
+	if (typeof value !== "string" || value === "") throw new Error(`PI WEB host PI sessions capability v1 ${label} must be a non-empty string`);
+	if (publicStringExceedsUtf8ByteLimit(value, maxBytes)) throw new Error(`PI WEB host PI sessions capability v1 ${label} must be at most ${String(maxBytes)} UTF-8 bytes`);
+	return value;
+}
+function publicStringExceedsUtf8ByteLimit(value, maxBytes) {
+	let bytes = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		const codePoint = value.codePointAt(index);
+		if (codePoint === void 0) break;
+		if (codePoint > 65535) index += 1;
+		bytes += codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
+		if (bytes > maxBytes) return true;
+	}
+	return false;
+}
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null || typeof value === "function" ? typeof Reflect.get(value, "then") === "function" : false;
+}
+function isPublicJsonObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function invalidPiWebHostWorkspaces() {
+	return /* @__PURE__ */ new Error("PI WEB host workspaces capability v1 must expose resolve");
+}
+function invalidPiWebHostPiSessions() {
+	return /* @__PURE__ */ new Error("PI WEB host PI sessions capability v1 must expose create and run");
+}
+// pi-packages/scheduled-tasks/extensions/index.ts
+var id = (description) => Type.String({
+	minLength: 1,
+	maxLength: 512,
+	description
+});
+var taskId = id("Task ID returned by scheduled task tools.");
+var executionId = id("Execution ID returned by dispatch or history, or included in the task's initial message.");
+var revision = Type.Integer({
+	minimum: 1,
+	description: "Current task revision from inspect; stale writes reject. Read again before retrying."
+});
+var definition = Type.Object({
+	name: Type.String({
+		minLength: 1,
+		maxLength: 512
+	}),
+	projectId: id("Registered project ID from scheduled_tasks_targets; not a filesystem path."),
+	workspaceId: id("Registered workspace ID from scheduled_tasks_targets; not a filesystem path."),
+	prompt: Type.String({
+		minLength: 1,
+		maxLength: 49152,
+		description: "Initial instructions for a normal conversation."
+	}),
+	model: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 512,
+		description: "Requested provider/model ID. Omit to use the session default. If unavailable at dispatch, the scheduler uses the default and records a notice."
+	})),
+	thinkingLevel: Type.Optional(Type.Enum([
+		"off",
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	], { description: "Requested thinking level. Omit to use the session default. If unavailable at dispatch, the scheduler uses the default and records a notice." })),
+	timezone: Type.Optional(Type.String({ description: "IANA timezone. Omit only to use the configured default; if no default exists, ask the user." })),
+	schedule: Type.Union([Type.Object({
+		kind: Type.Literal("once"),
+		at: Type.String({ description: "Future ISO timestamp with an explicit UTC offset or Z." })
+	}, { additionalProperties: false }), Type.Object({
+		kind: Type.Literal("cron"),
+		expression: Type.String({ description: "Deterministic five-field cron expression, evaluated in the task timezone." })
+	}, { additionalProperties: false })]),
+	contextPaths: Type.Optional(Type.Array(Type.String({ description: "Workspace-relative shared context file; read when dispatched, not snapshotted." }), { maxItems: 32 }))
+}, { additionalProperties: false });
+var object = (properties) => Type.Object(properties, { additionalProperties: false });
+/** Thin deferred transport: the daemon owns all state, validation and dispatch. */
+function scheduledTasksExtension(pi) {
+	function register(operation, description, parameters, readOnly) {
+		pi.registerTool(defineTool({
+			name: `scheduled_tasks_${operation}`,
+			label: `Scheduled tasks: ${operation}`,
+			description,
+			exposure: "deferred",
+			namespace: {
+				name: "scheduled_tasks",
+				description: "Create and manage machine-local scheduled agent tasks and explicit execution outcomes.",
+				instructions: "Use targets for registered project/workspace IDs. Inspect before revision-checked edits. Ask for timezone if no configured default exists. Pause/archive affect only future scheduling. Delete requires an archived task and permanently removes it and all its history, not conversations. Dispatch creates an ordinary independent conversation. Never infer an execution outcome from session activity; use report explicitly. Do not blindly repeat a dispatch after an error or uncertainty; inspect history first."
+			},
+			annotations: {
+				readOnlyHint: readOnly,
+				destructiveHint: operation === "delete",
+				openWorldHint: !readOnly,
+				idempotentHint: readOnly
+			},
+			parameters,
+			async execute(_toolCallId, input, signal) {
+				signal?.throwIfAborted();
+				const peer = createCompanionBackend(pi.events, "scheduled-tasks").forScope({ kind: "machine" });
+				if (peer.request === void 0) throw new Error("Scheduled tasks backend does not support requests");
+				const result = await peer.request(operation, input, signal === void 0 ? {} : { signal });
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result)
+					}],
+					details: result
+				};
+			}
+		}));
+	}
+	register("targets", "List registered local projects, or workspaces for a project. Use these opaque IDs when creating tasks.", object({ projectId: Type.Optional(id("Omit to list projects; supply a project ID to list its workspaces.")) }), true);
+	register("overview", "List scheduled tasks, configured default timezone, next dispatches and latest explicit execution outcomes.", object({}), true);
+	register("inspect", "Read a task's full current definition and revision before editing it.", object({ taskId }), true);
+	register("create", "Create a one-off or recurring agent task. Resolve target IDs with targets first. If timezone is omitted and no default exists, ask the user; do not guess.", definition, false);
+	register("update", "Replace a task definition at its current revision. Preserve unchanged fields from inspect. Changes affect future dispatches, not existing conversations.", object({
+		taskId,
+		revision,
+		definition
+	}), false);
+	register("pause", "Pause or resume future scheduled dispatches. Does not pause or resume any existing conversation.", object({
+		taskId,
+		revision,
+		paused: Type.Boolean()
+	}), false);
+	register("archive", "Archive a task, preventing future scheduled and manual dispatches. Preserve history and existing conversations.", object({
+		taskId,
+		revision
+	}), false);
+	register("delete", "Permanently delete a task and all its revisions, execution history and outcome reports. Only archived tasks can be deleted; archive first and use its new revision. Existing conversations and their transcripts are not deleted or stopped. Rejects while dispatch admission is in progress; inspect again before retrying.", object({
+		taskId,
+		revision
+	}), false);
+	register("dispatch", "Manually dispatch one execution as a normal independent conversation, including for a paused task. Does not consume its scheduled occurrence. Inspect history before retrying any ambiguous result; no automatic retries.", object({ taskId }), false);
+	register("history", "Read paged execution history and conversation IDs, optionally limited to one task. Outcomes are explicit reports, not session status.", object({
+		taskId: Type.Optional(taskId),
+		limit: Type.Optional(Type.Integer({
+			minimum: 1,
+			maximum: 50
+		})),
+		offset: Type.Optional(Type.Integer({ minimum: 0 }))
+	}), true);
+	register("execution", "Retrieve an execution's dispatched task revision, instructions, shared context paths, conversation identity and full outcome correction history.", object({ executionId }), true);
+	register("report", "Explicitly report a completed or errored execution with a summary, or correct a previous report. Corrections retain history. Reporting does not stop the conversation or disable a recurring task.", object({
+		executionId,
+		outcome: Type.Enum(["completed", "errored"]),
+		summary: Type.String({
+			minLength: 1,
+			maxLength: 16384
+		})
+	}), false);
+}
+export { scheduledTasksExtension as default };