privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-KFIO6LUW.mjs

@@ -0,0 +1,1096 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  buildDelegateChildArgv,
+  delegateChildEnv,
+  ensureDelegateChildSessionDir,
+  preflightDelegateLaunch,
+  resolveDelegateChildExtensionPath
+} from "./c-C5NK6UYV.mjs";
+import {
+  DELEGATE_INLINE_ANSWER_BYTES,
+  DELEGATE_MANIFEST_SCHEMA_VERSION,
+  DELEGATE_RECEIPT_SCHEMA_VERSION,
+  DELEGATE_RESULT_PACKAGE_SCHEMA_VERSION,
+  DelegateError
+} from "./c-IFSP3R4D.mjs";
+import {
+  canonicalJson
+} from "./c-KIVXWBYD.mjs";
+import {
+  resolveAnthropicAttributionExtensionPath
+} from "./c-BFW6CDVL.mjs";
+import {
+  replaceFileDurable
+} from "./c-DR7XQI32.mjs";
+import {
+  sanitizePathSegment
+} from "./c-I3C6LBW4.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/pi-background-tasks/src/core/delegate/runner.ts?ext=pi-background-tasks
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile2, rmdir } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+
+// node_modules/pi-background-tasks/src/core/delegate/artifacts.ts?ext=pi-background-tasks
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { basename, isAbsolute, join, relative, sep } from "node:path";
+
+// node_modules/pi-background-tasks/src/core/delegate/result-package.ts?ext=pi-background-tasks
+import { createHash } from "node:crypto";
+var DELEGATE_RESULT_PACKAGE_FILENAME = "result.json";
+function sha256Bytes(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+__name(sha256Bytes, "sha256Bytes");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function fail(message, code, taskId) {
+  const details = { code, childCreated: true };
+  if (taskId !== void 0) details.taskId = taskId;
+  throw new DelegateError(message, details);
+}
+__name(fail, "fail");
+function serializeDelegateResultPackage(pkg) {
+  return `${canonicalJson(pkg)}
+`;
+}
+__name(serializeDelegateResultPackage, "serializeDelegateResultPackage");
+function requireString(record, key, taskId) {
+  const value = record[key];
+  if (typeof value !== "string")
+    fail(`delegate result package field ${key} must be a string`, "child_result_invalid", taskId);
+  return value;
+}
+__name(requireString, "requireString");
+function requireInteger(record, key, taskId) {
+  const value = record[key];
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+    fail(
+      `delegate result package field ${key} must be a non-negative safe integer`,
+      "child_result_invalid",
+      taskId
+    );
+  return value;
+}
+__name(requireInteger, "requireInteger");
+var SHA256_PATTERN = /^[0-9a-f]{64}$/;
+function requireSha256(record, key, taskId) {
+  const value = requireString(record, key, taskId);
+  if (!SHA256_PATTERN.test(value))
+    fail(
+      `delegate result package field ${key} must be a lowercase SHA-256 digest`,
+      "child_result_invalid",
+      taskId
+    );
+  return value;
+}
+__name(requireSha256, "requireSha256");
+function parseUsage(value, taskId) {
+  if (!isRecord(value))
+    fail("delegate result package usage must be an object", "child_result_invalid", taskId);
+  const status = value["status"];
+  if (status === "unavailable") {
+    const reason = value["reason"];
+    if (typeof reason !== "string")
+      fail(
+        "delegate result package unavailable usage must state a reason",
+        "child_result_invalid",
+        taskId
+      );
+    return { status: "unavailable", reason };
+  }
+  if (status !== "observed")
+    fail(
+      "delegate result package usage status must be observed or unavailable",
+      "child_result_invalid",
+      taskId
+    );
+  const usage = value["usage"];
+  if (!isRecord(usage))
+    fail(
+      "delegate result package observed usage must be an object",
+      "child_result_invalid",
+      taskId
+    );
+  const cost = usage["cost"];
+  if (!isRecord(cost))
+    fail(
+      "delegate result package observed usage must carry a complete cost breakdown",
+      "child_result_invalid",
+      taskId
+    );
+  const number = /* @__PURE__ */ __name((record, key) => {
+    const raw = record[key];
+    if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0)
+      fail(
+        `delegate result package usage.${key} must be a non-negative finite number`,
+        "child_result_invalid",
+        taskId
+      );
+    return raw;
+  }, "number");
+  return {
+    status: "observed",
+    usage: {
+      input: number(usage, "input"),
+      output: number(usage, "output"),
+      cacheRead: number(usage, "cacheRead"),
+      cacheWrite: number(usage, "cacheWrite"),
+      totalTokens: number(usage, "totalTokens"),
+      cost: {
+        input: number(cost, "input"),
+        output: number(cost, "output"),
+        cacheRead: number(cost, "cacheRead"),
+        cacheWrite: number(cost, "cacheWrite"),
+        total: number(cost, "total")
+      }
+    }
+  };
+}
+__name(parseUsage, "parseUsage");
+function parseAttestations(value, taskId) {
+  if (!Array.isArray(value))
+    fail(
+      "delegate result package route_attestations must be an array",
+      "route_attestation_missing",
+      taskId
+    );
+  if (value.length === 0)
+    fail(
+      "delegate result package carries no route attestation, so the route the child actually used cannot be proven",
+      "route_attestation_missing",
+      taskId
+    );
+  return value.map((entry) => {
+    if (!isRecord(entry))
+      fail("delegate route attestation must be an object", "route_attestation_missing", taskId);
+    return {
+      provider: requireString(entry, "provider", taskId),
+      model: requireString(entry, "model", taskId),
+      stop_reason: requireString(entry, "stop_reason", taskId)
+    };
+  });
+}
+__name(parseAttestations, "parseAttestations");
+function parseSpillContentFormat(value, taskId) {
+  if (value === void 0) return void 0;
+  if (value !== "single_text_utf8" && value !== "tool_result_content_json_v1" && value !== "opaque_bytes") {
+    fail("delegate spill receipt content_format is invalid", "child_result_invalid", taskId);
+  }
+  return value;
+}
+__name(parseSpillContentFormat, "parseSpillContentFormat");
+function parseSpillReceipts(value, taskId) {
+  if (!Array.isArray(value))
+    fail(
+      "delegate result package spilled_artifacts must be an array",
+      "child_result_invalid",
+      taskId
+    );
+  return value.map((entry) => {
+    if (!isRecord(entry))
+      fail("delegate spill receipt must be an object", "child_result_invalid", taskId);
+    if (entry["schema_version"] !== DELEGATE_RECEIPT_SCHEMA_VERSION)
+      fail("delegate spill receipt schema_version mismatch", "child_result_invalid", taskId);
+    return {
+      schema_version: DELEGATE_RECEIPT_SCHEMA_VERSION,
+      artifact: requireString(entry, "artifact", taskId),
+      tool_name: requireString(entry, "tool_name", taskId),
+      tool_call_id: requireString(entry, "tool_call_id", taskId),
+      turn_sequence: requireInteger(entry, "turn_sequence", taskId),
+      source_call_index: requireInteger(entry, "source_call_index", taskId),
+      byte_length: requireInteger(entry, "byte_length", taskId),
+      sha256: requireSha256(entry, "sha256", taskId),
+      content_format: parseSpillContentFormat(entry["content_format"], taskId)
+    };
+  });
+}
+__name(parseSpillReceipts, "parseSpillReceipts");
+function verifyDelegateResultPackage(raw, expected) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    fail(
+      `delegate result package is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      "child_result_invalid",
+      expected.taskId
+    );
+  }
+  if (!isRecord(parsed))
+    fail("delegate result package must be a JSON object", "child_result_invalid", expected.taskId);
+  if (parsed["schema_version"] !== DELEGATE_RESULT_PACKAGE_SCHEMA_VERSION)
+    fail(
+      `delegate result package schema_version must be ${DELEGATE_RESULT_PACKAGE_SCHEMA_VERSION}`,
+      "child_result_invalid",
+      expected.taskId
+    );
+  const taskId = requireString(parsed, "task_id", expected.taskId);
+  const launchNonce = requireString(parsed, "launch_nonce", expected.taskId);
+  if (taskId !== expected.taskId || launchNonce !== expected.launchNonce)
+    fail(
+      "delegate result package identity does not match the launched task; a stale or foreign package is never accepted",
+      "child_result_invalid",
+      expected.taskId
+    );
+  const seedSha256 = requireSha256(parsed, "seed_sha256", expected.taskId);
+  if (seedSha256 !== expected.seedSha256)
+    fail(
+      `delegate result package was produced from a different seed: expected ${expected.seedSha256}, package declares ${seedSha256}`,
+      "seed_hash_mismatch",
+      expected.taskId
+    );
+  const routeRecord = parsed["route"];
+  if (!isRecord(routeRecord))
+    fail(
+      "delegate result package route must be an object",
+      "child_result_invalid",
+      expected.taskId
+    );
+  const provider = requireString(routeRecord, "provider", expected.taskId);
+  const model = requireString(routeRecord, "model", expected.taskId);
+  if (provider !== expected.route.provider || model !== expected.route.model)
+    fail(
+      `delegate result package route ${provider}/${model} does not match the pinned route ${expected.route.provider}/${expected.route.model}`,
+      "route_mismatch",
+      expected.taskId
+    );
+  const attestations = parseAttestations(parsed["route_attestations"], expected.taskId);
+  for (const attestation of attestations) {
+    if (attestation.provider !== expected.route.provider || attestation.model !== expected.route.model)
+      fail(
+        `delegate child produced an assistant message on ${attestation.provider}/${attestation.model}, but the pinned route is ${expected.route.provider}/${expected.route.model}`,
+        "route_mismatch",
+        expected.taskId
+      );
+  }
+  const answerRecord = parsed["answer"];
+  if (!isRecord(answerRecord))
+    fail(
+      "delegate result package answer must be an object",
+      "child_result_invalid",
+      expected.taskId
+    );
+  if (answerRecord["encoding"] !== "utf-8")
+    fail(
+      "delegate result package answer encoding must be utf-8",
+      "child_result_encoding_invalid",
+      expected.taskId
+    );
+  const declaredLength = requireInteger(answerRecord, "byte_length", expected.taskId);
+  const declaredSha = requireSha256(answerRecord, "sha256", expected.taskId);
+  const blocksValue = answerRecord["blocks"];
+  if (!Array.isArray(blocksValue))
+    fail(
+      "delegate result package answer blocks must be an array",
+      "child_result_invalid",
+      expected.taskId
+    );
+  const blocks = [];
+  const buffers = [];
+  for (const [index, entry] of blocksValue.entries()) {
+    if (!isRecord(entry))
+      fail(
+        `delegate answer block ${String(index)} must be an object`,
+        "child_result_invalid",
+        expected.taskId
+      );
+    if (entry["kind"] !== "text")
+      fail(
+        `delegate answer block ${String(index)} kind must be text`,
+        "child_result_invalid",
+        expected.taskId
+      );
+    const byteLength = requireInteger(entry, "byte_length", expected.taskId);
+    const sha = requireSha256(entry, "sha256", expected.taskId);
+    const dataBase64 = requireString(entry, "data_base64", expected.taskId);
+    const bytes = Buffer.from(dataBase64, "base64");
+    if (bytes.toString("base64") !== dataBase64)
+      fail(
+        `delegate answer block ${String(index)} is not strict base64`,
+        "child_result_invalid",
+        expected.taskId
+      );
+    if (bytes.length !== byteLength)
+      fail(
+        `delegate answer block ${String(index)} declares ${String(byteLength)} bytes but carries ${String(bytes.length)}`,
+        "answer_hash_mismatch",
+        expected.taskId
+      );
+    const actual = sha256Bytes(bytes);
+    if (actual !== sha)
+      fail(
+        `delegate answer block ${String(index)} hash mismatch: declared ${sha}, computed ${actual}`,
+        "answer_hash_mismatch",
+        expected.taskId
+      );
+    blocks.push({ kind: "text", byte_length: byteLength, sha256: sha, data_base64: dataBase64 });
+    buffers.push(bytes);
+  }
+  const aggregate = Buffer.concat(buffers);
+  if (aggregate.length !== declaredLength)
+    fail(
+      `delegate answer declares ${String(declaredLength)} bytes but its blocks total ${String(aggregate.length)}`,
+      "answer_hash_mismatch",
+      expected.taskId
+    );
+  const aggregateSha = sha256Bytes(aggregate);
+  if (aggregateSha !== declaredSha)
+    fail(
+      `delegate answer aggregate hash mismatch: declared ${declaredSha}, computed ${aggregateSha}`,
+      "answer_hash_mismatch",
+      expected.taskId
+    );
+  const answer = aggregate.toString("utf8");
+  if (!Buffer.from(answer, "utf8").equals(aggregate))
+    fail(
+      "delegate answer bytes are not well-formed UTF-8; they are preserved on disk and never returned with substitution characters",
+      "child_result_encoding_invalid",
+      expected.taskId
+    );
+  return {
+    package: {
+      schema_version: DELEGATE_RESULT_PACKAGE_SCHEMA_VERSION,
+      task_id: taskId,
+      launch_nonce: launchNonce,
+      seed_sha256: seedSha256,
+      directive_sha256: requireSha256(parsed, "directive_sha256", expected.taskId),
+      route: { provider, model },
+      route_attestations: attestations,
+      stop_reason: requireString(parsed, "stop_reason", expected.taskId),
+      turns: requireInteger(parsed, "turns", expected.taskId),
+      tool_calls: requireInteger(parsed, "tool_calls", expected.taskId),
+      usage: parseUsage(parsed["usage"], expected.taskId),
+      answer: {
+        encoding: "utf-8",
+        byte_length: declaredLength,
+        sha256: declaredSha,
+        blocks
+      },
+      spilled_artifacts: parseSpillReceipts(parsed["spilled_artifacts"], expected.taskId)
+    },
+    answer,
+    answerBytes: aggregate
+  };
+}
+__name(verifyDelegateResultPackage, "verifyDelegateResultPackage");
+
+// node_modules/pi-background-tasks/src/core/delegate/artifacts.ts?ext=pi-background-tasks
+var DELEGATE_ARTIFACT_NAMES = {
+  seed: "seed.json",
+  ledger: "context-omission-ledger.json",
+  budgetPlan: "budget-plan.json",
+  manifest: "manifest.json",
+  outcome: "outcome.json",
+  result: DELEGATE_RESULT_PACKAGE_FILENAME,
+  childPrompt: "child-prompt.txt",
+  runtimeBudget: "runtime-budget.json",
+  error: "error.json"
+};
+var DELEGATE_SPILL_DIRNAME = "spill";
+function sha256Bytes2(bytes) {
+  return createHash2("sha256").update(bytes).digest("hex");
+}
+__name(sha256Bytes2, "sha256Bytes");
+function pathInside(parent, child) {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel) && !rel.split(sep).includes("..");
+}
+__name(pathInside, "pathInside");
+function artifactError(message, cause) {
+  const suffix = cause === void 0 ? "" : `: ${cause instanceof Error ? cause.message : String(cause)}`;
+  return new DelegateError(`${message}${suffix}`, {
+    code: "artifact_error",
+    childCreated: true,
+    remediation: [
+      "The delegate artifact directory could not be written. Check free disk space and directory permissions."
+    ]
+  });
+}
+__name(artifactError, "artifactError");
+var DelegateArtifactStore = class _DelegateArtifactStore {
+  static {
+    __name(this, "DelegateArtifactStore");
+  }
+  rootAbs;
+  rootDisplay;
+  spillAbs;
+  now;
+  manifest;
+  writeChain = Promise.resolve();
+  totalSpilledBytes = 0;
+  constructor(rootAbs, rootDisplay, now, manifest) {
+    this.rootAbs = rootAbs;
+    this.rootDisplay = rootDisplay;
+    this.spillAbs = join(rootAbs, DELEGATE_SPILL_DIRNAME);
+    this.now = now;
+    this.manifest = manifest;
+  }
+  /**
+   * Create the artifact root with exclusive semantics.
+   *
+   * The directory name embeds the task id, which is cryptographically random, so
+   * two delegates launched in the same assistant message cannot collide. The
+   * directory is created with `recursive: false` so a pre-existing directory is
+   * a loud failure rather than a silent reuse.
+   */
+  static async create(options) {
+    const sessionSegment = sanitizePathSegment(
+      options.sessionId ?? `session-${String(process.pid)}`
+    );
+    const runDirName = `${sessionSegment}-${String(process.pid)}`;
+    const parentAbs = join(options.cwd, ".pi", "delegate", runDirName);
+    const rootAbs = join(parentAbs, options.taskId);
+    const rootDisplay = join(".pi", "delegate", runDirName, options.taskId);
+    try {
+      await mkdir(parentAbs, { recursive: true, mode: 448 });
+      await mkdir(rootAbs, { recursive: false, mode: 448 });
+      await chmod(rootAbs, 448);
+      await mkdir(join(rootAbs, DELEGATE_SPILL_DIRNAME), { recursive: false, mode: 448 });
+    } catch (error) {
+      throw artifactError(`could not create delegate artifact directory ${rootDisplay}`, error);
+    }
+    const timestamp = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+    const manifest = {
+      schema_version: DELEGATE_MANIFEST_SCHEMA_VERSION,
+      task_id: options.taskId,
+      launch_nonce: options.launchNonce,
+      created_at: timestamp,
+      updated_at: timestamp,
+      cwd: options.cwd,
+      child_session_id: options.childSessionId,
+      child_session_dir: options.childSessionDir,
+      extension_mode: options.extensionMode,
+      route: options.route,
+      limits: options.limits,
+      seed_sha256: options.seedSha256,
+      state: "launched",
+      artifacts: {}
+    };
+    const store = new _DelegateArtifactStore(
+      rootAbs,
+      rootDisplay,
+      options.now ?? (() => /* @__PURE__ */ new Date()),
+      manifest
+    );
+    await store.persistManifest();
+    return store;
+  }
+  get artifactDir() {
+    return this.rootDisplay;
+  }
+  get artifactDirAbs() {
+    return this.rootAbs;
+  }
+  get spillDirAbs() {
+    return this.spillAbs;
+  }
+  get resultPathAbs() {
+    return join(this.rootAbs, DELEGATE_ARTIFACT_NAMES.result);
+  }
+  snapshot() {
+    return { ...this.manifest, artifacts: { ...this.manifest.artifacts } };
+  }
+  async writeSeed(serialized) {
+    return this.write(DELEGATE_ARTIFACT_NAMES.seed, serialized);
+  }
+  /** Persist the exact prompt bytes handed to the child over stdin. */
+  async writeChildPrompt(bytes) {
+    return this.write(DELEGATE_ARTIFACT_NAMES.childPrompt, bytes);
+  }
+  async writeLedger(ledger) {
+    return this.write(DELEGATE_ARTIFACT_NAMES.ledger, `${canonicalJson(ledger)}
+`);
+  }
+  async writeBudgetPlan(plan) {
+    return this.write(DELEGATE_ARTIFACT_NAMES.budgetPlan, `${canonicalJson(plan)}
+`);
+  }
+  /** Commit the run. The rename performed here is the single success point. */
+  async commitResult(pkg) {
+    const ref = await this.write(
+      DELEGATE_ARTIFACT_NAMES.result,
+      serializeDelegateResultPackage(pkg)
+    );
+    await this.setState("committed");
+    return ref;
+  }
+  async readCommittedResult() {
+    try {
+      return await readFile(this.resultPathAbs, "utf8");
+    } catch (error) {
+      const diagnosticNames = [
+        DELEGATE_ARTIFACT_NAMES.error,
+        DELEGATE_ARTIFACT_NAMES.outcome,
+        DELEGATE_ARTIFACT_NAMES.runtimeBudget,
+        DELEGATE_ARTIFACT_NAMES.manifest
+      ].filter((name) => existsSync(join(this.rootAbs, name)));
+      throw new DelegateError(
+        `delegate result package could not be read at ${join(this.rootDisplay, DELEGATE_ARTIFACT_NAMES.result)}; no committed answer is available (${error instanceof Error ? error.message : String(error)})`,
+        {
+          code: "result_unavailable",
+          childCreated: true,
+          taskId: this.manifest.task_id,
+          artifactDir: this.rootDisplay,
+          preserved: diagnosticNames,
+          remediation: diagnosticNames.length === 0 ? [
+            "No diagnostic control artifact exists; inspect the background task merged output if one was created."
+          ] : [`Inspect the existing delegate control artifacts: ${diagnosticNames.join(", ")}.`]
+        }
+      );
+    }
+  }
+  async writeError(state, message) {
+    await this.write(
+      DELEGATE_ARTIFACT_NAMES.error,
+      `${canonicalJson({ state, error: message })}
+`
+    );
+    await this.setState(state, message);
+  }
+  async setState(state, error) {
+    await this.update((manifest) => {
+      manifest.state = state;
+      if (error !== void 0) manifest.error = error;
+    });
+  }
+  /**
+   * Spill one oversized tool payload.
+   *
+   * The filename encodes `(turnSequence, sourceCallIndex, toolCallId)` assigned
+   * before the tool executed, so a receipt can never be associated with the
+   * wrong call when parallel results complete out of order.
+   *
+   * A spill that cannot be committed is a terminal failure. The original payload
+   * is never returned as a fallback and no receipt is emitted for a file that
+   * was not committed.
+   */
+  async spillToolPayload(input) {
+    const nextTotal = this.totalSpilledBytes + input.payload.length;
+    if (nextTotal > input.maxTotalBytes) {
+      throw new DelegateError(
+        `delegate aggregate tool output would reach ${String(nextTotal)} bytes, exceeding the ${String(input.maxTotalBytes)}-byte cap for one run`,
+        {
+          code: "aggregate_tool_output_cap",
+          childCreated: true,
+          taskId: this.manifest.task_id,
+          artifactDir: this.rootDisplay,
+          preserved: [this.rootDisplay],
+          remediation: [
+            "The delegate read more tool output than one run is allowed to accumulate. Narrow the investigation prompt or raise the cap deliberately."
+          ]
+        }
+      );
+    }
+    const safeCallId = sanitizePathSegment(input.toolCallId).slice(0, 64);
+    const name = `t${String(input.turnSequence).padStart(4, "0")}-c${String(
+      input.sourceCallIndex
+    ).padStart(4, "0")}-${safeCallId}.bin`;
+    const absPath = join(this.spillAbs, name);
+    if (!pathInside(this.spillAbs, absPath)) {
+      throw artifactError(`delegate spill path escapes the artifact directory: ${name}`);
+    }
+    try {
+      await this.durableReplace(absPath, input.payload);
+    } catch (error) {
+      throw new DelegateError(
+        `delegate could not durably spill a ${String(input.payload.length)}-byte tool result; the payload is not forwarded and no receipt is emitted`,
+        {
+          code: "artifact_spill_failed",
+          childCreated: true,
+          taskId: this.manifest.task_id,
+          artifactDir: this.rootDisplay,
+          preserved: [this.rootDisplay],
+          remediation: [
+            `Underlying cause: ${error instanceof Error ? error.message : String(error)}`,
+            "Check free disk space and permissions on the delegate artifact directory."
+          ]
+        }
+      );
+    }
+    this.totalSpilledBytes = nextTotal;
+    return {
+      schema_version: DELEGATE_RECEIPT_SCHEMA_VERSION,
+      artifact: join(DELEGATE_SPILL_DIRNAME, name),
+      tool_name: input.toolName,
+      tool_call_id: input.toolCallId,
+      turn_sequence: input.turnSequence,
+      source_call_index: input.sourceCallIndex,
+      byte_length: input.payload.length,
+      sha256: sha256Bytes2(input.payload),
+      content_format: "opaque_bytes"
+    };
+  }
+  /**
+   * Read an exact byte range from a spilled artifact.
+   *
+   * Returns exactly the requested range or fails. It never returns a shorter
+   * range than requested, and it never clamps the request to what happens to be
+   * available: a request past end-of-file is a loud error naming the real size.
+   */
+  async readSpillRange(relativePath, offset, length) {
+    if (!Number.isSafeInteger(offset) || offset < 0)
+      throw this.readFailure(relativePath, "offset must be a non-negative integer");
+    if (!Number.isSafeInteger(length) || length <= 0)
+      throw this.readFailure(relativePath, "length must be a positive integer");
+    const absPath = join(this.rootAbs, relativePath);
+    if (!pathInside(this.rootAbs, absPath))
+      throw this.readFailure(relativePath, "path escapes the delegate artifact directory");
+    let handle;
+    try {
+      handle = await open(absPath, "r");
+    } catch (error) {
+      throw this.readFailure(
+        relativePath,
+        `cannot open artifact: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    try {
+      const stats = await handle.stat();
+      const totalBytes = stats.size;
+      if (offset + length > totalBytes) {
+        throw this.readFailure(
+          relativePath,
+          `requested bytes ${String(offset)}..${String(offset + length)} exceed the artifact size of ${String(totalBytes)} bytes; the read is refused rather than silently shortened`
+        );
+      }
+      const buffer = Buffer.alloc(length);
+      const { bytesRead } = await handle.read(buffer, 0, length, offset);
+      if (bytesRead !== length) {
+        throw this.readFailure(
+          relativePath,
+          `read returned ${String(bytesRead)} of ${String(length)} requested bytes`
+        );
+      }
+      return { bytes: buffer, totalBytes };
+    } finally {
+      await handle.close();
+    }
+  }
+  readFailure(relativePath, reason) {
+    return new DelegateError(`delegate artifact read failed for ${relativePath}: ${reason}`, {
+      code: "artifact_read_failed",
+      childCreated: true,
+      taskId: this.manifest.task_id,
+      artifactDir: this.rootDisplay
+    });
+  }
+  async durableReplace(absPath, data) {
+    await replaceFileDurable(absPath, data);
+  }
+  async write(name, data) {
+    const absPath = join(this.rootAbs, name);
+    if (name.length === 0 || name.includes("/") || name.includes("\\"))
+      throw artifactError(`invalid delegate artifact name: ${name}`);
+    if (!pathInside(this.rootAbs, absPath))
+      throw artifactError(`delegate artifact path escapes the run directory: ${name}`);
+    const bytes = Buffer.isBuffer(data) ? data : Buffer.from(data, "utf8");
+    try {
+      await this.durableReplace(absPath, data);
+    } catch (error) {
+      throw artifactError(`could not durably write delegate artifact ${name}`, error);
+    }
+    const ref = {
+      path: basename(absPath),
+      byte_length: bytes.length,
+      sha256: sha256Bytes2(bytes)
+    };
+    await this.update((manifest) => {
+      manifest.artifacts = { ...manifest.artifacts, [name]: ref };
+    });
+    return ref;
+  }
+  async persistManifest() {
+    const absPath = join(this.rootAbs, DELEGATE_ARTIFACT_NAMES.manifest);
+    try {
+      await this.durableReplace(absPath, `${canonicalJson(this.snapshot())}
+`);
+    } catch (error) {
+      throw artifactError("could not durably write the delegate manifest", error);
+    }
+  }
+  async update(mutator) {
+    const apply = /* @__PURE__ */ __name(async () => {
+      mutator(this.manifest);
+      this.manifest.updated_at = this.now().toISOString();
+      await this.persistManifest();
+    }, "apply");
+    const next = this.writeChain.then(apply, apply);
+    this.writeChain = next.catch(() => void 0);
+    await next;
+  }
+};
+async function discardDelegateArtifactRoot(rootAbs) {
+  await rm(rootAbs, { recursive: true, force: true });
+}
+__name(discardDelegateArtifactRoot, "discardDelegateArtifactRoot");
+
+// node_modules/pi-background-tasks/src/core/delegate/runner.ts?ext=pi-background-tasks
+var PREPARATION_CLEANUP_ERROR_MAX_CHARS = 320;
+function boundedPreparationError(error) {
+  const text = (error instanceof Error ? error.message : String(error)).replace(/\s+/gu, " ").trim();
+  if (text.length <= PREPARATION_CLEANUP_ERROR_MAX_CHARS) return text;
+  return `${text.slice(0, PREPARATION_CLEANUP_ERROR_MAX_CHARS)}\u2026`;
+}
+__name(boundedPreparationError, "boundedPreparationError");
+function filesystemErrorCode(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const code = Reflect.get(error, "code");
+  return typeof code === "string" ? code : void 0;
+}
+__name(filesystemErrorCode, "filesystemErrorCode");
+async function removeEmptyDirectory(path) {
+  try {
+    await rmdir(path);
+    return true;
+  } catch (error) {
+    const code = filesystemErrorCode(error);
+    if (code === "ENOENT") return true;
+    if (code === "ENOTEMPTY" || code === "EEXIST") return false;
+    throw error;
+  }
+}
+__name(removeEmptyDirectory, "removeEmptyDirectory");
+async function discardUnownedDelegatePreparation(rootAbs) {
+  await discardDelegateArtifactRoot(rootAbs);
+  const runParent = dirname(rootAbs);
+  if (!await removeEmptyDirectory(runParent)) return;
+  await removeEmptyDirectory(dirname(runParent));
+}
+__name(discardUnownedDelegatePreparation, "discardUnownedDelegatePreparation");
+function throwIfPreparationAborted(signal) {
+  if (signal?.aborted !== true) return;
+  const reason = signal.reason;
+  if (reason instanceof Error) throw reason;
+  throw new Error("delegate launch preparation was cancelled before task registration");
+}
+__name(throwIfPreparationAborted, "throwIfPreparationAborted");
+function preparationCleanupFailure(original, cleanup) {
+  return new AggregateError(
+    [original, cleanup],
+    `delegate launch preparation failed and rollback also failed: ${boundedPreparationError(cleanup)}`
+  );
+}
+__name(preparationCleanupFailure, "preparationCleanupFailure");
+async function prepareDelegateLaunch(input) {
+  throwIfPreparationAborted(input.signal);
+  const childExtensionPath = input.childExtensionPath ?? resolveDelegateChildExtensionPath();
+  let attributionExtensionPath;
+  if (input.route.provider === "anthropic") {
+    try {
+      attributionExtensionPath = input.attributionExtensionPath ?? resolveAnthropicAttributionExtensionPath();
+    } catch (error) {
+      throw new DelegateError(
+        `Anthropic delegate attribution extension could not be resolved: ${error instanceof Error ? error.message : String(error)}`,
+        {
+          code: "delegate_isolation_unsupported",
+          childCreated: false,
+          remediation: ["Reinstall the package; Anthropic delegates require attribution."]
+        }
+      );
+    }
+  }
+  throwIfPreparationAborted(input.signal);
+  const preflight = preflightDelegateLaunch(input);
+  throwIfPreparationAborted(input.signal);
+  let store;
+  try {
+    store = await DelegateArtifactStore.create({
+      cwd: input.cwd,
+      taskId: preflight.taskId,
+      launchNonce: preflight.launchNonce,
+      sessionId: input.sessionId,
+      childSessionId: preflight.childSessionId,
+      childSessionDir: "",
+      extensionMode: input.extensionMode,
+      route: input.route,
+      limits: preflight.limits,
+      seedSha256: preflight.seed.sha256,
+      ...input.now === void 0 ? {} : { now: input.now }
+    });
+    throwIfPreparationAborted(input.signal);
+    const seedRef = await store.writeSeed(preflight.seed.serialized);
+    throwIfPreparationAborted(input.signal);
+    if (seedRef.sha256 !== preflight.seed.sha256) {
+      throw new DelegateError("delegate seed hash changed between construction and persistence", {
+        code: "seed_persist_failed",
+        childCreated: false,
+        taskId: preflight.taskId,
+        artifactDir: store.artifactDir
+      });
+    }
+    await store.writeLedger(preflight.seed.ledger);
+    throwIfPreparationAborted(input.signal);
+    await store.writeBudgetPlan(preflight.plan);
+    throwIfPreparationAborted(input.signal);
+    const childSessionDirAbs = await ensureDelegateChildSessionDir(store.artifactDirAbs);
+    throwIfPreparationAborted(input.signal);
+    const seedPathAbs = join2(store.artifactDirAbs, "seed.json");
+    const argv = buildDelegateChildArgv({
+      route: input.route,
+      capability: input.capability,
+      extensionMode: input.extensionMode,
+      childSessionId: preflight.childSessionId,
+      childSessionDir: childSessionDirAbs,
+      childExtensionPath,
+      attributionExtensionPath,
+      systemPrompt: preflight.childSystemPrompt
+    });
+    const env = delegateChildEnv(
+      {
+        artifactDirAbs: store.artifactDirAbs,
+        seedPathAbs,
+        seedSha256: preflight.seed.sha256,
+        taskId: preflight.taskId,
+        launchNonce: preflight.launchNonce
+      },
+      input.env ?? process.env
+    );
+    const facts = {
+      taskId: preflight.taskId,
+      launchNonce: preflight.launchNonce,
+      artifactDir: store.artifactDir,
+      artifactDirAbs: store.artifactDirAbs,
+      seedSha256: preflight.seed.sha256,
+      childSessionId: preflight.childSessionId,
+      route: {
+        provider: input.route.provider,
+        model: input.route.model,
+        qualifiedId: input.route.qualified_id
+      },
+      budget: {
+        family: preflight.plan.route.family,
+        rate_source: preflight.plan.route.rate_source,
+        conservative_rate_source: preflight.plan.conservative_estimate.rateSource
+      },
+      extensionMode: input.extensionMode,
+      autoDeliver: input.autoDeliver
+    };
+    const stdinBytes = Buffer.from(preflight.childPrompt, "utf8");
+    await store.writeChildPrompt(stdinBytes);
+    throwIfPreparationAborted(input.signal);
+    const artifactDirAbs = store.artifactDirAbs;
+    let rollbackPromise;
+    const rollback = /* @__PURE__ */ __name(() => {
+      rollbackPromise ??= discardUnownedDelegatePreparation(artifactDirAbs);
+      return rollbackPromise;
+    }, "rollback");
+    return {
+      preflight,
+      store,
+      argv,
+      env,
+      facts,
+      childSessionDirAbs,
+      seedPathAbs,
+      stdinBytes,
+      rollback
+    };
+  } catch (error) {
+    if (store === void 0) throw error;
+    try {
+      await discardUnownedDelegatePreparation(store.artifactDirAbs);
+    } catch (cleanupError) {
+      throw preparationCleanupFailure(error, cleanupError);
+    }
+    throw error;
+  }
+}
+__name(prepareDelegateLaunch, "prepareDelegateLaunch");
+async function evaluateDelegateTerminal(input) {
+  const evaluation = await adjudicateDelegateTerminal(input);
+  try {
+    await replaceFileDurable(
+      join2(input.artifactDirAbs, "outcome.json"),
+      `${canonicalJson({
+        schema_version: "pi-background-tasks.delegate-outcome.v1",
+        task_id: input.taskId,
+        launch_nonce: input.launchNonce,
+        observed_task_status: input.taskStatus,
+        outcome: evaluation.outcome,
+        error_code: evaluation.error?.code ?? null
+      })}
+`
+    );
+  } catch {
+  }
+  return evaluation;
+}
+__name(evaluateDelegateTerminal, "evaluateDelegateTerminal");
+async function adjudicateDelegateTerminal(input) {
+  const resultPath = join2(input.artifactDirAbs, "result.json");
+  const terminalPath = join2(input.artifactDirAbs, "child-terminal.json");
+  if (!existsSync2(resultPath)) {
+    const recorded = existsSync2(terminalPath) ? await readChildTerminal(terminalPath) : void 0;
+    const cancelled = input.taskStatus === "killed";
+    const code = recorded?.code ?? (cancelled ? "child_cancelled" : "child_exited_without_commit");
+    const detail = recorded?.message ?? input.taskError ?? "the delegate child exited without committing a result package";
+    const preserved = [
+      "seed.json",
+      "budget-plan.json",
+      "child-terminal.json",
+      "runtime-budget.json"
+    ].filter((name) => existsSync2(join2(input.artifactDirAbs, name)));
+    if (input.taskOutputPath !== void 0 && input.taskOutputAbsPath !== void 0 && existsSync2(input.taskOutputAbsPath)) {
+      preserved.push(input.taskOutputPath);
+    }
+    const diagnosticTargets = preserved.filter(
+      (name) => name === "child-terminal.json" || name === "runtime-budget.json" || name === input.taskOutputPath
+    );
+    const diagnostic = diagnosticTargets.length === 0 ? "No child terminal record or merged task output exists; inspect the preserved launch artifacts listed above." : `Inspect the preserved diagnostic evidence: ${diagnosticTargets.join(", ")}.`;
+    const error = new DelegateError(`bg_delegate produced no committed answer: ${detail}`, {
+      code: isDelegateErrorCode(code) ? code : "child_exited_without_commit",
+      childCreated: true,
+      taskId: input.taskId,
+      artifactDir: input.artifactDirAbs,
+      preserved,
+      remediation: [
+        diagnostic,
+        "No partial answer is returned; nothing was truncated to look like success."
+      ]
+    });
+    const outcome = {
+      status: cancelled ? "cancelled" : "failed",
+      errorCode: error.code
+    };
+    return { outcome, error };
+  }
+  let raw;
+  try {
+    raw = await readFile2(resultPath, "utf8");
+  } catch (error) {
+    const failure = new DelegateError(
+      `bg_delegate could not read its committed result package: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        code: "artifact_read_failed",
+        childCreated: true,
+        taskId: input.taskId,
+        artifactDir: input.artifactDirAbs
+      }
+    );
+    return { outcome: { status: "failed", errorCode: failure.code }, error: failure };
+  }
+  try {
+    const verified = verifyDelegateResultPackage(raw, {
+      taskId: input.taskId,
+      launchNonce: input.launchNonce,
+      seedSha256: input.seedSha256,
+      route: input.route
+    });
+    return {
+      outcome: {
+        status: "committed",
+        answerBytes: verified.package.answer.byte_length,
+        answerSha256: verified.package.answer.sha256,
+        turns: verified.package.turns,
+        toolCalls: verified.package.tool_calls
+      },
+      result: verified
+    };
+  } catch (error) {
+    if (error instanceof DelegateError) {
+      return { outcome: { status: "failed", errorCode: error.code }, error };
+    }
+    throw error;
+  }
+}
+__name(adjudicateDelegateTerminal, "adjudicateDelegateTerminal");
+async function readChildTerminal(path) {
+  try {
+    const parsed = JSON.parse(await readFile2(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return void 0;
+    const code = Reflect.get(parsed, "code");
+    const message = Reflect.get(parsed, "message");
+    if (typeof code !== "string" || typeof message !== "string") return void 0;
+    return { code, message };
+  } catch {
+    return void 0;
+  }
+}
+__name(readChildTerminal, "readChildTerminal");
+var DELEGATE_ERROR_CODE_SET = /* @__PURE__ */ new Set([
+  "delegate_hook_contract_unsupported",
+  "delegate_isolation_unsupported",
+  "route_unresolved",
+  "route_capacity_unknown",
+  "seed_projection_failed",
+  "seed_budget_exceeded",
+  "seed_persist_failed",
+  "invalid_arguments",
+  "child_spawn_failed",
+  "child_startup_failed",
+  "child_timeout",
+  "child_cancelled",
+  "child_turn_limit",
+  "child_tool_call_limit",
+  "child_exited_without_commit",
+  "provider_context_budget_exhausted",
+  "aggregate_tool_output_cap",
+  "child_model_output_limit",
+  "child_capture_limit",
+  "child_result_invalid",
+  "child_result_encoding_invalid",
+  "route_attestation_missing",
+  "route_mismatch",
+  "seed_hash_mismatch",
+  "answer_hash_mismatch",
+  "artifact_spill_failed",
+  "artifact_read_failed",
+  "artifact_error",
+  "result_not_ready",
+  "result_unavailable",
+  "result_too_large_for_inline",
+  "task_unknown"
+]);
+function isDelegateErrorCode(value) {
+  return DELEGATE_ERROR_CODE_SET.has(value);
+}
+__name(isDelegateErrorCode, "isDelegateErrorCode");
+function decideDelegateDelivery(answerBytes, requested, cap = DELEGATE_INLINE_ANSWER_BYTES) {
+  if (requested === "artifact") {
+    return { mode: "artifact", reason: "artifact delivery was requested explicitly" };
+  }
+  if (answerBytes <= cap) {
+    return {
+      mode: "inline",
+      reason: `the answer is ${String(answerBytes)} bytes, within the ${String(cap)}-byte inline cap`
+    };
+  }
+  return {
+    mode: "artifact",
+    reason: `the answer is ${String(answerBytes)} bytes, over the ${String(cap)}-byte inline cap`
+  };
+}
+__name(decideDelegateDelivery, "decideDelegateDelivery");
+function inlineTooLarge(taskId, artifactDir, answerBytes, cap = DELEGATE_INLINE_ANSWER_BYTES) {
+  return new DelegateError(
+    `bg_result cannot return this answer inline: it is ${String(answerBytes)} bytes, over the ${String(cap)}-byte inline cap. The complete verified answer is preserved at ${join2(artifactDir, "result.json")}. It is not truncated to fit.`,
+    {
+      code: "result_too_large_for_inline",
+      childCreated: true,
+      taskId,
+      artifactDir,
+      preserved: [join2(artifactDir, "result.json")],
+      remediation: [
+        'Call bg_result with delivery:"artifact" to receive the verified metadata plus the artifact reference.',
+        "Read the answer from the artifact path directly if the full text is required."
+      ]
+    }
+  );
+}
+__name(inlineTooLarge, "inlineTooLarge");
+
+export {
+  prepareDelegateLaunch,
+  evaluateDelegateTerminal,
+  adjudicateDelegateTerminal,
+  decideDelegateDelivery,
+  inlineTooLarge
+};