@runtypelabs/cli 2.46.2 → 2.47.1

package/dist/index.js

@@ -2,8 +2,8 @@
 import { createRequire } from "node:module";
 import { Command, InvalidArgumentError, Option } from "commander";
 import chalk from "chalk";
-import * as fs$1 from "node:fs";
-import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import * as fs$2 from "node:fs";
+import fs, { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import * as path$2 from "node:path";
 import path, { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import React, { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
@@ -15,7 +15,7 @@ import { ClientTokensNamespace, DEFAULT_STALL_STOP_AFTER, ENSURE_RELEASE_DEPLOY_
 import Conf from "conf";
 import os, { tmpdir } from "os";
 import path$1, { delimiter, dirname as dirname$1, join as join$1, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
-import fs, { copyFileSync, existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, unlinkSync, writeFileSync as writeFileSync$1 } from "fs";
+import fs$1, { copyFileSync, existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, unlinkSync, writeFileSync as writeFileSync$1 } from "fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import readline from "readline";
 import { ErrorDisplay, Spinner, StatusBar, StreamOutput, renderMarkdownToTerminal, theme } from "@runtypelabs/ink-components";
@@ -37,6 +37,7 @@ import { createServer } from "node:http";
 import { createServer as createServer$1 } from "node:net";
 import { zipSync } from "fflate";
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import WebSocket from "ws";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -7492,7 +7493,7 @@ const UNIFIED_SSE_EVENT_TYPES = _unifiedTuple([
 * Canonical record type guard: a non-null object that is NOT an array.
 * This is the array-EXCLUDING variant — `isRecord([])` is false.
 */
-function isRecord$1(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -11142,19 +11143,19 @@ const toolElicitationConfigSchema = strictObject({
 });
 function canonicalToolInputDefinition(value) {
 	if (Array.isArray(value)) return `[${value.map(canonicalToolInputDefinition).join(",")}]`;
-	if (isRecord$1(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalToolInputDefinition(value[key])}`).join(",")}}`;
+	if (isRecord$3(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalToolInputDefinition(value[key])}`).join(",")}}`;
 	return JSON.stringify(value) ?? "null";
 }
 /** Validate authored input against the final dispatch schema at every definition boundary. */
 function validateToolElicitationDefinition(tool, ctx) {
-	if (!isRecord$1(tool)) {
+	if (!isRecord$3(tool)) {
 		ctx.addIssue({
 			code: "custom",
 			message: "Runtime tool definition must be an object"
 		});
 		return;
 	}
-	const config = isRecord$1(tool.config) ? tool.config : void 0;
+	const config = isRecord$3(tool.config) ? tool.config : void 0;
 	if (config?.elicit === void 0) return;
 	const issue = (message) => {
 		ctx.addIssue({
@@ -11188,7 +11189,7 @@ function validateToolElicitationDefinition(tool, ctx) {
 		"required",
 		"additionalProperties"
 	]);
-	if (!isSupportedElicitationSchema(final) || !isRecord$1(final) || final.type !== "object" || final.additionalProperties !== false || !isRecord$1(final.properties) || Object.keys(final).some((key) => !allowedRootKeys.has(key))) {
+	if (!isSupportedElicitationSchema(final) || !isRecord$3(final) || final.type !== "object" || final.additionalProperties !== false || !isRecord$3(final.properties) || Object.keys(final).some((key) => !allowedRootKeys.has(key))) {
 		issue("Final parametersSchema must be a closed, projectable object without cross-field constraints");
 		return;
 	}
@@ -13381,6 +13382,18 @@ _enum([
 * fragments, and the agent-facing skill references.
 */
 const DISPATCH_TRANSIENT_SECRETS_RETIRED_NOTE = `Retired on BOTH dispatch targets. A NON-EMPTY map is rejected with 400: RUNTIME_AGENT_TRANSIENT_SECRETS_UNSUPPORTED on an agent dispatch, RUNTIME_FLOW_TRANSIENT_SECRETS_UNSUPPORTED on a flow dispatch (the flow target used to drop the map silently). An empty map is accepted and does nothing. Store credentials as managed secrets and reference them as {{secret:NAME}}. The field is kept on the wire for compatibility only.`;
+/**
+* The normalizer names the ingest records, restated here because `@runtypelabs/shared` cannot import
+* `@runtypelabs/execution-ingest`. Pinned against the ingest's own constants by
+* `apps/api/tests/connect-agent-framework-producers.test.ts`.
+*/
+const TRACE_NORMALIZER_NAMES = {
+	flue: "runtype-ingest/flue-normalizer",
+	openInference: "runtype-ingest/openinference-normalizer",
+	aiSdk: "runtype-ingest/ai-sdk-normalizer",
+	cloudflareAgents: "runtype-ingest/cloudflare-agents-normalizer"
+};
+TRACE_NORMALIZER_NAMES.flue, TRACE_NORMALIZER_NAMES.aiSdk, TRACE_NORMALIZER_NAMES.openInference, TRACE_NORMALIZER_NAMES.openInference, TRACE_NORMALIZER_NAMES.cloudflareAgents;
 //#endregion
 //#region ../shared/dist/container-sandbox-timeout.mjs
 /**
@@ -14784,9 +14797,9 @@ function walkSteps$1(steps, basePath, context, state) {
 	steps.forEach((step, index) => walkStep(step, `${basePath}[${index}]`, context, state));
 }
 function walkStep(node, path, context, state) {
-	if (!isRecord$1(node)) return;
+	if (!isRecord$3(node)) return;
 	if (node.enabled === false && !state.includeDisabled) return;
-	const config = isRecord$1(node.config) ? node.config : void 0;
+	const config = isRecord$3(node.config) ? node.config : void 0;
 	if (!config) return;
 	state.visitor.visitStep?.(node, config, path, context);
 	if (node.type === "execute-agent") state.visitor.visitExecuteAgent(node, config, path, context);
@@ -14807,21 +14820,21 @@ function walkStep(node, path, context, state) {
 		conditionalDepth: state.conditionalDepth + 1
 	};
 	if (Array.isArray(config.branches)) config.branches.forEach((branch, branchIndex) => {
-		if (!isRecord$1(branch)) return;
+		if (!isRecord$3(branch)) return;
 		walkSteps$1(branch.steps, `${path}.config.branches[${branchIndex}].steps`, context, nested);
 	});
 	for (const key of CONDITIONAL_BRANCH_STEP_KEYS$2) walkSteps$1(config[key], `${path}.config.${key}`, context, nested);
 }
 function visitFlowFallbacks(config, path, context, state) {
 	const { visitFlowFallback, visitStepFallback } = state.visitor;
-	if (!visitFlowFallback && !visitStepFallback || !isRecord$1(config.errorHandling)) return;
+	if (!visitFlowFallback && !visitStepFallback || !isRecord$3(config.errorHandling)) return;
 	const fallbacks = config.errorHandling.fallbacks;
 	if (!Array.isArray(fallbacks)) return;
 	fallbacks.forEach((fallback, index) => {
-		if (!isRecord$1(fallback)) return;
+		if (!isRecord$3(fallback)) return;
 		const fallbackPath = `${path}.config.errorHandling.fallbacks[${index}]`;
 		if (fallback.type === "flow") visitFlowFallback?.(fallback, fallbackPath, context);
-		else if (fallback.type === "step" && visitStepFallback && isRecord$1(fallback.stepConfig)) {
+		else if (fallback.type === "step" && visitStepFallback && isRecord$3(fallback.stepConfig)) {
 			visitStepFallback(fallback, fallback.stepConfig, fallbackPath, context);
 			walkToolPayloads(fallback.stepConfig.tools, `${fallbackPath}.stepConfig.tools`, context, state);
 		}
@@ -14830,7 +14843,7 @@ function visitFlowFallbacks(config, path, context, state) {
 const TOOL_BAG_KEYS = ["runtimeTools", "inlineTools"];
 /** Descend the inline flow-as-tool and skill payloads a step's tool bag can carry. */
 function walkToolPayloads(tools, path, context, state) {
-	if (!isRecord$1(tools)) return;
+	if (!isRecord$3(tools)) return;
 	for (const key of TOOL_BAG_KEYS) {
 		const bag = tools[key];
 		if (!Array.isArray(bag)) continue;
@@ -14844,12 +14857,12 @@ function walkRuntimeTools(runtimeTools, basePath, context, state) {
 		walkDepth: state.walkDepth + 1
 	};
 	runtimeTools.forEach((tool, index) => {
-		if (!isRecord$1(tool)) return;
-		const config = isRecord$1(tool.config) ? tool.config : void 0;
+		if (!isRecord$3(tool)) return;
+		const config = isRecord$3(tool.config) ? tool.config : void 0;
 		if (!config) return;
 		const toolPath = `${basePath}[${index}].config`;
-		if (isRecord$1(config.skill) && Array.isArray(config.skill.resolvedTools)) walkRuntimeTools(config.skill.resolvedTools, `${toolPath}.skill.resolvedTools`, context, deeper);
-		if (!state.skipInlineFlows && isRecord$1(config.flow) && Array.isArray(config.flow.steps)) {
+		if (isRecord$3(config.skill) && Array.isArray(config.skill.resolvedTools)) walkRuntimeTools(config.skill.resolvedTools, `${toolPath}.skill.resolvedTools`, context, deeper);
+		if (!state.skipInlineFlows && isRecord$3(config.flow) && Array.isArray(config.flow.steps)) {
 			const nestedContext = state.visitor.enterNestedFlow?.(config.flow, context) ?? context;
 			walkSteps$1(config.flow.steps, `${toolPath}.flow.steps`, nestedContext, {
 				...deeper,
@@ -15963,7 +15976,7 @@ const EGRESS_PROVIDER_REMEDIATION = "Set sandboxProvider to \"cloudflare-worker\
 * Returns every issue so validators can surface them together.
 */
 function collectCustomToolEgressIssues(config) {
-	if (!isRecord$1(config)) return [];
+	if (!isRecord$3(config)) return [];
 	const issues = [];
 	const provider = resolveSandboxProvider(config.sandboxProvider);
 	const networkParse = config.networkAccess === void 0 ? void 0 : sandboxNetworkAccessSchema.safeParse(config.networkAccess);
@@ -18889,7 +18902,7 @@ function snakeToCamel(str) {
 * Input is unknown (not ApprovalConfig) because values come from unvalidated stored JSONB.
 */
 function isEffectiveApprovalPolicy(approval) {
-	if (!isRecord$1(approval)) return false;
+	if (!isRecord$3(approval)) return false;
 	const require = approval.require;
 	if (require === true) return true;
 	return Array.isArray(require) && require.length > 0;
@@ -18900,8 +18913,8 @@ function isEffectiveApprovalPolicy(approval) {
 * Applied to every step type, not just prompt, because step configs are stored JSONB read without re-parsing.
 */
 function configRequiresApproval(config) {
-	if (!isRecord$1(config)) return false;
-	return isEffectiveApprovalPolicy((isRecord$1(config.tools) ? config.tools : void 0)?.approval);
+	if (!isRecord$3(config)) return false;
+	return isEffectiveApprovalPolicy((isRecord$3(config.tools) ? config.tools : void 0)?.approval);
 }
 /**
 * System-scope variables (`_flow`, `_user`, `_execution`, `_record`) carry
@@ -18984,7 +18997,7 @@ for (const snakeKey of Object.keys(SNAKE_CASE_TOOL_KEYS)) if (!(snakeToCamel(sna
 */
 const LEGACY_TOOL_KEY_SUGGESTIONS = { builtinTools: "toolIds" };
 /** Alias of the canonical `isRecord` guard, kept for existing flow-validator consumers. */
-const isObjectRecord$1 = isRecord$1;
+const isObjectRecord$1 = isRecord$3;
 /**
 * Sandbox providers that are network-isolated (fail-closed on egress) by default.
 * runtype-sandbox/cloudflare-sandbox included: DO egress treats unset network-access as 'off' (post-Fable handoff 05 F1).
@@ -21336,7 +21349,7 @@ function validateCodeModeConfig(value, stepTools, stepIndex, stepRef) {
 function validateCustomToolEgress(tools, stepIndex, stepRef, buckets) {
 	if (!Array.isArray(tools.runtimeTools)) return;
 	tools.runtimeTools.forEach((tool, toolIndex) => {
-		if (!isRecord$1(tool) || tool.toolType !== "custom") return;
+		if (!isRecord$3(tool) || tool.toolType !== "custom") return;
 		const toolName = typeof tool.name === "string" ? tool.name : `#${toolIndex}`;
 		for (const issue of collectCustomToolEgressIssues(tool.config)) addIssue("error", {
 			code: issue.code,
@@ -21740,18 +21753,6 @@ function extractSecretReferencesFromAnyValue(value, maxDepth = 10) {
 	}
 }
 Math.ceil(26214400 * (4 / 3)) + 16;
-/**
-* The normalizer names the ingest records, restated here because `@runtypelabs/shared` cannot import
-* `@runtypelabs/execution-ingest`. Pinned against the ingest's own constants by
-* `apps/api/tests/connect-agent-framework-producers.test.ts`.
-*/
-const TRACE_NORMALIZER_NAMES = {
-	flue: "runtype-ingest/flue-normalizer",
-	openInference: "runtype-ingest/openinference-normalizer",
-	aiSdk: "runtype-ingest/ai-sdk-normalizer",
-	cloudflareAgents: "runtype-ingest/cloudflare-agents-normalizer"
-};
-TRACE_NORMALIZER_NAMES.flue, TRACE_NORMALIZER_NAMES.aiSdk, TRACE_NORMALIZER_NAMES.openInference, TRACE_NORMALIZER_NAMES.openInference;
 Object.freeze([
 	Object.freeze({
 		id: "overview",
@@ -23791,7 +23792,7 @@ function appendForwardedCoreIssues(flow, base, result) {
 	const coreResult = validateFlowStructure(parsed.data);
 	const push = (issue, severity) => {
 		if (!FORWARDED_CORE_CODES.has(issue.code)) return;
-		(severity === "error" ? result.errors : result.warnings).push(createIssue(severity, issue.code, issue.message, reprefixCorePath(issue.path, base), void 0, isRecord$1(issue.details) ? issue.details : void 0));
+		(severity === "error" ? result.errors : result.warnings).push(createIssue(severity, issue.code, issue.message, reprefixCorePath(issue.path, base), void 0, isRecord$3(issue.details) ? issue.details : void 0));
 	};
 	for (const issue of coreResult.errors) push(issue, "error");
 	for (const issue of coreResult.warnings) push(issue, "warning");
@@ -24143,37 +24144,37 @@ const CONDITIONAL_BRANCH_STEP_KEYS = [
 function scanRuntimeTools(tools, acc, depth) {
 	if (depth > 10 || !Array.isArray(tools)) return;
 	for (const tool of tools) {
-		if (!isRecord$1(tool) || tool.enabled === false) continue;
+		if (!isRecord$3(tool) || tool.enabled === false) continue;
 		if (isClientExecutedToolType(tool.toolType)) acc.hasClientExecutedTools = true;
-		const config = isRecord$1(tool.config) ? tool.config : void 0;
+		const config = isRecord$3(tool.config) ? tool.config : void 0;
 		if (!config) continue;
 		if (config.elicit !== void 0 && depth > 0) acc.hasUnsupportedToolInput = true;
-		if (isRecord$1(config.flow)) scanSteps(config.flow.steps, acc, depth + 1);
-		const inlineAgent = isRecord$1(config.agent) ? config.agent : isRecord$1(config.subAgent) ? config.subAgent : void 0;
+		if (isRecord$3(config.flow)) scanSteps(config.flow.steps, acc, depth + 1);
+		const inlineAgent = isRecord$3(config.agent) ? config.agent : isRecord$3(config.subAgent) ? config.subAgent : void 0;
 		if (inlineAgent) scanAgentDefinition(inlineAgent, acc, depth + 1);
 	}
 }
 function scanToolsBlock(tools, acc, depth) {
-	if (!isRecord$1(tools)) return;
+	if (!isRecord$3(tools)) return;
 	scanRuntimeTools(tools.runtimeTools, acc, depth);
 }
 function scanSteps(steps, acc, depth) {
 	if (depth > 10 || !Array.isArray(steps)) return;
 	for (const step of steps) {
-		if (!isRecord$1(step) || step.enabled === false) continue;
+		if (!isRecord$3(step) || step.enabled === false) continue;
 		if (typeof step.type === "string") acc.stepTypes.add(step.type);
-		const config = isRecord$1(step.config) ? step.config : void 0;
+		const config = isRecord$3(step.config) ? step.config : void 0;
 		if (!config) continue;
 		scanToolsBlock(config.tools, acc, depth);
 		scanSteps(config.steps, acc, depth + 1);
 		for (const key of CONDITIONAL_BRANCH_STEP_KEYS) scanSteps(config[key], acc, depth + 1);
 		if (!Array.isArray(config.branches)) continue;
-		for (const branch of config.branches) if (isRecord$1(branch)) scanSteps(branch.steps, acc, depth + 1);
+		for (const branch of config.branches) if (isRecord$3(branch)) scanSteps(branch.steps, acc, depth + 1);
 	}
 }
 /** Read the tools block from either supported inline FPO agent shape. */
 function agentToolsBlock(agent) {
-	if (isRecord$1(agent.config)) return agent.config.tools;
+	if (isRecord$3(agent.config)) return agent.config.tools;
 	return agent.toolsConfig;
 }
 function scanAgentDefinition(agent, acc, depth) {
@@ -24181,9 +24182,9 @@ function scanAgentDefinition(agent, acc, depth) {
 	scanToolsBlock(agentToolsBlock(agent), acc, depth);
 	if (!Array.isArray(agent.capabilities)) return;
 	for (const capability of agent.capabilities) {
-		if (!isRecord$1(capability)) continue;
-		if (isRecord$1(capability.flow)) scanSteps(capability.flow.steps, acc, depth + 1);
-		if (isRecord$1(capability.subAgent)) scanAgentDefinition(capability.subAgent, acc, depth + 1);
+		if (!isRecord$3(capability)) continue;
+		if (isRecord$3(capability.flow)) scanSteps(capability.flow.steps, acc, depth + 1);
+		if (isRecord$3(capability.subAgent)) scanAgentDefinition(capability.subAgent, acc, depth + 1);
 	}
 }
 /**
@@ -24194,10 +24195,10 @@ function scanAgentDefinition(agent, acc, depth) {
 function referencedCapabilityIds(agent) {
 	const ids = [];
 	if (Array.isArray(agent.capabilityToolRefs)) {
-		for (const ref of agent.capabilityToolRefs) if (isRecord$1(ref) && typeof ref.capabilityId === "string") ids.push(ref.capabilityId);
+		for (const ref of agent.capabilityToolRefs) if (isRecord$3(ref) && typeof ref.capabilityId === "string") ids.push(ref.capabilityId);
 	}
 	const tools = agentToolsBlock(agent);
-	const toolIds = isRecord$1(tools) ? tools.toolIds : void 0;
+	const toolIds = isRecord$3(tools) ? tools.toolIds : void 0;
 	if (Array.isArray(toolIds)) {
 		for (const toolId of toolIds) if (typeof toolId === "string" && toolId.startsWith("capability:")) ids.push(toolId.slice(11));
 	}
@@ -24209,8 +24210,8 @@ function scanCapability(capabilityId, capabilities, acc, visited, nested = false
 	visited.add(visitKey);
 	const capability = capabilities.get(capabilityId);
 	if (!capability) return;
-	if (isRecord$1(capability.flow)) scanSteps(capability.flow.steps, acc, nested ? 1 : 0);
-	if (!isRecord$1(capability.agent)) return;
+	if (isRecord$3(capability.flow)) scanSteps(capability.flow.steps, acc, nested ? 1 : 0);
+	if (!isRecord$3(capability.agent)) return;
 	scanAgentDefinition(capability.agent, acc, 0);
 	for (const ref of referencedCapabilityIds(capability.agent)) scanCapability(ref, capabilities, acc, visited, true);
 }
@@ -24233,7 +24234,7 @@ function agUiServerAuthoredPauseIssues(fpo) {
 	if (surfaces.length === 0) return [];
 	const capabilities = /* @__PURE__ */ new Map();
 	for (const capability of Array.isArray(fpo.capabilities) ? fpo.capabilities : []) {
-		if (!isRecord$1(capability) || typeof capability.id !== "string") continue;
+		if (!isRecord$3(capability) || typeof capability.id !== "string") continue;
 		if (!capabilities.has(capability.id)) capabilities.set(capability.id, capability);
 	}
 	const reasonsByCapability = /* @__PURE__ */ new Map();
@@ -24256,11 +24257,11 @@ function agUiServerAuthoredPauseIssues(fpo) {
 	};
 	const issues = [];
 	for (const [si, surface] of surfaces.entries()) {
-		if (!isRecord$1(surface) || surface.type !== "ag-ui") continue;
+		if (!isRecord$3(surface) || surface.type !== "ag-ui") continue;
 		const surfaceName = typeof surface.name === "string" ? surface.name : "ag-ui";
 		const routes = Array.isArray(surface.routes) ? surface.routes : [];
 		for (const [ri, route] of routes.entries()) {
-			if (!isRecord$1(route) || typeof route.capabilityId !== "string") continue;
+			if (!isRecord$3(route) || typeof route.capabilityId !== "string") continue;
 			const reasons = reasonsFor(route.capabilityId);
 			if (reasons.length === 0) continue;
 			issues.push(createIssue("warning", AG_UI_SERVER_AUTHORED_PAUSE_CODE, pauseMessage(surfaceName, route.capabilityId, reasons), `surfaces[${si}].routes[${ri}].capabilityId`, suggestedFixFor(reasons), { reasons }));
@@ -26040,7 +26041,7 @@ const MANAGED_DEPLOYMENT_STATUSES = [
 ];
 const managedDeploymentEnvironmentSchema = _enum(MANAGED_SANDBOX_ENVIRONMENTS);
 const managedSandboxCapabilitySchema = _enum(MANAGED_SANDBOX_CAPABILITIES);
-const identifierSchema = string().min(1).max(200);
+const identifierSchema$1 = string().min(1).max(200);
 const sha256HexSchema = string().regex(/^[0-9a-f]{64}$/, "expected a lowercase hex SHA-256 digest");
 /**
 * The complete profile identity persisted with a deployment, repeating the
@@ -26048,11 +26049,11 @@ const sha256HexSchema = string().regex(/^[0-9a-f]{64}$/, "expected a lowercase h
 * stored fewer could be admitted against a drifted profile.
 */
 const managedSandboxProfileIdentitySchema = object({
-	providerId: identifierSchema,
-	profileId: identifierSchema,
-	sdkVersion: identifierSchema,
-	runtimeClass: identifierSchema,
-	accountTier: identifierSchema,
+	providerId: identifierSchema$1,
+	profileId: identifierSchema$1,
+	sdkVersion: identifierSchema$1,
+	runtimeClass: identifierSchema$1,
+	accountTier: identifierSchema$1,
 	environment: managedDeploymentEnvironmentSchema
 }).strict();
 /**
@@ -26061,10 +26062,10 @@ const managedSandboxProfileIdentitySchema = object({
 */
 const managedDeploymentCredentialAuthoritySchema = discriminatedUnion("kind", [object({
 	kind: literal("organization-connection"),
-	connectionId: identifierSchema
+	connectionId: identifierSchema$1
 }).strict(), object({
 	kind: literal("platform-managed"),
-	providerPolicyId: identifierSchema
+	providerPolicyId: identifierSchema$1
 }).strict()]);
 const managedDeploymentAvailabilitySchema = _enum(["on-demand", "warm"]);
 const managedDeploymentRestartPolicySchema = _enum([
@@ -26082,11 +26083,11 @@ const managedDeploymentHealthSchema = discriminatedUnion("kind", [object({ kind:
 	expectedStatus: number$1().int().min(100).max(599)
 }).strict()]);
 const managedDeploymentSourceRefSchema = object({
-	sourceAssetId: identifierSchema,
+	sourceAssetId: identifierSchema$1,
 	sourceHash: sha256HexSchema
 }).strict();
 const managedDeploymentRuntimeProfileRefSchema = object({
-	runtimeProfileId: identifierSchema,
+	runtimeProfileId: identifierSchema$1,
 	runtimeProfileDigest: sha256HexSchema
 }).strict();
 object({
@@ -26110,7 +26111,7 @@ object({
 		restartPolicy: managedDeploymentRestartPolicySchema,
 		ingress: managedDeploymentIngressSchema,
 		health: managedDeploymentHealthSchema,
-		networkPolicyRef: identifierSchema
+		networkPolicyRef: identifierSchema$1
 	}).strict(),
 	displayName: string().min(1).max(200).optional()
 }).strict();
@@ -26508,7 +26509,7 @@ function createConf(encryptionKey) {
 		cwd: CREDENTIALS_DIR
 	});
 }
-function isCorruptStoreError(error) {
+function isCorruptStoreError$1(error) {
 	if (error instanceof SyntaxError) return true;
 	const message = error instanceof Error ? error.message : String(error);
 	return typeof message === "string" && message.includes("JSON");
@@ -26521,9 +26522,9 @@ var CredentialStore = class {
 		try {
 			this.config = createConf(this.encryptionKey);
 		} catch (error) {
-			if (isCorruptStoreError(error)) {
+			if (isCorruptStoreError$1(error)) {
 				try {
-					if (fs.existsSync(CREDENTIALS_PATH)) fs.unlinkSync(CREDENTIALS_PATH);
+					if (fs$1.existsSync(CREDENTIALS_PATH)) fs$1.unlinkSync(CREDENTIALS_PATH);
 				} catch {}
 				this.config = createConf(this.encryptionKey);
 			} else throw error;
@@ -32020,7 +32021,7 @@ function formatToolMetadata(metadata) {
 	if (!metadata || Object.keys(metadata).length === 0) return void 0;
 	const { judgment, ...rest } = metadata;
 	const parts = [];
-	if (isRecord$1(judgment)) {
+	if (isRecord$3(judgment)) {
 		const model = judgment.resolvedModelId ?? judgment.requestedModel ?? "unknown";
 		const cost = typeof judgment.estimatedCostUsd === "number" ? `$${judgment.estimatedCostUsd.toFixed(6)}` : "unknown";
 		parts.push(`judgment: model ${String(model)}, key source ${String(judgment.keySource ?? "unknown")}, estimated cost ${cost}`);
@@ -37646,7 +37647,7 @@ function applyMaxLines(raw, maxLines) {
 function readFileContent(filePath, snapshots, liveTools, maxLines = 5e3) {
 	try {
 		return {
-			...applyMaxLines(fs$1.readFileSync(filePath, "utf-8"), maxLines),
+			...applyMaxLines(fs$2.readFileSync(filePath, "utf-8"), maxLines),
 			source: "disk"
 		};
 	} catch {}
@@ -37664,7 +37665,7 @@ function readFileContent(filePath, snapshots, liveTools, maxLines = 5e3) {
 }
 //#endregion
 //#region src/marathon/sandbox.ts
-function isRecord(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseSandboxProvider(value) {
@@ -37844,7 +37845,7 @@ function createSandboxLocalTool(client, provider, debugMode) {
 			};
 			const language = parseSandboxLanguage(provider, args.language);
 			const timeout = parseSandboxTimeout(args.timeoutMs, provider);
-			const parameters = isRecord(args.parameters) ? args.parameters : {};
+			const parameters = isRecord$2(args.parameters) ? args.parameters : {};
 			const gateDecision = evaluateGeneratedRuntimeToolProposal({
 				name: "run_sandbox_code",
 				description: `Execute code in ${provider}`,
@@ -38176,14 +38177,14 @@ function createEventLogWriter(stateFilePath, initialSessionIndex) {
 	let stream = null;
 	function ensureDir() {
 		if (!dirCreated) {
-			fs$1.mkdirSync(eventsDir, { recursive: true });
+			fs$2.mkdirSync(eventsDir, { recursive: true });
 			dirCreated = true;
 		}
 	}
 	function ensureStream() {
 		if (!stream || stream.destroyed) {
 			ensureDir();
-			stream = fs$1.createWriteStream(currentPath, { flags: "a" });
+			stream = fs$2.createWriteStream(currentPath, { flags: "a" });
 			stream.on("error", () => {});
 		}
 	}
@@ -38212,8 +38213,8 @@ function createEventLogWriter(stateFilePath, initialSessionIndex) {
 *  Returns an empty array if the file doesn't exist. */
 function readSessionEventLog(stateFilePath, sessionIndex) {
 	const logPath = sessionEventLogPath(stateFilePath, sessionIndex);
-	if (!fs$1.existsSync(logPath)) return [];
-	const content = fs$1.readFileSync(logPath, "utf-8");
+	if (!fs$2.existsSync(logPath)) return [];
+	const content = fs$2.readFileSync(logPath, "utf-8");
 	const events = [];
 	for (const line of content.split("\n")) {
 		if (!line.trim()) continue;
@@ -38248,7 +38249,7 @@ function isTreeLogEntry(value) {
 function loadTreeLog(filePath) {
 	let raw;
 	try {
-		raw = fs$1.readFileSync(filePath, "utf-8");
+		raw = fs$2.readFileSync(filePath, "utf-8");
 	} catch {
 		return null;
 	}
@@ -38285,8 +38286,8 @@ function loadTreeLog(filePath) {
 	};
 }
 function appendLine(log, entry) {
-	fs$1.mkdirSync(path$2.dirname(log.filePath), { recursive: true });
-	fs$1.appendFileSync(log.filePath, JSON.stringify(entry) + "\n");
+	fs$2.mkdirSync(path$2.dirname(log.filePath), { recursive: true });
+	fs$2.appendFileSync(log.filePath, JSON.stringify(entry) + "\n");
 	log.entries.push(entry);
 	if (entry.type !== "head") {
 		log.byId.set(entry.id, entry);
@@ -41427,7 +41428,7 @@ function MarathonApp({ taskName, agentId, model, sandbox, goal, initialSessionCo
 		setShowSessionMenu(false);
 		try {
 			let json;
-			if (stateFilePath && fs$1.existsSync(stateFilePath)) json = fs$1.readFileSync(stateFilePath, "utf-8");
+			if (stateFilePath && fs$2.existsSync(stateFilePath)) json = fs$2.readFileSync(stateFilePath, "utf-8");
 			else json = JSON.stringify({
 				sessionSnapshots,
 				content: state.content,
@@ -41450,8 +41451,8 @@ function MarathonApp({ taskName, agentId, model, sandbox, goal, initialSessionCo
 		setShowSessionMenu(false);
 		try {
 			let json;
-			if (stateFilePath && fs$1.existsSync(stateFilePath)) {
-				const raw = fs$1.readFileSync(stateFilePath, "utf-8");
+			if (stateFilePath && fs$2.existsSync(stateFilePath)) {
+				const raw = fs$2.readFileSync(stateFilePath, "utf-8");
 				const parsed = JSON.parse(raw);
 				json = JSON.stringify(compactMarathonStateJsonForContextExport(parsed), null, 2);
 			} else {
@@ -41477,7 +41478,7 @@ function MarathonApp({ taskName, agentId, model, sandbox, goal, initialSessionCo
 	]);
 	const handleOpenStateFile = useCallback(() => {
 		setShowSessionMenu(false);
-		if (stateFilePath && fs$1.existsSync(stateFilePath)) {
+		if (stateFilePath && fs$2.existsSync(stateFilePath)) {
 			open(stateFilePath);
 			showFlash("Opening state file...");
 		} else showFlash("No state file yet");
@@ -41872,7 +41873,7 @@ function MarathonApp({ taskName, agentId, model, sandbox, goal, initialSessionCo
 			const file = detailFile ?? trackedFiles[fileCursor];
 			if (file) {
 				const filePath = path$2.resolve(file.path);
-				if (fs$1.existsSync(filePath)) {
+				if (fs$2.existsSync(filePath)) {
 					open(filePath);
 					showFlash(`Opening ${file.path}`);
 				} else showFlash("File not found on disk");
@@ -42387,7 +42388,7 @@ function MarathonApp({ taskName, agentId, model, sandbox, goal, initialSessionCo
 					onOpenDashboard: handleOpenDashboard,
 					onClose: () => setShowSessionMenu(false),
 					hasDashboard: !!agentPageUrl,
-					hasStateFile: !!stateFilePath && fs$1.existsSync(stateFilePath)
+					hasStateFile: !!stateFilePath && fs$2.existsSync(stateFilePath)
 				})
 			}),
 			showUpgradeModal && upgradePrompt && /* @__PURE__ */ jsx(Box, {
@@ -42939,9 +42940,9 @@ function getProjectStateDir(projectDir) {
 	const hash = crypto$2.createHash("sha256").update(dir).digest("hex").slice(0, 12);
 	const stateDir = path$2.join(getRuntypeHomeDir(), "projects", hash);
 	const breadcrumb = path$2.join(stateDir, "project-path.txt");
-	if (!fs$1.existsSync(breadcrumb)) {
-		fs$1.mkdirSync(stateDir, { recursive: true });
-		fs$1.writeFileSync(breadcrumb, dir);
+	if (!fs$2.existsSync(breadcrumb)) {
+		fs$2.mkdirSync(stateDir, { recursive: true });
+		fs$2.writeFileSync(breadcrumb, dir);
 	}
 	return stateDir;
 }
@@ -42970,14 +42971,14 @@ function ensureMarathonFileCheckpoint(taskName, targetPath, stateDir, stateFileP
 	const normalizedTargetPath = path$2.resolve(targetPath);
 	const relativeTargetPath = path$2.relative(process.cwd(), normalizedTargetPath);
 	if (!relativeTargetPath || relativeTargetPath.startsWith("..")) return void 0;
-	if (!fs$1.existsSync(normalizedTargetPath)) return void 0;
-	if (!fs$1.statSync(normalizedTargetPath).isFile()) return void 0;
+	if (!fs$2.existsSync(normalizedTargetPath)) return void 0;
+	if (!fs$2.statSync(normalizedTargetPath).isFile()) return void 0;
 	if (relativeTargetPath.replace(/\\/g, "/").startsWith(".runtype/")) return void 0;
 	if (normalizedTargetPath.startsWith(getRuntypeHomeDir() + path$2.sep)) return void 0;
 	const checkpointPath = resolveMarathonCheckpointPath(taskName, normalizedTargetPath, stateDir, stateFilePath);
-	if (fs$1.existsSync(checkpointPath)) return checkpointPath;
-	fs$1.mkdirSync(path$2.dirname(checkpointPath), { recursive: true });
-	fs$1.copyFileSync(normalizedTargetPath, checkpointPath);
+	if (fs$2.existsSync(checkpointPath)) return checkpointPath;
+	fs$2.mkdirSync(path$2.dirname(checkpointPath), { recursive: true });
+	fs$2.copyFileSync(normalizedTargetPath, checkpointPath);
 	return checkpointPath;
 }
 function restoreMarathonFileCheckpoint(taskName, targetPath, stateDir, stateFilePath) {
@@ -42988,13 +42989,13 @@ function restoreMarathonFileCheckpoint(taskName, targetPath, stateDir, stateFile
 		error: `Cannot restore checkpoint outside the current repository: ${normalizedTargetPath}`
 	};
 	const checkpointPath = resolveMarathonCheckpointPath(taskName, normalizedTargetPath, stateDir, stateFilePath);
-	if (!fs$1.existsSync(checkpointPath)) return {
+	if (!fs$2.existsSync(checkpointPath)) return {
 		restored: false,
 		checkpointPath,
 		error: `No checkpoint found for ${normalizedTargetPath}`
 	};
-	fs$1.mkdirSync(path$2.dirname(normalizedTargetPath), { recursive: true });
-	fs$1.copyFileSync(checkpointPath, normalizedTargetPath);
+	fs$2.mkdirSync(path$2.dirname(normalizedTargetPath), { recursive: true });
+	fs$2.copyFileSync(checkpointPath, normalizedTargetPath);
 	return {
 		restored: true,
 		checkpointPath
@@ -43524,7 +43525,7 @@ function normalizeMarathonStatePath(candidatePath) {
 }
 function marathonStatePathExists(candidatePath) {
 	if (!candidatePath) return false;
-	return fs$1.existsSync(path$2.resolve(candidatePath));
+	return fs$2.existsSync(path$2.resolve(candidatePath));
 }
 function isMarathonArtifactStatePath(candidatePath) {
 	if (!candidatePath) return false;
@@ -43685,7 +43686,7 @@ function sanitizeLoadedMarathonState(state) {
 }
 function loadState(filePath) {
 	try {
-		const raw = fs$1.readFileSync(filePath, "utf-8");
+		const raw = fs$2.readFileSync(filePath, "utf-8");
 		return sanitizeLoadedMarathonState(JSON.parse(raw));
 	} catch {
 		return null;
@@ -43693,7 +43694,7 @@ function loadState(filePath) {
 }
 function saveState(filePath, state, options) {
 	const dir = path$2.dirname(filePath);
-	fs$1.mkdirSync(dir, { recursive: true });
+	fs$2.mkdirSync(dir, { recursive: true });
 	const stateToWrite = options?.stripSnapshotEvents && state.sessionSnapshots?.length ? {
 		...state,
 		sessionSnapshots: state.sessionSnapshots.map((snapshot) => ({
@@ -43701,7 +43702,7 @@ function saveState(filePath, state, options) {
 			rawEvents: []
 		}))
 	} : state;
-	fs$1.writeFileSync(filePath, JSON.stringify(stateToWrite, null, 2));
+	fs$2.writeFileSync(filePath, JSON.stringify(stateToWrite, null, 2));
 	syncTreeLogWithState(filePath, state);
 }
 function extractRunTaskResumeState(state) {
@@ -43747,11 +43748,11 @@ function offsetNewContextCompactionSummaries(summaries, existingSummaryIds, sess
 function findStateFile(name, stateDir) {
 	if (stateDir) return stateFilePath(name, stateDir);
 	const homePath = stateFilePath(name, getMarathonStateDir());
-	if (fs$1.existsSync(homePath)) return homePath;
+	if (fs$2.existsSync(homePath)) return homePath;
 	const oldMarathonPath = stateFilePath(name, path$2.join(process.cwd(), ".runtype", "marathons"));
-	if (fs$1.existsSync(oldMarathonPath)) return oldMarathonPath;
+	if (fs$2.existsSync(oldMarathonPath)) return oldMarathonPath;
 	const oldTaskPath = stateFilePath(name, path$2.join(process.cwd(), ".runtype", "tasks"));
-	if (fs$1.existsSync(oldTaskPath)) return oldTaskPath;
+	if (fs$2.existsSync(oldTaskPath)) return oldTaskPath;
 	return homePath;
 }
 function findLatestStateFile(stateDir) {
@@ -43762,11 +43763,11 @@ function findLatestStateFile(stateDir) {
 	];
 	let latest = null;
 	for (const dir of dirs) {
-		if (!fs$1.existsSync(dir)) continue;
-		const files = fs$1.readdirSync(dir).filter((f) => f.endsWith(".json"));
+		if (!fs$2.existsSync(dir)) continue;
+		const files = fs$2.readdirSync(dir).filter((f) => f.endsWith(".json"));
 		for (const file of files) {
 			const fullPath = path$2.join(dir, file);
-			const stat = fs$1.statSync(fullPath);
+			const stat = fs$2.statSync(fullPath);
 			if (!latest || stat.mtimeMs > latest.mtime) latest = {
 				name: file.replace(".json", ""),
 				filePath: fullPath,
@@ -43850,7 +43851,7 @@ async function resolveMarathonStateResolution(options, taskName, filePath, promp
 		};
 	}
 	if (options.fresh) return { action: "fresh" };
-	if (!fs$1.existsSync(filePath)) return { action: "fresh" };
+	if (!fs$2.existsSync(filePath)) return { action: "fresh" };
 	if (!allowPrompt) throw new Error(`Local marathon state already exists at ${filePath}. Use --resume to continue it or --fresh to start over.`);
 	const choice = await promptForChoice({
 		reason: "existing-state",
@@ -44130,9 +44131,9 @@ function shouldIgnoreRepoEntry(entryPath) {
 function safeReadTextFile(filePath) {
 	try {
 		if (isSensitivePath(normalizeToolPath(filePath).replace(/\\/g, "/"))) return null;
-		const stat = fs$1.statSync(filePath);
+		const stat = fs$2.statSync(filePath);
 		if (!stat.isFile() || stat.size > 1048576) return null;
-		const buffer = fs$1.readFileSync(filePath);
+		const buffer = fs$2.readFileSync(filePath);
 		if (buffer.includes(0)) return null;
 		return buffer.toString("utf-8");
 	} catch {
@@ -44140,14 +44141,14 @@ function safeReadTextFile(filePath) {
 	}
 }
 function walkRepo(startPath, visitor) {
-	if (!fs$1.existsSync(startPath) || !fs$1.statSync(startPath).isDirectory()) return;
+	if (!fs$2.existsSync(startPath) || !fs$2.statSync(startPath).isDirectory()) return;
 	const stack = [startPath];
 	while (stack.length > 0) {
 		const currentDir = stack.pop();
 		if (!currentDir) continue;
 		let entries;
 		try {
-			entries = fs$1.readdirSync(currentDir, { withFileTypes: true });
+			entries = fs$2.readdirSync(currentDir, { withFileTypes: true });
 		} catch {
 			continue;
 		}
@@ -44187,7 +44188,7 @@ function buildTree(dirPath, maxDepth, depth = 0) {
 	if (depth > maxDepth || shouldIgnoreRepoEntry(dirPath)) return [];
 	let entries;
 	try {
-		entries = fs$1.readdirSync(dirPath, { withFileTypes: true });
+		entries = fs$2.readdirSync(dirPath, { withFileTypes: true });
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		return [`${"  ".repeat(depth)}[error reading ${normalizeToolPath(dirPath)}: ${message}]`];
@@ -44224,8 +44225,8 @@ function resolveCanonicalToolPath(toolPath, allowMissing) {
 	let remainingSegments = absolutePath.slice(canonicalPath.length).split(path$2.sep);
 	let symlinksFollowed = 0;
 	try {
-		if (fs$1.existsSync(absolutePath)) return {
-			canonicalPath: fs$1.realpathSync.native(absolutePath),
+		if (fs$2.existsSync(absolutePath)) return {
+			canonicalPath: fs$2.realpathSync.native(absolutePath),
 			exists: true
 		};
 		if (!allowMissing) return null;
@@ -44237,25 +44238,25 @@ function resolveCanonicalToolPath(toolPath, allowMissing) {
 				continue;
 			}
 			const candidatePath = path$2.join(canonicalPath, segment);
-			const entry = fs$1.lstatSync(candidatePath, { throwIfNoEntry: false });
+			const entry = fs$2.lstatSync(candidatePath, { throwIfNoEntry: false });
 			if (!entry) {
 				canonicalPath = candidatePath;
 				continue;
 			}
 			if (entry.isSymbolicLink()) {
 				if (++symlinksFollowed > MAX_TOOL_PATH_SYMLINKS) return null;
-				const target = fs$1.readlinkSync(candidatePath);
+				const target = fs$2.readlinkSync(candidatePath);
 				const targetRoot = path$2.isAbsolute(target) ? path$2.parse(target).root : "";
 				if (targetRoot) canonicalPath = targetRoot;
 				remainingSegments = [...target.slice(targetRoot.length).split(path$2.sep), ...remainingSegments];
 				continue;
 			}
 			if (remainingSegments.length > 0 && !entry.isDirectory()) return null;
-			canonicalPath = fs$1.realpathSync.native(candidatePath);
+			canonicalPath = fs$2.realpathSync.native(candidatePath);
 		}
 		return {
 			canonicalPath,
-			exists: fs$1.existsSync(canonicalPath)
+			exists: fs$2.existsSync(canonicalPath)
 		};
 	} catch {
 		return null;
@@ -44281,7 +44282,7 @@ function resolveToolPath(toolPath, options = {}) {
 		ok: false,
 		error: `Path does not exist: ${requestedPath}`
 	};
-	const workspaceRoot = fs$1.realpathSync.native(process.cwd());
+	const workspaceRoot = fs$2.realpathSync.native(process.cwd());
 	const extraRoots = (options.allowedRoots || []).map((rootPath) => canonicalizeAllowedRoot(rootPath));
 	const matchedRoot = [...extraRoots, workspaceRoot].find((rootPath) => isPathWithinRoot(resolved.canonicalPath, rootPath));
 	if (!matchedRoot) return {
@@ -44302,7 +44303,7 @@ function resolveToolPath(toolPath, options = {}) {
 		}
 	}
 	if (resolved.exists) {
-		const stat = fs$1.statSync(resolved.canonicalPath);
+		const stat = fs$2.statSync(resolved.canonicalPath);
 		if (options.requireFile && !stat.isFile()) return {
 			ok: false,
 			error: `Path is not a file: ${requestedPath}`
@@ -44350,7 +44351,7 @@ function createDefaultLocalTools(context) {
 					allowedRoots: allowedReadRoots
 				});
 				if (!resolvedPath.ok) return `Error: ${resolvedPath.error}`;
-				return fs$1.readFileSync(resolvedPath.resolvedPath, "utf-8");
+				return fs$2.readFileSync(resolvedPath.resolvedPath, "utf-8");
 			}
 		},
 		write_file: {
@@ -44373,10 +44374,10 @@ function createDefaultLocalTools(context) {
 				const resolvedPath = resolveToolPath(String(args.path || ""), { allowMissing: true });
 				if (!resolvedPath.ok) return `Error: ${resolvedPath.error}`;
 				const content = String(args.content || "");
-				if (fs$1.existsSync(resolvedPath.resolvedPath) && fs$1.statSync(resolvedPath.resolvedPath).isDirectory()) return `Error: Path is a directory: ${String(args.path || "")}`;
+				if (fs$2.existsSync(resolvedPath.resolvedPath) && fs$2.statSync(resolvedPath.resolvedPath).isDirectory()) return `Error: Path is a directory: ${String(args.path || "")}`;
 				const dir = path$2.dirname(resolvedPath.resolvedPath);
-				fs$1.mkdirSync(dir, { recursive: true });
-				fs$1.writeFileSync(resolvedPath.resolvedPath, content);
+				fs$2.mkdirSync(dir, { recursive: true });
+				fs$2.writeFileSync(resolvedPath.resolvedPath, content);
 				return "ok";
 			}
 		},
@@ -44392,7 +44393,7 @@ function createDefaultLocalTools(context) {
 			execute: async (args) => {
 				const resolvedPath = resolveToolPath(String(args.path || "."), { requireDirectory: true });
 				if (!resolvedPath.ok) return `Error: ${resolvedPath.error}`;
-				return fs$1.readdirSync(resolvedPath.resolvedPath, { withFileTypes: true }).filter((entry) => !shouldIgnoreRepoEntry(path$2.join(resolvedPath.resolvedPath, entry.name))).map((entry) => entry.name).join("\n");
+				return fs$2.readdirSync(resolvedPath.resolvedPath, { withFileTypes: true }).filter((entry) => !shouldIgnoreRepoEntry(path$2.join(resolvedPath.resolvedPath, entry.name))).map((entry) => entry.name).join("\n");
 			}
 		},
 		search_repo: {
@@ -44556,8 +44557,8 @@ function createCheckpointedWriteFileTool(taskName, stateDir, planPath, stateFile
 			const content = String(args.content || "");
 			ensureMarathonFileCheckpoint(taskName, resolvedPath.resolvedPath, stateDir, stateFilePath);
 			const dir = path$2.dirname(resolvedPath.resolvedPath);
-			fs$1.mkdirSync(dir, { recursive: true });
-			fs$1.writeFileSync(resolvedPath.resolvedPath, content);
+			fs$2.mkdirSync(dir, { recursive: true });
+			fs$2.writeFileSync(resolvedPath.resolvedPath, content);
 			const ext = path$2.extname(resolvedPath.resolvedPath).toLowerCase();
 			if (ext === ".js" || ext === ".jsx") {
 				const syntaxError = quickJsSyntaxCheck(content);
@@ -44633,7 +44634,7 @@ function createEditFileTool(taskName, stateDir, planPath, stateFilePath) {
 			if (oldString === newString) return "Error: old_string and new_string are identical";
 			let content;
 			try {
-				content = fs$1.readFileSync(resolvedPath.resolvedPath, "utf-8");
+				content = fs$2.readFileSync(resolvedPath.resolvedPath, "utf-8");
 			} catch {
 				return `Error: Could not read file: ${String(args.path || "")}`;
 			}
@@ -44644,7 +44645,7 @@ function createEditFileTool(taskName, stateDir, planPath, stateFilePath) {
 			}
 			ensureMarathonFileCheckpoint(taskName, resolvedPath.resolvedPath, stateDir, stateFilePath);
 			const updated = replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
-			fs$1.writeFileSync(resolvedPath.resolvedPath, updated);
+			fs$2.writeFileSync(resolvedPath.resolvedPath, updated);
 			const ext = path$2.extname(resolvedPath.resolvedPath).toLowerCase();
 			if (ext === ".js" || ext === ".jsx") {
 				const syntaxError = quickJsSyntaxCheck(updated);
@@ -44696,13 +44697,13 @@ function createReadOffloadedOutputTool(taskName, stateDir, stateFilePath) {
 			};
 			const idEmbeddedSha256 = /^art_([0-9a-f]{64})$/.exec(outputId)?.[1];
 			const outputPath = path$2.join(getOffloadedOutputDir(taskName, stateDir, stateFilePath), `${outputId}.txt`);
-			if (!fs$1.existsSync(outputPath) || !fs$1.statSync(outputPath).isFile()) {
+			if (!fs$2.existsSync(outputPath) || !fs$2.statSync(outputPath).isFile()) {
 				const resolvedStateFilePath = getStateFilePathForTask(taskName, stateDir, stateFilePath);
 				const log = loadTreeLog(treeLogPathForStateFile(resolvedStateFilePath));
 				const artifact = log ? findArtifactPayload(log, outputId) : void 0;
 				if (artifact) {
 					const ledgerPath = path$2.resolve(path$2.dirname(treeLogPathForStateFile(resolvedStateFilePath)), artifact.relativePath);
-					if (fs$1.existsSync(ledgerPath) && fs$1.statSync(ledgerPath).isFile()) return verifyContent(fs$1.readFileSync(ledgerPath, "utf-8"), artifact.sha256);
+					if (fs$2.existsSync(ledgerPath) && fs$2.statSync(ledgerPath).isFile()) return verifyContent(fs$2.readFileSync(ledgerPath, "utf-8"), artifact.sha256);
 					return [
 						`Error: offloaded output recorded in the context ledger but missing locally: ${outputId}`,
 						artifact.host ? `Stored on host: ${artifact.host}` : void 0,
@@ -44711,7 +44712,7 @@ function createReadOffloadedOutputTool(taskName, stateDir, stateFilePath) {
 				}
 				return `Error: offloaded output not found: ${outputId}`;
 			}
-			return verifyContent(fs$1.readFileSync(outputPath, "utf-8"), idEmbeddedSha256);
+			return verifyContent(fs$2.readFileSync(outputPath, "utf-8"), idEmbeddedSha256);
 		}
 	};
 }
@@ -44895,7 +44896,7 @@ function resolveLedgerToolResult(tool, stateFilePath, log) {
 	if (!artifact) return result;
 	const artifactPath = path$2.resolve(path$2.dirname(treeLogPathForStateFile(stateFilePath)), artifact.relativePath);
 	try {
-		if (fs$1.existsSync(artifactPath) && fs$1.statSync(artifactPath).isFile()) return fs$1.readFileSync(artifactPath, "utf-8");
+		if (fs$2.existsSync(artifactPath) && fs$2.statSync(artifactPath).isFile()) return fs$2.readFileSync(artifactPath, "utf-8");
 	} catch {}
 	return result;
 }
@@ -45109,8 +45110,8 @@ function offloadToolOutput(taskName, toolName, output, options = {}, stateDir) {
 	const dir = artifactStoreDirForStateFile(stateFilePath);
 	const fileName = `${outputId}.txt`;
 	const filePath = path$2.join(dir, fileName);
-	fs$1.mkdirSync(dir, { recursive: true });
-	if (!fs$1.existsSync(filePath)) fs$1.writeFileSync(filePath, output, "utf-8");
+	fs$2.mkdirSync(dir, { recursive: true });
+	if (!fs$2.existsSync(filePath)) fs$2.writeFileSync(filePath, output, "utf-8");
 	recordOffloadedArtifact({
 		taskName,
 		toolName,
@@ -45260,14 +45261,14 @@ const RULES_DIR = ".marathon/rules";
 function loadRules(cwd) {
 	const baseCwd = cwd || process.cwd();
 	const rulesDir = path$2.resolve(baseCwd, RULES_DIR);
-	if (!fs$1.existsSync(rulesDir)) return [];
+	if (!fs$2.existsSync(rulesDir)) return [];
 	const rules = [];
 	try {
-		const entries = fs$1.readdirSync(rulesDir).filter((f) => f.endsWith(".md"));
+		const entries = fs$2.readdirSync(rulesDir).filter((f) => f.endsWith(".md"));
 		for (const entry of entries) {
 			const filePath = path$2.join(rulesDir, entry);
 			try {
-				const parsed = parseRuleFile(fs$1.readFileSync(filePath, "utf-8"));
+				const parsed = parseRuleFile(fs$2.readFileSync(filePath, "utf-8"));
 				rules.push({
 					...parsed,
 					filePath
@@ -45443,7 +45444,7 @@ async function loadModulePlaybook(filePath) {
 	return config;
 }
 function parsePlaybookFile(filePath) {
-	const raw = fs$1.readFileSync(filePath, "utf-8");
+	const raw = fs$2.readFileSync(filePath, "utf-8");
 	if (path$2.extname(filePath).toLowerCase() === ".json") return JSON.parse(raw);
 	return parse(raw);
 }
@@ -45505,7 +45506,7 @@ async function loadPlaybookPlugins(plugins, playbookFilePath, playbookName) {
 		const resolved = path$2.resolve(baseDir, plugin);
 		if (resolved !== baseDir && !resolved.startsWith(baseDir + path$2.sep)) throw new Error(`Playbook '${playbookName}': plugin "${plugin}" resolves outside the playbook's directory. Keep plugin modules next to the playbook.`);
 		if (!PLUGIN_EXTENSIONS.has(path$2.extname(resolved).toLowerCase())) throw new Error(`Playbook '${playbookName}': plugin "${plugin}" must be a .js, .mjs, or .cjs module.`);
-		if (!fs$1.existsSync(resolved)) throw new Error(`Playbook '${playbookName}': plugin "${plugin}" not found at ${resolved}.`);
+		if (!fs$2.existsSync(resolved)) throw new Error(`Playbook '${playbookName}': plugin "${plugin}" not found at ${resolved}.`);
 		const mod = await import(pathToFileURL(resolved).href);
 		if (typeof mod.default !== "function") throw new Error(`Playbook '${playbookName}': plugin "${plugin}" must export a default function: export default ({ registerWorkflowHook }) => { ... }`);
 		await mod.default({ registerWorkflowHook });
@@ -45538,7 +45539,7 @@ function toWorkflowConfig(config) {
 async function loadPlaybook(nameOrPath, cwd) {
 	const candidates = getCandidatePaths(nameOrPath, cwd || process.cwd());
 	for (const candidate of candidates) {
-		if (!fs$1.existsSync(candidate) || fs$1.statSync(candidate).isDirectory()) continue;
+		if (!fs$2.existsSync(candidate) || fs$2.statSync(candidate).isDirectory()) continue;
 		const ext = path$2.extname(candidate).toLowerCase();
 		const config = MODULE_PLAYBOOK_EXTENSIONS.has(ext) ? await loadModulePlaybook(candidate) : parsePlaybookFile(candidate);
 		validatePlaybook(config, candidate);
@@ -45930,7 +45931,7 @@ async function taskAction(agent, options) {
 			forcedResumeFilePath = stateResolution.filePath;
 		} else {
 			resumeRequested = false;
-			if (options.fresh && fs$1.existsSync(filePath)) {
+			if (options.fresh && fs$2.existsSync(filePath)) {
 				if (useStartupShell) setStartupStatus("starting fresh");
 				else console.log(chalk.gray(`Starting fresh and ignoring saved local state at ${filePath}`));
 			}
@@ -48764,17 +48765,17 @@ const deployCommand = new Command("deploy").description("Export an agent and sca
 		}
 		slugSet.add(slug);
 	}
-	fs$1.mkdirSync(path$2.join(outDir, "agents"), { recursive: true });
-	fs$1.mkdirSync(path$2.join(outDir, "packages"), { recursive: true });
+	fs$2.mkdirSync(path$2.join(outDir, "agents"), { recursive: true });
+	fs$2.mkdirSync(path$2.join(outDir, "packages"), { recursive: true });
 	for (const { name, def } of agentDefs) {
 		const filename = `${slugify(name)}.json`;
-		fs$1.writeFileSync(path$2.join(outDir, "agents", filename), JSON.stringify(def, null, 2));
+		fs$2.writeFileSync(path$2.join(outDir, "agents", filename), JSON.stringify(def, null, 2));
 		console.log(`  Wrote agents/${filename}`);
 	}
 	const agentNames = agentDefs.map((a) => a.name);
 	let monorepoRoot = process.cwd();
 	for (let i = 0; i < 8; i++) {
-		if (fs$1.existsSync(path$2.join(monorepoRoot, "pnpm-workspace.yaml"))) break;
+		if (fs$2.existsSync(path$2.join(monorepoRoot, "pnpm-workspace.yaml"))) break;
 		const parent = path$2.dirname(monorepoRoot);
 		if (parent === monorepoRoot) break;
 		monorepoRoot = parent;
@@ -48790,35 +48791,35 @@ const deployCommand = new Command("deploy").description("Export an agent and sca
 	const secretNames = Array.from(allSecrets);
 	const optionalSettings = Array.from(allOptionalSettings.values());
 	if (target === "cloudflare") {
-		fs$1.mkdirSync(path$2.join(outDir, "src"), { recursive: true });
-		fs$1.writeFileSync(path$2.join(outDir, "src", "index.ts"), workerIndexTs(agentSlugs));
-		fs$1.writeFileSync(path$2.join(outDir, "wrangler.toml"), wranglerToml(projectName));
-		fs$1.writeFileSync(path$2.join(outDir, "package.json"), workerPackageJson(projectName, "workspace:*"));
-		fs$1.writeFileSync(path$2.join(outDir, "tsconfig.json"), workerTsconfigJson());
+		fs$2.mkdirSync(path$2.join(outDir, "src"), { recursive: true });
+		fs$2.writeFileSync(path$2.join(outDir, "src", "index.ts"), workerIndexTs(agentSlugs));
+		fs$2.writeFileSync(path$2.join(outDir, "wrangler.toml"), wranglerToml(projectName));
+		fs$2.writeFileSync(path$2.join(outDir, "package.json"), workerPackageJson(projectName, "workspace:*"));
+		fs$2.writeFileSync(path$2.join(outDir, "tsconfig.json"), workerTsconfigJson());
 		const setupPath = path$2.join(outDir, "setup.sh");
-		fs$1.writeFileSync(setupPath, workerSetupSh(monorepoRoot));
-		fs$1.chmodSync(setupPath, 493);
-		fs$1.writeFileSync(path$2.join(outDir, "README.md"), workerReadme(agentNames, secretNames, optionalSettings));
+		fs$2.writeFileSync(setupPath, workerSetupSh(monorepoRoot));
+		fs$2.chmodSync(setupPath, 493);
+		fs$2.writeFileSync(path$2.join(outDir, "README.md"), workerReadme(agentNames, secretNames, optionalSettings));
 	} else if (target === "vercel") {
-		fs$1.mkdirSync(path$2.join(outDir, "api"), { recursive: true });
-		fs$1.writeFileSync(path$2.join(outDir, "api", "[[...route]].ts"), vercelRouteTs(agentSlugs));
-		fs$1.writeFileSync(path$2.join(outDir, "vercel.json"), vercelJson());
-		fs$1.writeFileSync(path$2.join(outDir, "package.json"), vercelPackageJson(projectName, "workspace:*"));
-		fs$1.writeFileSync(path$2.join(outDir, "tsconfig.json"), vercelTsconfigJson());
+		fs$2.mkdirSync(path$2.join(outDir, "api"), { recursive: true });
+		fs$2.writeFileSync(path$2.join(outDir, "api", "[[...route]].ts"), vercelRouteTs(agentSlugs));
+		fs$2.writeFileSync(path$2.join(outDir, "vercel.json"), vercelJson());
+		fs$2.writeFileSync(path$2.join(outDir, "package.json"), vercelPackageJson(projectName, "workspace:*"));
+		fs$2.writeFileSync(path$2.join(outDir, "tsconfig.json"), vercelTsconfigJson());
 		const setupPath = path$2.join(outDir, "setup.sh");
-		fs$1.writeFileSync(setupPath, vercelSetupSh(monorepoRoot));
-		fs$1.chmodSync(setupPath, 493);
-		fs$1.writeFileSync(path$2.join(outDir, "README.md"), vercelReadme(agentNames, secretNames, optionalSettings));
+		fs$2.writeFileSync(setupPath, vercelSetupSh(monorepoRoot));
+		fs$2.chmodSync(setupPath, 493);
+		fs$2.writeFileSync(path$2.join(outDir, "README.md"), vercelReadme(agentNames, secretNames, optionalSettings));
 	} else {
-		fs$1.writeFileSync(path$2.join(outDir, "server.ts"), serverTs());
-		fs$1.writeFileSync(path$2.join(outDir, "Dockerfile"), dockerfile());
-		fs$1.writeFileSync(path$2.join(outDir, ".dockerignore"), dockerignore());
-		fs$1.writeFileSync(path$2.join(outDir, "tsconfig.json"), tsconfigJson());
-		fs$1.writeFileSync(path$2.join(outDir, "package.json"), packageJson(projectName, "workspace:*"));
+		fs$2.writeFileSync(path$2.join(outDir, "server.ts"), serverTs());
+		fs$2.writeFileSync(path$2.join(outDir, "Dockerfile"), dockerfile());
+		fs$2.writeFileSync(path$2.join(outDir, ".dockerignore"), dockerignore());
+		fs$2.writeFileSync(path$2.join(outDir, "tsconfig.json"), tsconfigJson());
+		fs$2.writeFileSync(path$2.join(outDir, "package.json"), packageJson(projectName, "workspace:*"));
 		const setupPath = path$2.join(outDir, "setup.sh");
-		fs$1.writeFileSync(setupPath, setupSh(monorepoRoot));
-		fs$1.chmodSync(setupPath, 493);
-		fs$1.writeFileSync(path$2.join(outDir, "README.md"), readme(agentNames, secretNames, optionalSettings));
+		fs$2.writeFileSync(setupPath, setupSh(monorepoRoot));
+		fs$2.chmodSync(setupPath, 493);
+		fs$2.writeFileSync(path$2.join(outDir, "README.md"), readme(agentNames, secretNames, optionalSettings));
 	}
 	console.log("");
 	console.log(chalk.green(`✓ Scaffold written to ${outDir}`));
@@ -48887,13 +48888,13 @@ const agentExportRuntimeCommand = new Command("export-runtime").description("Exp
 		if (options.format === "json") {
 			const exported = await client.agents.exportRuntime(id, selector.params);
 			const body = `${JSON.stringify(exported, null, 2)}\n`;
-			if (options.output) fs$1.writeFileSync(path$2.resolve(options.output), body);
+			if (options.output) fs$2.writeFileSync(path$2.resolve(options.output), body);
 			else process.stdout.write(body);
 			return;
 		}
 		const bundle = await client.agents.exportRuntimeBundle(id, selector.params);
 		const outPath = path$2.resolve(options.output ?? bundle.fileName);
-		fs$1.writeFileSync(outPath, bundle.bytes);
+		fs$2.writeFileSync(outPath, bundle.bytes);
 		console.log(JSON.stringify({
 			path: outPath,
 			bytes: bundle.bytes.byteLength,
@@ -51232,7 +51233,7 @@ async function storedOrganizationId() {
 		return null;
 	}
 }
-const apiKeysCommand = new Command("api-keys").description("Manage API keys");
+const apiKeysCommand = new Command("api-keys").alias("keys").description("Manage API keys");
 apiKeysCommand.command("list").description("List your API keys").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
 	const apiKey = await ensureAuth();
 	if (!apiKey) return;
@@ -57955,13 +57956,987 @@ var DeviceProviderError = class extends Error {
 		this.name = "DeviceProviderError";
 	}
 };
+object({
+	audience: literal("runtype-device-relay"),
+	deviceId: string().min(1).max(128),
+	connectionId: string().min(1).max(128),
+	nonce: string().min(16).max(128),
+	issuedAt: number$1().int().nonnegative(),
+	expiresAt: number$1().int().positive()
+}).strict();
+new TextEncoder();
+function bytesToBase64Url(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/gu, "-").replace(/\//gu, "_").replace(/=+$/u, "");
+}
+function base64UrlToBytes(value) {
+	if (!/^[A-Za-z0-9_-]+$/u.test(value)) return null;
+	const padded = value.replace(/-/gu, "+").replace(/_/gu, "/") + "=".repeat((4 - value.length % 4) % 4);
+	try {
+		const binary = atob(padded);
+		return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region ../device-bridge/src/device-identity.ts
+const encoder = new TextEncoder();
+function toArrayBuffer(bytes) {
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy.buffer;
+}
+function exportedKeyBytes(value) {
+	if (!(value instanceof ArrayBuffer)) throw new Error("Expected a binary key export");
+	return new Uint8Array(value);
+}
+/**
+* Builds the exact string a device signs to open a relay connection.
+* Format: `runtype-device-connect-v1`, device id, timestamp, and nonce, separated by newlines.
+*/
+function deviceConnectionSignaturePayload(input) {
+	return `runtype-device-connect-v1\n${input.deviceId}\n${input.timestamp}\n${input.nonce}`;
+}
+function requireCryptoKeyPair(value) {
+	if ("publicKey" in value && "privateKey" in value) return value;
+	throw new Error("Ed25519 identity must be a key pair");
+}
+async function generateDeviceIdentity() {
+	const keyPair = requireCryptoKeyPair(await crypto.subtle.generateKey("Ed25519", true, ["sign", "verify"]));
+	const rawPublicKey = exportedKeyBytes(await crypto.subtle.exportKey("raw", keyPair.publicKey));
+	if (rawPublicKey.byteLength !== 32) throw new Error("Ed25519 public key must be 32 bytes");
+	return {
+		keyPair,
+		publicKey: bytesToBase64Url(rawPublicKey)
+	};
+}
+async function exportDevicePrivateKey(privateKey) {
+	return bytesToBase64Url(exportedKeyBytes(await crypto.subtle.exportKey("pkcs8", privateKey)));
+}
+async function importDevicePrivateKey(privateKey) {
+	const pkcs8 = base64UrlToBytes(privateKey);
+	if (!pkcs8) throw new Error("Device private key must be base64url PKCS8");
+	return crypto.subtle.importKey("pkcs8", toArrayBuffer(pkcs8), { name: "Ed25519" }, false, ["sign"]);
+}
+async function signDeviceConnectionChallenge(input) {
+	const signature = new Uint8Array(await crypto.subtle.sign("Ed25519", input.privateKey, encoder.encode(deviceConnectionSignaturePayload({
+		deviceId: input.deviceId,
+		timestamp: input.timestamp,
+		nonce: input.nonce
+	}))));
+	if (signature.byteLength !== 64) throw new Error("Ed25519 signature must be 64 bytes");
+	return bytesToBase64Url(signature);
+}
+const DEVICE_MAX_FRAME_BYTES = 1048576;
+const identifierSchema = string().min(1).max(128);
+const isoDateSchema = datetime({ offset: true });
+const jsonObjectSchema = record(string(), unknown());
+const devicePlatformSchema = _enum(["macos", "cli"]);
+const devicePermissionStateSchema = _enum([
+	"granted",
+	"denied",
+	"not_determined",
+	"restricted",
+	"unavailable"
+]);
+const devicePluginHealthSchema = _enum([
+	"healthy",
+	"degraded",
+	"unavailable",
+	"disabled"
+]);
+const deviceToolSchema = object({
+	name: identifierSchema.regex(/^[a-z][a-z0-9_]*$/),
+	title: string().min(1).max(120),
+	description: string().min(1).max(2e3),
+	inputSchema: jsonObjectSchema,
+	sideEffect: boolean().default(false)
+}).strict();
+const deviceCapabilityManifestSchema = object({
+	deviceId: identifierSchema,
+	generatedAt: isoDateSchema,
+	plugins: array(object({
+		id: identifierSchema.regex(/^[a-z][a-z0-9_-]*$/),
+		displayName: string().min(1).max(120),
+		version: string().min(1).max(64),
+		health: devicePluginHealthSchema,
+		statusMessage: string().max(500).optional(),
+		permissions: record(string(), devicePermissionStateSchema).default({}),
+		tools: array(deviceToolSchema).max(50)
+	}).strict()).max(20)
+}).strict().superRefine((manifest, ctx) => {
+	const toolNames = /* @__PURE__ */ new Set();
+	let toolCount = 0;
+	for (const plugin of manifest.plugins) for (const tool of plugin.tools) {
+		toolCount++;
+		if (toolNames.has(tool.name)) ctx.addIssue({
+			code: "custom",
+			message: `Duplicate device tool name: ${tool.name}`,
+			path: ["plugins"]
+		});
+		toolNames.add(tool.name);
+	}
+	if (toolCount > 50) ctx.addIssue({
+		code: "custom",
+		message: `Device manifests may advertise at most 50 tools`,
+		path: ["plugins"]
+	});
+});
+const deviceErrorSchema = object({
+	code: _enum([
+		"DEVICE_OFFLINE",
+		"DEVICE_REVOKED",
+		"DEVICE_BUSY",
+		"PLUGIN_UNAVAILABLE",
+		"PERMISSION_DENIED",
+		"MESSAGES_NOT_READY",
+		"APP_VERSION_UNSUPPORTED",
+		"PROTOCOL_VERSION_UNSUPPORTED",
+		"REQUEST_EXPIRED",
+		"AMBIGUOUS_SIDE_EFFECT",
+		"POLICY_DENIED",
+		"TOOL_NOT_FOUND",
+		"INVALID_REQUEST",
+		"DUPLICATE_INVOCATION",
+		"INTERNAL_ERROR"
+	]),
+	message: string().min(1).max(1e3),
+	retryable: boolean(),
+	details: jsonObjectSchema.optional()
+}).strict();
+const deviceInvocationSchema = object({
+	id: identifierSchema,
+	idempotencyKey: string().min(16).max(256),
+	toolName: identifierSchema,
+	sideEffect: boolean(),
+	arguments: jsonObjectSchema,
+	requestedAt: isoDateSchema,
+	deadline: isoDateSchema
+}).strict();
+const deviceInvocationResultSchema = object({
+	invocationId: identifierSchema,
+	status: _enum([
+		"success",
+		"error",
+		"ambiguous"
+	]),
+	completedAt: isoDateSchema,
+	output: unknown().optional(),
+	error: deviceErrorSchema.optional()
+}).strict().superRefine((result, ctx) => {
+	if (result.status === "success" && result.error) ctx.addIssue({
+		code: "custom",
+		message: "Successful results cannot include an error"
+	});
+	if (result.status !== "success" && !result.error) ctx.addIssue({
+		code: "custom",
+		message: "Non-success results must include an error"
+	});
+});
+const protocolEnvelopeSchema = object({ protocolVersion: literal(1) });
+const relayToDeviceMessageSchema = discriminatedUnion("type", [
+	protocolEnvelopeSchema.extend({
+		type: literal("invoke"),
+		invocation: deviceInvocationSchema
+	}).strict(),
+	protocolEnvelopeSchema.extend({
+		type: literal("cancel"),
+		invocationId: identifierSchema,
+		reason: string().max(500).optional()
+	}).strict(),
+	protocolEnvelopeSchema.extend({
+		type: literal("event_ack"),
+		eventId: identifierSchema
+	}).strict(),
+	protocolEnvelopeSchema.extend({
+		type: literal("shutdown"),
+		reason: _enum([
+			"revoked",
+			"replaced",
+			"maintenance",
+			"unsupported_version"
+		])
+	}).strict()
+]);
+const deviceToRelayMessageSchema = discriminatedUnion("type", [
+	protocolEnvelopeSchema.extend({
+		type: literal("hello"),
+		deviceId: identifierSchema,
+		connectionId: identifierSchema,
+		platform: devicePlatformSchema,
+		appVersion: string().min(1).max(64),
+		connectedAt: isoDateSchema
+	}).strict(),
+	protocolEnvelopeSchema.extend({
+		type: literal("capabilities"),
+		manifest: deviceCapabilityManifestSchema
+	}).strict(),
+	protocolEnvelopeSchema.extend({
+		type: literal("heartbeat"),
+		sentAt: isoDateSchema
+	}).strict(),
+	protocolEnvelopeSchema.extend({
+		type: literal("invocation_result"),
+		result: deviceInvocationResultSchema
+	}).strict(),
+	protocolEnvelopeSchema.extend({
+		type: literal("event"),
+		eventId: identifierSchema,
+		pluginId: identifierSchema,
+		eventName: identifierSchema,
+		occurredAt: isoDateSchema,
+		payload: jsonObjectSchema
+	}).strict()
+]);
+object({
+	deviceId: identifierSchema,
+	online: boolean(),
+	lastSeenAt: isoDateSchema.optional(),
+	connectionId: identifierSchema.optional(),
+	appVersion: string().max(64).optional(),
+	protocolVersion: number$1().int().positive().optional(),
+	manifest: deviceCapabilityManifestSchema.optional()
+}).strict();
+function deviceError(code, message, retryable, details) {
+	return deviceErrorSchema.parse({
+		code,
+		message,
+		retryable,
+		details
+	});
+}
+//#endregion
+//#region ../device-bridge/src/localhost-http.ts
+const LOCALHOST_HTTP_TOOL_NAME = "localhost_http_call";
+const LOCALHOST_HTTP_MAX_BODY_BYTES = DEVICE_MAX_FRAME_BYTES;
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"localhost",
+	"::1"
+]);
+const localhostHttpCallArgsSchema = object({
+	method: _enum([
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE",
+		"HEAD"
+	]),
+	url: string().url(),
+	headers: record(string(), string().max(8192)).optional(),
+	allowedAuthHeaderName: string().regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/).max(256).optional(),
+	body: string().max(LOCALHOST_HTTP_MAX_BODY_BYTES).optional(),
+	timeoutMs: number$1().int().min(100).max(3e5).optional()
+}).strict();
+const localhostHttpCallResultSchema = object({
+	status: number$1().int().min(100).max(599),
+	statusText: string().max(120),
+	headers: record(string(), string()),
+	body: string().max(LOCALHOST_HTTP_MAX_BODY_BYTES)
+}).strict();
+var LocalhostHttpCallError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "LocalhostHttpCallError";
+	}
+};
+function parseLoopbackHttpUrl(urlString) {
+	let url;
+	try {
+		url = new URL(urlString);
+	} catch {
+		throw new LocalhostHttpCallError("URL is not valid", "INVALID_REQUEST");
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new LocalhostHttpCallError("Only http and https loopback URLs are allowed", "NOT_LOOPBACK");
+	if (url.username || url.password) throw new LocalhostHttpCallError("Loopback URLs cannot include credentials", "INVALID_REQUEST");
+	const hostname = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+	if (!LOOPBACK_HOSTS.has(hostname)) throw new LocalhostHttpCallError("Device HTTP calls may only target 127.0.0.1, localhost, or ::1", "NOT_LOOPBACK");
+	return url;
+}
+function normalizedLoopbackPort(url) {
+	if (url.port !== "") return url.port;
+	return url.protocol === "https:" ? "443" : "80";
+}
+/**
+* Reports whether a device HTTP call may be forwarded to the listen target.
+* Loopback host aliases compare equal. A URL that is not loopback HTTP is refused.
+*/
+function isAllowedListenTarget(requestUrl, forwardTo) {
+	try {
+		const request = parseLoopbackHttpUrl(requestUrl);
+		const target = parseLoopbackHttpUrl(forwardTo);
+		return request.protocol === target.protocol && normalizedLoopbackPort(request) === normalizedLoopbackPort(target);
+	} catch (error) {
+		if (error instanceof LocalhostHttpCallError) return false;
+		throw error;
+	}
+}
+const FORWARDED_REQUEST_HEADERS = /* @__PURE__ */ new Set([
+	"accept",
+	"authorization",
+	"a2a-version",
+	"content-type",
+	"x-api-key"
+]);
+const BLOCKED_AUTH_HEADERS = /* @__PURE__ */ new Set([
+	"host",
+	"cookie",
+	"connection",
+	"content-length",
+	"transfer-encoding",
+	"upgrade",
+	"proxy-authorization",
+	"proxy-authenticate",
+	"te",
+	"trailer",
+	"keep-alive"
+]);
+function forwardedRequestHeaders(headers, allowedAuthHeaderName) {
+	const out = new Headers();
+	if (!headers) return out;
+	for (const [name, value] of Object.entries(headers)) {
+		const normalized = name.toLowerCase();
+		const configuredAuth = normalized === allowedAuthHeaderName?.toLowerCase() && !BLOCKED_AUTH_HEADERS.has(normalized) && !normalized.startsWith("sec-") && !normalized.startsWith("proxy-");
+		if (!FORWARDED_REQUEST_HEADERS.has(normalized) && !configuredAuth) continue;
+		out.set(name, value);
+	}
+	return out;
+}
+async function readResponseBody(response) {
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	const chunks = [];
+	let bytes = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			bytes += value.byteLength;
+			if (bytes > LOCALHOST_HTTP_MAX_BODY_BYTES) {
+				await reader.cancel();
+				throw new LocalhostHttpCallError(`Response body exceeds ${LOCALHOST_HTTP_MAX_BODY_BYTES} bytes`, "BODY_TOO_LARGE");
+			}
+			chunks.push(decoder.decode(value, { stream: true }));
+		}
+		chunks.push(decoder.decode());
+		return chunks.join("");
+	} finally {
+		reader.releaseLock();
+	}
+}
+async function executeLocalhostHttpCall(args, fetchImpl = fetch, signal) {
+	const url = parseLoopbackHttpUrl(args.url);
+	const timeoutMs = args.timeoutMs ?? 3e4;
+	const response = await fetchImpl(url, {
+		method: args.method,
+		headers: forwardedRequestHeaders(args.headers, args.allowedAuthHeaderName),
+		body: args.method === "GET" || args.method === "HEAD" ? void 0 : args.body,
+		signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs),
+		redirect: "error"
+	});
+	const body = await readResponseBody(response);
+	const headers = {};
+	response.headers.forEach((value, key) => {
+		headers[key] = value;
+	});
+	return localhostHttpCallResultSchema.parse({
+		status: response.status,
+		statusText: response.statusText,
+		headers,
+		body
+	});
+}
+//#endregion
+//#region src/lib/device-listen-identity.ts
+const DEVICE_LISTEN_CONFIG = "device-listen";
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function copyIdentity(identity) {
+	return {
+		deviceId: identity.deviceId,
+		name: identity.name,
+		publicKey: identity.publicKey,
+		privateKey: identity.privateKey
+	};
+}
+function readIdentity(value) {
+	if (!isRecord$1(value)) throw new Error("Stored device identity is invalid");
+	const { deviceId, name, publicKey, privateKey } = value;
+	if (deviceId !== null && (typeof deviceId !== "string" || deviceId.length === 0)) throw new Error("Stored device identity is invalid");
+	if (typeof name !== "string" || name.trim().length === 0 || name.length > 120) throw new Error("Stored device identity is invalid");
+	if (typeof publicKey !== "string" || !/^[A-Za-z0-9_-]{43}$/u.test(publicKey)) throw new Error("Stored device identity is invalid");
+	if (typeof privateKey !== "string" || !/^[A-Za-z0-9_-]{40,}$/u.test(privateKey)) throw new Error("Stored device identity is invalid");
+	return {
+		deviceId,
+		name,
+		publicKey,
+		privateKey
+	};
+}
+/** Hostname shown in Runtype until the operator passes --name. */
+function resolveDeviceListenName(requested) {
+	const explicit = requested?.trim();
+	if (explicit) return explicit.slice(0, 120);
+	const hostname = os$1.hostname().trim();
+	if (!hostname) return "This computer";
+	return hostname.slice(0, 120);
+}
+async function createDeviceListenIdentity(name) {
+	const { keyPair, publicKey } = await generateDeviceIdentity();
+	return {
+		deviceId: null,
+		name,
+		publicKey,
+		privateKey: await exportDevicePrivateKey(keyPair.privateKey)
+	};
+}
+async function signDeviceListenChallenge(identity, input) {
+	return signDeviceConnectionChallenge({
+		privateKey: await importDevicePrivateKey(identity.privateKey),
+		...input
+	});
+}
+function deviceListenEncryptionKey() {
+	const hostname = os$1.hostname();
+	const username = os$1.userInfo().username;
+	return createHash("sha256").update(`runtype-device-listen-${hostname}-${username}`).digest("hex");
+}
+function isCorruptStoreError(error) {
+	if (error instanceof SyntaxError) return true;
+	const message = error instanceof Error ? error.message : String(error);
+	return /JSON|bad decrypt|authenticate data|unable to authenticate/iu.test(message);
+}
+function createConfig(cwd, encryptionKey, configName) {
+	return new Conf({
+		projectName: "runtype-cli",
+		projectSuffix: "",
+		configName,
+		cwd,
+		encryptionKey,
+		defaults: { identities: {} }
+	});
+}
+function openConfig(cwd, encryptionKey, configName) {
+	try {
+		return createConfig(cwd, encryptionKey, configName);
+	} catch (error) {
+		if (!isCorruptStoreError(error)) throw error;
+		const filePath = path.join(cwd, `${configName}.json`);
+		if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+		return createConfig(cwd, encryptionKey, configName);
+	}
+}
+function createDeviceListenIdentityStore(options) {
+	const config = openConfig(options.cwd ?? getRuntypeHomeDir(), options.encryptionKey ?? deviceListenEncryptionKey(), workspaceConfigName(options.workspace));
+	return {
+		async load(apiUrl) {
+			const value = (config.get("identities") ?? {})[normalizeApiUrl(apiUrl)];
+			if (value === void 0) return null;
+			return readIdentity(value);
+		},
+		async save(apiUrl, identity) {
+			const key = normalizeApiUrl(apiUrl);
+			const identities = {
+				...config.get("identities"),
+				[key]: copyIdentity(readIdentity(identity))
+			};
+			config.set("identities", identities);
+		}
+	};
+}
+function workspaceConfigName(workspace) {
+	if (!workspace.userId) throw new Error("Authenticated device owner is required");
+	const scope = createHash("sha256").update(JSON.stringify([workspace.userId, workspace.orgId])).digest("hex");
+	return `${DEVICE_LISTEN_CONFIG}-${scope}`;
+}
+function frameText(data) {
+	if (typeof data === "string") return data;
+	if (Buffer.isBuffer(data)) return data.toString("utf8");
+	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
+	return Buffer.concat(data).toString("utf8");
+}
+function closeReason(reason) {
+	return typeof reason === "string" ? reason : reason.toString("utf8");
+}
+function localhostFailureCode(error) {
+	if (error.code === "NOT_LOOPBACK") return "POLICY_DENIED";
+	if (error.code === "REQUEST_EXPIRED") return "REQUEST_EXPIRED";
+	if (error.code === "INTERNAL_ERROR") return "INTERNAL_ERROR";
+	return "INVALID_REQUEST";
+}
+function resultMessage(invocationId, status, output, error) {
+	return deviceToRelayMessageSchema.parse({
+		type: "invocation_result",
+		protocolVersion: 1,
+		result: {
+			invocationId,
+			status,
+			completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			...status === "success" ? { output } : { error }
+		}
+	});
+}
+function failureMessage(invocationId, code, message) {
+	return resultMessage(invocationId, "error", void 0, deviceError(code, message.slice(0, 1e3), false));
+}
+async function executeInvocation(invocation, forwardTo, fetchImpl, signal) {
+	if (invocation.toolName !== "localhost_http_call") return failureMessage(invocation.id, "TOOL_NOT_FOUND", `Tool ${invocation.toolName} is not available`);
+	const deadline = Date.parse(invocation.deadline);
+	if (Number.isNaN(deadline) || deadline <= Date.now()) return failureMessage(invocation.id, "REQUEST_EXPIRED", "Device invocation expired before local execution");
+	const parsed = localhostHttpCallArgsSchema.safeParse(invocation.arguments);
+	if (!parsed.success) return failureMessage(invocation.id, "INVALID_REQUEST", "localhost_http_call arguments are invalid");
+	if (!isAllowedListenTarget(parsed.data.url, forwardTo)) return failureMessage(invocation.id, "POLICY_DENIED", "That URL is outside the forwarded loopback port");
+	try {
+		const timeoutMs = Math.min(parsed.data.timeoutMs ?? 3e4, deadline - Date.now());
+		if (timeoutMs <= 0) return failureMessage(invocation.id, "REQUEST_EXPIRED", "Device invocation expired");
+		const output = await executeLocalhostHttpCall({
+			...parsed.data,
+			timeoutMs
+		}, fetchImpl, signal);
+		return resultMessage(invocation.id, "success", output);
+	} catch (error) {
+		if (error instanceof LocalhostHttpCallError) return failureMessage(invocation.id, localhostFailureCode(error), error.message);
+		const message = error instanceof Error ? error.message : "The localhost request failed";
+		return failureMessage(invocation.id, "INTERNAL_ERROR", message || "The localhost request failed");
+	}
+}
+function connectRelaySocket(relayUrl, headers) {
+	const socket = new WebSocket(relayUrl, { headers });
+	return {
+		send(data) {
+			socket.send(data);
+		},
+		close(code, reason) {
+			socket.close(code, reason);
+		},
+		onOpen(listener) {
+			socket.on("open", listener);
+		},
+		onMessage(listener) {
+			socket.on("message", (data) => listener(data));
+		},
+		onClose(listener) {
+			socket.on("close", (code, reason) => listener(code, reason));
+		},
+		onError(listener) {
+			socket.on("error", listener);
+		}
+	};
+}
+function startDeviceListenSession(options) {
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const socket = (options.socketFactory ?? connectRelaySocket)(options.relayUrl, { Authorization: `Bearer ${options.token}` });
+	let settled = false;
+	let terminal = null;
+	let heartbeat = null;
+	const active = /* @__PURE__ */ new Map();
+	const abortActive = () => {
+		for (const controller of active.values()) controller.abort();
+		active.clear();
+	};
+	let resolveClosed = () => {};
+	const closed = new Promise((resolve) => {
+		resolveClosed = resolve;
+	});
+	const finish = (code, reason) => {
+		if (settled) return;
+		settled = true;
+		abortActive();
+		if (heartbeat) clearInterval(heartbeat);
+		heartbeat = null;
+		resolveClosed({
+			code,
+			reason,
+			intent: terminal ?? "unexpected"
+		});
+		try {
+			socket.close(code, reason);
+		} catch {
+			return;
+		}
+	};
+	const send = (message) => {
+		socket.send(JSON.stringify(deviceToRelayMessageSchema.parse(message)));
+	};
+	const localhostManifest = () => ({
+		deviceId: options.deviceId,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		plugins: [{
+			id: "localhost-http",
+			displayName: "Localhost HTTP",
+			version: "1.0.0",
+			health: "healthy",
+			permissions: {},
+			tools: [{
+				name: LOCALHOST_HTTP_TOOL_NAME,
+				title: "Call a loopback HTTP origin",
+				description: "Fetch a 127.0.0.1, localhost, or ::1 URL from the paired device. Used to call a local agent.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						method: {
+							type: "string",
+							enum: [
+								"GET",
+								"POST",
+								"PUT",
+								"PATCH",
+								"DELETE",
+								"HEAD"
+							]
+						},
+						url: { type: "string" },
+						headers: {
+							type: "object",
+							additionalProperties: { type: "string" }
+						},
+						body: { type: "string" },
+						timeoutMs: {
+							type: "integer",
+							minimum: 100,
+							maximum: 3e5
+						},
+						allowedAuthHeaderName: { type: "string" }
+					},
+					required: ["method", "url"],
+					additionalProperties: false
+				},
+				sideEffect: true
+			}]
+		}]
+	});
+	socket.onOpen(() => {
+		try {
+			send({
+				type: "hello",
+				protocolVersion: 1,
+				deviceId: options.deviceId,
+				connectionId: options.connectionId,
+				platform: "cli",
+				appVersion: options.appVersion,
+				connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			send({
+				type: "capabilities",
+				protocolVersion: 1,
+				manifest: localhostManifest()
+			});
+			heartbeat = setInterval(() => {
+				if (settled) return;
+				try {
+					send({
+						type: "heartbeat",
+						protocolVersion: 1,
+						sentAt: (/* @__PURE__ */ new Date()).toISOString()
+					});
+				} catch {
+					finish(1011, "Heartbeat failed");
+				}
+			}, options.heartbeatIntervalMs ?? 2e4);
+			options.onListening?.();
+		} catch (error) {
+			finish(1011, error instanceof Error ? error.message : "Device hello failed");
+		}
+	});
+	socket.onMessage((data) => {
+		handleFrame(data).catch(() => {
+			finish(1011, "Device session failed");
+		});
+	});
+	socket.onClose((code, reason) => {
+		finish(code, closeReason(reason));
+	});
+	socket.onError(() => {
+		try {
+			socket.close(1011, "Relay socket error");
+		} catch {
+			finish(1011, "Relay socket error");
+		}
+	});
+	async function handleFrame(data) {
+		let parsed;
+		try {
+			parsed = relayToDeviceMessageSchema.safeParse(JSON.parse(frameText(data)));
+		} catch {
+			return;
+		}
+		if (!parsed.success || settled) return;
+		if (parsed.data.type === "shutdown") {
+			abortActive();
+			terminal = parsed.data.reason === "revoked" ? "revoked" : terminal;
+			socket.close(1e3, parsed.data.reason);
+			return;
+		}
+		if (parsed.data.type === "cancel") {
+			active.get(parsed.data.invocationId)?.abort();
+			return;
+		}
+		if (parsed.data.type !== "invoke") return;
+		const invocation = parsed.data.invocation;
+		if (active.has(invocation.id)) return;
+		const controller = new AbortController();
+		active.set(invocation.id, controller);
+		try {
+			const message = await executeInvocation(invocation, options.forwardTo, fetchImpl, controller.signal);
+			if (!settled && !controller.signal.aborted) send(message);
+		} finally {
+			active.delete(invocation.id);
+		}
+	}
+	return {
+		closed,
+		close(code = 1e3, reason = "Interrupted") {
+			if (settled) return;
+			terminal = terminal ?? "stop";
+			abortActive();
+			try {
+				socket.close(code, reason);
+			} catch {
+				finish(code, reason);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/lib/device-listen.ts
+const DEVICE_LISTEN_RECONNECT_DELAYS_MS = [
+	250,
+	500,
+	1e3
+];
+var DeviceListenError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DeviceListenError";
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function httpStatus(error) {
+	if (!isRecord(error) || typeof error.statusCode !== "number") return null;
+	return error.statusCode;
+}
+function unwrapData$1(response) {
+	if (!isRecord(response) || !("data" in response)) throw new DeviceListenError("Runtype API returned an invalid device response");
+	return response.data;
+}
+function requireDeviceId(value) {
+	if (!isRecord(value) || typeof value.id !== "string" || value.id.length === 0) throw new DeviceListenError("Runtype API returned an invalid device response");
+	return value.id;
+}
+function readRelayConnection(value) {
+	if (!isRecord(value) || typeof value.connectionId !== "string" || value.connectionId.length === 0 || typeof value.token !== "string" || value.token.length === 0 || typeof value.relayUrl !== "string" || value.relayUrl.length === 0) throw new DeviceListenError("Runtype API returned an invalid device response");
+	return {
+		connectionId: value.connectionId,
+		token: value.token,
+		relayUrl: value.relayUrl
+	};
+}
+function delay(milliseconds) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, milliseconds);
+	});
+}
+function installProcessSignalHandlers(stop) {
+	const onStop = () => stop();
+	process.on("SIGINT", onStop);
+	process.on("SIGTERM", onStop);
+	return () => {
+		process.off("SIGINT", onStop);
+		process.off("SIGTERM", onStop);
+	};
+}
+function deviceListenAppVersion(version = getCliVersion()) {
+	const value = `runtype-cli/${version}`;
+	return value.length <= 64 ? value : value.slice(0, 64);
+}
+function assertListenForwardTarget(value) {
+	if (!value?.trim()) throw new DeviceListenError("Missing required option --forward-to <url>");
+	try {
+		const url = parseLoopbackHttpUrl(value.trim());
+		return `${url.protocol}//${url.host}`;
+	} catch (error) {
+		throw new DeviceListenError(error instanceof Error ? error.message : String(error));
+	}
+}
+function printListening(deviceId, forwardTo) {
+	console.log("Listening for this workspace");
+	console.log(`  Device   ${deviceId}`);
+	console.log(`  Forward  ${forwardTo}`);
+	console.log("  Only this Runtype workspace can call this process.");
+	console.log("  Keep this running. Ctrl-C to stop.");
+}
+async function pairIdentity(client, identity, appVersion) {
+	const session = unwrapData$1(await client.post("/devices/pairing-sessions", {}));
+	if (!isRecord(session) || typeof session.code !== "string" || session.code.length === 0) throw new DeviceListenError("Runtype API returned an invalid device response");
+	identity.deviceId = requireDeviceId(unwrapData$1(await client.post("/devices/pair", {
+		code: session.code,
+		name: identity.name,
+		platform: "cli",
+		publicKey: identity.publicKey,
+		appVersion
+	})));
+}
+async function requestConnectionToken(client, identity, nonce, timestamp) {
+	if (!identity.deviceId) throw new DeviceListenError("Device is not paired");
+	const signature = await signDeviceListenChallenge(identity, {
+		deviceId: identity.deviceId,
+		timestamp,
+		nonce
+	});
+	return readRelayConnection(unwrapData$1(await client.post(`/devices/${encodeURIComponent(identity.deviceId)}/connection-token`, {
+		timestamp,
+		nonce,
+		signature
+	})));
+}
+async function verifyStoredDeviceOwnership(client, deviceId) {
+	let response;
+	try {
+		response = await client.get(`/devices/${encodeURIComponent(deviceId)}`);
+	} catch (error) {
+		if (httpStatus(error) === 403 || httpStatus(error) === 404) throw new DeviceListenError("Cannot reuse this device in the authenticated workspace. Verify ownership and DEVICES:READ permission.");
+		throw error;
+	}
+	if (requireDeviceId(unwrapData$1(response)) !== deviceId) throw new DeviceListenError("Runtype API returned a different device during ownership verification");
+}
+async function recoverRevokedIdentity(client, store, apiUrl, identity, appVersion) {
+	const rotated = await createDeviceListenIdentity(identity.name);
+	identity.publicKey = rotated.publicKey;
+	identity.privateKey = rotated.privateKey;
+	identity.deviceId = null;
+	await store.save(apiUrl, identity);
+	await pairIdentity(client, identity, appVersion);
+	await store.save(apiUrl, identity);
+}
+async function obtainConnection(client, store, apiUrl, identity, appVersion, createNonce, now, repaired) {
+	if (!identity.deviceId) {
+		await pairIdentity(client, identity, appVersion);
+		await store.save(apiUrl, identity);
+	} else await verifyStoredDeviceOwnership(client, identity.deviceId);
+	try {
+		return await requestConnectionToken(client, identity, createNonce(), now());
+	} catch (error) {
+		if (httpStatus(error) === 503) throw new DeviceListenError("Device relay is not configured");
+		if (httpStatus(error) !== 410) throw error;
+		if (repaired.done) throw new DeviceListenError("This device was revoked");
+		repaired.done = true;
+		await recoverRevokedIdentity(client, store, apiUrl, identity, appVersion);
+		try {
+			return await requestConnectionToken(client, identity, createNonce(), now());
+		} catch (retryError) {
+			if (httpStatus(retryError) === 503) throw new DeviceListenError("Device relay is not configured");
+			if (httpStatus(retryError) === 410) throw new DeviceListenError("This device was revoked");
+			throw retryError;
+		}
+	}
+}
+async function runDeviceListen(options) {
+	const forwardTo = assertListenForwardTarget(options.forwardTo);
+	const sleep = options.sleep ?? delay;
+	const setExitCode = options.setExitCode ?? ((code) => {
+		process.exitCode = code;
+	});
+	const reconnectDelays = options.reconnectDelaysMs ?? DEVICE_LISTEN_RECONNECT_DELAYS_MS;
+	const createNonce = options.createNonce ?? (() => randomUUID());
+	const now = options.now ?? (() => Date.now());
+	const appVersion = options.appVersion ?? deviceListenAppVersion();
+	const runtime = {
+		stopping: false,
+		active: null
+	};
+	const requestStop = () => {
+		runtime.stopping = true;
+		runtime.active?.close(1e3, "Interrupted");
+	};
+	const uninstall = (options.installSignalHandlers ?? installProcessSignalHandlers)(requestStop);
+	const repaired = { done: false };
+	let announcedJson = false;
+	let reconnects = 0;
+	try {
+		let identity = await options.identityStore.load(options.apiUrl);
+		if (!identity) {
+			identity = await createDeviceListenIdentity(resolveDeviceListenName(options.name));
+			await options.identityStore.save(options.apiUrl, identity);
+		} else if (options.name?.trim()) {
+			identity = {
+				...identity,
+				name: resolveDeviceListenName(options.name)
+			};
+			await options.identityStore.save(options.apiUrl, identity);
+		}
+		while (!runtime.stopping) {
+			const credentials = await obtainConnection(options.client, options.identityStore, options.apiUrl, identity, appVersion, createNonce, now, repaired);
+			if (runtime.stopping || !identity.deviceId) break;
+			const deviceId = identity.deviceId;
+			const session = startDeviceListenSession({
+				relayUrl: credentials.relayUrl,
+				token: credentials.token,
+				deviceId,
+				connectionId: credentials.connectionId,
+				forwardTo,
+				appVersion,
+				socketFactory: options.socketFactory,
+				fetchImpl: options.fetchImpl,
+				onListening: () => {
+					reconnects = 0;
+					if (options.json) {
+						if (announcedJson) return;
+						announcedJson = true;
+						console.log(JSON.stringify({
+							deviceId,
+							forwardTo,
+							relayUrl: credentials.relayUrl
+						}));
+						return;
+					}
+					printListening(deviceId, forwardTo);
+				}
+			});
+			runtime.active = session;
+			if (runtime.stopping) session.close(1e3, "Interrupted");
+			const close = await session.closed;
+			runtime.active = null;
+			if (runtime.stopping || close.intent === "stop") {
+				setExitCode(0);
+				return;
+			}
+			if (close.intent === "revoked") throw new DeviceListenError("This device was revoked");
+			if (reconnects >= reconnectDelays.length) {
+				console.error(chalk.red("Offline. Stopped listening after repeated disconnects."));
+				setExitCode(1);
+				return;
+			}
+			console.error(chalk.yellow("Offline. Reconnecting."));
+			await sleep(reconnectDelays[reconnects] ?? 0);
+			reconnects += 1;
+			if (runtime.stopping) break;
+		}
+		setExitCode(0);
+	} catch (error) {
+		setExitCode(1);
+		throw error;
+	} finally {
+		runtime.active?.close(1e3, "Stopped");
+		runtime.active = null;
+		uninstall();
+	}
+}
 //#endregion
 //#region src/lib/macos-device-provider.ts
 const MAX_SIDECAR_OUTPUT_BYTES = 1048576;
 const MAX_HELPER_BYTES = 104857600;
 const DEFAULT_SIDECAR_TIMEOUT_MS = 3e4;
 function parseHello(value) {
-	if (!isRecord$1(value) || typeof value.providerId !== "string" || typeof value.protocolVersion !== "number" || typeof value.helperVersion !== "string" || typeof value.platform !== "string" || !Array.isArray(value.capabilities) || !value.capabilities.every((capability) => typeof capability === "string")) throw new DeviceProviderError("The native helper returned an invalid hello response", "INVALID_RESPONSE");
+	if (!isRecord$3(value) || typeof value.providerId !== "string" || typeof value.protocolVersion !== "number" || typeof value.helperVersion !== "string" || typeof value.platform !== "string" || !Array.isArray(value.capabilities) || !value.capabilities.every((capability) => typeof capability === "string")) throw new DeviceProviderError("The native helper returned an invalid hello response", "INVALID_RESPONSE");
 	return value;
 }
 async function isExecutable(filePath) {
@@ -58070,7 +59045,7 @@ var MacOSDeviceProvider = class {
 		const binaryPath = await this.resolveBinary();
 		if (!binaryPath) throw new DeviceProviderError("The Runtype macOS device helper is not installed. Run `runtype devices setup` first.", "HELPER_NOT_INSTALLED");
 		const result = await this.invokeAt(binaryPath, method, params);
-		if (!isRecord$1(result)) throw new DeviceProviderError("The native helper returned a non-object result", "INVALID_RESPONSE");
+		if (!isRecord$3(result)) throw new DeviceProviderError("The native helper returned a non-object result", "INVALID_RESPONSE");
 		return result;
 	}
 	async removeInstalledBinary() {
@@ -58218,21 +59193,23 @@ const defaultDependencies = {
 	sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
 	setExitCode: (code) => {
 		process.exitCode = code;
-	}
+	},
+	createIdentityStore: (workspace) => createDeviceListenIdentityStore({ workspace }),
+	runListen: (options) => runDeviceListen(options)
 };
 function unwrapData(response) {
-	if (!isRecord$1(response) || !("data" in response)) throw new Error("Runtype API returned an invalid device response");
+	if (!isRecord$3(response) || !("data" in response)) throw new Error("Runtype API returned an invalid device response");
 	return response.data;
 }
 function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function apiStatusCode(error) {
-	return isRecord$1(error) && typeof error.statusCode === "number" ? error.statusCode : null;
+	return isRecord$3(error) && typeof error.statusCode === "number" ? error.statusCode : null;
 }
 function isRecordedRevocationError(error) {
 	if (apiStatusCode(error) !== 503) return false;
-	const data = isRecord$1(error) && isRecord$1(error.data) ? error.data : null;
+	const data = isRecord$3(error) && isRecord$3(error.data) ? error.data : null;
 	return (typeof data?.error === "string" ? data.error : errorMessage(error)).toLowerCase().includes("revocation was recorded");
 }
 function printCommandError(label, error) {
@@ -58381,6 +59358,35 @@ function createDevicesCommand(overrides = {}) {
 			dependencies.setExitCode(1);
 		}
 	});
+	command.command("listen").description("Forward this Runtype workspace's calls to a localhost agent. Does not publish a URL. Does not bind that port.").option("--forward-to <url>", "Loopback HTTP URL of the local agent").option("--name <name>", "Device name shown in Runtype").option("--json", "Output the connected session as JSON").action(async (options) => {
+		let forwardTo;
+		try {
+			forwardTo = assertListenForwardTarget(options.forwardTo);
+		} catch (error) {
+			printCommandError("Cannot forward to that URL", error);
+			dependencies.setExitCode(1);
+			return;
+		}
+		const client = await authenticatedClient(dependencies);
+		if (!client) return;
+		try {
+			const workspace = await client.get("/auth/me");
+			if (typeof workspace.userId !== "string" || !workspace.userId || workspace.orgId !== null && typeof workspace.orgId !== "string") throw new Error("Cannot verify the authenticated workspace");
+			await dependencies.runListen({
+				client,
+				apiUrl: dependencies.getApiUrl(),
+				forwardTo,
+				name: options.name,
+				json: Boolean(options.json),
+				identityStore: dependencies.createIdentityStore(workspace),
+				sleep: dependencies.sleep,
+				setExitCode: dependencies.setExitCode
+			});
+		} catch (error) {
+			printCommandError("Failed to listen for workspace calls", error);
+			dependencies.setExitCode(1);
+		}
+	});
 	command.command("list").description("List paired devices and relay status").option("--json", "Output as JSON").action(async (options) => {
 		try {
 			const client = await authenticatedClient(dependencies);
@@ -58579,7 +59585,7 @@ function createDevicesCommand(overrides = {}) {
 				return;
 			}
 			const entries = (await readFile(status.logPath, "utf8").catch((error) => {
-				if ((isRecord$1(error) ? error.code : void 0) === "ENOENT") return "";
+				if ((isRecord$3(error) ? error.code : void 0) === "ENOENT") return "";
 				throw error;
 			})).split(/\r?\n/u);
 			if (entries.at(-1) === "") entries.pop();