@elpapi42/pi-fleet 0.1.0-beta.10 → 0.1.0-beta.14

package/dist/cli.mjs

@@ -5,7 +5,6 @@ var __export = (target, all) => {
 };
 
 // src/entry/cli.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
 import { pathToFileURL } from "node:url";
 
 // node_modules/commander/lib/error.js
@@ -3391,7 +3390,7 @@ function splitArgv(argv) {
 
 // src/shared/product-identity.ts
 var PRODUCT_BINARY = "pifleet";
-var PRODUCT_VERSION = "0.1.0-beta.10";
+var PRODUCT_VERSION = "0.1.0-beta.14";
 
 // src/shared/identifiers.ts
 var AGENT_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
@@ -3399,16 +3398,156 @@ function isAgentName(value) {
   return AGENT_NAME_PATTERN.test(value);
 }
 
+// src/client/sdk-facade.ts
+function createPiFleetClient(transport) {
+  return new PiFleetClientImpl(transport);
+}
+var PiFleetClientImpl = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  #closed = false;
+  #closedController = new AbortController();
+  async create(input, options = {}) {
+    return this.agent(
+      await this.callAgent(() => this.transport.create(input, this.signal(options.signal)))
+    );
+  }
+  async get(name, options = {}) {
+    const summary = await this.callAgent(
+      () => this.transport.get(name, this.signal(options.signal))
+    );
+    if (summary === null) {
+      throw new PiFleetError("agent_not_found", `Agent ${name} was not found.`);
+    }
+    return this.agent(summary);
+  }
+  async list(options = {}) {
+    return this.callAgent(() => this.transport.list(this.signal(options.signal)));
+  }
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#closedController.abort();
+    await this.transport.close();
+  }
+  agent(summary) {
+    return new AgentImpl(this, this.transport, summary);
+  }
+  async callAgent(operation) {
+    this.assertOpen();
+    try {
+      return await operation();
+    } catch (error) {
+      throw PiFleetError.from(error);
+    }
+  }
+  signal(signal) {
+    this.assertOpen();
+    return signal === void 0 ? this.#closedController.signal : AbortSignal.any([signal, this.#closedController.signal]);
+  }
+  assertOpen() {
+    if (this.#closed) throw new PiFleetError("runtime_unavailable", "pi-fleet client is closed");
+  }
+};
+var agentInternals = /* @__PURE__ */ new WeakMap();
+var AgentImpl = class {
+  constructor(client, transport, initialSummary) {
+    this.client = client;
+    this.transport = transport;
+    this.id = initialSummary.id;
+    this.name = initialSummary.name;
+    agentInternals.set(this, { client, transport, initialSummary });
+  }
+  id;
+  name;
+  status(options = {}) {
+    return this.client.callAgent(
+      () => this.transport.status(this.target(), this.client.signal(options.signal))
+    );
+  }
+  send(message, options = {}) {
+    return this.client.callAgent(
+      () => this.transport.send(
+        this.target(),
+        message,
+        options.delivery ?? "steer",
+        this.client.signal(options.signal)
+      )
+    );
+  }
+  receive(options = {}) {
+    return this.receiveInternal(options, false);
+  }
+  receiveInternal(options, untilIdle) {
+    return this.client.callAgent(
+      () => this.transport.receive(
+        this.target(),
+        receiveStart(options),
+        this.client.signal(options.signal),
+        untilIdle
+      )
+    );
+  }
+  compact(options = {}) {
+    return this.client.callAgent(
+      () => this.transport.compact(this.target(), this.client.signal(options.signal))
+    );
+  }
+  destroy(options = {}) {
+    return this.client.callAgent(
+      () => this.transport.destroy(this.target(), this.client.signal(options.signal))
+    );
+  }
+  target() {
+    return { name: this.name, expectedAgentId: this.id };
+  }
+};
+function receiveStart(options) {
+  if ("after" in options && options.after !== void 0) {
+    return { kind: "after", cursor: options.after };
+  }
+  if ("fromStart" in options && options.fromStart === true) return { kind: "start" };
+  return { kind: "live" };
+}
+function agentInitialStatus(agent) {
+  return requireAgentInternals(agent).initialSummary;
+}
+function receiveAgentUntilIdle(agent, options = {}) {
+  const { client, transport } = requireAgentInternals(agent);
+  return client.callAgent(
+    () => transport.receive(
+      { name: agent.name, expectedAgentId: agent.id },
+      { kind: "live" },
+      client.signal(options.signal),
+      true
+    )
+  );
+}
+function requireAgentInternals(agent) {
+  const internals = agentInternals.get(agent);
+  if (internals === void 0) throw new Error("Unknown pi-fleet Agent handle");
+  return internals;
+}
+var PiFleetError = class _PiFleetError extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "PiFleetError";
+  }
+  static from(error) {
+    if (error instanceof _PiFleetError) return error;
+    return new _PiFleetError("internal_error", "pi-fleet client operation failed");
+  }
+};
+
 // src/cli/output.ts
 function writeResult(stream, result, human) {
   stream.write(human ? `${renderHuman(result)}
 ` : `${JSON.stringify(result)}
 `);
 }
-function writeWatchReady(stream, name) {
-  stream.write(`${JSON.stringify({ schemaVersion: 1, type: "watch.ready", agent: { name } })}
-`);
-}
 function writeError(stream, error, human) {
   if (human) {
     stream.write(`${error.message}
@@ -3424,8 +3563,6 @@ function renderHuman(result) {
       return `${result.agent.name}: ${result.agent.state} (${result.agent.process.state})`;
     case "message.accepted":
       return `${result.agent.name}: message accepted`;
-    case "response":
-      return result.response.text;
     case "agent.status":
       return `${result.agent.name}: ${result.agent.state} (${result.agent.process.state})`;
     case "agent.list":
@@ -3438,23 +3575,42 @@ function renderHuman(result) {
 }
 
 // src/cli/commands/common.ts
-function finishFinite(result, context, human) {
-  if (result.ok) {
-    writeResult(context.stdout, result.value, human);
+async function finishSdkFinite(operation, context, human) {
+  try {
+    writeResult(context.stdout, await operation, human);
     return 0;
+  } catch (error) {
+    const publicError2 = PiFleetError.from(error);
+    writeError(
+      context.stderr,
+      {
+        code: publicError2.code,
+        message: publicError2.message,
+        ...publicError2.details === void 0 ? {} : { details: publicError2.details }
+      },
+      human
+    );
+    return publicError2.code === "timeout" ? 124 : 1;
   }
-  writeError(context.stderr, result.error, human);
-  return result.error.code === "timeout" ? 124 : 1;
 }
 
 // src/cli/commands/compact.ts
 async function runCompact(input, context) {
   if (!isAgentName(input.name)) throw new Error("invalid agent name");
-  const result = await context.client.compact(
-    { name: input.name },
-    { signal: context.signal, operation: context.operationIds() }
+  return finishSdkFinite(
+    (async () => {
+      const agent = await context.client.get(input.name, { signal: context.signal });
+      const compaction = await agent.compact({ signal: context.signal });
+      return {
+        schemaVersion: 1,
+        type: "agent.compacted",
+        agent: { id: agent.id, name: agent.name },
+        compaction
+      };
+    })(),
+    context,
+    input.human
   );
-  return finishFinite(result, context, input.human);
 }
 
 // src/cli/commands/create.ts
@@ -3489,116 +3645,154 @@ function requireContent(value) {
 async function runCreate(input, context) {
   if (!isAgentName(input.name)) throw new Error("invalid agent name");
   const instructions = input.instructions === void 0 ? void 0 : await resolveMessageInput(input.instructions, context.stdin);
-  const result = await context.client.create(
-    {
-      name: input.name,
-      ...instructions === void 0 ? {} : { instructions },
-      cwd: resolve(context.cwd, input.cwd ?? "."),
-      piArgv: context.piArgv
-    },
-    { signal: context.signal, operation: context.operationIds() }
+  return finishSdkFinite(
+    (async () => {
+      const agent = await context.client.create(
+        {
+          name: input.name,
+          ...instructions === void 0 ? {} : { instructions },
+          cwd: resolve(context.cwd, input.cwd ?? "."),
+          piArgs: context.piArgv
+        },
+        { signal: context.signal }
+      );
+      return {
+        schemaVersion: 1,
+        type: "agent.created",
+        agent: agentInitialStatus(agent)
+      };
+    })(),
+    context,
+    input.human
   );
-  return finishFinite(result, context, input.human);
 }
 
 // src/cli/commands/destroy.ts
 async function runDestroy(input, context) {
   if (!isAgentName(input.name)) throw new Error("invalid agent name");
-  const result = await context.client.destroy(
-    { name: input.name },
-    { signal: context.signal, operation: context.operationIds() }
+  return finishSdkFinite(
+    (async () => {
+      const agent = await context.client.get(input.name, { signal: context.signal });
+      await agent.destroy({ signal: context.signal });
+      return {
+        schemaVersion: 1,
+        type: "agent.destroyed",
+        agent: { id: agent.id, name: agent.name }
+      };
+    })(),
+    context,
+    input.human
   );
-  return finishFinite(result, context, input.human);
 }
 
 // src/cli/commands/list.ts
 async function runList(input, context) {
-  const result = await context.client.list({ signal: context.signal });
-  return finishFinite(result, context, input.human);
-}
-
-// src/shared/result.ts
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-
-// src/shared/duration.ts
-var UNIT_TO_MILLISECONDS = {
-  ms: 1,
-  s: 1e3,
-  m: 6e4,
-  h: 36e5
-};
-function parseDuration(input) {
-  const match = /^(\d+)(ms|s|m|h)?$/.exec(input);
-  if (match === null) {
-    return err("invalid_duration");
-  }
-  const amount = Number(match[1]);
-  const unit = match[2] ?? "ms";
-  return ok(amount * UNIT_TO_MILLISECONDS[unit]);
+  return finishSdkFinite(
+    context.client.list({ signal: context.signal }).then((agents) => ({
+      schemaVersion: 1,
+      type: "agent.list",
+      agents
+    })),
+    context,
+    input.human
+  );
 }
 
 // src/cli/commands/receive.ts
+import { once } from "node:events";
 async function runReceive(input, context) {
   if (!isAgentName(input.name)) throw new Error("invalid agent name");
-  const parsedTimeout = input.timeout === void 0 ? void 0 : parseDuration(input.timeout);
-  if (parsedTimeout !== void 0 && !parsedTimeout.ok) throw new Error("invalid timeout duration");
-  const timeoutMs = parsedTimeout?.ok === true ? parsedTimeout.value : void 0;
-  const result = await context.client.receive(
-    { name: input.name },
-    { signal: context.signal, ...timeoutMs === void 0 ? {} : { timeoutMs } }
-  );
-  return finishFinite(result, context, input.human);
+  if (input.after !== void 0 && input.fromStart) {
+    throw new Error("--after and --from-start cannot be combined");
+  }
+  if (input.untilIdle && (input.after !== void 0 || input.fromStart)) {
+    throw new Error("--until-idle uses a live boundary and cannot be combined with history");
+  }
+  try {
+    const agent = await context.client.get(input.name, { signal: context.signal });
+    const stream = input.untilIdle ? await receiveAgentUntilIdle(agent, { signal: context.signal }) : await agent.receive(
+      input.after !== void 0 ? { after: input.after, signal: context.signal } : input.fromStart ? { fromStart: true, signal: context.signal } : { signal: context.signal }
+    );
+    context.stderr.write(
+      input.human ? `receive ready at ${stream.cursor}
+` : `${JSON.stringify({ schemaVersion: 1, type: "receive.ready", cursor: stream.cursor })}
+`
+    );
+    for await (const event of stream) {
+      const output = input.human ? `${renderHumanEvent(event)}
+` : `${JSON.stringify(event)}
+`;
+      try {
+        if (!context.stdout.write(output)) await once(context.stdout, "drain");
+      } catch (error) {
+        if (error.code === "EPIPE") return 0;
+        throw error;
+      }
+    }
+    return 0;
+  } catch (error) {
+    const publicError2 = PiFleetError.from(error);
+    writeError(
+      context.stderr,
+      {
+        code: publicError2.code,
+        message: publicError2.message,
+        ...publicError2.details === void 0 ? {} : { details: publicError2.details }
+      },
+      input.human
+    );
+    return publicError2.code === "timeout" ? 124 : 1;
+  }
+}
+function renderHumanEvent(event) {
+  return JSON.stringify(event);
 }
 
 // src/cli/commands/send.ts
 async function runSend(input, context) {
   if (!isAgentName(input.name)) throw new Error("invalid agent name");
   const message = await resolveMessageInput(input.message, context.stdin);
-  const result = await context.client.send(
-    { name: input.name, message },
-    { signal: context.signal, operation: context.operationIds() }
+  return finishSdkFinite(
+    (async () => {
+      const agent = await context.client.get(input.name, { signal: context.signal });
+      const receipt = await agent.send(message, {
+        delivery: input.delivery,
+        signal: context.signal
+      });
+      return {
+        schemaVersion: 1,
+        type: "message.accepted",
+        agent: { id: agent.id, name: agent.name },
+        acceptedAt: receipt.acceptedAt
+      };
+    })(),
+    context,
+    input.human
   );
-  return finishFinite(result, context, input.human);
 }
 
 // src/cli/commands/status.ts
 async function runStatus(input, context) {
   if (!isAgentName(input.name)) throw new Error("invalid agent name");
-  const result = await context.client.status({ name: input.name }, { signal: context.signal });
-  return finishFinite(result, context, input.human);
-}
-
-// src/cli/commands/watch.ts
-import { once } from "node:events";
-async function runWatch(name, context) {
-  if (!isAgentName(name)) throw new Error("invalid agent name");
-  try {
-    for await (const result of context.client.watch({ name }, { signal: context.signal })) {
-      if (!result.ok) {
-        writeError(context.stderr, result.error, false);
-        return 1;
-      }
-      if (result.value.type === "ready") {
-        writeWatchReady(context.stderr, name);
-        continue;
-      }
-      if (!context.stdout.write(result.value.bytes)) await once(context.stdout, "drain");
-    }
-    return 0;
-  } catch (error) {
-    if (error.code === "EPIPE") return 0;
-    throw error;
-  }
+  return finishSdkFinite(
+    (async () => {
+      const agent = await context.client.get(input.name, { signal: context.signal });
+      return {
+        schemaVersion: 1,
+        type: "agent.status",
+        agent: agentInitialStatus(agent)
+      };
+    })(),
+    context,
+    input.human
+  );
 }
 
 // src/cli/program.ts
 function createProgram(context, setExitCode) {
-  const program2 = new Command().name(PRODUCT_BINARY).description("Pi-native execution infrastructure for programmatic orchestration").version(PRODUCT_VERSION).exitOverride().showHelpAfterError(false).showSuggestionAfterError(false).configureOutput({
+  const program2 = new Command().name(PRODUCT_BINARY).description(
+    "Control shared local Pi agents; stream durable semantic activity with user-owned sessions"
+  ).version(PRODUCT_VERSION).exitOverride().showHelpAfterError(false).showSuggestionAfterError(false).configureOutput({
     writeOut: (text) => context.stdout.write(text),
     writeErr: () => void 0
   });
@@ -3615,15 +3809,27 @@ function createProgram(context, setExitCode) {
       )
     );
   });
-  program2.command("send").description("Submit or steer Pi input").argument("<name>").argument("<message>").option("--human").action(async (name, message, options) => {
-    setExitCode(await runSend({ name, message, human: options.human ?? false }, context));
+  program2.command("send").description("Submit or steer Pi input").argument("<name>").argument("<message>").option("--follow-up", "Queue the input until Pi is fully done").option("--human").action(async (name, message, options) => {
+    setExitCode(
+      await runSend(
+        {
+          name,
+          message,
+          delivery: options.followUp === true ? "followUp" : "steer",
+          human: options.human ?? false
+        },
+        context
+      )
+    );
   });
-  program2.command("receive").description("Wait for idle and return the exact latest assistant text").argument("<name>").option("--timeout <duration>").option("--human").action(async (name, options) => {
+  program2.command("receive").description("Stream durable high-level Pi activity").argument("<name>").option("--after <cursor>", "Replay strictly after a receive cursor, then follow live").option("--from-start", "Replay retained agent history, then follow live").option("--until-idle", "Attach live and exit after the exact observed idle boundary").option("--human").action(async (name, options) => {
     setExitCode(
       await runReceive(
         {
           name,
-          ...options.timeout === void 0 ? {} : { timeout: options.timeout },
+          ...options.after === void 0 ? {} : { after: options.after },
+          fromStart: options.fromStart ?? false,
+          untilIdle: options.untilIdle ?? false,
           human: options.human ?? false
         },
         context
@@ -3636,9 +3842,6 @@ function createProgram(context, setExitCode) {
   program2.command("list").description("List agents without waking Pi").option("--human").action(async (options) => {
     setExitCode(await runList({ human: options.human ?? false }, context));
   });
-  program2.command("watch").description("Stream live raw Pi RPC JSONL").argument("<name>").action(async (name) => {
-    setExitCode(await runWatch(name, context));
-  });
   program2.command("compact").description("Compact an idle Pi agent session").argument("<name>").option("--human").action(async (name, options) => {
     setExitCode(await runCompact({ name, human: options.human ?? false }, context));
   });
@@ -3648,704 +3851,1545 @@ function createProgram(context, setExitCode) {
   return program2;
 }
 
-// src/client/socket-fleet-client.ts
-import { randomUUID } from "node:crypto";
-import { createConnection } from "node:net";
-
-// src/protocol/version.ts
-var PROTOCOL_VERSION = 2;
-var MAX_PROTOCOL_FRAME_BYTES = 1024 * 1024;
+// src/client/shared-client.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
 
-// src/protocol/jsonl.ts
-function readJsonLines(socket, onValue, onError, maxFrameBytes = MAX_PROTOCOL_FRAME_BYTES) {
-  let buffer = Buffer.alloc(0);
-  const onData = (chunk) => {
-    buffer = Buffer.concat([buffer, chunk]);
-    while (true) {
-      const newline = buffer.indexOf(10);
-      if (newline < 0) {
-        if (buffer.length > maxFrameBytes) {
-          onError(new Error("Protocol frame exceeds maximum size"));
-        }
-        return;
-      }
-      if (newline > maxFrameBytes) {
-        onError(new Error("Protocol frame exceeds maximum size"));
-        return;
-      }
-      const line = buffer.subarray(0, newline).toString("utf8").replace(/\r$/, "");
-      buffer = buffer.subarray(newline + 1);
-      if (line.length === 0) continue;
-      try {
-        onValue(JSON.parse(line));
-      } catch {
-        onError(new Error("Malformed JSON protocol frame"));
-        return;
-      }
-    }
+// src/pi/external-installation.ts
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { createReadStream } from "node:fs";
+import { access, realpath, stat } from "node:fs/promises";
+import { delimiter, dirname, isAbsolute, join } from "node:path";
+var VERSION_TIMEOUT_MS = 3e3;
+var MAX_VERSION_OUTPUT_BYTES = 4 * 1024;
+var ExternalPiResolutionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ExternalPiResolutionError";
+  }
+};
+function installationIdentity(installation) {
+  return {
+    mode: "external",
+    selectedPath: installation.selectedPath,
+    nodePath: installation.nodePath,
+    realPath: installation.realPath,
+    version: installation.version,
+    fingerprint: installation.fingerprint
   };
-  socket.on("data", onData);
-  return () => socket.off("data", onData);
-}
-function writeJsonLine(socket, value) {
-  return socket.write(`${JSON.stringify(value)}
-`);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
-var value_exports = {};
-__export(value_exports, {
-  HasPropertyKey: () => HasPropertyKey,
-  IsArray: () => IsArray,
-  IsAsyncIterator: () => IsAsyncIterator,
-  IsBigInt: () => IsBigInt,
-  IsBoolean: () => IsBoolean,
-  IsDate: () => IsDate,
-  IsFunction: () => IsFunction,
-  IsIterator: () => IsIterator,
-  IsNull: () => IsNull,
-  IsNumber: () => IsNumber,
-  IsObject: () => IsObject,
-  IsRegExp: () => IsRegExp,
-  IsString: () => IsString,
-  IsSymbol: () => IsSymbol,
-  IsUint8Array: () => IsUint8Array,
-  IsUndefined: () => IsUndefined
-});
-function HasPropertyKey(value, key) {
-  return key in value;
 }
-function IsAsyncIterator(value) {
-  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
-}
-function IsArray(value) {
-  return Array.isArray(value);
+async function resolveExternalPiInstallation(options = {}) {
+  const env = options.env ?? process.env;
+  const selectedPath = await resolveSelectedPath(env);
+  const nodePath = options.nodePath ?? await resolveNodePath(env);
+  await inspectNode(nodePath);
+  const executionEnv = externalPiExecutionEnvironment(env, selectedPath, nodePath);
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const observation = await observeInstallation(selectedPath, executionEnv, options);
+    if (observation !== null) {
+      return {
+        selectedPath,
+        nodePath,
+        ...observation
+      };
+    }
+  }
+  throw new ExternalPiResolutionError(
+    "pi_installation_changed",
+    "Pi changed while its installation was being observed."
+  );
 }
-function IsBigInt(value) {
-  return typeof value === "bigint";
+function externalPiExecutionEnvironment(env, selectedPath, nodePath) {
+  return {
+    ...env,
+    PATH: [dirname(nodePath), dirname(selectedPath), env.PATH].filter((value) => value !== void 0 && value.length > 0).join(delimiter)
+  };
 }
-function IsBoolean(value) {
-  return typeof value === "boolean";
+async function observeInstallation(selectedPath, env, options) {
+  const beforeRealPath = await inspectExecutable(selectedPath, "Pi");
+  const beforeHash = await hashFile(beforeRealPath);
+  const versionOutput = await (options.versionCommand ?? ((executable) => readVersion(executable, env, options.versionTimeoutMs, options.maxVersionOutputBytes)))(selectedPath);
+  const version = parseVersion(versionOutput);
+  const afterRealPath = await inspectExecutable(selectedPath, "Pi");
+  const afterHash = await hashFile(afterRealPath);
+  if (beforeRealPath !== afterRealPath || beforeHash !== afterHash) return null;
+  return {
+    realPath: afterRealPath,
+    version,
+    fingerprint: createHash("sha256").update(JSON.stringify([selectedPath, afterRealPath, version, afterHash])).digest("hex")
+  };
 }
-function IsDate(value) {
-  return value instanceof globalThis.Date;
-}
-function IsFunction(value) {
-  return typeof value === "function";
-}
-function IsIterator(value) {
-  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
-}
-function IsNull(value) {
-  return value === null;
+async function resolveSelectedPath(env) {
+  const explicit = env.PIFLEET_PI_EXECUTABLE;
+  if (explicit !== void 0) {
+    if (!isAbsolute(explicit)) {
+      throw new ExternalPiResolutionError(
+        "invalid_arguments",
+        "PIFLEET_PI_EXECUTABLE must be an absolute path."
+      );
+    }
+    return explicit;
+  }
+  return resolvePathExecutable(env, "pi", "Pi", "pi_not_found");
 }
-function IsNumber(value) {
-  return typeof value === "number";
+async function resolveNodePath(env) {
+  return resolvePathExecutable(env, "node", "Node", "pi_not_executable");
 }
-function IsObject(value) {
-  return typeof value === "object" && value !== null;
+async function resolvePathExecutable(env, name, label, missingCode) {
+  const path2 = env.PATH;
+  if (path2 === void 0 || path2.length === 0) {
+    throw new ExternalPiResolutionError(missingCode, `${label} was not found on PATH.`);
+  }
+  for (const directory of path2.split(delimiter)) {
+    if (!isAbsolute(directory)) {
+      throw new ExternalPiResolutionError(
+        "invalid_arguments",
+        `PATH entries used to select ${label} must be absolute paths.`
+      );
+    }
+    const candidate = join(directory, name);
+    try {
+      await inspectExecutable(candidate, label);
+      return candidate;
+    } catch (error) {
+      if (!(error instanceof ExternalPiResolutionError) || error.code !== "pi_not_executable" && error.code !== "pi_not_found") {
+        throw error;
+      }
+    }
+  }
+  throw new ExternalPiResolutionError(missingCode, `${label} was not found on PATH.`);
 }
-function IsRegExp(value) {
-  return value instanceof globalThis.RegExp;
+async function inspectExecutable(path2, label) {
+  try {
+    const target = await realpath(path2);
+    const metadata = await stat(target);
+    if (!metadata.isFile()) {
+      throw new ExternalPiResolutionError("pi_not_executable", `${label} is not a file: ${path2}`);
+    }
+    await access(path2, constants.X_OK);
+    return target;
+  } catch (error) {
+    if (error instanceof ExternalPiResolutionError) throw error;
+    if (error.code === "ENOENT") {
+      throw new ExternalPiResolutionError("pi_not_found", `${label} was not found: ${path2}`);
+    }
+    throw new ExternalPiResolutionError("pi_not_executable", `${label} is not executable: ${path2}`);
+  }
 }
-function IsString(value) {
-  return typeof value === "string";
+async function inspectNode(nodePath) {
+  if (!isAbsolute(nodePath)) {
+    throw new ExternalPiResolutionError("invalid_arguments", "Node must be an absolute path.");
+  }
+  try {
+    await inspectExecutable(nodePath, "Node");
+  } catch {
+    throw new ExternalPiResolutionError("pi_not_executable", `Node is not executable: ${nodePath}`);
+  }
 }
-function IsSymbol(value) {
-  return typeof value === "symbol";
+async function hashFile(path2) {
+  const hash = createHash("sha256");
+  await new Promise((resolveHash, rejectHash) => {
+    const stream = createReadStream(path2);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.once("error", rejectHash);
+    stream.once("end", resolveHash);
+  });
+  return hash.digest("hex");
 }
-function IsUint8Array(value) {
-  return value instanceof globalThis.Uint8Array;
+async function readVersion(executable, env, timeoutMs = VERSION_TIMEOUT_MS, maxOutputBytes = MAX_VERSION_OUTPUT_BYTES) {
+  const child = spawn(executable, ["--version"], {
+    detached: process.platform !== "win32",
+    env,
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const chunks = [];
+  let outputBytes = 0;
+  let terminalError = null;
+  let terminated = false;
+  const terminate = () => {
+    if (terminated) return;
+    terminated = true;
+    if (process.platform !== "win32" && child.pid !== void 0) {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+        return;
+      } catch {
+      }
+    }
+    child.kill("SIGKILL");
+  };
+  child.stdout.on("data", (chunk) => {
+    if (terminalError !== null) return;
+    outputBytes += chunk.byteLength;
+    if (outputBytes > maxOutputBytes) {
+      terminalError = new ExternalPiResolutionError(
+        "pi_version_unavailable",
+        "Pi version output exceeded its limit."
+      );
+      terminate();
+      return;
+    }
+    chunks.push(chunk);
+  });
+  child.stderr.resume();
+  return new Promise((resolveVersion, rejectVersion) => {
+    const timer = setTimeout(() => {
+      terminalError = new ExternalPiResolutionError(
+        "pi_version_unavailable",
+        "Pi version command timed out."
+      );
+      terminate();
+    }, timeoutMs);
+    child.once("error", () => {
+      terminalError ??= new ExternalPiResolutionError(
+        "pi_version_unavailable",
+        "Pi version command failed."
+      );
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      if (terminalError !== null) {
+        rejectVersion(terminalError);
+        return;
+      }
+      if (code !== 0) {
+        rejectVersion(
+          new ExternalPiResolutionError("pi_version_unavailable", "Pi version command failed.")
+        );
+        return;
+      }
+      try {
+        resolveVersion(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks)));
+      } catch {
+        rejectVersion(
+          new ExternalPiResolutionError(
+            "pi_version_unavailable",
+            "Pi version command returned invalid UTF-8."
+          )
+        );
+      }
+    });
+  });
 }
-function IsUndefined(value) {
-  return value === void 0;
+function parseVersion(output) {
+  const match = /^(?:pi\s+)?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\s*$/i.exec(output);
+  if (match?.[1] === void 0) {
+    throw new ExternalPiResolutionError(
+      "pi_version_unavailable",
+      "Pi version command returned an invalid version."
+    );
+  }
+  return match[1];
 }
 
-// node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
-function ArrayType(value) {
-  return value.map((value2) => Visit(value2));
-}
-function DateType(value) {
-  return new Date(value.getTime());
-}
-function Uint8ArrayType(value) {
-  return new Uint8Array(value);
-}
-function RegExpType(value) {
-  return new RegExp(value.source, value.flags);
-}
-function ObjectType(value) {
-  const result = {};
-  for (const key of Object.getOwnPropertyNames(value)) {
-    result[key] = Visit(value[key]);
+// src/platform/client/start-runtime.ts
+import { execFile, spawn as spawn2 } from "node:child_process";
+import { access as access2, readFile as readFile3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join5, resolve as resolve5 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+// src/platform/shared/runtime-ownership.ts
+import { lstat } from "node:fs/promises";
+import { createConnection } from "node:net";
+var RuntimeOwnershipBlockedError = class extends Error {
+  code = "runtime_upgrade_deferred";
+  constructor(message) {
+    super(message);
+    this.name = "RuntimeOwnershipBlockedError";
   }
-  for (const key of Object.getOwnPropertySymbols(value)) {
-    result[key] = Visit(value[key]);
+};
+async function inspectControlSocketOwnership(socketPath, probe = probeControlSocket) {
+  const stats = await lstat(socketPath).catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (stats === null) return "absent";
+  if (!stats.isSocket()) {
+    throw new RuntimeOwnershipBlockedError(
+      `Refusing to replace non-socket pi-fleet control path ${socketPath}`
+    );
   }
-  return result;
-}
-function Visit(value) {
-  return IsArray(value) ? ArrayType(value) : IsDate(value) ? DateType(value) : IsUint8Array(value) ? Uint8ArrayType(value) : IsRegExp(value) ? RegExpType(value) : IsObject(value) ? ObjectType(value) : value;
-}
-function Clone(value) {
-  return Visit(value);
+  return probe(socketPath);
 }
-
-// node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
-function CloneType(schema, options) {
-  return options === void 0 ? Clone(schema) : Clone({ ...options, ...schema });
+function probeControlSocket(socketPath) {
+  return new Promise((resolveProbe) => {
+    const socket = createConnection(socketPath);
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolveProbe(result);
+    };
+    const timer = setTimeout(() => settle("uncertain"), 200);
+    socket.once("connect", () => settle("responsive"));
+    socket.once("error", (error) => {
+      settle(error.code === "ECONNREFUSED" || error.code === "ENOENT" ? "stale" : "uncertain");
+    });
+  });
 }
 
-// node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
-function IsObject2(value) {
-  return value !== null && typeof value === "object";
-}
-function IsArray2(value) {
-  return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
-}
-function IsUndefined2(value) {
-  return value === void 0;
-}
-function IsNumber2(value) {
-  return typeof value === "number";
-}
+// src/platform/install/runtime-release.ts
+import { createHash as createHash3, randomUUID } from "node:crypto";
+import { chmod, cp, lstat as lstat3, mkdir, readFile as readFile2, rename, rm, writeFile } from "node:fs/promises";
+import { join as join3, posix, resolve as resolve3, sep as sep2 } from "node:path";
 
-// node_modules/@sinclair/typebox/build/esm/system/policy.mjs
-var TypeSystemPolicy;
-(function(TypeSystemPolicy2) {
-  TypeSystemPolicy2.InstanceMode = "default";
-  TypeSystemPolicy2.ExactOptionalPropertyTypes = false;
-  TypeSystemPolicy2.AllowArrayObject = false;
-  TypeSystemPolicy2.AllowNaN = false;
-  TypeSystemPolicy2.AllowNullVoid = false;
-  function IsExactOptionalProperty(value, key) {
-    return TypeSystemPolicy2.ExactOptionalPropertyTypes ? key in value : value[key] !== void 0;
+// src/platform/install/tree-integrity.ts
+import { createHash as createHash2 } from "node:crypto";
+import { lstat as lstat2, readFile, readdir, realpath as realpath2, stat as stat2 } from "node:fs/promises";
+import { join as join2, relative, resolve as resolve2, sep } from "node:path";
+async function hashDirectoryTree(root, manifestPath) {
+  const resolvedRoot = resolve2(root);
+  const entries = await collectFiles(resolvedRoot, resolvedRoot);
+  const hash = createHash2("sha256");
+  let bytes = 0;
+  for (const entry of entries) {
+    const contents = await readFile(entry.absolutePath);
+    bytes += contents.length;
+    hash.update(entry.relativePath);
+    hash.update("\0");
+    hash.update(String(contents.length));
+    hash.update("\0");
+    hash.update(contents);
+    hash.update("\0");
   }
-  TypeSystemPolicy2.IsExactOptionalProperty = IsExactOptionalProperty;
-  function IsObjectLike(value) {
-    const isObject = IsObject2(value);
-    return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !IsArray2(value);
+  return {
+    path: manifestPath,
+    files: entries.length,
+    bytes,
+    sha256: hash.digest("hex")
+  };
+}
+async function collectFiles(root, directory) {
+  const output = [];
+  for (const name of (await readdir(directory)).sort()) {
+    const absolutePath = join2(directory, name);
+    const linkInfo = await lstat2(absolutePath);
+    const info = linkInfo.isSymbolicLink() ? await stat2(absolutePath) : linkInfo;
+    if (info.isDirectory()) {
+      if (linkInfo.isSymbolicLink()) {
+        throw new Error(`Runtime dependency tree contains a directory symlink: ${absolutePath}`);
+      }
+      output.push(...await collectFiles(root, absolutePath));
+      continue;
+    }
+    if (!info.isFile()) {
+      throw new Error(`Runtime dependency tree contains an unsupported entry: ${absolutePath}`);
+    }
+    if (linkInfo.isSymbolicLink()) {
+      const target = await realpath2(absolutePath);
+      if (target !== root && !target.startsWith(`${root}${sep}`)) {
+        throw new Error(
+          `Runtime dependency tree contains an external file symlink: ${absolutePath}`
+        );
+      }
+    }
+    const relativePath = relative(root, absolutePath).split(sep).join("/");
+    if (relativePath.length === 0 || relativePath.startsWith("../")) {
+      throw new Error(`Runtime dependency path escapes its root: ${absolutePath}`);
+    }
+    output.push({ absolutePath, relativePath });
   }
-  TypeSystemPolicy2.IsObjectLike = IsObjectLike;
-  function IsRecordLike(value) {
-    return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+  return output.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+
+// src/platform/install/runtime-release.ts
+var requiredRuntimeArtifacts = /* @__PURE__ */ new Set([
+  "package.json",
+  "bin/pifleet.mjs",
+  "bin/pifleet-runtime.mjs",
+  "dist/cli.mjs",
+  "dist/runtime.mjs",
+  "dist/journal-sqlite-worker.mjs",
+  "dist/client.mjs",
+  "dist/client-meta.json",
+  "dist/client/index.d.ts",
+  "dist/client/sdk-facade.d.ts",
+  "dist/client/contracts.d.ts"
+]);
+var dependencyTreePath = "node_modules";
+async function materializeRuntime(options) {
+  const sourceRoot = resolve3(options.sourceRoot);
+  const manifestBytes = await readFile2(join3(sourceRoot, "dist", "runtime-manifest.json"));
+  const sourceManifest = await parseRuntimeManifest(manifestBytes, sourceRoot);
+  if (sourceManifest.closure !== void 0) {
+    await verifyRuntime(sourceRoot);
+    return sourceRoot;
   }
-  TypeSystemPolicy2.IsRecordLike = IsRecordLike;
-  function IsNumberLike(value) {
-    return TypeSystemPolicy2.AllowNaN ? IsNumber2(value) : Number.isFinite(value);
+  await verifyRuntimeFiles(sourceRoot, sourceManifest);
+  await verifyDependencyIdentities(sourceRoot, sourceManifest.dependencies);
+  const sourceTreeRoot = resolveInside(sourceRoot, dependencyTreePath);
+  const sourceTreeBefore = await hashDirectoryTree(sourceTreeRoot, dependencyTreePath);
+  const sourceManifestSha256 = createHash3("sha256").update(manifestBytes).digest("hex");
+  const materializedManifest = {
+    ...sourceManifest,
+    closure: { sourceManifestSha256, tree: sourceTreeBefore }
+  };
+  const materializedManifestBytes = serializeManifest(materializedManifest);
+  const closureHash = createHash3("sha256").update(sourceManifestSha256).update("\0").update(JSON.stringify(sourceTreeBefore)).digest("hex").slice(0, 16);
+  const applicationRoot = resolve3(options.applicationRoot);
+  await ensurePrivateDirectory(applicationRoot);
+  const releasesRoot = join3(applicationRoot, "releases");
+  await ensurePrivateDirectory(releasesRoot);
+  const destination = join3(releasesRoot, `${sourceManifest.package.version}-${closureHash}`);
+  if (await pathExists(destination)) {
+    await verifyExpectedRuntime(destination, materializedManifest, materializedManifestBytes);
+    return destination;
   }
-  TypeSystemPolicy2.IsNumberLike = IsNumberLike;
-  function IsVoidLike(value) {
-    const isUndefined = IsUndefined2(value);
-    return TypeSystemPolicy2.AllowNullVoid ? isUndefined || value === null : isUndefined;
+  const staging = join3(releasesRoot, `.staging-${randomUUID()}`);
+  await mkdir(staging, { mode: 448 });
+  try {
+    await cp(join3(sourceRoot, "dist"), join3(staging, "dist"), {
+      recursive: true,
+      dereference: true
+    });
+    await cp(join3(sourceRoot, "bin"), join3(staging, "bin"), {
+      recursive: true,
+      dereference: true
+    });
+    await cp(join3(sourceRoot, "package.json"), join3(staging, "package.json"));
+    await cp(sourceTreeRoot, join3(staging, dependencyTreePath), {
+      recursive: true,
+      dereference: true
+    });
+    await options.hooks?.afterDependencyCopy?.();
+    const stagedTree = await hashDirectoryTree(
+      join3(staging, dependencyTreePath),
+      dependencyTreePath
+    );
+    assertSameTree(sourceTreeBefore, stagedTree, "copied dependency closure");
+    const sourceTreeAfter = await hashDirectoryTree(sourceTreeRoot, dependencyTreePath);
+    assertSameTree(sourceTreeBefore, sourceTreeAfter, "source dependency closure");
+    await writeFile(join3(staging, "dist", "runtime-manifest.json"), materializedManifestBytes);
+    await verifyExpectedRuntime(staging, materializedManifest, materializedManifestBytes);
+    await chmod(staging, 448);
+    try {
+      await rename(staging, destination);
+    } catch (error) {
+      if (!isDestinationRace(error) || !await pathExists(destination)) throw error;
+      await verifyExpectedRuntime(destination, materializedManifest, materializedManifestBytes);
+    }
+    return destination;
+  } finally {
+    await rm(staging, { recursive: true, force: true });
   }
-  TypeSystemPolicy2.IsVoidLike = IsVoidLike;
-})(TypeSystemPolicy || (TypeSystemPolicy = {}));
-
-// node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs
-function ImmutableArray(value) {
-  return globalThis.Object.freeze(value).map((value2) => Immutable(value2));
 }
-function ImmutableDate(value) {
-  return value;
+async function verifyRuntime(root) {
+  const resolvedRoot = resolve3(root);
+  const manifestBytes = await readFile2(join3(resolvedRoot, "dist", "runtime-manifest.json"));
+  const manifest = await parseRuntimeManifest(manifestBytes, resolvedRoot);
+  if (manifest.closure === void 0) {
+    throw new Error("Runtime release manifest is missing its materialized closure");
+  }
+  await verifyRuntimeFiles(resolvedRoot, manifest);
+  await verifyDependencyIdentities(resolvedRoot, manifest.dependencies);
+  const actualTree = await hashDirectoryTree(
+    resolveInside(resolvedRoot, dependencyTreePath),
+    dependencyTreePath
+  );
+  assertSameTree(manifest.closure.tree, actualTree, "materialized dependency closure");
 }
-function ImmutableUint8Array(value) {
-  return value;
+async function verifyExpectedRuntime(root, expected, expectedBytes) {
+  const manifestPath = join3(root, "dist", "runtime-manifest.json");
+  const actualBytes = await readFile2(manifestPath);
+  if (!actualBytes.equals(expectedBytes)) {
+    throw new Error("Materialized runtime manifest does not match the expected closure");
+  }
+  const actual = await parseRuntimeManifest(actualBytes, root);
+  if (actual.closure === void 0 || expected.closure === void 0) {
+    throw new Error("Materialized runtime manifest is missing its closure");
+  }
+  await verifyRuntimeFiles(root, actual);
+  await verifyDependencyIdentities(root, actual.dependencies);
+  const actualTree = await hashDirectoryTree(
+    resolveInside(root, dependencyTreePath),
+    dependencyTreePath
+  );
+  assertSameTree(expected.closure.tree, actualTree, "materialized dependency closure");
 }
-function ImmutableRegExp(value) {
-  return value;
+async function verifyRuntimeFiles(root, manifest) {
+  for (const file of manifest.files) {
+    const path2 = resolveInside(root, file.path);
+    const info = await lstat3(path2);
+    if (info.isSymbolicLink()) {
+      throw new Error(`Runtime artifact ${file.path} must not be a symbolic link`);
+    }
+    if (!info.isFile() || info.size !== file.bytes) {
+      throw new Error(`Runtime artifact ${file.path} has changed`);
+    }
+    const hash = createHash3("sha256").update(await readFile2(path2)).digest("hex");
+    if (hash !== file.sha256) {
+      throw new Error(`Runtime artifact ${file.path} failed verification`);
+    }
+  }
 }
-function ImmutableObject(value) {
-  const result = {};
-  for (const key of Object.getOwnPropertyNames(value)) {
-    result[key] = Immutable(value[key]);
+async function verifyDependencyIdentities(root, dependencies) {
+  const nodeModules = resolveInside(root, dependencyTreePath);
+  const modulesInfo = await lstat3(nodeModules);
+  if (!modulesInfo.isDirectory() || modulesInfo.isSymbolicLink()) {
+    throw new Error("Runtime dependency closure must be a regular directory");
   }
-  for (const key of Object.getOwnPropertySymbols(value)) {
-    result[key] = Immutable(value[key]);
+  for (const dependency of dependencies) {
+    const packageRoot = resolveInside(root, dependency.path);
+    const packageInfo = await lstat3(packageRoot);
+    if (!packageInfo.isDirectory() || packageInfo.isSymbolicLink()) {
+      throw new Error(`Runtime dependency ${dependency.name} must be a regular directory`);
+    }
+    const packageJsonPath = join3(packageRoot, "package.json");
+    const packageJsonInfo = await lstat3(packageJsonPath);
+    if (!packageJsonInfo.isFile() || packageJsonInfo.isSymbolicLink()) {
+      throw new Error(`Runtime dependency ${dependency.name} has an unsafe package.json`);
+    }
+    const identity = await readPackageMetadata(packageRoot);
+    if (identity.name !== dependency.name || identity.version !== dependency.version) {
+      throw new Error(`Runtime dependency ${dependency.name} has an unexpected identity`);
+    }
   }
-  return globalThis.Object.freeze(result);
-}
-function Immutable(value) {
-  return IsArray(value) ? ImmutableArray(value) : IsDate(value) ? ImmutableDate(value) : IsUint8Array(value) ? ImmutableUint8Array(value) : IsRegExp(value) ? ImmutableRegExp(value) : IsObject(value) ? ImmutableObject(value) : value;
 }
-
-// node_modules/@sinclair/typebox/build/esm/type/create/type.mjs
-function CreateType(schema, options) {
-  const result = options !== void 0 ? { ...options, ...schema } : schema;
-  switch (TypeSystemPolicy.InstanceMode) {
-    case "freeze":
-      return Immutable(result);
-    case "clone":
-      return Clone(result);
-    default:
-      return result;
+async function parseRuntimeManifest(bytes, root) {
+  let candidate;
+  try {
+    candidate = JSON.parse(bytes.toString("utf8"));
+  } catch {
+    throw new Error("Runtime manifest is not valid JSON");
   }
+  await validateRuntimeManifest(candidate, root);
+  return candidate;
 }
-
-// node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
-var TypeBoxError = class extends Error {
-  constructor(message) {
-    super(message);
+async function validateRuntimeManifest(candidate, root) {
+  if (!isRecord(candidate) || candidate.schemaVersion !== 4) {
+    throw new Error("Runtime manifest has an unsupported schema version");
+  }
+  if (!isRecord(candidate.package) || typeof candidate.package.name !== "string" || typeof candidate.package.version !== "string" || !isRecord(candidate.piRuntime) || candidate.piRuntime.mode !== "external" || !isRuntimeContract(candidate.runtime)) {
+    throw new Error("Runtime manifest has an invalid package identity");
+  }
+  const packageMetadata = await readPackageMetadata(root, true);
+  if (candidate.package.name !== packageMetadata.name || candidate.package.version !== packageMetadata.version || packageMetadata.runtime === void 0 || !sameRuntimeContract(candidate.runtime, packageMetadata.runtime) || packageMetadata.clientExport === void 0) {
+    throw new Error("Runtime manifest package identity does not match package.json");
+  }
+  if (!Array.isArray(candidate.files) || !Array.isArray(candidate.dependencies)) {
+    throw new Error("Runtime manifest has invalid artifact lists");
+  }
+  const filePaths = /* @__PURE__ */ new Set();
+  for (const file of candidate.files) {
+    if (!isRecord(file) || !isManifestPath(file.path) || !isValidSize(file.bytes) || !isSha256(file.sha256)) {
+      throw new Error("Runtime manifest contains an invalid artifact");
+    }
+    if (filePaths.has(file.path)) {
+      throw new Error(`Runtime manifest has duplicate path ${file.path}`);
+    }
+    filePaths.add(file.path);
+  }
+  for (const required of requiredRuntimeArtifacts) {
+    if (!filePaths.has(required)) {
+      throw new Error(`Runtime manifest is missing required artifact ${required}`);
+    }
+  }
+  const dependencyPaths = /* @__PURE__ */ new Set();
+  const dependencyNames = /* @__PURE__ */ new Set();
+  for (const dependency of candidate.dependencies) {
+    if (!isRecord(dependency) || !isManifestPath(dependency.path) || typeof dependency.name !== "string" || dependency.name.length === 0 || typeof dependency.version !== "string" || dependency.version.length === 0 || dependency.path !== `node_modules/${dependency.name}`) {
+      throw new Error("Runtime manifest contains an invalid dependency declaration");
+    }
+    if (dependencyPaths.has(dependency.path) || dependencyNames.has(dependency.name)) {
+      throw new Error(`Runtime manifest has duplicate dependency ${dependency.name}`);
+    }
+    dependencyPaths.add(dependency.path);
+    dependencyNames.add(dependency.name);
+  }
+  const expectedDependencies = packageMetadata.dependencies;
+  if (dependencyNames.size !== Object.keys(expectedDependencies).length || [...dependencyNames].some(
+    (name) => expectedDependencies[name] !== candidate.dependencies.find(
+      (dependency) => dependency.name === name
+    )?.version
+  )) {
+    throw new Error("Runtime manifest dependencies do not match package.json");
+  }
+  for (const filePath of filePaths) {
+    for (const dependencyPath of dependencyPaths) {
+      if (filePath === dependencyPath || filePath.startsWith(`${dependencyPath}/`) || dependencyPath.startsWith(`${filePath}/`)) {
+        throw new Error(`Runtime manifest has overlapping paths ${filePath} and ${dependencyPath}`);
+      }
+    }
+  }
+  if (candidate.closure !== void 0) {
+    if (!isRecord(candidate.closure) || !isSha256(candidate.closure.sourceManifestSha256) || !isTreeIntegrity(candidate.closure.tree) || candidate.closure.tree.path !== dependencyTreePath) {
+      throw new Error("Runtime manifest contains an invalid materialized closure");
+    }
   }
-};
-
-// node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
-var TransformKind = Symbol.for("TypeBox.Transform");
-var ReadonlyKind = Symbol.for("TypeBox.Readonly");
-var OptionalKind = Symbol.for("TypeBox.Optional");
-var Hint = Symbol.for("TypeBox.Hint");
-var Kind = Symbol.for("TypeBox.Kind");
-
-// node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
-function IsReadonly(value) {
-  return IsObject(value) && value[ReadonlyKind] === "Readonly";
-}
-function IsOptional(value) {
-  return IsObject(value) && value[OptionalKind] === "Optional";
-}
-function IsAny(value) {
-  return IsKindOf(value, "Any");
-}
-function IsArgument(value) {
-  return IsKindOf(value, "Argument");
-}
-function IsArray3(value) {
-  return IsKindOf(value, "Array");
-}
-function IsAsyncIterator2(value) {
-  return IsKindOf(value, "AsyncIterator");
 }
-function IsBigInt2(value) {
-  return IsKindOf(value, "BigInt");
+async function readPackageMetadata(root, requireRuntimeContract = false) {
+  let candidate;
+  try {
+    candidate = JSON.parse(await readFile2(join3(root, "package.json"), "utf8"));
+  } catch {
+    throw new Error("Runtime package.json is not valid JSON");
+  }
+  if (!isRecord(candidate) || typeof candidate.name !== "string" || typeof candidate.version !== "string" || requireRuntimeContract && !isRuntimeContract(candidate.pifleet) || candidate.dependencies !== void 0 && !isRecord(candidate.dependencies) || isRecord(candidate.dependencies) && Object.values(candidate.dependencies).some((version) => typeof version !== "string")) {
+    throw new Error("Runtime package.json has invalid package metadata");
+  }
+  const clientExport = isRecord(candidate.exports) ? candidate.exports["./client"] : void 0;
+  return {
+    name: candidate.name,
+    version: candidate.version,
+    ...isRuntimeContract(candidate.pifleet) ? { runtime: candidate.pifleet } : {},
+    ...isRecord(clientExport) && clientExport.types === "./dist/client/index.d.ts" && clientExport.import === "./dist/client.mjs" ? {
+      clientExport: {
+        types: "./dist/client/index.d.ts",
+        import: "./dist/client.mjs"
+      }
+    } : {},
+    dependencies: isRecord(candidate.dependencies) ? candidate.dependencies : {}
+  };
 }
-function IsBoolean2(value) {
-  return IsKindOf(value, "Boolean");
+function serializeManifest(manifest) {
+  return Buffer.from(`${JSON.stringify(manifest, null, 2)}
+`);
 }
-function IsComputed(value) {
-  return IsKindOf(value, "Computed");
+function assertSameTree(expected, actual, label) {
+  if (expected.path !== actual.path || expected.files !== actual.files || expected.bytes !== actual.bytes || expected.sha256 !== actual.sha256) {
+    throw new Error(`Runtime ${label} changed during materialization`);
+  }
 }
-function IsConstructor(value) {
-  return IsKindOf(value, "Constructor");
+function resolveInside(root, path2) {
+  if (!isManifestPath(path2)) throw new Error(`Runtime manifest contains an unsafe path ${path2}`);
+  const resolved = resolve3(root, path2);
+  if (!resolved.startsWith(`${root}${sep2}`)) {
+    throw new Error(`Runtime manifest contains an unsafe path ${path2}`);
+  }
+  return resolved;
 }
-function IsDate2(value) {
-  return IsKindOf(value, "Date");
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
 }
-function IsFunction2(value) {
-  return IsKindOf(value, "Function");
+function isRuntimeContract(value) {
+  return isRecord(value) && value.protocolVersion === 3 && value.journalSchemaVersion === 3 && value.clientExport === "./client";
 }
-function IsInteger(value) {
-  return IsKindOf(value, "Integer");
+function sameRuntimeContract(left, right) {
+  return left.protocolVersion === right.protocolVersion && left.journalSchemaVersion === right.journalSchemaVersion && left.clientExport === right.clientExport;
 }
-function IsIntersect(value) {
-  return IsKindOf(value, "Intersect");
+function isManifestPath(value) {
+  return typeof value === "string" && value.length > 0 && !value.includes("\\") && !value.startsWith("/") && posix.normalize(value) === value && value.split("/").every((part) => part.length > 0 && part !== "." && part !== "..");
 }
-function IsIterator2(value) {
-  return IsKindOf(value, "Iterator");
+function isValidSize(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
-function IsKindOf(value, kind) {
-  return IsObject(value) && Kind in value && value[Kind] === kind;
+function isSha256(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
 }
-function IsLiteralValue(value) {
-  return IsBoolean(value) || IsNumber(value) || IsString(value);
+function isTreeIntegrity(value) {
+  return isRecord(value) && isManifestPath(value.path) && isValidSize(value.files) && isValidSize(value.bytes) && isSha256(value.sha256);
 }
-function IsLiteral(value) {
-  return IsKindOf(value, "Literal");
+function isDestinationRace(error) {
+  const code = error.code;
+  return code === "EEXIST" || code === "ENOTEMPTY";
 }
-function IsMappedKey(value) {
-  return IsKindOf(value, "MappedKey");
+async function ensurePrivateDirectory(path2) {
+  await mkdir(path2, { recursive: true, mode: 448 });
+  const info = await lstat3(path2);
+  if (!info.isDirectory() || info.isSymbolicLink()) {
+    throw new Error(`Refusing unsafe runtime release path ${path2}`);
+  }
+  if (typeof process.getuid === "function" && info.uid !== process.getuid()) {
+    throw new Error(`Runtime release path ${path2} is not owned by the current user`);
+  }
+  await chmod(path2, 448);
 }
-function IsMappedResult(value) {
-  return IsKindOf(value, "MappedResult");
+async function pathExists(path2) {
+  try {
+    await lstat3(path2);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
 }
-function IsNever(value) {
-  return IsKindOf(value, "Never");
+
+// src/platform/shared/paths.ts
+import { homedir, tmpdir } from "node:os";
+import { join as join4, resolve as resolve4 } from "node:path";
+function resolveApplicationRoot(env = process.env) {
+  return env.PIFLEET_APPLICATION_ROOT ?? (process.platform === "darwin" ? join4(homedir(), "Library", "Application Support", "pi-fleet", "runtime") : join4(env.XDG_DATA_HOME ?? join4(homedir(), ".local", "share"), "pi-fleet"));
 }
-function IsNot(value) {
-  return IsKindOf(value, "Not");
+function resolveFleetPaths(env = process.env) {
+  const explicitRoot = env.PIFLEET_STATE_ROOT;
+  if (explicitRoot !== void 0) {
+    const root = resolve4(explicitRoot);
+    return {
+      runtimeRoot: root,
+      stateRoot: root,
+      socketPath: join4(root, "control.sock"),
+      databasePath: join4(root, "fleet.sqlite")
+    };
+  }
+  const runtimeRoot = join4(
+    env.XDG_RUNTIME_DIR ?? tmpdir(),
+    `pifleet-${process.getuid?.() ?? "user"}`
+  );
+  const stateRoot = process.platform === "darwin" ? join4(homedir(), "Library", "Application Support", "pi-fleet") : join4(env.XDG_STATE_HOME ?? join4(homedir(), ".local", "state"), "pi-fleet");
+  return {
+    runtimeRoot,
+    stateRoot,
+    socketPath: join4(runtimeRoot, "control.sock"),
+    databasePath: join4(stateRoot, "fleet.sqlite")
+  };
 }
-function IsNull2(value) {
-  return IsKindOf(value, "Null");
+
+// src/platform/client/start-runtime.ts
+var execFileAsync = promisify(execFile);
+async function ensureRuntime(options) {
+  const inspectOwnership = options.inspectOwnership ?? inspectControlSocketOwnership;
+  const initialOwnership = await inspectOwnership(options.socketPath);
+  if (initialOwnership === "responsive") return;
+  assertRuntimeStartAllowed(initialOwnership, options.socketPath);
+  let env = { ...process.env, ...options.env };
+  const registered = env.PIFLEET_DISABLE_REGISTERED_SERVICE === "1" ? false : options.registeredRuntimeStarter !== void 0 ? await options.registeredRuntimeStarter(env) : await startRegisteredRuntime({
+    env,
+    ...options.home === void 0 ? {} : { home: options.home }
+  });
+  if (!registered) {
+    if (options.piInstallation !== void 0) {
+      const installation = await options.piInstallation();
+      if (installation !== null) {
+        env = {
+          ...env,
+          PIFLEET_PI_EXECUTABLE: installation.selectedPath,
+          PIFLEET_PI_NODE: installation.nodePath
+        };
+      }
+    }
+    const sourceRoot = options.sourceRoot ?? await findPackageRoot(fileURLToPath(import.meta.url));
+    const release = await materializeRuntime({
+      sourceRoot,
+      applicationRoot: options.applicationRoot ?? resolveApplicationRoot(env)
+    });
+    const runtimePath = join5(release, "bin", "pifleet-runtime.mjs");
+    const child = spawn2(process.execPath, [runtimePath], {
+      detached: true,
+      env,
+      stdio: "ignore"
+    });
+    child.unref();
+  }
+  const deadline = Date.now() + (options.timeoutMs ?? 5e3);
+  while (Date.now() < deadline) {
+    const ownership = await inspectOwnership(options.socketPath);
+    if (ownership === "responsive") return;
+    if (ownership === "uncertain") {
+      throw new RuntimeOwnershipBlockedError(
+        `pi-fleet control socket ownership is uncertain for ${options.socketPath}`
+      );
+    }
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 25));
+  }
+  throw new Error(`pi-fleet runtime did not become ready at ${options.socketPath}`);
 }
-function IsNumber3(value) {
-  return IsKindOf(value, "Number");
+function assertRuntimeStartAllowed(ownership, socketPath) {
+  if (ownership === "uncertain") {
+    throw new RuntimeOwnershipBlockedError(
+      `pi-fleet control socket ownership is uncertain for ${socketPath}`
+    );
+  }
 }
-function IsObject3(value) {
-  return IsKindOf(value, "Object");
+async function startRegisteredRuntime(options) {
+  const home = options.home ?? homedir2();
+  if (process.platform === "linux") {
+    const unit = join5(home, ".config", "systemd", "user", "pi-fleet.service");
+    if (!await exists(unit)) return false;
+    await assertRegisteredStateRoot(unit, "linux", options.env);
+    await execFileAsync("systemctl", ["--user", "start", "pi-fleet.service"]);
+    return true;
+  }
+  if (process.platform === "darwin") {
+    const plist = join5(home, "Library", "LaunchAgents", "works.elpapi.pifleet.plist");
+    if (!await exists(plist)) return false;
+    await assertRegisteredStateRoot(plist, "darwin", options.env);
+    const domain = `gui/${process.getuid?.() ?? 0}`;
+    await execFileAsync("launchctl", ["kickstart", `${domain}/works.elpapi.pifleet`]);
+    return true;
+  }
+  return false;
 }
-function IsPromise(value) {
-  return IsKindOf(value, "Promise");
+function installedServiceStateRoot(contents, platform) {
+  const encoded = platform === "linux" ? /^Environment=PIFLEET_STATE_ROOT=(.+)$/m.exec(contents)?.[1] : /<key>PIFLEET_STATE_ROOT<\/key><string>([^<]+)<\/string>/.exec(contents)?.[1];
+  if (encoded === void 0) return void 0;
+  if (platform === "linux") return encoded;
+  return encoded.replaceAll("&apos;", "'").replaceAll("&quot;", '"').replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
 }
-function IsRecord(value) {
-  return IsKindOf(value, "Record");
+var PiServiceMismatchError = class extends Error {
+  code = "pi_service_mismatch";
+  constructor(message) {
+    super(message);
+    this.name = "PiServiceMismatchError";
+  }
+};
+async function assertRegisteredPiSelection(options) {
+  const home = options.home ?? homedir2();
+  const platform = process.platform;
+  if (platform !== "linux" && platform !== "darwin") return;
+  const path2 = platform === "linux" ? join5(home, ".config", "systemd", "user", "pi-fleet.service") : join5(home, "Library", "LaunchAgents", "works.elpapi.pifleet.plist");
+  if (!await exists(path2)) return;
+  const contents = await readFile3(path2, "utf8");
+  const installed = installedServicePiExecutable(contents, platform);
+  const installedNode = installedServicePiNode(contents, platform);
+  if (installed === void 0 || installedNode === void 0 || resolve5(installed) !== resolve5(options.selectedPath) || resolve5(installedNode) !== resolve5(options.nodePath)) {
+    throw new PiServiceMismatchError(
+      `The installed pi-fleet service uses a different Pi executable or Node interpreter; repair it from the environment selecting ${options.selectedPath}.`
+    );
+  }
 }
-function IsRef(value) {
-  return IsKindOf(value, "Ref");
+function installedServicePiExecutable(contents, platform) {
+  return installedServiceEnvironmentValue(contents, platform, "PIFLEET_PI_EXECUTABLE");
 }
-function IsRegExp2(value) {
-  return IsKindOf(value, "RegExp");
+function installedServicePiNode(contents, platform) {
+  return installedServiceEnvironmentValue(contents, platform, "PIFLEET_PI_NODE");
 }
-function IsString2(value) {
-  return IsKindOf(value, "String");
+function installedServiceEnvironmentValue(contents, platform, key) {
+  const encoded = platform === "linux" ? new RegExp(`Environment=(?:"${key}=([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|${key}=(.+))$`, "m").exec(contents)?.slice(1).find(Boolean) : new RegExp(`<key>${key}<\\/key><string>([^<]+)<\\/string>`).exec(contents)?.[1];
+  if (encoded === void 0) return void 0;
+  if (platform === "darwin") {
+    return encoded.replaceAll("&apos;", "'").replaceAll("&quot;", '"').replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
+  }
+  return encoded.replaceAll('\\"', '"').replaceAll("\\\\", "\\");
 }
-function IsSymbol2(value) {
-  return IsKindOf(value, "Symbol");
+async function assertRegisteredStateRoot(definitionPath, platform, env) {
+  const installed = installedServiceStateRoot(await readFile3(definitionPath, "utf8"), platform);
+  const requested = resolve5(resolveFleetPaths(env).stateRoot);
+  if (installed === void 0) {
+    if (env.PIFLEET_STATE_ROOT === void 0) return;
+    throw new Error(
+      `Registered pi-fleet service uses the default state root, but this command requested ${requested}. Run the pi-fleet installer with PIFLEET_STATE_ROOT=${requested} to repair the service, or omit the override.`
+    );
+  }
+  if (resolve5(installed) !== requested) {
+    throw new Error(
+      `Registered pi-fleet service uses state root ${installed}, but this command requested ${requested}. Repair the service with the intended PIFLEET_STATE_ROOT before retrying.`
+    );
+  }
 }
-function IsTemplateLiteral(value) {
-  return IsKindOf(value, "TemplateLiteral");
+async function findPackageRoot(modulePath) {
+  let candidate = dirname2(modulePath);
+  for (let depth = 0; depth < 6; depth += 1) {
+    if (await exists(join5(candidate, "dist", "runtime-manifest.json"))) return candidate;
+    const parent = dirname2(candidate);
+    if (parent === candidate) break;
+    candidate = parent;
+  }
+  throw new Error("Unable to locate the pi-fleet package runtime manifest.");
 }
-function IsThis(value) {
-  return IsKindOf(value, "This");
+async function exists(path2) {
+  try {
+    await access2(path2);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function IsTransform(value) {
-  return IsObject(value) && TransformKind in value;
+
+// src/client/socket-fleet-client.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { createConnection as createConnection2 } from "node:net";
+
+// src/protocol/version.ts
+var PROTOCOL_VERSION = 3;
+var MAX_PROTOCOL_FRAME_BYTES = 1024 * 1024;
+
+// src/protocol/jsonl.ts
+function readJsonLines(socket, onValue, onError, maxFrameBytes = MAX_PROTOCOL_FRAME_BYTES) {
+  let buffer = Buffer.alloc(0);
+  const onData = (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (true) {
+      const newline = buffer.indexOf(10);
+      if (newline < 0) {
+        if (buffer.length > maxFrameBytes) {
+          onError(new Error("Protocol frame exceeds maximum size"));
+        }
+        return;
+      }
+      if (newline > maxFrameBytes) {
+        onError(new Error("Protocol frame exceeds maximum size"));
+        return;
+      }
+      const line = buffer.subarray(0, newline).toString("utf8").replace(/\r$/, "");
+      buffer = buffer.subarray(newline + 1);
+      if (line.length === 0) continue;
+      try {
+        onValue(JSON.parse(line));
+      } catch {
+        onError(new Error("Malformed JSON protocol frame"));
+        return;
+      }
+    }
+  };
+  socket.on("data", onData);
+  return () => socket.off("data", onData);
 }
-function IsTuple(value) {
-  return IsKindOf(value, "Tuple");
+function writeJsonLine(socket, value) {
+  return socket.write(`${JSON.stringify(value)}
+`);
 }
-function IsUndefined3(value) {
-  return IsKindOf(value, "Undefined");
+
+// node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
+var value_exports = {};
+__export(value_exports, {
+  HasPropertyKey: () => HasPropertyKey,
+  IsArray: () => IsArray,
+  IsAsyncIterator: () => IsAsyncIterator,
+  IsBigInt: () => IsBigInt,
+  IsBoolean: () => IsBoolean,
+  IsDate: () => IsDate,
+  IsFunction: () => IsFunction,
+  IsIterator: () => IsIterator,
+  IsNull: () => IsNull,
+  IsNumber: () => IsNumber,
+  IsObject: () => IsObject,
+  IsRegExp: () => IsRegExp,
+  IsString: () => IsString,
+  IsSymbol: () => IsSymbol,
+  IsUint8Array: () => IsUint8Array,
+  IsUndefined: () => IsUndefined
+});
+function HasPropertyKey(value, key) {
+  return key in value;
 }
-function IsUnion(value) {
-  return IsKindOf(value, "Union");
+function IsAsyncIterator(value) {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
 }
-function IsUint8Array2(value) {
-  return IsKindOf(value, "Uint8Array");
+function IsArray(value) {
+  return Array.isArray(value);
 }
-function IsUnknown(value) {
-  return IsKindOf(value, "Unknown");
+function IsBigInt(value) {
+  return typeof value === "bigint";
 }
-function IsUnsafe(value) {
-  return IsKindOf(value, "Unsafe");
+function IsBoolean(value) {
+  return typeof value === "boolean";
 }
-function IsVoid(value) {
-  return IsKindOf(value, "Void");
+function IsDate(value) {
+  return value instanceof globalThis.Date;
 }
-function IsKind(value) {
-  return IsObject(value) && Kind in value && IsString(value[Kind]);
+function IsFunction(value) {
+  return typeof value === "function";
 }
-function IsSchema(value) {
-  return IsAny(value) || IsArgument(value) || IsArray3(value) || IsBoolean2(value) || IsBigInt2(value) || IsAsyncIterator2(value) || IsComputed(value) || IsConstructor(value) || IsDate2(value) || IsFunction2(value) || IsInteger(value) || IsIntersect(value) || IsIterator2(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull2(value) || IsNumber3(value) || IsObject3(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString2(value) || IsSymbol2(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined3(value) || IsUnion(value) || IsUint8Array2(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
+function IsIterator(value) {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+}
+function IsNull(value) {
+  return value === null;
+}
+function IsNumber(value) {
+  return typeof value === "number";
+}
+function IsObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function IsRegExp(value) {
+  return value instanceof globalThis.RegExp;
+}
+function IsString(value) {
+  return typeof value === "string";
+}
+function IsSymbol(value) {
+  return typeof value === "symbol";
+}
+function IsUint8Array(value) {
+  return value instanceof globalThis.Uint8Array;
+}
+function IsUndefined(value) {
+  return value === void 0;
 }
 
-// node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
-var type_exports = {};
-__export(type_exports, {
-  IsAny: () => IsAny2,
-  IsArgument: () => IsArgument2,
-  IsArray: () => IsArray4,
-  IsAsyncIterator: () => IsAsyncIterator3,
-  IsBigInt: () => IsBigInt3,
-  IsBoolean: () => IsBoolean3,
-  IsComputed: () => IsComputed2,
-  IsConstructor: () => IsConstructor2,
-  IsDate: () => IsDate3,
-  IsFunction: () => IsFunction3,
-  IsImport: () => IsImport,
-  IsInteger: () => IsInteger2,
-  IsIntersect: () => IsIntersect2,
-  IsIterator: () => IsIterator3,
-  IsKind: () => IsKind2,
-  IsKindOf: () => IsKindOf2,
-  IsLiteral: () => IsLiteral2,
-  IsLiteralBoolean: () => IsLiteralBoolean,
-  IsLiteralNumber: () => IsLiteralNumber,
-  IsLiteralString: () => IsLiteralString,
-  IsLiteralValue: () => IsLiteralValue2,
-  IsMappedKey: () => IsMappedKey2,
-  IsMappedResult: () => IsMappedResult2,
-  IsNever: () => IsNever2,
-  IsNot: () => IsNot2,
-  IsNull: () => IsNull3,
-  IsNumber: () => IsNumber4,
-  IsObject: () => IsObject4,
-  IsOptional: () => IsOptional2,
-  IsPromise: () => IsPromise2,
-  IsProperties: () => IsProperties,
-  IsReadonly: () => IsReadonly2,
-  IsRecord: () => IsRecord2,
-  IsRecursive: () => IsRecursive,
-  IsRef: () => IsRef2,
-  IsRegExp: () => IsRegExp3,
-  IsSchema: () => IsSchema2,
-  IsString: () => IsString3,
-  IsSymbol: () => IsSymbol3,
-  IsTemplateLiteral: () => IsTemplateLiteral2,
-  IsThis: () => IsThis2,
-  IsTransform: () => IsTransform2,
-  IsTuple: () => IsTuple2,
-  IsUint8Array: () => IsUint8Array3,
-  IsUndefined: () => IsUndefined4,
-  IsUnion: () => IsUnion2,
-  IsUnionLiteral: () => IsUnionLiteral,
-  IsUnknown: () => IsUnknown2,
-  IsUnsafe: () => IsUnsafe2,
-  IsVoid: () => IsVoid2,
-  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError
-});
-var TypeGuardUnknownTypeError = class extends TypeBoxError {
-};
-var KnownTypes = [
-  "Argument",
-  "Any",
-  "Array",
-  "AsyncIterator",
-  "BigInt",
-  "Boolean",
-  "Computed",
-  "Constructor",
-  "Date",
-  "Enum",
-  "Function",
-  "Integer",
-  "Intersect",
-  "Iterator",
-  "Literal",
-  "MappedKey",
-  "MappedResult",
-  "Not",
-  "Null",
-  "Number",
-  "Object",
-  "Promise",
-  "Record",
-  "Ref",
-  "RegExp",
-  "String",
-  "Symbol",
-  "TemplateLiteral",
-  "This",
-  "Tuple",
-  "Undefined",
-  "Union",
-  "Uint8Array",
-  "Unknown",
-  "Void"
-];
-function IsPattern(value) {
-  try {
-    new RegExp(value);
-    return true;
-  } catch {
-    return false;
-  }
+// node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
+function ArrayType(value) {
+  return value.map((value2) => Visit(value2));
 }
-function IsControlCharacterFree(value) {
-  if (!IsString(value))
-    return false;
-  for (let i = 0; i < value.length; i++) {
-    const code = value.charCodeAt(i);
-    if (code >= 7 && code <= 13 || code === 27 || code === 127) {
-      return false;
-    }
-  }
-  return true;
+function DateType(value) {
+  return new Date(value.getTime());
 }
-function IsAdditionalProperties(value) {
-  return IsOptionalBoolean(value) || IsSchema2(value);
+function Uint8ArrayType(value) {
+  return new Uint8Array(value);
 }
-function IsOptionalBigInt(value) {
-  return IsUndefined(value) || IsBigInt(value);
+function RegExpType(value) {
+  return new RegExp(value.source, value.flags);
 }
-function IsOptionalNumber(value) {
-  return IsUndefined(value) || IsNumber(value);
+function ObjectType(value) {
+  const result = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Visit(value[key]);
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Visit(value[key]);
+  }
+  return result;
 }
-function IsOptionalBoolean(value) {
-  return IsUndefined(value) || IsBoolean(value);
+function Visit(value) {
+  return IsArray(value) ? ArrayType(value) : IsDate(value) ? DateType(value) : IsUint8Array(value) ? Uint8ArrayType(value) : IsRegExp(value) ? RegExpType(value) : IsObject(value) ? ObjectType(value) : value;
 }
-function IsOptionalString(value) {
-  return IsUndefined(value) || IsString(value);
+function Clone(value) {
+  return Visit(value);
 }
-function IsOptionalPattern(value) {
-  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value) && IsPattern(value);
+
+// node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
+function CloneType(schema, options) {
+  return options === void 0 ? Clone(schema) : Clone({ ...options, ...schema });
 }
-function IsOptionalFormat(value) {
-  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value);
+
+// node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
+function IsObject2(value) {
+  return value !== null && typeof value === "object";
 }
-function IsOptionalSchema(value) {
-  return IsUndefined(value) || IsSchema2(value);
+function IsArray2(value) {
+  return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
 }
-function IsReadonly2(value) {
-  return IsObject(value) && value[ReadonlyKind] === "Readonly";
+function IsUndefined2(value) {
+  return value === void 0;
 }
-function IsOptional2(value) {
-  return IsObject(value) && value[OptionalKind] === "Optional";
+function IsNumber2(value) {
+  return typeof value === "number";
 }
-function IsAny2(value) {
-  return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
+
+// node_modules/@sinclair/typebox/build/esm/system/policy.mjs
+var TypeSystemPolicy;
+(function(TypeSystemPolicy2) {
+  TypeSystemPolicy2.InstanceMode = "default";
+  TypeSystemPolicy2.ExactOptionalPropertyTypes = false;
+  TypeSystemPolicy2.AllowArrayObject = false;
+  TypeSystemPolicy2.AllowNaN = false;
+  TypeSystemPolicy2.AllowNullVoid = false;
+  function IsExactOptionalProperty(value, key) {
+    return TypeSystemPolicy2.ExactOptionalPropertyTypes ? key in value : value[key] !== void 0;
+  }
+  TypeSystemPolicy2.IsExactOptionalProperty = IsExactOptionalProperty;
+  function IsObjectLike(value) {
+    const isObject = IsObject2(value);
+    return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !IsArray2(value);
+  }
+  TypeSystemPolicy2.IsObjectLike = IsObjectLike;
+  function IsRecordLike(value) {
+    return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+  }
+  TypeSystemPolicy2.IsRecordLike = IsRecordLike;
+  function IsNumberLike(value) {
+    return TypeSystemPolicy2.AllowNaN ? IsNumber2(value) : Number.isFinite(value);
+  }
+  TypeSystemPolicy2.IsNumberLike = IsNumberLike;
+  function IsVoidLike(value) {
+    const isUndefined = IsUndefined2(value);
+    return TypeSystemPolicy2.AllowNullVoid ? isUndefined || value === null : isUndefined;
+  }
+  TypeSystemPolicy2.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (TypeSystemPolicy = {}));
+
+// node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs
+function ImmutableArray(value) {
+  return globalThis.Object.freeze(value).map((value2) => Immutable(value2));
 }
-function IsArgument2(value) {
-  return IsKindOf2(value, "Argument") && IsNumber(value.index);
+function ImmutableDate(value) {
+  return value;
 }
-function IsArray4(value) {
-  return IsKindOf2(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema2(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
+function ImmutableUint8Array(value) {
+  return value;
 }
-function IsAsyncIterator3(value) {
-  return IsKindOf2(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+function ImmutableRegExp(value) {
+  return value;
 }
-function IsBigInt3(value) {
-  return IsKindOf2(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
+function ImmutableObject(value) {
+  const result = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Immutable(value[key]);
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Immutable(value[key]);
+  }
+  return globalThis.Object.freeze(result);
 }
-function IsBoolean3(value) {
-  return IsKindOf2(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
+function Immutable(value) {
+  return IsArray(value) ? ImmutableArray(value) : IsDate(value) ? ImmutableDate(value) : IsUint8Array(value) ? ImmutableUint8Array(value) : IsRegExp(value) ? ImmutableRegExp(value) : IsObject(value) ? ImmutableObject(value) : value;
 }
-function IsComputed2(value) {
-  return IsKindOf2(value, "Computed") && IsString(value.target) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema));
+
+// node_modules/@sinclair/typebox/build/esm/type/create/type.mjs
+function CreateType(schema, options) {
+  const result = options !== void 0 ? { ...options, ...schema } : schema;
+  switch (TypeSystemPolicy.InstanceMode) {
+    case "freeze":
+      return Immutable(result);
+    case "clone":
+      return Clone(result);
+    default:
+      return result;
+  }
 }
-function IsConstructor2(value) {
-  return IsKindOf2(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
+
+// node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
+var TypeBoxError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
+var TransformKind = Symbol.for("TypeBox.Transform");
+var ReadonlyKind = Symbol.for("TypeBox.Readonly");
+var OptionalKind = Symbol.for("TypeBox.Optional");
+var Hint = Symbol.for("TypeBox.Hint");
+var Kind = Symbol.for("TypeBox.Kind");
+
+// node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
+function IsReadonly(value) {
+  return IsObject(value) && value[ReadonlyKind] === "Readonly";
 }
-function IsDate3(value) {
-  return IsKindOf2(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
+function IsOptional(value) {
+  return IsObject(value) && value[OptionalKind] === "Optional";
 }
-function IsFunction3(value) {
-  return IsKindOf2(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
+function IsAny(value) {
+  return IsKindOf(value, "Any");
 }
-function IsImport(value) {
-  return IsKindOf2(value, "Import") && HasPropertyKey(value, "$defs") && IsObject(value.$defs) && IsProperties(value.$defs) && HasPropertyKey(value, "$ref") && IsString(value.$ref) && value.$ref in value.$defs;
+function IsArgument(value) {
+  return IsKindOf(value, "Argument");
 }
-function IsInteger2(value) {
-  return IsKindOf2(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+function IsArray3(value) {
+  return IsKindOf(value, "Array");
 }
-function IsProperties(value) {
-  return IsObject(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema2(schema));
+function IsAsyncIterator2(value) {
+  return IsKindOf(value, "AsyncIterator");
 }
-function IsIntersect2(value) {
-  return IsKindOf2(value, "Intersect") && (IsString(value.type) && value.type !== "object" ? false : true) && IsArray(value.allOf) && value.allOf.every((schema) => IsSchema2(schema) && !IsTransform2(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
+function IsBigInt2(value) {
+  return IsKindOf(value, "BigInt");
 }
-function IsIterator3(value) {
-  return IsKindOf2(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+function IsBoolean2(value) {
+  return IsKindOf(value, "Boolean");
 }
-function IsKindOf2(value, kind) {
-  return IsObject(value) && Kind in value && value[Kind] === kind;
+function IsComputed(value) {
+  return IsKindOf(value, "Computed");
 }
-function IsLiteralString(value) {
-  return IsLiteral2(value) && IsString(value.const);
+function IsConstructor(value) {
+  return IsKindOf(value, "Constructor");
 }
-function IsLiteralNumber(value) {
-  return IsLiteral2(value) && IsNumber(value.const);
+function IsDate2(value) {
+  return IsKindOf(value, "Date");
 }
-function IsLiteralBoolean(value) {
-  return IsLiteral2(value) && IsBoolean(value.const);
+function IsFunction2(value) {
+  return IsKindOf(value, "Function");
 }
-function IsLiteral2(value) {
-  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue2(value.const);
+function IsInteger(value) {
+  return IsKindOf(value, "Integer");
 }
-function IsLiteralValue2(value) {
-  return IsBoolean(value) || IsNumber(value) || IsString(value);
+function IsIntersect(value) {
+  return IsKindOf(value, "Intersect");
 }
-function IsMappedKey2(value) {
-  return IsKindOf2(value, "MappedKey") && IsArray(value.keys) && value.keys.every((key) => IsNumber(key) || IsString(key));
+function IsIterator2(value) {
+  return IsKindOf(value, "Iterator");
 }
-function IsMappedResult2(value) {
-  return IsKindOf2(value, "MappedResult") && IsProperties(value.properties);
+function IsKindOf(value, kind) {
+  return IsObject(value) && Kind in value && value[Kind] === kind;
 }
-function IsNever2(value) {
-  return IsKindOf2(value, "Never") && IsObject(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
+function IsLiteralValue(value) {
+  return IsBoolean(value) || IsNumber(value) || IsString(value);
 }
-function IsNot2(value) {
-  return IsKindOf2(value, "Not") && IsSchema2(value.not);
+function IsLiteral(value) {
+  return IsKindOf(value, "Literal");
 }
-function IsNull3(value) {
-  return IsKindOf2(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
+function IsMappedKey(value) {
+  return IsKindOf(value, "MappedKey");
 }
-function IsNumber4(value) {
-  return IsKindOf2(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+function IsMappedResult(value) {
+  return IsKindOf(value, "MappedResult");
 }
-function IsObject4(value) {
-  return IsKindOf2(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
+function IsNever(value) {
+  return IsKindOf(value, "Never");
 }
-function IsPromise2(value) {
-  return IsKindOf2(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema2(value.item);
+function IsNot(value) {
+  return IsKindOf(value, "Not");
 }
-function IsRecord2(value) {
-  return IsKindOf2(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject(value.patternProperties) && ((schema) => {
-    const keys = Object.getOwnPropertyNames(schema.patternProperties);
-    return keys.length === 1 && IsPattern(keys[0]) && IsObject(schema.patternProperties) && IsSchema2(schema.patternProperties[keys[0]]);
-  })(value);
+function IsNull2(value) {
+  return IsKindOf(value, "Null");
 }
-function IsRecursive(value) {
-  return IsObject(value) && Hint in value && value[Hint] === "Recursive";
+function IsNumber3(value) {
+  return IsKindOf(value, "Number");
 }
-function IsRef2(value) {
-  return IsKindOf2(value, "Ref") && IsOptionalString(value.$id) && IsString(value.$ref);
+function IsObject3(value) {
+  return IsKindOf(value, "Object");
 }
-function IsRegExp3(value) {
-  return IsKindOf2(value, "RegExp") && IsOptionalString(value.$id) && IsString(value.source) && IsString(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
+function IsPromise(value) {
+  return IsKindOf(value, "Promise");
 }
-function IsString3(value) {
-  return IsKindOf2(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
+function IsRecord(value) {
+  return IsKindOf(value, "Record");
 }
-function IsSymbol3(value) {
-  return IsKindOf2(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
+function IsRef(value) {
+  return IsKindOf(value, "Ref");
 }
-function IsTemplateLiteral2(value) {
-  return IsKindOf2(value, "TemplateLiteral") && value.type === "string" && IsString(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
+function IsRegExp2(value) {
+  return IsKindOf(value, "RegExp");
 }
-function IsThis2(value) {
-  return IsKindOf2(value, "This") && IsOptionalString(value.$id) && IsString(value.$ref);
+function IsString2(value) {
+  return IsKindOf(value, "String");
 }
-function IsTransform2(value) {
-  return IsObject(value) && TransformKind in value;
+function IsSymbol2(value) {
+  return IsKindOf(value, "Symbol");
 }
-function IsTuple2(value) {
-  return IsKindOf2(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber(value.minItems) && IsNumber(value.maxItems) && value.minItems === value.maxItems && // empty
-  (IsUndefined(value.items) && IsUndefined(value.additionalItems) && value.minItems === 0 || IsArray(value.items) && value.items.every((schema) => IsSchema2(schema)));
+function IsTemplateLiteral(value) {
+  return IsKindOf(value, "TemplateLiteral");
 }
-function IsUndefined4(value) {
-  return IsKindOf2(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
+function IsThis(value) {
+  return IsKindOf(value, "This");
 }
-function IsUnionLiteral(value) {
-  return IsUnion2(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
+function IsTransform(value) {
+  return IsObject(value) && TransformKind in value;
 }
-function IsUnion2(value) {
-  return IsKindOf2(value, "Union") && IsOptionalString(value.$id) && IsObject(value) && IsArray(value.anyOf) && value.anyOf.every((schema) => IsSchema2(schema));
+function IsTuple(value) {
+  return IsKindOf(value, "Tuple");
 }
-function IsUint8Array3(value) {
-  return IsKindOf2(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
+function IsUndefined3(value) {
+  return IsKindOf(value, "Undefined");
 }
-function IsUnknown2(value) {
-  return IsKindOf2(value, "Unknown") && IsOptionalString(value.$id);
+function IsUnion(value) {
+  return IsKindOf(value, "Union");
 }
-function IsUnsafe2(value) {
-  return IsKindOf2(value, "Unsafe");
+function IsUint8Array2(value) {
+  return IsKindOf(value, "Uint8Array");
 }
-function IsVoid2(value) {
-  return IsKindOf2(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
+function IsUnknown(value) {
+  return IsKindOf(value, "Unknown");
 }
-function IsKind2(value) {
-  return IsObject(value) && Kind in value && IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
+function IsUnsafe(value) {
+  return IsKindOf(value, "Unsafe");
 }
-function IsSchema2(value) {
-  return IsObject(value) && (IsAny2(value) || IsArgument2(value) || IsArray4(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsComputed2(value) || IsConstructor2(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect2(value) || IsIterator3(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull3(value) || IsNumber4(value) || IsObject4(value) || IsPromise2(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined4(value) || IsUnion2(value) || IsUint8Array3(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
+function IsVoid(value) {
+  return IsKindOf(value, "Void");
 }
-
-// node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
-var PatternBoolean = "(true|false)";
-var PatternNumber = "(0|[1-9][0-9]*)";
-var PatternString = "(.*)";
-var PatternNever = "(?!.*)";
-var PatternBooleanExact = `^${PatternBoolean}$`;
-var PatternNumberExact = `^${PatternNumber}$`;
-var PatternStringExact = `^${PatternString}$`;
-var PatternNeverExact = `^${PatternNever}$`;
-
-// node_modules/@sinclair/typebox/build/esm/type/sets/set.mjs
-function SetIncludes(T, S) {
-  return T.includes(S);
+function IsKind(value) {
+  return IsObject(value) && Kind in value && IsString(value[Kind]);
 }
-function SetDistinct(T) {
-  return [...new Set(T)];
+function IsSchema(value) {
+  return IsAny(value) || IsArgument(value) || IsArray3(value) || IsBoolean2(value) || IsBigInt2(value) || IsAsyncIterator2(value) || IsComputed(value) || IsConstructor(value) || IsDate2(value) || IsFunction2(value) || IsInteger(value) || IsIntersect(value) || IsIterator2(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull2(value) || IsNumber3(value) || IsObject3(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString2(value) || IsSymbol2(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined3(value) || IsUnion(value) || IsUint8Array2(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
 }
-function SetIntersect(T, S) {
-  return T.filter((L) => S.includes(L));
+
+// node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
+var type_exports = {};
+__export(type_exports, {
+  IsAny: () => IsAny2,
+  IsArgument: () => IsArgument2,
+  IsArray: () => IsArray4,
+  IsAsyncIterator: () => IsAsyncIterator3,
+  IsBigInt: () => IsBigInt3,
+  IsBoolean: () => IsBoolean3,
+  IsComputed: () => IsComputed2,
+  IsConstructor: () => IsConstructor2,
+  IsDate: () => IsDate3,
+  IsFunction: () => IsFunction3,
+  IsImport: () => IsImport,
+  IsInteger: () => IsInteger2,
+  IsIntersect: () => IsIntersect2,
+  IsIterator: () => IsIterator3,
+  IsKind: () => IsKind2,
+  IsKindOf: () => IsKindOf2,
+  IsLiteral: () => IsLiteral2,
+  IsLiteralBoolean: () => IsLiteralBoolean,
+  IsLiteralNumber: () => IsLiteralNumber,
+  IsLiteralString: () => IsLiteralString,
+  IsLiteralValue: () => IsLiteralValue2,
+  IsMappedKey: () => IsMappedKey2,
+  IsMappedResult: () => IsMappedResult2,
+  IsNever: () => IsNever2,
+  IsNot: () => IsNot2,
+  IsNull: () => IsNull3,
+  IsNumber: () => IsNumber4,
+  IsObject: () => IsObject4,
+  IsOptional: () => IsOptional2,
+  IsPromise: () => IsPromise2,
+  IsProperties: () => IsProperties,
+  IsReadonly: () => IsReadonly2,
+  IsRecord: () => IsRecord2,
+  IsRecursive: () => IsRecursive,
+  IsRef: () => IsRef2,
+  IsRegExp: () => IsRegExp3,
+  IsSchema: () => IsSchema2,
+  IsString: () => IsString3,
+  IsSymbol: () => IsSymbol3,
+  IsTemplateLiteral: () => IsTemplateLiteral2,
+  IsThis: () => IsThis2,
+  IsTransform: () => IsTransform2,
+  IsTuple: () => IsTuple2,
+  IsUint8Array: () => IsUint8Array3,
+  IsUndefined: () => IsUndefined4,
+  IsUnion: () => IsUnion2,
+  IsUnionLiteral: () => IsUnionLiteral,
+  IsUnknown: () => IsUnknown2,
+  IsUnsafe: () => IsUnsafe2,
+  IsVoid: () => IsVoid2,
+  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError
+});
+var TypeGuardUnknownTypeError = class extends TypeBoxError {
+};
+var KnownTypes = [
+  "Argument",
+  "Any",
+  "Array",
+  "AsyncIterator",
+  "BigInt",
+  "Boolean",
+  "Computed",
+  "Constructor",
+  "Date",
+  "Enum",
+  "Function",
+  "Integer",
+  "Intersect",
+  "Iterator",
+  "Literal",
+  "MappedKey",
+  "MappedResult",
+  "Not",
+  "Null",
+  "Number",
+  "Object",
+  "Promise",
+  "Record",
+  "Ref",
+  "RegExp",
+  "String",
+  "Symbol",
+  "TemplateLiteral",
+  "This",
+  "Tuple",
+  "Undefined",
+  "Union",
+  "Uint8Array",
+  "Unknown",
+  "Void"
+];
+function IsPattern(value) {
+  try {
+    new RegExp(value);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function SetIntersectManyResolve(T, Init) {
-  return T.reduce((Acc, L) => {
-    return SetIntersect(Acc, L);
-  }, Init);
+function IsControlCharacterFree(value) {
+  if (!IsString(value))
+    return false;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 7 && code <= 13 || code === 27 || code === 127) {
+      return false;
+    }
+  }
+  return true;
 }
-function SetIntersectMany(T) {
-  return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
+function IsAdditionalProperties(value) {
+  return IsOptionalBoolean(value) || IsSchema2(value);
+}
+function IsOptionalBigInt(value) {
+  return IsUndefined(value) || IsBigInt(value);
+}
+function IsOptionalNumber(value) {
+  return IsUndefined(value) || IsNumber(value);
+}
+function IsOptionalBoolean(value) {
+  return IsUndefined(value) || IsBoolean(value);
+}
+function IsOptionalString(value) {
+  return IsUndefined(value) || IsString(value);
+}
+function IsOptionalPattern(value) {
+  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value) && IsPattern(value);
+}
+function IsOptionalFormat(value) {
+  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value);
+}
+function IsOptionalSchema(value) {
+  return IsUndefined(value) || IsSchema2(value);
+}
+function IsReadonly2(value) {
+  return IsObject(value) && value[ReadonlyKind] === "Readonly";
+}
+function IsOptional2(value) {
+  return IsObject(value) && value[OptionalKind] === "Optional";
+}
+function IsAny2(value) {
+  return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
+}
+function IsArgument2(value) {
+  return IsKindOf2(value, "Argument") && IsNumber(value.index);
+}
+function IsArray4(value) {
+  return IsKindOf2(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema2(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
+}
+function IsAsyncIterator3(value) {
+  return IsKindOf2(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+}
+function IsBigInt3(value) {
+  return IsKindOf2(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
+}
+function IsBoolean3(value) {
+  return IsKindOf2(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
+}
+function IsComputed2(value) {
+  return IsKindOf2(value, "Computed") && IsString(value.target) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema));
+}
+function IsConstructor2(value) {
+  return IsKindOf2(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
+}
+function IsDate3(value) {
+  return IsKindOf2(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
+}
+function IsFunction3(value) {
+  return IsKindOf2(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
+}
+function IsImport(value) {
+  return IsKindOf2(value, "Import") && HasPropertyKey(value, "$defs") && IsObject(value.$defs) && IsProperties(value.$defs) && HasPropertyKey(value, "$ref") && IsString(value.$ref) && value.$ref in value.$defs;
+}
+function IsInteger2(value) {
+  return IsKindOf2(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+function IsProperties(value) {
+  return IsObject(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema2(schema));
+}
+function IsIntersect2(value) {
+  return IsKindOf2(value, "Intersect") && (IsString(value.type) && value.type !== "object" ? false : true) && IsArray(value.allOf) && value.allOf.every((schema) => IsSchema2(schema) && !IsTransform2(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
+}
+function IsIterator3(value) {
+  return IsKindOf2(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+}
+function IsKindOf2(value, kind) {
+  return IsObject(value) && Kind in value && value[Kind] === kind;
+}
+function IsLiteralString(value) {
+  return IsLiteral2(value) && IsString(value.const);
+}
+function IsLiteralNumber(value) {
+  return IsLiteral2(value) && IsNumber(value.const);
+}
+function IsLiteralBoolean(value) {
+  return IsLiteral2(value) && IsBoolean(value.const);
+}
+function IsLiteral2(value) {
+  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue2(value.const);
+}
+function IsLiteralValue2(value) {
+  return IsBoolean(value) || IsNumber(value) || IsString(value);
+}
+function IsMappedKey2(value) {
+  return IsKindOf2(value, "MappedKey") && IsArray(value.keys) && value.keys.every((key) => IsNumber(key) || IsString(key));
+}
+function IsMappedResult2(value) {
+  return IsKindOf2(value, "MappedResult") && IsProperties(value.properties);
+}
+function IsNever2(value) {
+  return IsKindOf2(value, "Never") && IsObject(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
+}
+function IsNot2(value) {
+  return IsKindOf2(value, "Not") && IsSchema2(value.not);
+}
+function IsNull3(value) {
+  return IsKindOf2(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
+}
+function IsNumber4(value) {
+  return IsKindOf2(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+function IsObject4(value) {
+  return IsKindOf2(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
+}
+function IsPromise2(value) {
+  return IsKindOf2(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema2(value.item);
+}
+function IsRecord2(value) {
+  return IsKindOf2(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject(value.patternProperties) && ((schema) => {
+    const keys = Object.getOwnPropertyNames(schema.patternProperties);
+    return keys.length === 1 && IsPattern(keys[0]) && IsObject(schema.patternProperties) && IsSchema2(schema.patternProperties[keys[0]]);
+  })(value);
+}
+function IsRecursive(value) {
+  return IsObject(value) && Hint in value && value[Hint] === "Recursive";
+}
+function IsRef2(value) {
+  return IsKindOf2(value, "Ref") && IsOptionalString(value.$id) && IsString(value.$ref);
+}
+function IsRegExp3(value) {
+  return IsKindOf2(value, "RegExp") && IsOptionalString(value.$id) && IsString(value.source) && IsString(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
+}
+function IsString3(value) {
+  return IsKindOf2(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
+}
+function IsSymbol3(value) {
+  return IsKindOf2(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
+}
+function IsTemplateLiteral2(value) {
+  return IsKindOf2(value, "TemplateLiteral") && value.type === "string" && IsString(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
+}
+function IsThis2(value) {
+  return IsKindOf2(value, "This") && IsOptionalString(value.$id) && IsString(value.$ref);
+}
+function IsTransform2(value) {
+  return IsObject(value) && TransformKind in value;
+}
+function IsTuple2(value) {
+  return IsKindOf2(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber(value.minItems) && IsNumber(value.maxItems) && value.minItems === value.maxItems && // empty
+  (IsUndefined(value.items) && IsUndefined(value.additionalItems) && value.minItems === 0 || IsArray(value.items) && value.items.every((schema) => IsSchema2(schema)));
+}
+function IsUndefined4(value) {
+  return IsKindOf2(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
+}
+function IsUnionLiteral(value) {
+  return IsUnion2(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
+}
+function IsUnion2(value) {
+  return IsKindOf2(value, "Union") && IsOptionalString(value.$id) && IsObject(value) && IsArray(value.anyOf) && value.anyOf.every((schema) => IsSchema2(schema));
+}
+function IsUint8Array3(value) {
+  return IsKindOf2(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
+}
+function IsUnknown2(value) {
+  return IsKindOf2(value, "Unknown") && IsOptionalString(value.$id);
+}
+function IsUnsafe2(value) {
+  return IsKindOf2(value, "Unsafe");
+}
+function IsVoid2(value) {
+  return IsKindOf2(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
+}
+function IsKind2(value) {
+  return IsObject(value) && Kind in value && IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
+}
+function IsSchema2(value) {
+  return IsObject(value) && (IsAny2(value) || IsArgument2(value) || IsArray4(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsComputed2(value) || IsConstructor2(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect2(value) || IsIterator3(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull3(value) || IsNumber4(value) || IsObject4(value) || IsPromise2(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined4(value) || IsUnion2(value) || IsUint8Array3(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
+var PatternBoolean = "(true|false)";
+var PatternNumber = "(0|[1-9][0-9]*)";
+var PatternString = "(.*)";
+var PatternNever = "(?!.*)";
+var PatternBooleanExact = `^${PatternBoolean}$`;
+var PatternNumberExact = `^${PatternNumber}$`;
+var PatternStringExact = `^${PatternString}$`;
+var PatternNeverExact = `^${PatternNever}$`;
+
+// node_modules/@sinclair/typebox/build/esm/type/sets/set.mjs
+function SetIncludes(T, S) {
+  return T.includes(S);
+}
+function SetDistinct(T) {
+  return [...new Set(T)];
+}
+function SetIntersect(T, S) {
+  return T.filter((L) => S.includes(L));
+}
+function SetIntersectManyResolve(T, Init) {
+  return T.reduce((Acc, L) => {
+    return SetIntersect(Acc, L);
+  }, Init);
+}
+function SetIntersectMany(T) {
+  return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
 }
 function SetUnionMany(T) {
   const Acc = [];
@@ -6191,1234 +7235,882 @@ var TransformDecodeBuilder = class {
   constructor(schema) {
     this.schema = schema;
   }
-  Decode(decode) {
-    return new TransformEncodeBuilder(this.schema, decode);
-  }
-};
-var TransformEncodeBuilder = class {
-  constructor(schema, decode) {
-    this.schema = schema;
-    this.decode = decode;
-  }
-  EncodeTransform(encode, schema) {
-    const Encode = (value) => schema[TransformKind].Encode(encode(value));
-    const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
-    const Codec = { Encode, Decode };
-    return { ...schema, [TransformKind]: Codec };
-  }
-  EncodeSchema(encode, schema) {
-    const Codec = { Decode: this.decode, Encode: encode };
-    return { ...schema, [TransformKind]: Codec };
-  }
-  Encode(encode) {
-    return IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
-  }
-};
-function Transform(schema) {
-  return new TransformDecodeBuilder(schema);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.mjs
-function Unsafe(options = {}) {
-  return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
-function Void(options) {
-  return CreateType({ [Kind]: "Void", type: "void" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
-var type_exports2 = {};
-__export(type_exports2, {
-  Any: () => Any,
-  Argument: () => Argument2,
-  Array: () => Array2,
-  AsyncIterator: () => AsyncIterator,
-  Awaited: () => Awaited,
-  BigInt: () => BigInt,
-  Boolean: () => Boolean2,
-  Capitalize: () => Capitalize,
-  Composite: () => Composite,
-  Const: () => Const,
-  Constructor: () => Constructor,
-  ConstructorParameters: () => ConstructorParameters,
-  Date: () => Date2,
-  Enum: () => Enum,
-  Exclude: () => Exclude,
-  Extends: () => Extends,
-  Extract: () => Extract,
-  Function: () => Function,
-  Index: () => Index,
-  InstanceType: () => InstanceType,
-  Instantiate: () => Instantiate,
-  Integer: () => Integer,
-  Intersect: () => Intersect,
-  Iterator: () => Iterator,
-  KeyOf: () => KeyOf,
-  Literal: () => Literal,
-  Lowercase: () => Lowercase,
-  Mapped: () => Mapped,
-  Module: () => Module,
-  Never: () => Never,
-  Not: () => Not,
-  Null: () => Null,
-  Number: () => Number2,
-  Object: () => Object2,
-  Omit: () => Omit,
-  Optional: () => Optional,
-  Parameters: () => Parameters,
-  Partial: () => Partial,
-  Pick: () => Pick,
-  Promise: () => Promise2,
-  Readonly: () => Readonly,
-  ReadonlyOptional: () => ReadonlyOptional,
-  Record: () => Record,
-  Recursive: () => Recursive,
-  Ref: () => Ref,
-  RegExp: () => RegExp2,
-  Required: () => Required,
-  Rest: () => Rest,
-  ReturnType: () => ReturnType,
-  String: () => String2,
-  Symbol: () => Symbol2,
-  TemplateLiteral: () => TemplateLiteral,
-  Transform: () => Transform,
-  Tuple: () => Tuple,
-  Uint8Array: () => Uint8Array2,
-  Uncapitalize: () => Uncapitalize,
-  Undefined: () => Undefined,
-  Union: () => Union,
-  Unknown: () => Unknown,
-  Unsafe: () => Unsafe,
-  Uppercase: () => Uppercase,
-  Void: () => Void
-});
-
-// node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
-var Type = type_exports2;
-
-// src/protocol/pi-identity.ts
-var MANAGED_PI_ARTIFACT_ID = "@earendil-works/pi-coding-agent@0.80.10";
-var PiRuntimeIdentitySchema = Type.Union([
-  Type.Object(
-    {
-      mode: Type.Literal("managed"),
-      artifactId: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  ),
-  Type.Object(
-    {
-      mode: Type.Literal("external"),
-      selectedPath: Type.String({ minLength: 1 }),
-      nodePath: Type.String({ minLength: 1 }),
-      realPath: Type.String({ minLength: 1 }),
-      version: Type.String({ minLength: 1 }),
-      fingerprint: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  )
-]);
-var MANAGED_PI_RUNTIME_IDENTITY = Object.freeze({
-  mode: "managed",
-  artifactId: MANAGED_PI_ARTIFACT_ID
-});
-
-// src/client/socket-fleet-client.ts
-var SocketFleetClient = class {
-  constructor(options) {
-    this.options = options;
-  }
-  create(input, options) {
-    return this.#request("agent.create", input, options);
-  }
-  send(input, options) {
-    return this.#request("agent.send", input, options);
-  }
-  receive(input, options) {
-    return this.#request("agent.receive", { ...input, timeoutMs: options.timeoutMs }, options);
-  }
-  status(input, options) {
-    return this.#request("agent.status", input, options);
-  }
-  list(options) {
-    return this.#request("agent.list", {}, options);
-  }
-  async *watch(input, options) {
-    let socket;
-    try {
-      await this.options.beforeConnect?.();
-      socket = await connect(this.options.socketPath, options.signal);
-    } catch (error) {
-      yield err(connectionError(error));
-      return;
-    }
-    const requestId = randomUUID();
-    const frames = frameIterator(socket, options.signal);
-    writeJsonLine(socket, {
-      v: PROTOCOL_VERSION,
-      requestId,
-      method: "agent.watch",
-      params: input
-    });
-    let endedExplicitly = false;
-    try {
-      for await (const frame of frames) {
-        if (!isRecord(frame) || frame.requestId !== requestId) continue;
-        if (frame.v !== PROTOCOL_VERSION) {
-          yield err({
-            code: "protocol_incompatible",
-            message: "The running pi-fleet runtime is incompatible with this client; repair or restart it."
-          });
-          return;
-        }
-        if (frame.stream === "ready") {
-          yield ok({ type: "ready" });
-          continue;
-        }
-        if (frame.stream === "end") {
-          endedExplicitly = true;
-          return;
-        }
-        if (frame.stream === "chunk" && typeof frame.data === "string") {
-          yield ok({ type: "chunk", bytes: Buffer.from(frame.data, "base64") });
-          continue;
-        }
-        if (frame.stream === "error" && isErrorRecord(frame.error)) {
-          yield err(frame.error);
-          return;
-        }
-        yield err({ code: "protocol_error", message: "Invalid watch stream frame." });
-        return;
-      }
-      if (!endedExplicitly && !options.signal.aborted) {
-        yield err({
-          code: "runtime_unavailable",
-          message: "Runtime connection closed before the watch stream ended."
-        });
-      }
-    } catch (error) {
-      if (!options.signal.aborted) yield err(connectionError(error));
-    } finally {
-      socket.destroy();
-    }
-  }
-  destroy(input, options) {
-    return this.#request("agent.destroy", input, options);
-  }
-  compact(input, options) {
-    return this.#request("agent.compact", input, options);
-  }
-  async #request(method, params, options) {
-    let socket;
-    try {
-      await this.options.beforeConnect?.();
-      socket = await connect(this.options.socketPath, options.signal);
-    } catch (error) {
-      return err(connectionError(error));
-    }
-    const requestId = randomUUID();
-    let piIdentity;
-    try {
-      piIdentity = requiresPiIdentity(method) ? await this.#piIdentity() : void 0;
-    } catch (error) {
-      socket.destroy();
-      return err(piSelectionError(error));
-    }
-    const response = firstMatchingFrame(socket, requestId, options.signal);
-    writeJsonLine(socket, {
-      v: PROTOCOL_VERSION,
-      requestId,
-      method,
-      params,
-      ...isMutationOptions(options) ? { operation: options.operation } : {},
-      ...piIdentity === void 0 ? {} : { runtime: { pi: piIdentity } }
-    });
-    try {
-      const frame = await response;
-      if (!isRecord(frame) || frame.requestId !== requestId || typeof frame.ok !== "boolean") {
-        return err({ code: "protocol_error", message: "Invalid runtime response." });
-      }
-      if (frame.v !== PROTOCOL_VERSION) {
-        return err({
-          code: "protocol_incompatible",
-          message: "The running pi-fleet runtime is incompatible with this client; repair or restart it."
-        });
-      }
-      if (frame.ok) return ok(frame.result);
-      if (method === "agent.compact" && isErrorRecord(frame.error) && frame.error.code === "invalid_request" && frame.error.message === "Invalid protocol request: /method") {
-        return err({
-          code: "protocol_incompatible",
-          message: "The running pi-fleet runtime does not support compact; upgrade or repair it."
-        });
-      }
-      if (isErrorRecord(frame.error)) return err(frame.error);
-      return err({ code: "protocol_error", message: "Runtime returned an invalid error." });
-    } catch (error) {
-      return err(connectionError(error));
-    } finally {
-      socket.destroy();
-    }
-  }
-  async #piIdentity() {
-    const configured = this.options.piIdentity;
-    if (configured === void 0) return MANAGED_PI_RUNTIME_IDENTITY;
-    return typeof configured === "function" ? configured() : configured;
-  }
-};
-function piSelectionError(error) {
-  const code = error.code;
-  if (code === "pi_not_found" || code === "pi_not_executable" || code === "pi_version_unavailable" || code === "pi_version_unsupported" || code === "pi_installation_changed" || code === "pi_service_mismatch") {
-    return { code, message: error instanceof Error ? error.message : "Pi is unavailable." };
-  }
-  return { code: "internal_error", message: "Pi selection failed." };
-}
-function isMutationOptions(options) {
-  return "operation" in options;
-}
-function requiresPiIdentity(method) {
-  return method === "agent.create" || method === "agent.send" || method === "agent.compact";
-}
-function connect(socketPath, signal) {
-  return new Promise((resolveConnect, rejectConnect) => {
-    if (signal.aborted) {
-      rejectConnect(new Error("Request cancelled"));
-      return;
-    }
-    const socket = createConnection(socketPath);
-    const onAbort = () => socket.destroy(new Error("Request cancelled"));
-    signal.addEventListener("abort", onAbort, { once: true });
-    socket.once("connect", () => {
-      signal.removeEventListener("abort", onAbort);
-      resolveConnect(socket);
-    });
-    socket.once("error", rejectConnect);
-  });
-}
-function firstMatchingFrame(socket, requestId, signal) {
-  return new Promise((resolveFrame, rejectFrame) => {
-    let settled = false;
-    const finish = (action) => {
-      if (settled) return;
-      settled = true;
-      stop();
-      signal.removeEventListener("abort", onAbort);
-      action();
-    };
-    const stop = readJsonLines(
-      socket,
-      (frame) => {
-        if (!isRecord(frame) || frame.requestId !== requestId) return;
-        finish(() => resolveFrame(frame));
-      },
-      (error) => finish(() => rejectFrame(error))
-    );
-    const onAbort = () => finish(() => rejectFrame(new Error("Request cancelled")));
-    signal.addEventListener("abort", onAbort, { once: true });
-    socket.once(
-      "close",
-      () => finish(() => rejectFrame(new Error("Runtime connection closed before responding")))
-    );
-  });
-}
-async function* frameIterator(socket, signal, maxQueuedBytes = 1024 * 1024) {
-  const queue = [];
-  let queuedBytes = 0;
-  let paused = false;
-  let ended = false;
-  let failure = null;
-  let wake = null;
-  const notify = () => {
-    wake?.();
-    wake = null;
-  };
-  const stop = readJsonLines(
-    socket,
-    (frame) => {
-      const bytes = Buffer.byteLength(JSON.stringify(frame), "utf8");
-      queue.push({ value: frame, bytes });
-      queuedBytes += bytes;
-      if (queuedBytes >= maxQueuedBytes && !paused) {
-        socket.pause();
-        paused = true;
-      }
-      notify();
-    },
-    (error) => {
-      failure = error;
-      ended = true;
-      notify();
-    }
-  );
-  socket.once("end", () => {
-    failure = new Error("Runtime connection closed before completing the stream");
-    ended = true;
-    notify();
-  });
-  const onAbort = () => {
-    failure = new Error("Request cancelled");
-    ended = true;
-    notify();
-  };
-  signal.addEventListener("abort", onAbort, { once: true });
-  try {
-    while (!ended || queue.length > 0) {
-      if (queue.length === 0) {
-        await new Promise((resolveWake) => {
-          wake = resolveWake;
-        });
-        continue;
-      }
-      const item = queue.shift();
-      if (item === void 0) continue;
-      queuedBytes -= item.bytes;
-      if (paused && queuedBytes < maxQueuedBytes / 2) {
-        socket.resume();
-        paused = false;
-      }
-      yield item.value;
-    }
-    if (failure !== null) throw failure;
-  } finally {
-    stop();
-    signal.removeEventListener("abort", onAbort);
-  }
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function isErrorRecord(value) {
-  return isRecord(value) && typeof value.code === "string" && typeof value.message === "string";
-}
-function connectionError(error) {
-  return {
-    code: "runtime_unavailable",
-    message: error instanceof Error ? error.message : "Unable to connect to pi-fleet runtime."
-  };
-}
-
-// src/pi/external-installation.ts
-import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { constants } from "node:fs";
-import { createReadStream } from "node:fs";
-import { access, realpath, stat } from "node:fs/promises";
-import { delimiter, dirname, isAbsolute, join } from "node:path";
-var VERSION_TIMEOUT_MS = 3e3;
-var MAX_VERSION_OUTPUT_BYTES = 4 * 1024;
-var ExternalPiResolutionError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "ExternalPiResolutionError";
-  }
-};
-async function resolveExternalPiInstallation(options = {}) {
-  const env = options.env ?? process.env;
-  const selectedPath = await resolveSelectedPath(env);
-  const nodePath = options.nodePath ?? await resolveNodePath(env);
-  await inspectNode(nodePath);
-  const executionEnv = externalPiExecutionEnvironment(env, selectedPath, nodePath);
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    const observation = await observeInstallation(selectedPath, executionEnv, options);
-    if (observation !== null) {
-      return {
-        selectedPath,
-        nodePath,
-        ...observation
-      };
-    }
-  }
-  throw new ExternalPiResolutionError(
-    "pi_installation_changed",
-    "Pi changed while its installation was being observed."
-  );
-}
-function externalPiExecutionEnvironment(env, selectedPath, nodePath) {
-  return {
-    ...env,
-    PATH: [dirname(nodePath), dirname(selectedPath), env.PATH].filter((value) => value !== void 0 && value.length > 0).join(delimiter)
-  };
-}
-async function observeInstallation(selectedPath, env, options) {
-  const beforeRealPath = await inspectExecutable(selectedPath, "Pi");
-  const beforeHash = await hashFile(beforeRealPath);
-  const versionOutput = await (options.versionCommand ?? ((executable) => readVersion(executable, env, options.versionTimeoutMs, options.maxVersionOutputBytes)))(selectedPath);
-  const version = parseVersion(versionOutput);
-  const afterRealPath = await inspectExecutable(selectedPath, "Pi");
-  const afterHash = await hashFile(afterRealPath);
-  if (beforeRealPath !== afterRealPath || beforeHash !== afterHash) return null;
-  return {
-    realPath: afterRealPath,
-    version,
-    fingerprint: createHash("sha256").update(JSON.stringify([selectedPath, afterRealPath, version, afterHash])).digest("hex")
-  };
-}
-async function resolveSelectedPath(env) {
-  const explicit = env.PIFLEET_PI_EXECUTABLE;
-  if (explicit !== void 0) {
-    if (!isAbsolute(explicit)) {
-      throw new ExternalPiResolutionError(
-        "invalid_arguments",
-        "PIFLEET_PI_EXECUTABLE must be an absolute path."
-      );
-    }
-    return explicit;
-  }
-  return resolvePathExecutable(env, "pi", "Pi", "pi_not_found");
-}
-async function resolveNodePath(env) {
-  return resolvePathExecutable(env, "node", "Node", "pi_not_executable");
-}
-async function resolvePathExecutable(env, name, label, missingCode) {
-  const path2 = env.PATH;
-  if (path2 === void 0 || path2.length === 0) {
-    throw new ExternalPiResolutionError(missingCode, `${label} was not found on PATH.`);
-  }
-  for (const directory of path2.split(delimiter)) {
-    if (!isAbsolute(directory)) {
-      throw new ExternalPiResolutionError(
-        "invalid_arguments",
-        `PATH entries used to select ${label} must be absolute paths.`
-      );
-    }
-    const candidate = join(directory, name);
-    try {
-      await inspectExecutable(candidate, label);
-      return candidate;
-    } catch (error) {
-      if (!(error instanceof ExternalPiResolutionError) || error.code !== "pi_not_executable" && error.code !== "pi_not_found") {
-        throw error;
-      }
-    }
-  }
-  throw new ExternalPiResolutionError(missingCode, `${label} was not found on PATH.`);
-}
-async function inspectExecutable(path2, label) {
-  try {
-    const target = await realpath(path2);
-    const metadata = await stat(target);
-    if (!metadata.isFile()) {
-      throw new ExternalPiResolutionError("pi_not_executable", `${label} is not a file: ${path2}`);
-    }
-    await access(path2, constants.X_OK);
-    return target;
-  } catch (error) {
-    if (error instanceof ExternalPiResolutionError) throw error;
-    if (error.code === "ENOENT") {
-      throw new ExternalPiResolutionError("pi_not_found", `${label} was not found: ${path2}`);
-    }
-    throw new ExternalPiResolutionError("pi_not_executable", `${label} is not executable: ${path2}`);
-  }
-}
-async function inspectNode(nodePath) {
-  if (!isAbsolute(nodePath)) {
-    throw new ExternalPiResolutionError("invalid_arguments", "Node must be an absolute path.");
-  }
-  try {
-    await inspectExecutable(nodePath, "Node");
-  } catch {
-    throw new ExternalPiResolutionError("pi_not_executable", `Node is not executable: ${nodePath}`);
-  }
-}
-async function hashFile(path2) {
-  const hash = createHash("sha256");
-  await new Promise((resolveHash, rejectHash) => {
-    const stream = createReadStream(path2);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.once("error", rejectHash);
-    stream.once("end", resolveHash);
-  });
-  return hash.digest("hex");
-}
-async function readVersion(executable, env, timeoutMs = VERSION_TIMEOUT_MS, maxOutputBytes = MAX_VERSION_OUTPUT_BYTES) {
-  const child = spawn(executable, ["--version"], {
-    detached: process.platform !== "win32",
-    env,
-    shell: false,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  const chunks = [];
-  let outputBytes = 0;
-  let terminalError = null;
-  let terminated = false;
-  const terminate = () => {
-    if (terminated) return;
-    terminated = true;
-    if (process.platform !== "win32" && child.pid !== void 0) {
-      try {
-        process.kill(-child.pid, "SIGKILL");
-        return;
-      } catch {
-      }
-    }
-    child.kill("SIGKILL");
-  };
-  child.stdout.on("data", (chunk) => {
-    if (terminalError !== null) return;
-    outputBytes += chunk.byteLength;
-    if (outputBytes > maxOutputBytes) {
-      terminalError = new ExternalPiResolutionError(
-        "pi_version_unavailable",
-        "Pi version output exceeded its limit."
-      );
-      terminate();
-      return;
-    }
-    chunks.push(chunk);
-  });
-  child.stderr.resume();
-  return new Promise((resolveVersion, rejectVersion) => {
-    const timer = setTimeout(() => {
-      terminalError = new ExternalPiResolutionError(
-        "pi_version_unavailable",
-        "Pi version command timed out."
-      );
-      terminate();
-    }, timeoutMs);
-    child.once("error", () => {
-      terminalError ??= new ExternalPiResolutionError(
-        "pi_version_unavailable",
-        "Pi version command failed."
-      );
-    });
-    child.once("close", (code) => {
-      clearTimeout(timer);
-      if (terminalError !== null) {
-        rejectVersion(terminalError);
-        return;
-      }
-      if (code !== 0) {
-        rejectVersion(
-          new ExternalPiResolutionError("pi_version_unavailable", "Pi version command failed.")
-        );
-        return;
-      }
-      try {
-        resolveVersion(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks)));
-      } catch {
-        rejectVersion(
-          new ExternalPiResolutionError(
-            "pi_version_unavailable",
-            "Pi version command returned invalid UTF-8."
-          )
-        );
-      }
-    });
-  });
-}
-function parseVersion(output) {
-  const match = /^(?:pi\s+)?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\s*$/i.exec(output);
-  if (match?.[1] === void 0) {
-    throw new ExternalPiResolutionError(
-      "pi_version_unavailable",
-      "Pi version command returned an invalid version."
-    );
-  }
-  return match[1];
-}
-
-// src/pi/process.ts
-var DEFAULT_MAX_STDOUT_FRAME_BYTES = 8 * 1024 * 1024;
-
-// src/pi/external-target.ts
-function installationIdentity(installation) {
-  return {
-    mode: "external",
-    selectedPath: installation.selectedPath,
-    nodePath: installation.nodePath,
-    realPath: installation.realPath,
-    version: installation.version,
-    fingerprint: installation.fingerprint
-  };
-}
-
-// src/platform/client/start-runtime.ts
-import { execFile, spawn as spawn2 } from "node:child_process";
-import { access as access2, readFile as readFile3 } from "node:fs/promises";
-import { createConnection as createConnection2 } from "node:net";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join5, resolve as resolve5 } from "node:path";
-import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
-
-// src/platform/install/runtime-release.ts
-import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
-import { chmod, cp, lstat as lstat2, mkdir, readFile as readFile2, rename, rm, writeFile } from "node:fs/promises";
-import { join as join3, posix, resolve as resolve3, sep as sep2 } from "node:path";
-
-// src/platform/install/tree-integrity.ts
-import { createHash as createHash2 } from "node:crypto";
-import { lstat, readFile, readdir, realpath as realpath2, stat as stat2 } from "node:fs/promises";
-import { join as join2, relative, resolve as resolve2, sep } from "node:path";
-async function hashDirectoryTree(root, manifestPath) {
-  const resolvedRoot = resolve2(root);
-  const entries = await collectFiles(resolvedRoot, resolvedRoot);
-  const hash = createHash2("sha256");
-  let bytes = 0;
-  for (const entry of entries) {
-    const contents = await readFile(entry.absolutePath);
-    bytes += contents.length;
-    hash.update(entry.relativePath);
-    hash.update("\0");
-    hash.update(String(contents.length));
-    hash.update("\0");
-    hash.update(contents);
-    hash.update("\0");
-  }
-  return {
-    path: manifestPath,
-    files: entries.length,
-    bytes,
-    sha256: hash.digest("hex")
-  };
-}
-async function collectFiles(root, directory) {
-  const output = [];
-  for (const name of (await readdir(directory)).sort()) {
-    const absolutePath = join2(directory, name);
-    const linkInfo = await lstat(absolutePath);
-    const info = linkInfo.isSymbolicLink() ? await stat2(absolutePath) : linkInfo;
-    if (info.isDirectory()) {
-      if (linkInfo.isSymbolicLink()) {
-        throw new Error(`Runtime dependency tree contains a directory symlink: ${absolutePath}`);
-      }
-      output.push(...await collectFiles(root, absolutePath));
-      continue;
-    }
-    if (!info.isFile()) {
-      throw new Error(`Runtime dependency tree contains an unsupported entry: ${absolutePath}`);
-    }
-    if (linkInfo.isSymbolicLink()) {
-      const target = await realpath2(absolutePath);
-      if (target !== root && !target.startsWith(`${root}${sep}`)) {
-        throw new Error(
-          `Runtime dependency tree contains an external file symlink: ${absolutePath}`
-        );
-      }
-    }
-    const relativePath = relative(root, absolutePath).split(sep).join("/");
-    if (relativePath.length === 0 || relativePath.startsWith("../")) {
-      throw new Error(`Runtime dependency path escapes its root: ${absolutePath}`);
-    }
-    output.push({ absolutePath, relativePath });
-  }
-  return output.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
-}
-
-// src/platform/install/runtime-release.ts
-var requiredRuntimeArtifacts = /* @__PURE__ */ new Set([
-  "package.json",
-  "bin/pifleet.mjs",
-  "bin/pifleet-runtime.mjs",
-  "dist/cli.mjs",
-  "dist/runtime.mjs",
-  "dist/sqlite-worker.mjs"
-]);
-var dependencyTreePath = "node_modules";
-async function materializeRuntime(options) {
-  const sourceRoot = resolve3(options.sourceRoot);
-  const manifestBytes = await readFile2(join3(sourceRoot, "dist", "runtime-manifest.json"));
-  const sourceManifest = await parseRuntimeManifest(manifestBytes, sourceRoot);
-  if (sourceManifest.closure !== void 0) {
-    await verifyRuntime(sourceRoot);
-    return sourceRoot;
-  }
-  await verifyRuntimeFiles(sourceRoot, sourceManifest);
-  await verifyDependencyIdentities(sourceRoot, sourceManifest.dependencies);
-  const sourceTreeRoot = resolveInside(sourceRoot, dependencyTreePath);
-  const sourceTreeBefore = await hashDirectoryTree(sourceTreeRoot, dependencyTreePath);
-  const sourceManifestSha256 = createHash3("sha256").update(manifestBytes).digest("hex");
-  const materializedManifest = {
-    ...sourceManifest,
-    closure: { sourceManifestSha256, tree: sourceTreeBefore }
-  };
-  const materializedManifestBytes = serializeManifest(materializedManifest);
-  const closureHash = createHash3("sha256").update(sourceManifestSha256).update("\0").update(JSON.stringify(sourceTreeBefore)).digest("hex").slice(0, 16);
-  const applicationRoot = resolve3(options.applicationRoot);
-  await ensurePrivateDirectory(applicationRoot);
-  const releasesRoot = join3(applicationRoot, "releases");
-  await ensurePrivateDirectory(releasesRoot);
-  const destination = join3(releasesRoot, `${sourceManifest.package.version}-${closureHash}`);
-  if (await pathExists(destination)) {
-    await verifyExpectedRuntime(destination, materializedManifest, materializedManifestBytes);
-    return destination;
+  Decode(decode) {
+    return new TransformEncodeBuilder(this.schema, decode);
   }
-  const staging = join3(releasesRoot, `.staging-${randomUUID2()}`);
-  await mkdir(staging, { mode: 448 });
-  try {
-    await cp(join3(sourceRoot, "dist"), join3(staging, "dist"), {
-      recursive: true,
-      dereference: true
-    });
-    await cp(join3(sourceRoot, "bin"), join3(staging, "bin"), {
-      recursive: true,
-      dereference: true
-    });
-    await cp(join3(sourceRoot, "package.json"), join3(staging, "package.json"));
-    await cp(sourceTreeRoot, join3(staging, dependencyTreePath), {
-      recursive: true,
-      dereference: true
-    });
-    await options.hooks?.afterDependencyCopy?.();
-    const stagedTree = await hashDirectoryTree(
-      join3(staging, dependencyTreePath),
-      dependencyTreePath
-    );
-    assertSameTree(sourceTreeBefore, stagedTree, "copied dependency closure");
-    const sourceTreeAfter = await hashDirectoryTree(sourceTreeRoot, dependencyTreePath);
-    assertSameTree(sourceTreeBefore, sourceTreeAfter, "source dependency closure");
-    await writeFile(join3(staging, "dist", "runtime-manifest.json"), materializedManifestBytes);
-    await verifyExpectedRuntime(staging, materializedManifest, materializedManifestBytes);
-    await chmod(staging, 448);
-    try {
-      await rename(staging, destination);
-    } catch (error) {
-      if (!isDestinationRace(error) || !await pathExists(destination)) throw error;
-      await verifyExpectedRuntime(destination, materializedManifest, materializedManifestBytes);
-    }
-    return destination;
-  } finally {
-    await rm(staging, { recursive: true, force: true });
+};
+var TransformEncodeBuilder = class {
+  constructor(schema, decode) {
+    this.schema = schema;
+    this.decode = decode;
   }
-}
-async function verifyRuntime(root) {
-  const resolvedRoot = resolve3(root);
-  const manifestBytes = await readFile2(join3(resolvedRoot, "dist", "runtime-manifest.json"));
-  const manifest = await parseRuntimeManifest(manifestBytes, resolvedRoot);
-  if (manifest.closure === void 0) {
-    throw new Error("Runtime release manifest is missing its materialized closure");
+  EncodeTransform(encode, schema) {
+    const Encode = (value) => schema[TransformKind].Encode(encode(value));
+    const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
+    const Codec = { Encode, Decode };
+    return { ...schema, [TransformKind]: Codec };
   }
-  await verifyRuntimeFiles(resolvedRoot, manifest);
-  await verifyDependencyIdentities(resolvedRoot, manifest.dependencies);
-  const actualTree = await hashDirectoryTree(
-    resolveInside(resolvedRoot, dependencyTreePath),
-    dependencyTreePath
-  );
-  assertSameTree(manifest.closure.tree, actualTree, "materialized dependency closure");
-}
-async function verifyExpectedRuntime(root, expected, expectedBytes) {
-  const manifestPath = join3(root, "dist", "runtime-manifest.json");
-  const actualBytes = await readFile2(manifestPath);
-  if (!actualBytes.equals(expectedBytes)) {
-    throw new Error("Materialized runtime manifest does not match the expected closure");
+  EncodeSchema(encode, schema) {
+    const Codec = { Decode: this.decode, Encode: encode };
+    return { ...schema, [TransformKind]: Codec };
   }
-  const actual = await parseRuntimeManifest(actualBytes, root);
-  if (actual.closure === void 0 || expected.closure === void 0) {
-    throw new Error("Materialized runtime manifest is missing its closure");
+  Encode(encode) {
+    return IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
   }
-  await verifyRuntimeFiles(root, actual);
-  await verifyDependencyIdentities(root, actual.dependencies);
-  const actualTree = await hashDirectoryTree(
-    resolveInside(root, dependencyTreePath),
-    dependencyTreePath
-  );
-  assertSameTree(expected.closure.tree, actualTree, "materialized dependency closure");
+};
+function Transform(schema) {
+  return new TransformDecodeBuilder(schema);
 }
-async function verifyRuntimeFiles(root, manifest) {
-  for (const file of manifest.files) {
-    const path2 = resolveInside(root, file.path);
-    const info = await lstat2(path2);
-    if (info.isSymbolicLink()) {
-      throw new Error(`Runtime artifact ${file.path} must not be a symbolic link`);
-    }
-    if (!info.isFile() || info.size !== file.bytes) {
-      throw new Error(`Runtime artifact ${file.path} has changed`);
-    }
-    const hash = createHash3("sha256").update(await readFile2(path2)).digest("hex");
-    if (hash !== file.sha256) {
-      throw new Error(`Runtime artifact ${file.path} failed verification`);
-    }
-  }
+
+// node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.mjs
+function Unsafe(options = {}) {
+  return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
 }
-async function verifyDependencyIdentities(root, dependencies) {
-  const nodeModules = resolveInside(root, dependencyTreePath);
-  const modulesInfo = await lstat2(nodeModules);
-  if (!modulesInfo.isDirectory() || modulesInfo.isSymbolicLink()) {
-    throw new Error("Runtime dependency closure must be a regular directory");
-  }
-  for (const dependency of dependencies) {
-    const packageRoot = resolveInside(root, dependency.path);
-    const packageInfo = await lstat2(packageRoot);
-    if (!packageInfo.isDirectory() || packageInfo.isSymbolicLink()) {
-      throw new Error(`Runtime dependency ${dependency.name} must be a regular directory`);
+
+// node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
+function Void(options) {
+  return CreateType({ [Kind]: "Void", type: "void" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
+var type_exports2 = {};
+__export(type_exports2, {
+  Any: () => Any,
+  Argument: () => Argument2,
+  Array: () => Array2,
+  AsyncIterator: () => AsyncIterator,
+  Awaited: () => Awaited,
+  BigInt: () => BigInt,
+  Boolean: () => Boolean2,
+  Capitalize: () => Capitalize,
+  Composite: () => Composite,
+  Const: () => Const,
+  Constructor: () => Constructor,
+  ConstructorParameters: () => ConstructorParameters,
+  Date: () => Date2,
+  Enum: () => Enum,
+  Exclude: () => Exclude,
+  Extends: () => Extends,
+  Extract: () => Extract,
+  Function: () => Function,
+  Index: () => Index,
+  InstanceType: () => InstanceType,
+  Instantiate: () => Instantiate,
+  Integer: () => Integer,
+  Intersect: () => Intersect,
+  Iterator: () => Iterator,
+  KeyOf: () => KeyOf,
+  Literal: () => Literal,
+  Lowercase: () => Lowercase,
+  Mapped: () => Mapped,
+  Module: () => Module,
+  Never: () => Never,
+  Not: () => Not,
+  Null: () => Null,
+  Number: () => Number2,
+  Object: () => Object2,
+  Omit: () => Omit,
+  Optional: () => Optional,
+  Parameters: () => Parameters,
+  Partial: () => Partial,
+  Pick: () => Pick,
+  Promise: () => Promise2,
+  Readonly: () => Readonly,
+  ReadonlyOptional: () => ReadonlyOptional,
+  Record: () => Record,
+  Recursive: () => Recursive,
+  Ref: () => Ref,
+  RegExp: () => RegExp2,
+  Required: () => Required,
+  Rest: () => Rest,
+  ReturnType: () => ReturnType,
+  String: () => String2,
+  Symbol: () => Symbol2,
+  TemplateLiteral: () => TemplateLiteral,
+  Transform: () => Transform,
+  Tuple: () => Tuple,
+  Uint8Array: () => Uint8Array2,
+  Uncapitalize: () => Uncapitalize,
+  Undefined: () => Undefined,
+  Union: () => Union,
+  Unknown: () => Unknown,
+  Unsafe: () => Unsafe,
+  Uppercase: () => Uppercase,
+  Void: () => Void
+});
+
+// node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
+var Type = type_exports2;
+
+// src/protocol/pi-identity.ts
+var MANAGED_PI_ARTIFACT_ID = "@earendil-works/pi-coding-agent@0.80.10";
+var PiRuntimeIdentitySchema = Type.Union([
+  Type.Object(
+    {
+      mode: Type.Literal("managed"),
+      artifactId: Type.String({ minLength: 1 })
+    },
+    { additionalProperties: false }
+  ),
+  Type.Object(
+    {
+      mode: Type.Literal("external"),
+      selectedPath: Type.String({ minLength: 1 }),
+      nodePath: Type.String({ minLength: 1 }),
+      realPath: Type.String({ minLength: 1 }),
+      version: Type.String({ minLength: 1 }),
+      fingerprint: Type.String({ minLength: 1 })
+    },
+    { additionalProperties: false }
+  )
+]);
+var MANAGED_PI_RUNTIME_IDENTITY = Object.freeze({
+  mode: "managed",
+  artifactId: MANAGED_PI_ARTIFACT_ID
+});
+
+// src/protocol/semantic-segmentation.ts
+var SemanticEventReassembler = class {
+  #maxEventBytes;
+  #maxSegments;
+  #current;
+  constructor(maxEventBytes, maxSegments = 4096) {
+    assertPositiveInteger(maxEventBytes, "Semantic event reassembly limit");
+    assertPositiveInteger(maxSegments, "Semantic segment limit");
+    this.#maxEventBytes = maxEventBytes;
+    this.#maxSegments = maxSegments;
+  }
+  push(frame) {
+    assertFrame(frame);
+    if (frame.count > this.#maxSegments) {
+      throw new Error("Semantic event segment count exceeds reassembly limit");
+    }
+    if (frame.data.length === 0) throw new Error("Semantic event segment must not be empty");
+    if (frame.index === 0) {
+      if (this.#current !== void 0) throw new Error("Semantic event reassembly was interrupted");
+      this.#current = {
+        eventId: frame.eventId,
+        precedingCursor: frame.precedingCursor,
+        eventCursor: frame.eventCursor,
+        count: frame.count,
+        chunks: [],
+        bytes: 0
+      };
     }
-    const packageJsonPath = join3(packageRoot, "package.json");
-    const packageJsonInfo = await lstat2(packageJsonPath);
-    if (!packageJsonInfo.isFile() || packageJsonInfo.isSymbolicLink()) {
-      throw new Error(`Runtime dependency ${dependency.name} has an unsafe package.json`);
+    const current = this.#current;
+    if (current === void 0) throw new Error("Semantic event segment has no start");
+    if (frame.eventId !== current.eventId || frame.precedingCursor !== current.precedingCursor || frame.eventCursor !== current.eventCursor || frame.count !== current.count || frame.index !== current.chunks.length) {
+      this.reset();
+      throw new Error("Semantic event segment sequence is invalid");
+    }
+    const chunk = decodeBase64(frame.data);
+    if (current.bytes + chunk.length > this.#maxEventBytes) {
+      this.reset();
+      throw new Error("Semantic event exceeds reassembly limit");
+    }
+    current.chunks.push(chunk);
+    current.bytes += chunk.length;
+    if (current.chunks.length < current.count) return null;
+    const precedingCursor = current.precedingCursor;
+    const eventCursor = current.eventCursor;
+    const eventId = current.eventId;
+    const bytes = Buffer.concat(current.chunks, current.bytes);
+    this.reset();
+    let event;
+    try {
+      event = JSON.parse(bytes.toString("utf8"));
+    } catch {
+      throw new Error("Semantic event payload is invalid JSON");
     }
-    const identity = await readPackageMetadata(packageRoot);
-    if (identity.name !== dependency.name || identity.version !== dependency.version) {
-      throw new Error(`Runtime dependency ${dependency.name} has an unexpected identity`);
+    if (event.id !== eventId || event.cursor !== eventCursor) {
+      throw new Error("Semantic event payload identity does not match its segments");
     }
+    return { event, precedingCursor };
   }
-}
-async function parseRuntimeManifest(bytes, root) {
-  let candidate;
-  try {
-    candidate = JSON.parse(bytes.toString("utf8"));
-  } catch {
-    throw new Error("Runtime manifest is not valid JSON");
+  reset() {
+    this.#current = void 0;
   }
-  await validateRuntimeManifest(candidate, root);
-  return candidate;
+};
+function assertFrame(frame) {
+  if (frame.type !== "semantic.segment" || !Number.isSafeInteger(frame.index) || !Number.isSafeInteger(frame.count) || frame.index < 0 || frame.count <= 0 || frame.index >= frame.count) {
+    throw new Error("Semantic event segment metadata is invalid");
+  }
+}
+function decodeBase64(value) {
+  const decoded = Buffer.from(value, "base64");
+  if (decoded.toString("base64") !== value)
+    throw new Error("Semantic event segment is invalid base64");
+  return decoded;
+}
+function assertPositiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`${label} must be positive`);
+}
+
+// src/client/contracts.ts
+var PI_FLEET_ERROR_CODES = [
+  "agent_busy",
+  "agent_destroyed",
+  "agent_destroying",
+  "agent_not_found",
+  "capacity_exceeded",
+  "cancelled",
+  "compaction_failed",
+  "compaction_uncertain",
+  "cursor_expired",
+  "cursor_invalid",
+  "cursor_wrong_agent",
+  "delivery_uncertain",
+  "destroy_incomplete",
+  "incarnation_cleanup_uncertain",
+  "internal_error",
+  "invalid_arguments",
+  "invalid_request",
+  "name_taken",
+  "nothing_to_compact",
+  "observation_uncertain",
+  "operation_conflict",
+  "operation_in_progress",
+  "pi_installation_changed",
+  "pi_not_executable",
+  "pi_not_found",
+  "pi_runtime_mismatch",
+  "pi_service_mismatch",
+  "pi_start_failed",
+  "pi_version_unavailable",
+  "pi_version_unsupported",
+  "protocol_error",
+  "protocol_incompatible",
+  "receive_resource_exhausted",
+  "runtime_interrupted",
+  "runtime_unavailable",
+  "runtime_upgrade_deferred",
+  "semantic_event_too_large",
+  "stale_agent",
+  "state_corrupt",
+  "storage_unavailable",
+  "timeout"
+];
+var piFleetErrorCodeSet = new Set(PI_FLEET_ERROR_CODES);
+function isPiFleetErrorCode(value) {
+  return typeof value === "string" && piFleetErrorCodeSet.has(value);
 }
-async function validateRuntimeManifest(candidate, root) {
-  if (!isRecord2(candidate) || candidate.schemaVersion !== 4) {
-    throw new Error("Runtime manifest has an unsupported schema version");
-  }
-  if (!isRecord2(candidate.package) || typeof candidate.package.name !== "string" || typeof candidate.package.version !== "string" || !isRecord2(candidate.piRuntime) || candidate.piRuntime.mode !== "external") {
-    throw new Error("Runtime manifest has an invalid package identity");
+
+// src/shared/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+
+// src/client/socket-fleet-client.ts
+var SocketFleetClient = class {
+  constructor(options) {
+    this.options = options;
   }
-  const packageMetadata = await readPackageMetadata(root);
-  if (candidate.package.name !== packageMetadata.name || candidate.package.version !== packageMetadata.version) {
-    throw new Error("Runtime manifest package identity does not match package.json");
+  create(input, options) {
+    return this.#request("agent.create", input, options);
   }
-  if (!Array.isArray(candidate.files) || !Array.isArray(candidate.dependencies)) {
-    throw new Error("Runtime manifest has invalid artifact lists");
+  async send(input, options) {
+    const bound = await this.#bind(input, options);
+    if (!bound.ok) return bound;
+    return this.#request("agent.send", bound.value, options);
   }
-  const filePaths = /* @__PURE__ */ new Set();
-  for (const file of candidate.files) {
-    if (!isRecord2(file) || !isManifestPath(file.path) || !isValidSize(file.bytes) || !isSha256(file.sha256)) {
-      throw new Error("Runtime manifest contains an invalid artifact");
+  async *receive(input, options) {
+    const bound = await this.#bind(input, options);
+    if (!bound.ok) {
+      yield bound;
+      return;
     }
-    if (filePaths.has(file.path)) {
-      throw new Error(`Runtime manifest has duplicate path ${file.path}`);
+    let socket;
+    try {
+      await this.options.beforeConnect?.();
+      socket = await connect(this.options.socketPath, options.signal);
+    } catch (error) {
+      yield err(connectionError(error));
+      return;
     }
-    filePaths.add(file.path);
-  }
-  for (const required of requiredRuntimeArtifacts) {
-    if (!filePaths.has(required)) {
-      throw new Error(`Runtime manifest is missing required artifact ${required}`);
+    const requestId = randomUUID2();
+    const frames = frameIterator(socket, options.signal);
+    let reassembler = null;
+    let expectedCursor = null;
+    writeJsonLine(socket, {
+      v: PROTOCOL_VERSION,
+      requestId,
+      method: "agent.receive",
+      params: receiveParams(bound.value)
+    });
+    let ready = false;
+    let ended = false;
+    try {
+      for await (const frame of frames) {
+        if (!isRecord2(frame) || frame.requestId !== requestId) continue;
+        if (frame.v !== PROTOCOL_VERSION) {
+          yield err(protocolIncompatible());
+          return;
+        }
+        if (frame.stream === "ready" && typeof frame.cursor === "string") {
+          if (ready || !isRecord2(frame.limits) || !isPositiveSafeInteger(frame.limits.maxEventBytes) || !isPositiveSafeInteger(frame.limits.maxSegments)) {
+            yield err({ code: "protocol_error", message: "Invalid receive readiness frame." });
+            return;
+          }
+          ready = true;
+          expectedCursor = frame.cursor;
+          reassembler = new SemanticEventReassembler(
+            frame.limits.maxEventBytes,
+            frame.limits.maxSegments
+          );
+          yield ok({ type: "ready", cursor: expectedCursor });
+          continue;
+        }
+        if (frame.stream === "semantic.segment" && isSemanticSegment(frame.segment)) {
+          if (!ready) {
+            yield err({
+              code: "protocol_error",
+              message: "Receive event arrived before readiness."
+            });
+            return;
+          }
+          try {
+            if (reassembler === null || expectedCursor === null) {
+              throw new Error("Receive stream is not ready");
+            }
+            const complete = reassembler.push(frame.segment);
+            if (complete !== null) {
+              if (complete.precedingCursor !== expectedCursor) {
+                throw new Error("Receive event cursor chain is discontinuous");
+              }
+              expectedCursor = complete.event.cursor;
+              yield ok({ type: "event", cursor: complete.event.cursor, event: complete.event });
+            }
+          } catch {
+            yield err({ code: "protocol_error", message: "Receive stream segmentation failed." });
+            return;
+          }
+          continue;
+        }
+        if (frame.stream === "end") {
+          ended = true;
+          return;
+        }
+        if (frame.stream === "error" && isErrorRecord(frame.error)) {
+          yield err(frame.error);
+          return;
+        }
+        yield err({ code: "protocol_error", message: "Invalid receive stream frame." });
+        return;
+      }
+      if (!ended && !options.signal.aborted) {
+        yield err({
+          code: "runtime_unavailable",
+          message: "Runtime connection closed before the receive stream ended."
+        });
+      }
+    } catch (error) {
+      if (!options.signal.aborted) yield err(connectionError(error));
+    } finally {
+      socket.destroy();
     }
   }
-  const dependencyPaths = /* @__PURE__ */ new Set();
-  const dependencyNames = /* @__PURE__ */ new Set();
-  for (const dependency of candidate.dependencies) {
-    if (!isRecord2(dependency) || !isManifestPath(dependency.path) || typeof dependency.name !== "string" || dependency.name.length === 0 || typeof dependency.version !== "string" || dependency.version.length === 0 || dependency.path !== `node_modules/${dependency.name}`) {
-      throw new Error("Runtime manifest contains an invalid dependency declaration");
-    }
-    if (dependencyPaths.has(dependency.path) || dependencyNames.has(dependency.name)) {
-      throw new Error(`Runtime manifest has duplicate dependency ${dependency.name}`);
-    }
-    dependencyPaths.add(dependency.path);
-    dependencyNames.add(dependency.name);
+  status(input, options) {
+    return this.#request("agent.status", input, options);
   }
-  const expectedDependencies = packageMetadata.dependencies;
-  if (dependencyNames.size !== Object.keys(expectedDependencies).length || [...dependencyNames].some(
-    (name) => expectedDependencies[name] !== candidate.dependencies.find(
-      (dependency) => dependency.name === name
-    )?.version
-  )) {
-    throw new Error("Runtime manifest dependencies do not match package.json");
+  list(options) {
+    return this.#request("agent.list", {}, options);
   }
-  for (const filePath of filePaths) {
-    for (const dependencyPath of dependencyPaths) {
-      if (filePath === dependencyPath || filePath.startsWith(`${dependencyPath}/`) || dependencyPath.startsWith(`${filePath}/`)) {
-        throw new Error(`Runtime manifest has overlapping paths ${filePath} and ${dependencyPath}`);
+  async destroy(input, options) {
+    const bound = await this.#bind(input, options);
+    if (!bound.ok) return bound;
+    return this.#request("agent.destroy", bound.value, options);
+  }
+  async compact(input, options) {
+    const bound = await this.#bind(input, options);
+    if (!bound.ok) return bound;
+    return this.#request("agent.compact", bound.value, options);
+  }
+  async #bind(input, options) {
+    if (input.expectedAgentId !== void 0) {
+      return ok({ ...input, expectedAgentId: input.expectedAgentId });
+    }
+    const status = await this.status(
+      { name: input.name },
+      {
+        signal: options.signal,
+        ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
       }
-    }
+    );
+    if (!status.ok) return status;
+    return ok({ ...input, expectedAgentId: status.value.agent.id });
   }
-  if (candidate.closure !== void 0) {
-    if (!isRecord2(candidate.closure) || !isSha256(candidate.closure.sourceManifestSha256) || !isTreeIntegrity(candidate.closure.tree) || candidate.closure.tree.path !== dependencyTreePath) {
-      throw new Error("Runtime manifest contains an invalid materialized closure");
+  async #request(method, params, options) {
+    let socket;
+    try {
+      await this.options.beforeConnect?.();
+      socket = await connect(this.options.socketPath, options.signal);
+    } catch (error) {
+      return err(connectionError(error));
+    }
+    const requestId = randomUUID2();
+    let piIdentity;
+    try {
+      piIdentity = requiresPiIdentity(method) ? await this.#piIdentity() : void 0;
+    } catch (error) {
+      socket.destroy();
+      return err(piSelectionError(error));
+    }
+    const response = firstMatchingFrame(socket, requestId, options.signal);
+    writeJsonLine(socket, {
+      v: PROTOCOL_VERSION,
+      requestId,
+      method,
+      params,
+      ...isMutationOptions(options) ? { operation: options.operation } : {},
+      ...piIdentity === void 0 ? {} : { runtime: { pi: piIdentity } }
+    });
+    try {
+      const frame = await response;
+      if (!isRecord2(frame) || frame.requestId !== requestId || typeof frame.ok !== "boolean") {
+        return err({ code: "protocol_error", message: "Invalid runtime response." });
+      }
+      if (frame.v !== PROTOCOL_VERSION) return err(protocolIncompatible());
+      if (frame.ok) return ok(frame.result);
+      if (isErrorRecord(frame.error)) return err(frame.error);
+      return err({ code: "protocol_error", message: "Runtime returned an invalid error." });
+    } catch (error) {
+      return err(connectionError(error));
+    } finally {
+      socket.destroy();
     }
   }
-}
-async function readPackageMetadata(root) {
-  let candidate;
-  try {
-    candidate = JSON.parse(await readFile2(join3(root, "package.json"), "utf8"));
-  } catch {
-    throw new Error("Runtime package.json is not valid JSON");
-  }
-  if (!isRecord2(candidate) || typeof candidate.name !== "string" || typeof candidate.version !== "string" || candidate.dependencies !== void 0 && !isRecord2(candidate.dependencies) || isRecord2(candidate.dependencies) && Object.values(candidate.dependencies).some((version) => typeof version !== "string")) {
-    throw new Error("Runtime package.json has invalid package metadata");
+  async #piIdentity() {
+    const configured = this.options.piIdentity;
+    if (configured === void 0) return MANAGED_PI_RUNTIME_IDENTITY;
+    return typeof configured === "function" ? configured() : configured;
   }
+};
+function receiveParams(input) {
+  const start = input.start ?? { kind: "live" };
   return {
-    name: candidate.name,
-    version: candidate.version,
-    dependencies: isRecord2(candidate.dependencies) ? candidate.dependencies : {}
+    name: input.name,
+    ...input.expectedAgentId === void 0 ? {} : { expectedAgentId: input.expectedAgentId },
+    ...start.kind === "after" ? { after: start.cursor } : {},
+    ...start.kind === "start" ? { fromStart: true } : {},
+    ...input.untilIdle === true ? { untilIdle: true } : {}
   };
 }
-function serializeManifest(manifest) {
-  return Buffer.from(`${JSON.stringify(manifest, null, 2)}
-`);
+function protocolIncompatible() {
+  return {
+    code: "protocol_incompatible",
+    message: "The running pi-fleet runtime is incompatible with this client; repair or restart it."
+  };
 }
-function assertSameTree(expected, actual, label) {
-  if (expected.path !== actual.path || expected.files !== actual.files || expected.bytes !== actual.bytes || expected.sha256 !== actual.sha256) {
-    throw new Error(`Runtime ${label} changed during materialization`);
+function piSelectionError(error) {
+  const code = error.code;
+  if (code === "pi_not_found" || code === "pi_not_executable" || code === "pi_version_unavailable" || code === "pi_version_unsupported" || code === "pi_installation_changed" || code === "pi_service_mismatch") {
+    return { code, message: error instanceof Error ? error.message : "Pi is unavailable." };
   }
+  return { code: "internal_error", message: "Pi selection failed." };
 }
-function resolveInside(root, path2) {
-  if (!isManifestPath(path2)) throw new Error(`Runtime manifest contains an unsafe path ${path2}`);
-  const resolved = resolve3(root, path2);
-  if (!resolved.startsWith(`${root}${sep2}`)) {
-    throw new Error(`Runtime manifest contains an unsafe path ${path2}`);
+function isMutationOptions(options) {
+  return "operation" in options;
+}
+function requiresPiIdentity(method) {
+  return method === "agent.create" || method === "agent.send" || method === "agent.compact";
+}
+function connect(socketPath, signal) {
+  return new Promise((resolveConnect, rejectConnect) => {
+    if (signal.aborted) {
+      rejectConnect(new Error("Request cancelled"));
+      return;
+    }
+    const socket = createConnection2(socketPath);
+    const onAbort = () => socket.destroy(new Error("Request cancelled"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    socket.once("connect", () => {
+      signal.removeEventListener("abort", onAbort);
+      resolveConnect(socket);
+    });
+    socket.once("error", rejectConnect);
+  });
+}
+function firstMatchingFrame(socket, requestId, signal) {
+  return new Promise((resolveFrame, rejectFrame) => {
+    let settled = false;
+    const finish = (action) => {
+      if (settled) return;
+      settled = true;
+      stop();
+      signal.removeEventListener("abort", onAbort);
+      action();
+    };
+    const stop = readJsonLines(
+      socket,
+      (frame) => {
+        if (!isRecord2(frame) || frame.requestId !== requestId) return;
+        finish(() => resolveFrame(frame));
+      },
+      (error) => finish(() => rejectFrame(error))
+    );
+    const onAbort = () => finish(() => rejectFrame(new Error("Request cancelled")));
+    signal.addEventListener("abort", onAbort, { once: true });
+    socket.once(
+      "close",
+      () => finish(() => rejectFrame(new Error("Runtime connection closed before responding")))
+    );
+  });
+}
+async function* frameIterator(socket, signal, maxQueuedBytes = 1024 * 1024) {
+  const queue = [];
+  let queuedBytes = 0;
+  let paused = false;
+  let ended = false;
+  let failure = null;
+  let wake = null;
+  const notify = () => {
+    wake?.();
+    wake = null;
+  };
+  const stop = readJsonLines(
+    socket,
+    (frame) => {
+      const bytes = Buffer.byteLength(JSON.stringify(frame));
+      queue.push({ value: frame, bytes });
+      queuedBytes += bytes;
+      if (queuedBytes >= maxQueuedBytes && !paused) {
+        socket.pause();
+        paused = true;
+      }
+      notify();
+    },
+    (error) => {
+      failure = error;
+      ended = true;
+      notify();
+    }
+  );
+  socket.once("end", () => {
+    failure = new Error("Runtime connection closed before completing the stream");
+    ended = true;
+    notify();
+  });
+  const onAbort = () => {
+    failure = new Error("Request cancelled");
+    ended = true;
+    notify();
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    while (!ended || queue.length > 0) {
+      if (queue.length === 0) {
+        await new Promise((resolveWake) => {
+          wake = resolveWake;
+        });
+        continue;
+      }
+      const item = queue.shift();
+      if (item === void 0) continue;
+      queuedBytes -= item.bytes;
+      if (paused && queuedBytes < maxQueuedBytes / 2) {
+        socket.resume();
+        paused = false;
+      }
+      yield item.value;
+    }
+    if (failure !== null) throw failure;
+  } finally {
+    stop();
+    signal.removeEventListener("abort", onAbort);
   }
-  return resolved;
+}
+function isSemanticSegment(value) {
+  return isRecord2(value) && value.type === "semantic.segment";
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
-function isManifestPath(value) {
-  return typeof value === "string" && value.length > 0 && !value.includes("\\") && !value.startsWith("/") && posix.normalize(value) === value && value.split("/").every((part) => part.length > 0 && part !== "." && part !== "..");
-}
-function isValidSize(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-function isSha256(value) {
-  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
-}
-function isTreeIntegrity(value) {
-  return isRecord2(value) && isManifestPath(value.path) && isValidSize(value.files) && isValidSize(value.bytes) && isSha256(value.sha256);
-}
-function isDestinationRace(error) {
-  const code = error.code;
-  return code === "EEXIST" || code === "ENOTEMPTY";
-}
-async function ensurePrivateDirectory(path2) {
-  await mkdir(path2, { recursive: true, mode: 448 });
-  const info = await lstat2(path2);
-  if (!info.isDirectory() || info.isSymbolicLink()) {
-    throw new Error(`Refusing unsafe runtime release path ${path2}`);
-  }
-  if (typeof process.getuid === "function" && info.uid !== process.getuid()) {
-    throw new Error(`Runtime release path ${path2} is not owned by the current user`);
-  }
-  await chmod(path2, 448);
+function isPositiveSafeInteger(value) {
+  return Number.isSafeInteger(value) && typeof value === "number" && value > 0;
 }
-async function pathExists(path2) {
-  try {
-    await lstat2(path2);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") return false;
-    throw error;
+function isErrorRecord(value) {
+  return isRecord2(value) && isPiFleetErrorCode(value.code) && typeof value.message === "string" && isSafeErrorDetails(value.code, value.details);
+}
+function isSafeErrorDetails(code, details) {
+  if (details === void 0) return true;
+  if (!isRecord2(details)) return false;
+  const allowed = code === "observation_uncertain" ? ["lastSafeCursor", "continuationCursor"] : ["lastSafeCursor"];
+  if (Object.keys(details).some((key) => !allowed.includes(key))) return false;
+  if (!(typeof details.lastSafeCursor === "string" || details.lastSafeCursor === void 0)) {
+    return false;
   }
+  if (code !== "observation_uncertain") return true;
+  return typeof details.continuationCursor === "string" || details.continuationCursor === null;
 }
-
-// src/platform/shared/paths.ts
-import { homedir, tmpdir } from "node:os";
-import { join as join4, resolve as resolve4 } from "node:path";
-function resolveApplicationRoot(env = process.env) {
-  return env.PIFLEET_APPLICATION_ROOT ?? (process.platform === "darwin" ? join4(homedir(), "Library", "Application Support", "pi-fleet", "runtime") : join4(env.XDG_DATA_HOME ?? join4(homedir(), ".local", "share"), "pi-fleet"));
-}
-function resolveFleetPaths(env = process.env) {
-  const explicitRoot = env.PIFLEET_STATE_ROOT;
-  if (explicitRoot !== void 0) {
-    const root = resolve4(explicitRoot);
-    return {
-      runtimeRoot: root,
-      stateRoot: root,
-      socketPath: join4(root, "control.sock"),
-      databasePath: join4(root, "fleet.sqlite")
-    };
-  }
-  const runtimeRoot = join4(
-    env.XDG_RUNTIME_DIR ?? tmpdir(),
-    `pifleet-${process.getuid?.() ?? "user"}`
-  );
-  const stateRoot = process.platform === "darwin" ? join4(homedir(), "Library", "Application Support", "pi-fleet") : join4(env.XDG_STATE_HOME ?? join4(homedir(), ".local", "state"), "pi-fleet");
+function connectionError(error) {
+  void error;
   return {
-    runtimeRoot,
-    stateRoot,
-    socketPath: join4(runtimeRoot, "control.sock"),
-    databasePath: join4(stateRoot, "fleet.sqlite")
+    code: "runtime_unavailable",
+    message: "Unable to connect to pi-fleet runtime."
   };
 }
 
-// src/platform/client/start-runtime.ts
-var execFileAsync = promisify(execFile);
-async function ensureRuntime(options) {
-  if (await canConnect(options.socketPath)) return;
-  let env = { ...process.env, ...options.env };
-  const registered = env.PIFLEET_DISABLE_REGISTERED_SERVICE === "1" ? false : options.registeredRuntimeStarter !== void 0 ? await options.registeredRuntimeStarter(env) : await startRegisteredRuntime({
+// src/client/shared-client.ts
+function createSharedClientConnection(options) {
+  const env = {
+    ...process.env,
+    ...options.env,
+    ...options.stateRoot === void 0 ? {} : { PIFLEET_STATE_ROOT: options.stateRoot }
+  };
+  const paths = resolveFleetPaths(env);
+  let installation;
+  const selectedPi = () => installation ??= resolveExternalPiInstallation({ env });
+  const selectPiForMutation = async () => {
+    const selected = await selectedPi();
+    if (env.PIFLEET_DISABLE_REGISTERED_SERVICE !== "1") {
+      await assertRegisteredPiSelection({
+        selectedPath: selected.selectedPath,
+        nodePath: selected.nodePath
+      });
+    }
+    return selected;
+  };
+  const ensureControlPlane = () => ensureRuntime({
+    socketPath: paths.socketPath,
     env,
-    ...options.home === void 0 ? {} : { home: options.home }
-  });
-  if (!registered) {
-    if (options.piInstallation !== void 0) {
-      const installation = await options.piInstallation();
-      env = {
-        ...env,
-        PIFLEET_PI_EXECUTABLE: installation.selectedPath,
-        PIFLEET_PI_NODE: installation.nodePath
-      };
+    ...options.applicationRoot === void 0 ? {} : { applicationRoot: options.applicationRoot },
+    piInstallation: async () => {
+      try {
+        return await selectedPi();
+      } catch {
+        return null;
+      }
     }
-    const sourceRoot = options.sourceRoot ?? await findPackageRoot(fileURLToPath(import.meta.url));
-    const release = await materializeRuntime({
-      sourceRoot,
-      applicationRoot: options.applicationRoot ?? resolveApplicationRoot(env)
-    });
-    const runtimePath = join5(release, "bin", "pifleet-runtime.mjs");
-    const child = spawn2(process.execPath, [runtimePath], {
-      detached: true,
-      env,
-      stdio: "ignore"
-    });
-    child.unref();
-  }
-  const deadline = Date.now() + (options.timeoutMs ?? 5e3);
-  while (Date.now() < deadline) {
-    if (await canConnect(options.socketPath)) return;
-    await new Promise((resolveDelay) => setTimeout(resolveDelay, 25));
-  }
-  throw new Error(`pi-fleet runtime did not become ready at ${options.socketPath}`);
+  });
+  const client = new SocketFleetClient({
+    socketPath: paths.socketPath,
+    ...options.autoStartRuntime ? { beforeConnect: ensureControlPlane } : {},
+    piIdentity: async () => installationIdentity(await selectPiForMutation())
+  });
+  return {
+    client,
+    operationIds: () => ({
+      operationId: randomUUID3(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    ensureControlPlane,
+    selectPiForMutation
+  };
 }
-async function startRegisteredRuntime(options) {
-  const home = options.home ?? homedir2();
-  if (process.platform === "linux") {
-    const unit = join5(home, ".config", "systemd", "user", "pi-fleet.service");
-    if (!await exists(unit)) return false;
-    await assertRegisteredStateRoot(unit, "linux", options.env);
-    await execFileAsync("systemctl", ["--user", "start", "pi-fleet.service"]);
-    return true;
+
+// src/client/sdk-transport.ts
+var FleetClientSdkTransport = class {
+  constructor(client, operationIds, options = {}) {
+    this.client = client;
+    this.operationIds = operationIds;
+    this.#reconnectDelayMs = options.reconnectDelayMs ?? 50;
+    this.#autoReconnect = options.autoReconnect !== false;
+  }
+  #reconnectDelayMs;
+  #autoReconnect;
+  #activeReceiveIterators = /* @__PURE__ */ new Set();
+  #closed = false;
+  async create(input, signal) {
+    const result = await this.client.create(
+      {
+        name: input.name,
+        ...input.instructions === void 0 ? {} : { instructions: input.instructions },
+        cwd: input.cwd,
+        piArgv: input.piArgs ?? []
+      },
+      { signal, operation: this.operationIds() }
+    );
+    return unwrap(result).agent;
   }
-  if (process.platform === "darwin") {
-    const plist = join5(home, "Library", "LaunchAgents", "works.elpapi.pifleet.plist");
-    if (!await exists(plist)) return false;
-    await assertRegisteredStateRoot(plist, "darwin", options.env);
-    const domain = `gui/${process.getuid?.() ?? 0}`;
-    await execFileAsync("launchctl", ["kickstart", `${domain}/works.elpapi.pifleet`]);
-    return true;
+  async get(name, signal) {
+    const result = await this.client.status({ name }, { signal });
+    if (!result.ok && result.error.code === "agent_not_found") return null;
+    return unwrap(result).agent;
   }
-  return false;
-}
-function installedServiceStateRoot(contents, platform) {
-  const encoded = platform === "linux" ? /^Environment=PIFLEET_STATE_ROOT=(.+)$/m.exec(contents)?.[1] : /<key>PIFLEET_STATE_ROOT<\/key><string>([^<]+)<\/string>/.exec(contents)?.[1];
-  if (encoded === void 0) return void 0;
-  if (platform === "linux") return encoded;
-  return encoded.replaceAll("&apos;", "'").replaceAll("&quot;", '"').replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
-}
-var PiServiceMismatchError = class extends Error {
-  code = "pi_service_mismatch";
-  constructor(message) {
-    super(message);
-    this.name = "PiServiceMismatchError";
+  async list(signal) {
+    return unwrap(await this.client.list({ signal })).agents;
   }
-};
-async function assertRegisteredPiSelection(options) {
-  const home = options.home ?? homedir2();
-  const platform = process.platform;
-  if (platform !== "linux" && platform !== "darwin") return;
-  const path2 = platform === "linux" ? join5(home, ".config", "systemd", "user", "pi-fleet.service") : join5(home, "Library", "LaunchAgents", "works.elpapi.pifleet.plist");
-  if (!await exists(path2)) return;
-  const contents = await readFile3(path2, "utf8");
-  const installed = installedServicePiExecutable(contents, platform);
-  const installedNode = installedServicePiNode(contents, platform);
-  if (installed === void 0 || installedNode === void 0 || resolve5(installed) !== resolve5(options.selectedPath) || resolve5(installedNode) !== resolve5(options.nodePath)) {
-    throw new PiServiceMismatchError(
-      `The installed pi-fleet service uses a different Pi executable or Node interpreter; repair it from the environment selecting ${options.selectedPath}.`
+  async status(target, signal) {
+    return unwrap(await this.client.status(target, { signal })).agent;
+  }
+  async send(target, message, delivery, signal) {
+    const result = unwrap(
+      await this.client.send(
+        { ...target, message, delivery },
+        { signal, operation: this.operationIds() }
+      )
     );
+    return { acceptedAt: result.acceptedAt };
   }
-}
-function installedServicePiExecutable(contents, platform) {
-  return installedServiceEnvironmentValue(contents, platform, "PIFLEET_PI_EXECUTABLE");
-}
-function installedServicePiNode(contents, platform) {
-  return installedServiceEnvironmentValue(contents, platform, "PIFLEET_PI_NODE");
-}
-function installedServiceEnvironmentValue(contents, platform, key) {
-  const encoded = platform === "linux" ? new RegExp(`Environment=(?:"${key}=([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|${key}=(.+))$`, "m").exec(contents)?.slice(1).find(Boolean) : new RegExp(`<key>${key}<\\/key><string>([^<]+)<\\/string>`).exec(contents)?.[1];
-  if (encoded === void 0) return void 0;
-  if (platform === "darwin") {
-    return encoded.replaceAll("&apos;", "'").replaceAll("&quot;", '"').replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
+  async receive(target, start, signal, untilIdle = false) {
+    const initial = await this.#attach(target, start, signal, void 0, untilIdle);
+    let iterated = false;
+    return {
+      cursor: initial.cursor,
+      [Symbol.asyncIterator]: () => {
+        if (iterated) {
+          throw new PiFleetError("invalid_request", "A receive stream can be iterated only once.");
+        }
+        iterated = true;
+        return this.#events(target, initial, signal, untilIdle);
+      }
+    };
   }
-  return encoded.replaceAll('\\"', '"').replaceAll("\\\\", "\\");
-}
-async function assertRegisteredStateRoot(definitionPath, platform, env) {
-  const installed = installedServiceStateRoot(await readFile3(definitionPath, "utf8"), platform);
-  const requested = resolve5(resolveFleetPaths(env).stateRoot);
-  if (installed === void 0) {
-    if (env.PIFLEET_STATE_ROOT === void 0) return;
-    throw new Error(
-      `Registered pi-fleet service uses the default state root, but this command requested ${requested}. Run the pi-fleet installer with PIFLEET_STATE_ROOT=${requested} to repair the service, or omit the override.`
-    );
+  async compact(target, signal) {
+    return unwrap(await this.client.compact(target, { signal, operation: this.operationIds() })).compaction;
   }
-  if (resolve5(installed) !== requested) {
-    throw new Error(
-      `Registered pi-fleet service uses state root ${installed}, but this command requested ${requested}. Repair the service with the intended PIFLEET_STATE_ROOT before retrying.`
-    );
+  async destroy(target, signal) {
+    unwrap(await this.client.destroy(target, { signal, operation: this.operationIds() }));
   }
-}
-async function findPackageRoot(modulePath) {
-  let candidate = dirname2(modulePath);
-  for (let depth = 0; depth < 6; depth += 1) {
-    if (await exists(join5(candidate, "dist", "runtime-manifest.json"))) return candidate;
-    const parent = dirname2(candidate);
-    if (parent === candidate) break;
-    candidate = parent;
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    const iterators = [...this.#activeReceiveIterators];
+    this.#activeReceiveIterators.clear();
+    await Promise.allSettled(iterators.map(async (iterator) => iterator.return?.()));
   }
-  throw new Error("Unable to locate the pi-fleet package runtime manifest.");
+  async *#events(target, initial, signal, untilIdle) {
+    let attachment = initial;
+    let cursor = initial.cursor;
+    while (true) {
+      let reconnect = false;
+      try {
+        while (true) {
+          const next = await attachment.iterator.next();
+          if (next.done) {
+            throwIfAborted(signal);
+            return;
+          }
+          const result = next.value;
+          if (!result.ok) {
+            if (result.error.code === "runtime_unavailable" && !untilIdle && this.#autoReconnect) {
+              reconnect = true;
+              break;
+            }
+            throw publicError(result.error);
+          }
+          if (result.value.type === "ready") {
+            throw new PiFleetError("protocol_error", "Receive emitted duplicate readiness.");
+          }
+          cursor = result.value.cursor;
+          yield result.value.event;
+        }
+      } finally {
+        await this.#release(attachment.iterator);
+      }
+      if (!reconnect) return;
+      await abortableDelay(this.#reconnectDelayMs, signal);
+      attachment = await this.#attach(target, { kind: "after", cursor }, signal, cursor, false);
+    }
+  }
+  async #attach(target, start, signal, expectedCursor, untilIdle = false) {
+    while (true) {
+      throwIfAborted(signal);
+      if (this.#closed) {
+        throw new PiFleetError("runtime_unavailable", "pi-fleet client is closed");
+      }
+      const input = {
+        ...target,
+        start,
+        ...untilIdle ? { untilIdle: true } : {}
+      };
+      const iterator = this.client.receive(input, { signal })[Symbol.asyncIterator]();
+      this.#activeReceiveIterators.add(iterator);
+      let first;
+      try {
+        first = await iterator.next();
+      } catch (error) {
+        await this.#release(iterator);
+        throw error;
+      }
+      if (first.done) {
+        await this.#release(iterator);
+        throwIfAborted(signal);
+        throw new PiFleetError(
+          "runtime_unavailable",
+          "Runtime connection closed before receive readiness."
+        );
+      }
+      if (!first.value.ok) {
+        await this.#release(iterator);
+        if (first.value.error.code === "runtime_unavailable" && this.#autoReconnect) {
+          await abortableDelay(this.#reconnectDelayMs, signal);
+          continue;
+        }
+        throw publicError(first.value.error);
+      }
+      if (first.value.value.type !== "ready") {
+        await this.#release(iterator);
+        throw new PiFleetError("protocol_error", "Receive event arrived before readiness.");
+      }
+      if (expectedCursor !== void 0 && first.value.value.cursor !== expectedCursor) {
+        await this.#release(iterator);
+        throw new PiFleetError(
+          "protocol_error",
+          "Reconnected receive boundary does not match the last emitted cursor."
+        );
+      }
+      return { cursor: first.value.value.cursor, iterator };
+    }
+  }
+  async #release(iterator) {
+    this.#activeReceiveIterators.delete(iterator);
+    await iterator.return?.();
+  }
+};
+function unwrap(result) {
+  if (result.ok) return result.value;
+  throw publicError(result.error);
 }
-async function exists(path2) {
-  try {
-    await access2(path2);
-    return true;
-  } catch {
-    return false;
+function publicError(error) {
+  if (!isPiFleetErrorCode(error.code)) {
+    return new PiFleetError("internal_error", "pi-fleet client operation failed");
   }
+  return new PiFleetError(error.code, error.message, error.details);
 }
-function canConnect(socketPath) {
-  return new Promise((resolveConnect) => {
-    const socket = createConnection2(socketPath);
-    const timer = setTimeout(() => {
-      socket.destroy();
-      resolveConnect(false);
-    }, 100);
-    socket.once("connect", () => {
-      clearTimeout(timer);
-      socket.destroy();
-      resolveConnect(true);
-    });
-    socket.once("error", () => {
+function throwIfAborted(signal) {
+  if (signal.aborted) throw new PiFleetError("cancelled", "Operation cancelled.");
+}
+function abortableDelay(durationMs, signal) {
+  throwIfAborted(signal);
+  if (durationMs === 0) return Promise.resolve();
+  return new Promise((resolveDelay, rejectDelay) => {
+    const onAbort = () => {
       clearTimeout(timer);
-      resolveConnect(false);
-    });
+      rejectDelay(new PiFleetError("cancelled", "Operation cancelled."));
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolveDelay();
+    }, durationMs);
+    signal.addEventListener("abort", onAbort, { once: true });
   });
 }
 
 // src/entry/cli.ts
 function defaultDependencies() {
   const abort = new AbortController();
-  const paths = resolveFleetPaths();
-  let installation;
-  const selectedPi = () => installation ??= resolveExternalPiInstallation({ env: process.env });
-  const mutationPi = async () => {
-    const selected = await selectedPi();
-    if (process.env.PIFLEET_DISABLE_REGISTERED_SERVICE !== "1") {
-      await assertRegisteredPiSelection({
-        selectedPath: selected.selectedPath,
-        nodePath: selected.nodePath
-      });
-    }
-    return selected;
-  };
+  const connection = createSharedClientConnection({
+    autoStartRuntime: true
+  });
   return {
-    client: new SocketFleetClient({
-      socketPath: paths.socketPath,
-      beforeConnect: () => ensureRuntime({
-        socketPath: paths.socketPath,
-        env: process.env,
-        piInstallation: selectedPi
-      }),
-      piIdentity: async () => installationIdentity(await mutationPi())
-    }),
+    client: createPiFleetClient(
+      new FleetClientSdkTransport(connection.client, connection.operationIds)
+    ),
     cwd: process.cwd(),
     stdin: process.stdin,
     stdout: process.stdout,
     stderr: process.stderr,
-    signal: abort.signal,
-    operationIds: () => ({ operationId: randomUUID3(), createdAt: (/* @__PURE__ */ new Date()).toISOString() })
+    signal: abort.signal
   };
 }
 async function runCli(argv, dependencies = defaultDependencies()) {
   const split = splitArgv(argv);
   const commandName = split.fleetArgv[0];
-  const human = commandName !== "watch" && split.fleetArgv.includes("--human");
+  const human = split.fleetArgv.includes("--human");
   if (split.piArgv.length > 0 && commandName !== "create") {
     writeError(
       dependencies.stderr,