privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-CRIHASQ6.mjs

@@ -0,0 +1,973 @@
+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 {
+  CURRENT_MODEL_SELECTION
+} from "./c-G4DLN7Q4.mjs";
+import {
+  FUSION_MODEL_CONFIG_SCHEMA_VERSION,
+  FusionError
+} from "./c-37GM3GMU.mjs";
+import {
+  replaceFileDurable
+} from "./c-DR7XQI32.mjs";
+import {
+  isJsonObject,
+  parseJsonText
+} from "./c-I3C6LBW4.mjs";
+import {
+  getAgentDir
+} from "./c-PTN4S6G2.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/pi-background-tasks/src/core/fusion/config.ts?ext=pi-background-tasks
+import { createHash as createHash2 } from "node:crypto";
+import { chmod, mkdir, open, readFile, rm } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+
+// node_modules/pi-background-tasks/src/core/anthropic-attribution.ts?ext=pi-background-tasks
+import { createHash, randomUUID } from "node:crypto";
+var CLAUDE_CODE_VERSION = "2.1.280";
+var CLAUDE_CODE_ENTRYPOINT = "sdk-cli";
+var ANTHROPIC_1M_CONTEXT_BETA = "context-1m-2025-08-07";
+var CLAUDE_CODE_200K_SUBSCRIPTION_CONTEXT_WINDOW = 2e5;
+var CLAUDE_CODE_LEGACY_BETA_VALUES = [
+  "claude-code-20250219",
+  "oauth-2025-04-20",
+  "interleaved-thinking-2025-05-14",
+  "thinking-token-count-2026-05-13",
+  "context-management-2025-06-27",
+  "prompt-caching-scope-2026-01-05",
+  "advisor-tool-2026-03-01",
+  "structured-outputs-2025-12-15"
+];
+var CLAUDE_CODE_ADAPTIVE_200K_BETA_VALUES = [
+  "claude-code-20250219",
+  "oauth-2025-04-20",
+  "interleaved-thinking-2025-05-14",
+  "thinking-token-count-2026-05-13",
+  "context-management-2025-06-27",
+  "prompt-caching-scope-2026-01-05",
+  "mid-conversation-system-2026-04-07"
+];
+var CLAUDE_CODE_FABLE_5_1_200K_BETA_VALUES = [
+  ...CLAUDE_CODE_ADAPTIVE_200K_BETA_VALUES,
+  "thinking-binding-controls-2026-08-01",
+  "cache-diagnosis-2026-04-07"
+];
+function build200KSubscriptionBetaHeader(values) {
+  if (values.includes(ANTHROPIC_1M_CONTEXT_BETA)) {
+    throw new Error(
+      `Anthropic attribution 200K subscription policy must not emit ${ANTHROPIC_1M_CONTEXT_BETA}`
+    );
+  }
+  return values.join(",");
+}
+__name(build200KSubscriptionBetaHeader, "build200KSubscriptionBetaHeader");
+var CLAUDE_CODE_BETA = build200KSubscriptionBetaHeader(CLAUDE_CODE_LEGACY_BETA_VALUES);
+var CLAUDE_CODE_ADAPTIVE_200K_BETA = build200KSubscriptionBetaHeader(
+  CLAUDE_CODE_ADAPTIVE_200K_BETA_VALUES
+);
+var CLAUDE_CODE_FABLE_5_1_200K_BETA = build200KSubscriptionBetaHeader(
+  CLAUDE_CODE_FABLE_5_1_200K_BETA_VALUES
+);
+var CLAUDE_AGENT_SDK_SYSTEM_TEXT = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
+var ANTHROPIC_LINEAGE_DIAGNOSTIC_TYPE = "anthropic-cache-lineage";
+var ANTHROPIC_LINEAGE_SCHEMA = "pi-anthropic-attribution.lineage.v1";
+var ANTHROPIC_PROJECTION_VERSION = 3;
+var ANTHROPIC_OFFICIAL_ORIGIN = "https://api.anthropic.com";
+var ANTHROPIC_BETA_MESSAGES_URL = `${ANTHROPIC_OFFICIAL_ORIGIN}/v1/messages?beta=true`;
+var COMPACTION_SUMMARY_PREFIX = "The conversation history before this point was compacted into the following summary:";
+var parseJsonSource = JSON.parse.bind(JSON);
+function claudeCode200KSubscriptionPolicy(modelId, beta, thinkingPolicy, features = {}) {
+  if (beta.split(",").includes(ANTHROPIC_1M_CONTEXT_BETA)) {
+    throw new Error(
+      `Anthropic attribution 200K subscription policy for ${modelId} must not emit ${ANTHROPIC_1M_CONTEXT_BETA}`
+    );
+  }
+  return {
+    modelId,
+    beta,
+    thinkingPolicy,
+    contextWindow: CLAUDE_CODE_200K_SUBSCRIPTION_CONTEXT_WINDOW,
+    enforcesThinkingPrefixBinding: features.enforcesThinkingPrefixBinding === true,
+    supportsCacheDiagnostics: features.supportsCacheDiagnostics === true
+  };
+}
+__name(claudeCode200KSubscriptionPolicy, "claudeCode200KSubscriptionPolicy");
+var CLAUDE_CODE_MODEL_POLICIES = Object.freeze({
+  "claude-3-5-haiku-20241022": claudeCode200KSubscriptionPolicy(
+    "claude-3-5-haiku-20241022",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-3-5-haiku-latest": claudeCode200KSubscriptionPolicy(
+    "claude-3-5-haiku-latest",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-3-5-sonnet-20240620": claudeCode200KSubscriptionPolicy(
+    "claude-3-5-sonnet-20240620",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-3-5-sonnet-20241022": claudeCode200KSubscriptionPolicy(
+    "claude-3-5-sonnet-20241022",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-3-7-sonnet-20250219": claudeCode200KSubscriptionPolicy(
+    "claude-3-7-sonnet-20250219",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-3-haiku-20240307": claudeCode200KSubscriptionPolicy(
+    "claude-3-haiku-20240307",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-3-opus-20240229": claudeCode200KSubscriptionPolicy(
+    "claude-3-opus-20240229",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-3-sonnet-20240229": claudeCode200KSubscriptionPolicy(
+    "claude-3-sonnet-20240229",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-fable-5": claudeCode200KSubscriptionPolicy(
+    "claude-fable-5",
+    CLAUDE_CODE_ADAPTIVE_200K_BETA,
+    "adaptive-effort"
+  ),
+  "claude-fable-5-1": claudeCode200KSubscriptionPolicy(
+    "claude-fable-5-1",
+    CLAUDE_CODE_FABLE_5_1_200K_BETA,
+    "adaptive-effort",
+    { enforcesThinkingPrefixBinding: true, supportsCacheDiagnostics: true }
+  ),
+  "claude-haiku-4-5": claudeCode200KSubscriptionPolicy(
+    "claude-haiku-4-5",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-haiku-4-5-20251001": claudeCode200KSubscriptionPolicy(
+    "claude-haiku-4-5-20251001",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-opus-4-0": claudeCode200KSubscriptionPolicy(
+    "claude-opus-4-0",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-opus-4-1": claudeCode200KSubscriptionPolicy(
+    "claude-opus-4-1",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-opus-4-1-20250805": claudeCode200KSubscriptionPolicy(
+    "claude-opus-4-1-20250805",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-opus-4-20250514": claudeCode200KSubscriptionPolicy(
+    "claude-opus-4-20250514",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-opus-4-5": claudeCode200KSubscriptionPolicy(
+    "claude-opus-4-5",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-opus-4-5-20251101": claudeCode200KSubscriptionPolicy(
+    "claude-opus-4-5-20251101",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-opus-4-6": claudeCode200KSubscriptionPolicy(
+    "claude-opus-4-6",
+    CLAUDE_CODE_ADAPTIVE_200K_BETA,
+    "adaptive-effort"
+  ),
+  "claude-opus-4-7": claudeCode200KSubscriptionPolicy(
+    "claude-opus-4-7",
+    CLAUDE_CODE_ADAPTIVE_200K_BETA,
+    "adaptive-effort"
+  ),
+  "claude-opus-4-8": claudeCode200KSubscriptionPolicy(
+    "claude-opus-4-8",
+    CLAUDE_CODE_ADAPTIVE_200K_BETA,
+    "adaptive-effort"
+  ),
+  "claude-opus-5": claudeCode200KSubscriptionPolicy(
+    "claude-opus-5",
+    CLAUDE_CODE_ADAPTIVE_200K_BETA,
+    "adaptive-effort"
+  ),
+  "claude-opus-5-5": claudeCode200KSubscriptionPolicy(
+    "claude-opus-5-5",
+    CLAUDE_CODE_ADAPTIVE_200K_BETA,
+    "adaptive-effort"
+  ),
+  "claude-sonnet-4-0": claudeCode200KSubscriptionPolicy(
+    "claude-sonnet-4-0",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-sonnet-4-20250514": claudeCode200KSubscriptionPolicy(
+    "claude-sonnet-4-20250514",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-sonnet-4-5": claudeCode200KSubscriptionPolicy(
+    "claude-sonnet-4-5",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-sonnet-4-5-20250929": claudeCode200KSubscriptionPolicy(
+    "claude-sonnet-4-5-20250929",
+    CLAUDE_CODE_BETA,
+    "fixed-budget"
+  ),
+  "claude-sonnet-4-6": claudeCode200KSubscriptionPolicy(
+    "claude-sonnet-4-6",
+    CLAUDE_CODE_ADAPTIVE_200K_BETA,
+    "adaptive-effort"
+  ),
+  "claude-sonnet-5": claudeCode200KSubscriptionPolicy(
+    "claude-sonnet-5",
+    CLAUDE_CODE_ADAPTIVE_200K_BETA,
+    "adaptive-effort"
+  ),
+  "claude-sonnet-5-5": claudeCode200KSubscriptionPolicy(
+    "claude-sonnet-5-5",
+    CLAUDE_CODE_ADAPTIVE_200K_BETA,
+    "adaptive-effort"
+  )
+});
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isPlainObject, "isPlainObject");
+function cloneAnthropicCacheControl(value) {
+  if (value === void 0) return void 0;
+  if (!isPlainObject(value)) {
+    throw new Error(
+      "Anthropic attribution cannot safely process malformed cache_control; expected an object"
+    );
+  }
+  if (value["type"] !== "ephemeral") {
+    throw new Error(
+      'Anthropic attribution cannot safely process malformed cache_control.type; expected "ephemeral"'
+    );
+  }
+  const ttl = value["ttl"];
+  if (ttl !== void 0 && ttl !== "1h" && ttl !== "5m") {
+    throw new Error(
+      'Anthropic attribution cannot safely process malformed cache_control.ttl; expected "1h" or "5m"'
+    );
+  }
+  return {
+    ...value,
+    type: "ephemeral",
+    ...ttl === void 0 ? {} : { ttl }
+  };
+}
+__name(cloneAnthropicCacheControl, "cloneAnthropicCacheControl");
+function inspectCacheControls(payload) {
+  let count = 0;
+  let hasLong = false;
+  const inspectBlock = /* @__PURE__ */ __name((block) => {
+    if (!isPlainObject(block) || block["cache_control"] === void 0) return;
+    const cacheControl = cloneAnthropicCacheControl(block["cache_control"]);
+    count += 1;
+    if (cacheControl?.ttl === "1h") hasLong = true;
+  }, "inspectBlock");
+  const system = payload["system"];
+  if (Array.isArray(system)) {
+    for (const block of system) inspectBlock(block);
+  }
+  const tools = payload["tools"];
+  if (Array.isArray(tools)) {
+    for (const tool of tools) inspectBlock(tool);
+  }
+  const messages = payload["messages"];
+  if (Array.isArray(messages)) {
+    for (const message of messages) {
+      if (!isPlainObject(message)) continue;
+      const content = message["content"];
+      if (Array.isArray(content)) {
+        for (const block of content) inspectBlock(block);
+      }
+    }
+  }
+  return { count, retention: count === 0 ? void 0 : hasLong ? "long" : "short" };
+}
+__name(inspectCacheControls, "inspectCacheControls");
+function normalizedAnthropicModelId(model) {
+  if (typeof model.id !== "string" || model.id.trim().length === 0) {
+    throw new Error("Anthropic attribution requires a non-empty model id");
+  }
+  const providerPrefix = "anthropic/";
+  return model.id.startsWith(providerPrefix) ? model.id.slice(providerPrefix.length) : model.id;
+}
+__name(normalizedAnthropicModelId, "normalizedAnthropicModelId");
+function isClaudeCodeIdentityText(text) {
+  return text.startsWith("x-anthropic-billing-header:") || text === CLAUDE_AGENT_SDK_SYSTEM_TEXT || text === "You are Claude Code, Anthropic's official CLI for Claude." || text === "You are Claude Code, Anthropic's official CLI for Claude, running within the Claude Agent SDK.";
+}
+__name(isClaudeCodeIdentityText, "isClaudeCodeIdentityText");
+function canonicalizeJson(value) {
+  if (Array.isArray(value)) return value.map(canonicalizeJson);
+  if (!isPlainObject(value)) return value;
+  const output = {};
+  for (const key of Object.keys(value).sort()) {
+    const child = value[key];
+    if (child !== void 0) output[key] = canonicalizeJson(child);
+  }
+  return output;
+}
+__name(canonicalizeJson, "canonicalizeJson");
+function canonicalJson(value) {
+  return JSON.stringify(canonicalizeJson(value));
+}
+__name(canonicalJson, "canonicalJson");
+function sha256Canonical(value) {
+  return createHash("sha256").update(canonicalJson(value), "utf8").digest("hex");
+}
+__name(sha256Canonical, "sha256Canonical");
+function isSha256(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/u.test(value);
+}
+__name(isSha256, "isSha256");
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+__name(isNonEmptyString, "isNonEmptyString");
+function blockWithoutCacheControl(block) {
+  if (!isPlainObject(block)) return block;
+  const output = { ...block };
+  delete output["cache_control"];
+  return output;
+}
+__name(blockWithoutCacheControl, "blockWithoutCacheControl");
+function promptMessagesWithoutCacheControls(messages) {
+  return messages.map((message) => {
+    const content = message["content"];
+    return {
+      ...message,
+      ...Array.isArray(content) ? { content: content.map(blockWithoutCacheControl) } : {}
+    };
+  });
+}
+__name(promptMessagesWithoutCacheControls, "promptMessagesWithoutCacheControls");
+function promptMessagesHash(messages) {
+  return sha256Canonical(promptMessagesWithoutCacheControls(messages));
+}
+__name(promptMessagesHash, "promptMessagesHash");
+function assistantContentHash(content) {
+  return sha256Canonical(content);
+}
+__name(assistantContentHash, "assistantContentHash");
+function parseAnthropicLineageDetails(message) {
+  const diagnostic = [...message.diagnostics ?? []].reverse().find((candidate) => candidate.type === ANTHROPIC_LINEAGE_DIAGNOSTIC_TYPE);
+  const details = diagnostic?.details;
+  if (!isPlainObject(details)) return void 0;
+  const sourceModel = details["source_model"];
+  const responseId = details["response_id"];
+  const assistantContentSha256 = details["assistant_content_sha256"];
+  const conversationStaticSha256 = details["conversation_static_sha256"];
+  const requestMessageCount = details["request_message_count"];
+  const requestMessagesSha256 = details["request_messages_sha256"];
+  const cacheProfileSha256 = details["cache_profile_sha256"];
+  const cacheRetention = details["cache_retention"];
+  const compactionBoundarySha256 = details["compaction_boundary_sha256"];
+  const signatureEpochSha256 = details["signature_epoch_sha256"];
+  const signatureEpochInheritsPrior = details["signature_epoch_inherits_prior"];
+  const previousMessageId = details["previous_message_id"];
+  if (details["schema_version"] !== ANTHROPIC_LINEAGE_SCHEMA || details["projection_version"] !== ANTHROPIC_PROJECTION_VERSION || details["source_provider"] !== "anthropic" || details["source_api"] !== "anthropic-messages" || !isNonEmptyString(sourceModel) || !isNonEmptyString(responseId) || !isSha256(assistantContentSha256) || !isSha256(conversationStaticSha256) || typeof requestMessageCount !== "number" || !Number.isSafeInteger(requestMessageCount) || requestMessageCount < 0 || !isSha256(requestMessagesSha256) || !isSha256(cacheProfileSha256) || cacheRetention !== "none" && cacheRetention !== "short" && cacheRetention !== "long" || compactionBoundarySha256 !== null && !isSha256(compactionBoundarySha256) || !isSha256(signatureEpochSha256) || typeof signatureEpochInheritsPrior !== "boolean" || previousMessageId !== null && !isNonEmptyString(previousMessageId)) {
+    return void 0;
+  }
+  return {
+    schema_version: ANTHROPIC_LINEAGE_SCHEMA,
+    projection_version: ANTHROPIC_PROJECTION_VERSION,
+    source_provider: "anthropic",
+    source_api: "anthropic-messages",
+    source_model: sourceModel,
+    response_id: responseId,
+    assistant_content_sha256: assistantContentSha256,
+    conversation_static_sha256: conversationStaticSha256,
+    request_message_count: requestMessageCount,
+    request_messages_sha256: requestMessagesSha256,
+    cache_profile_sha256: cacheProfileSha256,
+    cache_retention: cacheRetention,
+    compaction_boundary_sha256: compactionBoundarySha256,
+    signature_epoch_sha256: signatureEpochSha256,
+    signature_epoch_inherits_prior: signatureEpochInheritsPrior,
+    previous_message_id: previousMessageId
+  };
+}
+__name(parseAnthropicLineageDetails, "parseAnthropicLineageDetails");
+function isSuccessfulLineageStopReason(stopReason) {
+  return stopReason === "stop" || stopReason === "length" || stopReason === "toolUse";
+}
+__name(isSuccessfulLineageStopReason, "isSuccessfulLineageStopReason");
+function lineageBindsContainingAssistant(message, lineage) {
+  return message.provider === lineage.source_provider && message.api === lineage.source_api && isNonEmptyString(message.model) && message.model === lineage.source_model && isSuccessfulLineageStopReason(message.stopReason) && isNonEmptyString(message.responseId) && message.responseId === lineage.response_id && lineage.assistant_content_sha256 === assistantContentHash(message.content);
+}
+__name(lineageBindsContainingAssistant, "lineageBindsContainingAssistant");
+function conversationStaticHash(system, tools) {
+  const normalizedSystem = system.filter(
+    (block) => !isPlainObject(block) || typeof block["text"] !== "string" || !isClaudeCodeIdentityText(block["text"])
+  ).map(blockWithoutCacheControl);
+  return sha256Canonical({
+    attribution_profile: {
+      claude_code_version: CLAUDE_CODE_VERSION,
+      entrypoint: CLAUDE_CODE_ENTRYPOINT
+    },
+    system: normalizedSystem,
+    tools: tools.map(blockWithoutCacheControl)
+  });
+}
+__name(conversationStaticHash, "conversationStaticHash");
+function requestMessagesFromPayload(payload) {
+  const messages = payload["messages"];
+  if (!Array.isArray(messages) || messages.some((message) => !isPlainObject(message))) {
+    throw new Error("Anthropic attribution final payload.messages must be an object array");
+  }
+  for (const message of messages) {
+    if (message["role"] !== "user" && message["role"] !== "assistant") {
+      throw new Error("Anthropic attribution final payload message has an unsupported role");
+    }
+    const content = message["content"];
+    if (!Array.isArray(content) || content.some((block) => !isPlainObject(block))) {
+      throw new Error(
+        "Anthropic attribution final payload message content must use canonical block arrays"
+      );
+    }
+  }
+  return messages;
+}
+__name(requestMessagesFromPayload, "requestMessagesFromPayload");
+function systemBlocksFromPayload(payload) {
+  const system = payload["system"];
+  if (system === void 0) return [];
+  if (typeof system === "string") return [{ type: "text", text: system }];
+  if (!Array.isArray(system))
+    throw new Error("Anthropic attribution final payload.system must be a string or block array");
+  return system;
+}
+__name(systemBlocksFromPayload, "systemBlocksFromPayload");
+function toolsFromPayload(payload) {
+  const tools = payload["tools"];
+  if (tools === void 0) return [];
+  if (!Array.isArray(tools) || tools.some((tool) => !isPlainObject(tool))) {
+    throw new Error("Anthropic attribution final payload.tools must be an object array");
+  }
+  return tools;
+}
+__name(toolsFromPayload, "toolsFromPayload");
+function cacheProfileHash(model, policy, payload, staticSha256) {
+  return sha256Canonical({
+    projection_version: ANTHROPIC_PROJECTION_VERSION,
+    model: normalizedAnthropicModelId(model),
+    beta: policy.beta,
+    conversation_static_sha256: staticSha256,
+    thinking: payload["thinking"],
+    output_config: payload["output_config"],
+    tool_choice: payload["tool_choice"]
+  });
+}
+__name(cacheProfileHash, "cacheProfileHash");
+function cacheRetentionFromPayload(payload) {
+  return inspectCacheControls(payload).retention ?? "none";
+}
+__name(cacheRetentionFromPayload, "cacheRetentionFromPayload");
+function untrustedAssistantSha256(message) {
+  return sha256Canonical({
+    provider: message.provider ?? null,
+    api: message.api ?? null,
+    model: message.model ?? null,
+    response_id: message.responseId ?? null,
+    stop_reason: message.stopReason ?? null,
+    assistant_content_sha256: assistantContentHash(message.content),
+    lineage_diagnostics: (message.diagnostics ?? []).filter(
+      (diagnostic) => diagnostic.type === ANTHROPIC_LINEAGE_DIAGNOSTIC_TYPE
+    )
+  });
+}
+__name(untrustedAssistantSha256, "untrustedAssistantSha256");
+function targetLineageState(context, targetModelId) {
+  for (let index = context.messages.length - 1; index >= 0; index -= 1) {
+    const message = context.messages[index];
+    if (message?.role !== "assistant") continue;
+    const lineageDiagnostics = (message.diagnostics ?? []).filter(
+      (diagnostic) => diagnostic.type === ANTHROPIC_LINEAGE_DIAGNOSTIC_TYPE
+    );
+    const latestRawDetails = lineageDiagnostics.at(-1)?.details;
+    const receiptClaimsTarget = latestRawDetails?.["source_model"] === targetModelId;
+    const assistantClaimsTarget = message.model === targetModelId;
+    if (!assistantClaimsTarget && !receiptClaimsTarget) continue;
+    if ((message.stopReason === "error" || message.stopReason === "aborted") && lineageDiagnostics.length === 0) {
+      continue;
+    }
+    const lineage = parseAnthropicLineageDetails(message);
+    if (lineage?.source_model === targetModelId && lineageBindsContainingAssistant(message, lineage)) {
+      return { kind: "trusted", lineage };
+    }
+    return { kind: "untrusted", assistantSha256: untrustedAssistantSha256(message) };
+  }
+  return { kind: "none" };
+}
+__name(targetLineageState, "targetLineageState");
+function latestLineageForTarget(context, targetModelId) {
+  const state = targetLineageState(context, targetModelId);
+  return state.kind === "trusted" ? state.lineage : void 0;
+}
+__name(latestLineageForTarget, "latestLineageForTarget");
+function declaredCompactionBoundarySha256(messages) {
+  const firstMessage = messages[0];
+  if (firstMessage?.["role"] !== "user" || !Array.isArray(firstMessage["content"])) return null;
+  const declaresCompaction = firstMessage["content"].some(
+    (block) => isPlainObject(block) && block["type"] === "text" && typeof block["text"] === "string" && block["text"].startsWith(COMPACTION_SUMMARY_PREFIX)
+  );
+  if (!declaresCompaction) return null;
+  return sha256Canonical(promptMessagesWithoutCacheControls([firstMessage])[0]);
+}
+__name(declaredCompactionBoundarySha256, "declaredCompactionBoundarySha256");
+function hasLineageRequestPrefix(messages, previous) {
+  return messages.length >= previous.request_message_count && promptMessagesHash(messages.slice(0, previous.request_message_count)) === previous.request_messages_sha256;
+}
+__name(hasLineageRequestPrefix, "hasLineageRequestPrefix");
+function prepareAnthropicLineageDetails(args) {
+  const targetModelId = normalizedAnthropicModelId(args.model);
+  const messages = requestMessagesFromPayload(args.payload);
+  const staticSha256 = conversationStaticHash(
+    systemBlocksFromPayload(args.payload),
+    toolsFromPayload(args.payload)
+  );
+  const profileSha256 = cacheProfileHash(args.model, args.policy, args.payload, staticSha256);
+  const cacheRetention = cacheRetentionFromPayload(args.payload);
+  const compactionBoundarySha256 = declaredCompactionBoundarySha256(messages);
+  const signatureEpoch = args.signatureEpoch;
+  let previous = latestLineageForTarget(args.context, targetModelId);
+  if (previous !== void 0 && (signatureEpoch.sha256 !== previous.signature_epoch_sha256 || !hasLineageRequestPrefix(messages, previous) || previous.cache_profile_sha256 !== profileSha256 || previous.cache_retention !== cacheRetention)) {
+    previous = void 0;
+  }
+  return {
+    schema_version: ANTHROPIC_LINEAGE_SCHEMA,
+    projection_version: ANTHROPIC_PROJECTION_VERSION,
+    source_provider: "anthropic",
+    source_api: "anthropic-messages",
+    source_model: targetModelId,
+    conversation_static_sha256: staticSha256,
+    request_message_count: messages.length,
+    request_messages_sha256: promptMessagesHash(messages),
+    cache_profile_sha256: profileSha256,
+    cache_retention: cacheRetention,
+    compaction_boundary_sha256: compactionBoundarySha256,
+    signature_epoch_sha256: signatureEpoch.sha256,
+    signature_epoch_inherits_prior: signatureEpoch.inheritsPrior,
+    previous_message_id: previous?.response_id ?? null
+  };
+}
+__name(prepareAnthropicLineageDetails, "prepareAnthropicLineageDetails");
+var AnthropicLineageCoordinator = class {
+  static {
+    __name(this, "AnthropicLineageCoordinator");
+  }
+  inFlight = /* @__PURE__ */ new Set();
+  prepare(args) {
+    const targetModelId = normalizedAnthropicModelId(args.model);
+    const key = `${args.sessionId}\0${targetModelId}`;
+    if (this.inFlight.has(key)) {
+      throw new Error(
+        `Anthropic cache lineage already has an in-flight request for ${targetModelId}; concurrent continuations must fork`
+      );
+    }
+    const details = prepareAnthropicLineageDetails(args);
+    this.inFlight.add(key);
+    return { key, details };
+  }
+  release(prepared) {
+    this.inFlight.delete(prepared.key);
+  }
+};
+var anthropicLineageCoordinator = new AnthropicLineageCoordinator();
+
+// node_modules/pi-background-tasks/src/core/fusion/config.ts?ext=pi-background-tasks
+var FUSION_MODEL_CONFIG_FILE = "fusion-models.json";
+function defaultFusionModelConfig() {
+  return {
+    schema_version: FUSION_MODEL_CONFIG_SCHEMA_VERSION,
+    candidates: [CURRENT_MODEL_SELECTION, CURRENT_MODEL_SELECTION, CURRENT_MODEL_SELECTION],
+    evaluator: CURRENT_MODEL_SELECTION,
+    merger: CURRENT_MODEL_SELECTION
+  };
+}
+__name(defaultFusionModelConfig, "defaultFusionModelConfig");
+function fusionModelConfigPath(agentDir = getAgentDir()) {
+  return join(agentDir, FUSION_MODEL_CONFIG_FILE);
+}
+__name(fusionModelConfigPath, "fusionModelConfigPath");
+function sha256Hex(bytes) {
+  return createHash2("sha256").update(bytes).digest("hex");
+}
+__name(sha256Hex, "sha256Hex");
+async function revisionForPath(path) {
+  try {
+    const bytes = await readFile(path);
+    return { path, exists: true, sha256: sha256Hex(bytes) };
+  } catch (error) {
+    if (errorHasCode(error, "ENOENT")) return { path, exists: false, sha256: null };
+    throw error;
+  }
+}
+__name(revisionForPath, "revisionForPath");
+function errorHasCode(error, code) {
+  return isJsonObject(error) && error["code"] === code;
+}
+__name(errorHasCode, "errorHasCode");
+function keysOf(value) {
+  return Object.keys(value).sort();
+}
+__name(keysOf, "keysOf");
+function assertClosed(record, expected, label) {
+  const expectedSet = new Set(expected);
+  for (const key of Object.keys(record)) {
+    if (!expectedSet.has(key)) throw configError(`${label} contains unknown key ${key}`);
+  }
+  for (const key of expected) {
+    if (!Object.prototype.hasOwnProperty.call(record, key)) {
+      throw configError(`${label} is missing key ${key}`);
+    }
+  }
+}
+__name(assertClosed, "assertClosed");
+function configError(message) {
+  return new FusionError(message, { code: "config_invalid", childCreated: false });
+}
+__name(configError, "configError");
+function requireSelection(value, label) {
+  if (typeof value !== "string") throw configError(`${label} must be a string`);
+  if (value === CURRENT_MODEL_SELECTION) return value;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) throw configError(`${label} must not be blank`);
+  if (trimmed !== value) throw configError(`${label} must not have surrounding whitespace`);
+  if (!trimmed.includes("/")) throw configError(`${label} must be a qualified provider/model key`);
+  return trimmed;
+}
+__name(requireSelection, "requireSelection");
+function requireCandidateSelections(value) {
+  if (!Array.isArray(value)) throw configError("candidates must be an array");
+  if (value.length !== 3) throw configError("candidates must contain exactly three entries");
+  const first = requireSelection(value[0], "candidates[0]");
+  const second = requireSelection(value[1], "candidates[1]");
+  const third = requireSelection(value[2], "candidates[2]");
+  return [first, second, third];
+}
+__name(requireCandidateSelections, "requireCandidateSelections");
+function parseFusionModelConfig(value) {
+  if (!isJsonObject(value) || Array.isArray(value))
+    throw configError("fusion model config must be an object");
+  const record = value;
+  assertClosed(
+    record,
+    ["schema_version", "candidates", "evaluator", "merger"],
+    "fusion model config"
+  );
+  if (record["schema_version"] !== FUSION_MODEL_CONFIG_SCHEMA_VERSION) {
+    throw configError("fusion model config schema_version mismatch");
+  }
+  return {
+    schema_version: FUSION_MODEL_CONFIG_SCHEMA_VERSION,
+    candidates: requireCandidateSelections(record["candidates"]),
+    evaluator: requireSelection(record["evaluator"], "evaluator"),
+    merger: requireSelection(record["merger"], "merger")
+  };
+}
+__name(parseFusionModelConfig, "parseFusionModelConfig");
+async function loadFusionModelConfig(path = fusionModelConfigPath()) {
+  const revision = await revisionForPath(path);
+  if (!revision.exists) return { config: defaultFusionModelConfig(), revision };
+  let parsed;
+  try {
+    parsed = parseJsonText(await readFile(path, "utf8"));
+  } catch (error) {
+    throw configError(
+      `fusion model config is not valid JSON at ${path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const config = parseFusionModelConfig(parsed);
+  return { config, revision };
+}
+__name(loadFusionModelConfig, "loadFusionModelConfig");
+function qualifiedModelKey(model) {
+  return `${model.provider}/${model.id}`;
+}
+__name(qualifiedModelKey, "qualifiedModelKey");
+function requireContextWindow(model, label) {
+  const value = model.contextWindow;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new FusionError(`${label} has no positive context window`, {
+      code: "model_unavailable",
+      childCreated: false
+    });
+  }
+  return Math.floor(value);
+}
+__name(requireContextWindow, "requireContextWindow");
+function transportContextWindow(model, label) {
+  const advertised = requireContextWindow(model, label);
+  return model.provider === "anthropic" ? Math.min(advertised, CLAUDE_CODE_200K_SUBSCRIPTION_CONTEXT_WINDOW) : advertised;
+}
+__name(transportContextWindow, "transportContextWindow");
+function requireMaxOutputTokens(model, label) {
+  const value = model.maxTokens;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new FusionError(`${label} has no positive maximum output token capacity`, {
+      code: "model_unavailable",
+      childCreated: false
+    });
+  }
+  return Math.floor(value);
+}
+__name(requireMaxOutputTokens, "requireMaxOutputTokens");
+function modelIndex(models) {
+  const out = /* @__PURE__ */ new Map();
+  for (const model of models) out.set(qualifiedModelKey(model), model);
+  return out;
+}
+__name(modelIndex, "modelIndex");
+var FRONTIER_MODEL_PATTERN = /(?:^|[-_/])(?:gpt|codex|claude|opus|sonnet|o[134](?:-[a-z0-9.]+)*)(?:[-_/]|$)/iu;
+var TRUSTED_SUBSCRIPTION_ENDPOINTS = Object.freeze({
+  anthropic: "https://api.anthropic.com",
+  "openai-codex": "https://chatgpt.com/backend-api"
+});
+var AUTH_HEADER_NAMES = /* @__PURE__ */ new Set(["authorization", "proxy-authorization", "x-api-key", "api-key"]);
+function isKnownFrontierEndpoint(baseUrl) {
+  if (baseUrl === void 0 || baseUrl.trim().length === 0) return false;
+  try {
+    const hostname = new URL(baseUrl).hostname.toLowerCase().replace(/\.+$/u, "");
+    return hostname === "api.openai.com" || hostname === "api.anthropic.com" || hostname === "openrouter.ai" || hostname === "chatgpt.com" || hostname.endsWith(".openai.azure.com") || hostname.endsWith(".cognitiveservices.azure.com") || hostname.endsWith(".ai.azure.com");
+  } catch {
+    return false;
+  }
+}
+__name(isKnownFrontierEndpoint, "isKnownFrontierEndpoint");
+function assertTrustedSubscriptionEndpoint(model, slotLabel, provider) {
+  const expectedText = TRUSTED_SUBSCRIPTION_ENDPOINTS[provider];
+  const effectiveText = model.baseUrl?.trim() || expectedText;
+  let effective;
+  try {
+    effective = new URL(effectiveText);
+  } catch {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} has a malformed subscription endpoint`,
+      { code: "model_unavailable", childCreated: false }
+    );
+  }
+  const expected = new URL(expectedText);
+  const effectivePath = effective.href.slice(effective.origin.length).replace(/\/+$/u, "");
+  const expectedPath = expected.href.slice(expected.origin.length).replace(/\/+$/u, "");
+  if (effective.protocol !== "https:" || effective.username !== "" || effective.password !== "" || effective.search !== "" || effective.hash !== "" || effective.origin !== expected.origin || effectivePath !== expectedPath) {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} does not use the trusted Pi subscription endpoint ${expectedText}`,
+      { code: "model_unavailable", childCreated: false }
+    );
+  }
+  const unsafeHeader = Object.keys(model.headers ?? {}).find(
+    (name) => AUTH_HEADER_NAMES.has(name.toLowerCase())
+  );
+  if (unsafeHeader !== void 0) {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} overrides subscription authentication header ${unsafeHeader}`,
+      { code: "model_unavailable", childCreated: false }
+    );
+  }
+}
+__name(assertTrustedSubscriptionEndpoint, "assertTrustedSubscriptionEndpoint");
+function assertSubscriptionRoute(model, slotLabel, registry) {
+  const provider = model.provider.toLowerCase();
+  const frontier = provider === "openai" || provider === "openrouter" || provider === "anthropic" || provider === "openai-codex" || provider.includes("azure") || FRONTIER_MODEL_PATTERN.test(`${provider}/${model.id}`) || isKnownFrontierEndpoint(model.baseUrl);
+  if (!frontier) return;
+  if (provider !== "anthropic" && provider !== "openai-codex") {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} is a frontier-model API channel; Fusion requires the Pi Anthropic or Codex subscription route`,
+      { code: "model_unavailable", childCreated: false }
+    );
+  }
+  assertTrustedSubscriptionEndpoint(model, slotLabel, provider);
+  if (registry.isUsingOAuth === void 0) {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} cannot be admitted because ModelRegistry OAuth observation is unavailable`,
+      { code: "model_unavailable", childCreated: false }
+    );
+  }
+  if (!registry.isUsingOAuth(model)) {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} is not using subscription OAuth; metered API credentials are forbidden for Fusion`,
+      { code: "model_unavailable", childCreated: false }
+    );
+  }
+}
+__name(assertSubscriptionRoute, "assertSubscriptionRoute");
+function resolveSelection(selection, slotLabel, availableByKey, currentModel, thinkingLevel, registry) {
+  if (selection === CURRENT_MODEL_SELECTION) {
+    if (currentModel === void 0) {
+      throw new FusionError(`${slotLabel} uses $current but Pi has no current model`, {
+        code: "model_unavailable",
+        childCreated: false
+      });
+    }
+    const qualifiedId = qualifiedModelKey(currentModel);
+    const available = availableByKey.get(qualifiedId);
+    if (available === void 0) {
+      throw new FusionError(
+        `${slotLabel} current model is not available to child Pi: ${qualifiedId}`,
+        {
+          code: "model_unavailable",
+          childCreated: false
+        }
+      );
+    }
+    assertSubscriptionRoute(available, slotLabel, registry);
+    return {
+      selection,
+      source: "current",
+      provider: available.provider,
+      model: available.id,
+      qualifiedId,
+      thinkingLevel,
+      contextWindow: transportContextWindow(available, slotLabel),
+      maxOutputTokens: requireMaxOutputTokens(available, slotLabel)
+    };
+  }
+  const model = availableByKey.get(selection);
+  if (model === void 0) {
+    throw new FusionError(`${slotLabel} configured model is unavailable: ${selection}`, {
+      code: "model_unavailable",
+      childCreated: false
+    });
+  }
+  assertSubscriptionRoute(model, slotLabel, registry);
+  return {
+    selection,
+    source: "configured",
+    provider: model.provider,
+    model: model.id,
+    qualifiedId: selection,
+    thinkingLevel,
+    contextWindow: transportContextWindow(model, slotLabel),
+    maxOutputTokens: requireMaxOutputTokens(model, slotLabel)
+  };
+}
+__name(resolveSelection, "resolveSelection");
+function resolveFusionModels(input) {
+  const availableByKey = modelIndex(input.modelRegistry.getAvailable());
+  const [first, second, third] = input.config.candidates;
+  const resolve = /* @__PURE__ */ __name((selection, slot) => resolveSelection(
+    selection,
+    slot,
+    availableByKey,
+    input.currentModel,
+    input.thinkingLevel,
+    input.modelRegistry
+  ), "resolve");
+  return {
+    candidates: [
+      resolve(first, "candidate 1"),
+      resolve(second, "candidate 2"),
+      resolve(third, "candidate 3")
+    ],
+    evaluator: resolve(input.config.evaluator, "evaluator"),
+    merger: resolve(input.config.merger, "merger")
+  };
+}
+__name(resolveFusionModels, "resolveFusionModels");
+async function delay(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(delay, "delay");
+async function withConfigLock(path, fn) {
+  const dir = dirname(path);
+  const lockPath = join(dir, `.${basename(path)}.lock`);
+  const started = Date.now();
+  let handle;
+  while (handle === void 0) {
+    try {
+      handle = await open(lockPath, "wx", 384);
+    } catch (error) {
+      if (!errorHasCode(error, "EEXIST")) throw error;
+      if (Date.now() - started > 1e4) {
+        throw new FusionError(`timed out waiting for fusion model config lock: ${path}`, {
+          code: "config_conflict",
+          childCreated: false
+        });
+      }
+      await delay(25);
+    }
+  }
+  try {
+    await handle.writeFile(`${String(process.pid)}
+`);
+    await handle.sync();
+    return await fn();
+  } finally {
+    await handle.close();
+    await rm(lockPath, { force: true });
+  }
+}
+__name(withConfigLock, "withConfigLock");
+function prettyConfig(config) {
+  const sorted = {
+    schema_version: config.schema_version,
+    candidates: [...config.candidates],
+    evaluator: config.evaluator,
+    merger: config.merger
+  };
+  return `${JSON.stringify(sorted, null, 2)}
+`;
+}
+__name(prettyConfig, "prettyConfig");
+function revisionsMatch(expected, current) {
+  if (expected.path !== current.path) return false;
+  if (expected.exists !== current.exists) return false;
+  return expected.sha256 === current.sha256;
+}
+__name(revisionsMatch, "revisionsMatch");
+async function saveFusionModelConfig(path, config, expectedRevision) {
+  parseFusionModelConfig(config);
+  const dir = dirname(path);
+  await mkdir(dir, { recursive: true, mode: 448 });
+  await chmod(dir, 448);
+  return withConfigLock(path, async () => {
+    const current = await revisionForPath(path);
+    if (!revisionsMatch(expectedRevision, current)) {
+      throw new FusionError(`fusion model config changed on disk: ${path}`, {
+        code: "config_conflict",
+        childCreated: false
+      });
+    }
+    await replaceFileDurable(path, prettyConfig(config));
+    return revisionForPath(path);
+  });
+}
+__name(saveFusionModelConfig, "saveFusionModelConfig");
+function describeFusionModelConfig(config) {
+  return keysOf(config).join(", ");
+}
+__name(describeFusionModelConfig, "describeFusionModelConfig");
+
+export {
+  FUSION_MODEL_CONFIG_FILE,
+  defaultFusionModelConfig,
+  fusionModelConfigPath,
+  parseFusionModelConfig,
+  loadFusionModelConfig,
+  resolveFusionModels,
+  saveFusionModelConfig,
+  describeFusionModelConfig
+};