chainlesschain 0.166.96 → 0.166.98

package/src/lib/eval/verify01-workspace.js

@@ -0,0 +1,302 @@
+/** Shared file boundaries and snapshots; no process broker or npm dependencies. */
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { evalDigest } from "./evidence.js";
+const MAX_BYTES = 16 * 1024 * 1024;
+export const MAX_SNAPSHOT_BYTES = 512 * 1024 * 1024;
+const MAX_DIFF_BYTES = 32 * 1024 * 1024;
+const EMPTY_DELIVERABLE_DIGEST = evalDigest(Buffer.alloc(0));
+
+export function requireValue(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+export function relativeFile(value) {
+  requireValue(
+    typeof value === "string" &&
+      value.length > 0 &&
+      !value.includes("\0") &&
+      !/[\\:*?<>|"]/u.test(value) &&
+      !value.startsWith("/") &&
+      value.split("/").every((part) => part && !/[. ]$/u.test(part)),
+    "review paths must be exact relative files",
+  );
+  return value;
+}
+export function readBytes(file) {
+  const descriptor = fs.openSync(file, "r");
+  try {
+    const before = fs.fstatSync(descriptor, { bigint: true });
+    requireValue(
+      before.isFile() && before.size <= BigInt(MAX_BYTES),
+      "input must be a regular file within 16 MiB",
+    );
+    const bytes = Buffer.alloc(Number(before.size) + 1);
+    let count = 0;
+    while (count < bytes.length) {
+      const size = fs.readSync(
+        descriptor,
+        bytes,
+        count,
+        bytes.length - count,
+        null,
+      );
+      if (!size) break;
+      count += size;
+    }
+    const after = fs.fstatSync(descriptor, { bigint: true });
+    requireValue(
+      count === Number(before.size) &&
+        ["dev", "ino", "size", "mtimeNs", "ctimeNs"].every(
+          (key) => before[key] === after[key],
+        ),
+      "input changed during read",
+    );
+    return bytes.subarray(0, count);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+export function canonicalDirectory(directory) {
+  const absolute = path.resolve(directory);
+  const canonical = (fs.realpathSync.native || fs.realpathSync)(absolute);
+  const same =
+    process.platform === "win32"
+      ? canonical.toLowerCase() === absolute.toLowerCase()
+      : canonical === absolute;
+  const stat = fs.lstatSync(absolute);
+  requireValue(
+    same && stat.isDirectory() && !stat.isSymbolicLink(),
+    "task directory must be canonical and unaliased",
+  );
+  return canonical;
+}
+
+/** Trusted preparation only: a seed contains no answer and never overwrites
+ * a project file. Existing source paths are not passed to this helper. */
+export function seedVerify01Deliverables(directory, expectedFiles, budget) {
+  const root = canonicalDirectory(directory);
+  requireValue(
+    Array.isArray(expectedFiles) &&
+      expectedFiles.length > 0 &&
+      new Set(expectedFiles).size === expectedFiles.length,
+    "deliverable paths must be distinct",
+  );
+  expectedFiles.forEach(relativeFile);
+  const seeds = [];
+  for (const relative of expectedFiles) {
+    budget.remainingMs("deliverable-preparation");
+    let current = root;
+    for (const part of relative.split("/").slice(0, -1)) {
+      current = path.join(current, part);
+      within(root, current);
+      try {
+        fs.mkdirSync(current, { mode: 0o700 });
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+      canonicalDirectory(current);
+    }
+    const target = path.join(root, relative);
+    within(root, target);
+    const fd = fs.openSync(
+      target,
+      fs.constants.O_WRONLY |
+        fs.constants.O_CREAT |
+        fs.constants.O_EXCL |
+        (fs.constants.O_NOFOLLOW || 0),
+      0o600,
+    );
+    try {
+      const stat = fs.fstatSync(fd);
+      requireValue(
+        stat.isFile() && stat.nlink === 1 && stat.size === 0,
+        "seed must be an empty unaliased regular file",
+      );
+      regularPath(root, relative);
+      const named = fs.lstatSync(target);
+      requireValue(
+        named.dev === stat.dev && named.ino === stat.ino,
+        "seed path changed identity during preparation",
+      );
+      canonicalDirectory(path.dirname(target));
+      seeds.push(
+        Object.freeze({
+          path: relative,
+          before: null,
+          origin: "trusted-empty-deliverable-preparation",
+          digest: EMPTY_DELIVERABLE_DIGEST,
+          bytes: 0,
+          requestedMode: 0o600,
+          mode: stat.mode & 0o777,
+          preparedAt: new Date().toISOString(),
+        }),
+      );
+    } finally {
+      fs.closeSync(fd);
+    }
+  }
+  return Object.freeze(seeds);
+}
+
+export function within(root, file) {
+  const relative = path.relative(root, file);
+  requireValue(
+    relative &&
+      relative !== ".." &&
+      !relative.startsWith(`..${path.sep}`) &&
+      !path.isAbsolute(relative),
+    "path escapes its declared root",
+  );
+}
+
+export function regularPath(root, relative) {
+  relativeFile(relative);
+  const file = path.join(root, relative);
+  within(root, file);
+  let current = root;
+  for (const segment of relative.split("/")) {
+    current = path.join(current, segment);
+    requireValue(
+      !fs.lstatSync(current).isSymbolicLink(),
+      "review/project paths must not traverse links",
+    );
+  }
+  requireValue(
+    fs.lstatSync(file).isFile(),
+    "review/project artifact must be a regular file",
+  );
+  return file;
+}
+
+export function snapshotVerify01Workspace(directory, budget, stage) {
+  const files = new Map();
+  let total = 0;
+  let dependencyBytes = 0;
+  let dependencyFiles = 0;
+  const dependencyHash = createHash("sha256");
+  const buffer = Buffer.alloc(64 * 1024);
+  const visit = (current) => {
+    for (const entry of fs
+      .readdirSync(current, { withFileTypes: true })
+      .sort((a, b) => a.name.localeCompare(b.name, "en"))) {
+      budget.remainingMs(stage);
+      const full = path.join(current, entry.name);
+      const relative = path.relative(directory, full).split(path.sep).join("/");
+      if (entry.isDirectory()) visit(full);
+      else {
+        requireValue(
+          entry.isFile() || entry.isSymbolicLink(),
+          "task snapshot contains an unsupported filesystem object",
+        );
+        // Preserve link identities without following them into another root.
+        const dependency = relative.split("/").includes("node_modules");
+        if (dependency && entry.isSymbolicLink()) {
+          // A dependency linked outside the isolated workspace cannot be
+          // fingerprinted by this capture contract; never silently omit it.
+          within(directory, fs.realpathSync(full));
+        }
+        let bytes = entry.isSymbolicLink()
+          ? Buffer.from(fs.readlinkSync(full))
+          : dependency
+            ? null
+            : readBytes(full);
+        let digest, size;
+        if (dependency && bytes === null) {
+          const hash = createHash("sha256");
+          const fd = fs.openSync(full, "r");
+          size = 0;
+          try {
+            let count;
+            while (
+              (count = fs.readSync(fd, buffer, 0, buffer.length, null)) > 0
+            ) {
+              budget.remainingMs(stage);
+              size += count;
+              requireValue(
+                dependencyBytes + size <= 16 * 1024 ** 3,
+                "dependency fingerprint exceeds 16 GiB",
+              );
+              hash.update(buffer.subarray(0, count));
+            }
+          } finally {
+            fs.closeSync(fd);
+          }
+          digest = `sha256:${hash.digest("hex")}`;
+        } else {
+          size = bytes.length;
+          digest = evalDigest(bytes);
+        }
+        if (dependency) {
+          dependencyBytes += size;
+          dependencyFiles++;
+          bytes = null;
+        } else total += size;
+        requireValue(
+          total <= MAX_SNAPSHOT_BYTES &&
+            files.size - dependencyFiles < 100000 &&
+            dependencyFiles <= 1000000,
+          "task snapshot exceeds its capture bound",
+        );
+        const value = {
+          type: entry.isSymbolicLink() ? "link" : "file",
+          mode: fs.lstatSync(full).mode & 0o777,
+          bytes,
+          size,
+          digest,
+          dependency,
+        };
+        files.set(relative, value);
+        if (dependency)
+          dependencyHash.update(
+            JSON.stringify([relative, value.type, value.mode, size, digest]) +
+              "\n",
+          );
+      }
+    }
+  };
+  visit(directory);
+  files.dependencyBoundary = {
+    contract:
+      "all node_modules files and link identities streamed with SHA-256; links never followed; dependency bodies omitted; every change rejected",
+    files: dependencyFiles,
+    bytes: dependencyBytes,
+    digest: `sha256:${dependencyHash.digest("hex")}`,
+  };
+  return files;
+}
+
+export function diffVerify01Workspace(before, after) {
+  const result = [];
+  let total = 0;
+  for (const file of [...new Set([...before.keys(), ...after.keys()])].sort()) {
+    const old = before.get(file),
+      next = after.get(file);
+    if (
+      old?.digest === next?.digest &&
+      old?.type === next?.type &&
+      old?.mode === next?.mode
+    )
+      continue;
+    total += (old?.bytes?.length || 0) + (next?.bytes?.length || 0);
+    requireValue(
+      total <= MAX_DIFF_BYTES,
+      "task diff exceeds 32 MiB; preserve workspace for independent inspection",
+    );
+    const describe = (value) =>
+      value
+        ? {
+            type: value.type,
+            mode: value.mode,
+            digest: value.digest,
+            bytes: value.size,
+            dependency: value.dependency,
+            bytesBase64: value.bytes?.toString("base64") ?? null,
+          }
+        : null;
+    result.push({ path: file, before: describe(old), after: describe(next) });
+  }
+  return result;
+}

package/src/lib/execution-location-failure-site.js

@@ -27,6 +27,24 @@ export function readExecutionLocationStorageFailure(stderr) {
   return match ? `${match[1]}${match[2] || ""}` : null;
 }
 
+export function readExecutionLocationStorageLaunchFailure(stderr) {
+  const match = String(stderr || "")
+    .slice(0, MAX_DIAGNOSTIC_CHARS)
+    .match(
+      /\[windows-acl-launch:(inspect|repair|preflight):(spawn|timeout):(startup|initialize|traversal|lookup|repair-lock|repair-inspect|repair-write|verify):(EACCES|EPERM|ENOENT|ETIMEDOUT|EINVAL|ENOSYS|ENOMEM|EMFILE|ENFILE|ENOBUFS|EBUSY|UNKNOWN):(unknown|-?(?:0|[1-9][0-9]{0,4})):(spawnSync|spawn|unknown)\]/u,
+    );
+  if (!match) return null;
+  const [, operation, failureStage, progressStage, code, rawErrno, syscall] =
+    match;
+  const errno = rawErrno === "unknown" ? null : Number(rawErrno);
+  if (
+    (errno !== null && Math.abs(errno) > 65535) ||
+    (failureStage === "timeout") !== (code === "ETIMEDOUT")
+  )
+    return null;
+  return { operation, failureStage, progressStage, code, errno, syscall };
+}
+
 export function executionLocationFailureSite(error) {
   const stack = String(error?.stack || "").slice(0, MAX_DIAGNOSTIC_CHARS);
   for (const frame of stack.split(/\r?\n/u).slice(1)) {

package/src/lib/execution-location-target.js

@@ -7,6 +7,7 @@ import { TextDecoder } from "node:util";
 import {
   readExecutionLocationFailureSite,
   readExecutionLocationStorageFailure,
+  readExecutionLocationStorageLaunchFailure,
 } from "./execution-location-failure-site.js";
 import {
   EXECUTION_LOCATION_TARGET_ATTESTATION_SCHEMA,
@@ -1039,6 +1040,10 @@ function targetProcessFailure(result) {
   error.failureCategory = failureCategory;
   if (failureSite) error.failureSite = failureSite;
   if (storageFailure) error.storageFailure = storageFailure;
+  const storageLaunchFailure = readExecutionLocationStorageLaunchFailure(
+    result.stderr,
+  );
+  if (storageLaunchFailure) error.storageLaunchFailure = storageLaunchFailure;
   return error;
 }
 
@@ -1108,6 +1113,11 @@ function runTargetCommand(profile, cliArgs, deps = {}, options = {}) {
       error.failureCategory = failureCategory;
       if (failureSite) error.failureSite = failureSite;
       if (storageFailure) error.storageFailure = storageFailure;
+      const storageLaunchFailure = readExecutionLocationStorageLaunchFailure(
+        result?.stderr,
+      );
+      if (storageLaunchFailure)
+        error.storageLaunchFailure = storageLaunchFailure;
       throw error;
     }
     return options.interactive ? null : result.stdout;

package/src/lib/llm-connection-probe.js

@@ -1,13 +1,141 @@
 import { formatProviderResponseError } from "./provider-http-error.js";
+import { estimateCost } from "./llm-pricing.js";
 
 // Reasoning models spend the same output allowance on thinking before the
 // final answer. A 16-token probe can therefore receive HTTP 200 with only
 // reasoning_content and finish_reason=length from an otherwise usable model.
 const PROBE_OUTPUT_TOKENS = 1024;
+export const LLM_PROBE_SCHEMA = "chainlesschain.llm-connection-probe/v1";
+
+const count = (value) => Number.isSafeInteger(value) && value >= 0;
+
+/** Preserve missing/malformed usage as unknown, including cached prompt tokens. */
+export function normalizeLlmProbeUsage(provider, data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+  let usage;
+  if (provider === "ollama") {
+    usage = {
+      input_tokens: data.prompt_eval_count,
+      output_tokens: data.eval_count,
+    };
+  } else if (provider === "anthropic") {
+    usage = data.usage;
+  } else if (provider === "gemini") {
+    const raw = data.usageMetadata;
+    if (
+      !raw ||
+      !count(raw.candidatesTokenCount) ||
+      !count(raw.thoughtsTokenCount === undefined ? 0 : raw.thoughtsTokenCount)
+    )
+      return null;
+    const cached =
+      raw.cachedContentTokenCount === undefined
+        ? 0
+        : raw.cachedContentTokenCount;
+    if (
+      !count(raw.promptTokenCount) ||
+      !count(cached) ||
+      cached > raw.promptTokenCount
+    )
+      return null;
+    usage = {
+      input_tokens: raw.promptTokenCount - cached,
+      output_tokens: raw.candidatesTokenCount + (raw.thoughtsTokenCount ?? 0),
+      cache_read_input_tokens: cached,
+    };
+  } else {
+    const raw = data.usage;
+    if (!raw || !count(raw.prompt_tokens) || !count(raw.completion_tokens))
+      return null;
+    const detailed = raw.prompt_tokens_details?.cached_tokens;
+    const legacy = raw.prompt_cache_hit_tokens;
+    const cached =
+      detailed === undefined ? (legacy === undefined ? 0 : legacy) : detailed;
+    if (
+      !count(cached) ||
+      cached > raw.prompt_tokens ||
+      (detailed !== undefined && legacy !== undefined && detailed !== legacy)
+    )
+      return null;
+    usage = {
+      input_tokens: raw.prompt_tokens - cached,
+      output_tokens: raw.completion_tokens,
+      cache_read_input_tokens: cached,
+    };
+  }
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return null;
+  const normalized = {
+    input_tokens: usage.input_tokens,
+    output_tokens: usage.output_tokens,
+    cache_read_input_tokens:
+      usage.cache_read_input_tokens === undefined
+        ? 0
+        : usage.cache_read_input_tokens,
+    cache_creation_input_tokens:
+      usage.cache_creation_input_tokens === undefined
+        ? 0
+        : usage.cache_creation_input_tokens,
+  };
+  return Object.values(normalized).every(count) ? normalized : null;
+}
+
+export function priceLlmProbeUsage(target, usage) {
+  if (
+    !usage ||
+    ![
+      usage.input_tokens,
+      usage.output_tokens,
+      usage.cache_read_input_tokens,
+      usage.cache_creation_input_tokens,
+    ].every(count)
+  )
+    return null;
+  const estimate = estimateCost({
+    provider: target.provider,
+    model: target.model,
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    cacheReadTokens: usage.cache_read_input_tokens,
+    cacheCreationTokens: usage.cache_creation_input_tokens,
+  });
+  return estimate.matched && Number.isFinite(estimate.totalCost)
+    ? estimate.totalCost
+    : null;
+}
+
+export function llmProbeReceipt(
+  target,
+  { ok = false, reply = null, usage = null } = {},
+) {
+  const normalizedUsage =
+    usage === null
+      ? null
+      : {
+          input_tokens: usage.input_tokens,
+          output_tokens: usage.output_tokens,
+          cache_read_input_tokens: usage.cache_read_input_tokens,
+          cache_creation_input_tokens: usage.cache_creation_input_tokens,
+        };
+  return {
+    schema: LLM_PROBE_SCHEMA,
+    ok,
+    provider: target.provider,
+    model: target.model,
+    reply:
+      target.apiKey && typeof reply === "string"
+        ? reply.replaceAll(target.apiKey, "[REDACTED]")
+        : reply,
+    usage: normalizedUsage,
+    totalCostUsd: priceLlmProbeUsage(target, normalizedUsage),
+    currency: "USD",
+    costBasis: "token-estimate",
+    billingVerified: false,
+  };
+}
 
 export async function probeLlmConnection(
   target,
-  { fetchImpl = fetch, timeoutMs = 20_000 } = {},
+  { fetchImpl = fetch, timeoutMs = 20_000, includeUsage = false } = {},
 ) {
   const base = target.baseUrl.replace(/\/+$/, "");
   const headers = { "Content-Type": "application/json" };
@@ -50,6 +178,7 @@ export async function probeLlmConnection(
   }
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let usage = null;
   try {
     const response = await fetchImpl(url, {
       method: "POST",
@@ -60,9 +189,12 @@ export async function probeLlmConnection(
     });
     if (!response.ok)
       throw new Error(
-        await formatProviderResponseError(target.provider, response),
+        await formatProviderResponseError(target.provider, response, {
+          secrets: [target.apiKey],
+        }),
       );
     const data = await response.json();
+    usage = normalizeLlmProbeUsage(target.provider, data);
     const text =
       target.provider === "ollama"
         ? data.response
@@ -91,11 +223,20 @@ export async function probeLlmConnection(
         "The endpoint returned no model text; check the protocol and model",
       );
     }
-    return text.trim().slice(0, 100);
+    const reply = (
+      target.apiKey ? text.replaceAll(target.apiKey, "[REDACTED]") : text
+    )
+      .trim()
+      .slice(0, 100);
+    return includeUsage
+      ? llmProbeReceipt(target, { ok: true, reply, usage })
+      : reply;
   } catch (error) {
-    if (controller.signal.aborted)
-      throw new Error(`Connection test timed out after ${timeoutMs / 1000}s`);
-    throw error;
+    const failure = controller.signal.aborted
+      ? new Error(`Connection test timed out after ${timeoutMs / 1000}s`)
+      : error;
+    if (includeUsage) failure.probe = llmProbeReceipt(target, { usage });
+    throw failure;
   } finally {
     clearTimeout(timer);
   }

package/src/lib/provider-http-error.js

@@ -3,9 +3,14 @@
  * Keep structured provider diagnostics while redacting credential-shaped text.
  */
 
-function safePart(value) {
+function safePart(value, secrets = []) {
   if (value == null) return "";
-  return String(value)
+  let text = String(value);
+  for (const secret of secrets) {
+    if (typeof secret === "string" && secret)
+      text = text.replaceAll(secret, "***");
+  }
+  return text
     .replace(/\s+/g, " ")
     .replace(/\b(Bearer\s+)[A-Za-z0-9._~+/-]+=*\b/gi, "$1***")
     .replace(/\bsk-[A-Za-z0-9_-]{8,}\b/gi, "sk-***")
@@ -13,21 +18,24 @@ function safePart(value) {
     .slice(0, 400);
 }
 
-function errorDetail(payload) {
+function errorDetail(payload, secrets) {
   if (payload == null) return { code: "", message: "" };
   const raw =
     typeof payload === "object" && payload.error != null
       ? payload.error
       : payload;
   if (typeof raw === "string") {
-    return { code: "", message: safePart(raw) };
+    return { code: "", message: safePart(raw, secrets) };
   }
   if (!raw || typeof raw !== "object") {
-    return { code: "", message: safePart(raw) };
+    return { code: "", message: safePart(raw, secrets) };
   }
   return {
-    code: safePart(raw.code || raw.type),
-    message: safePart(raw.message || raw.error_description || raw.detail),
+    code: safePart(raw.code || raw.type, secrets),
+    message: safePart(
+      raw.message || raw.error_description || raw.detail,
+      secrets,
+    ),
   };
 }
 
@@ -36,9 +44,14 @@ function errorDetail(payload) {
  * accounts and model-access denials. Preserve the safe code/message so clients
  * can show the real corrective action.
  */
-export function formatProviderHttpError(provider, status, payload = null) {
+export function formatProviderHttpError(
+  provider,
+  status,
+  payload = null,
+  { secrets = [] } = {},
+) {
   const base = `${provider} API error: HTTP ${status}`;
-  const detail = errorDetail(payload);
+  const detail = errorDetail(payload, secrets);
   const detailText = [detail.code, detail.message].filter(Boolean).join(": ");
   const detailSentence = detailText.replace(/[.!?]+$/, "");
   const classified = `${detail.code} ${detail.message}`.toLowerCase();
@@ -76,7 +89,11 @@ export function formatProviderHttpError(provider, status, payload = null) {
   return detailSentence ? `${base} — ${detailSentence}` : base;
 }
 
-export async function formatProviderResponseError(provider, response) {
+export async function formatProviderResponseError(
+  provider,
+  response,
+  { secrets = [] } = {},
+) {
   let payload = null;
   try {
     const text = await response.text();
@@ -90,5 +107,7 @@ export async function formatProviderResponseError(provider, response) {
   } catch {
     // A broken/empty body still retains the HTTP status diagnosis.
   }
-  return formatProviderHttpError(provider, response.status, payload);
+  return formatProviderHttpError(provider, response.status, payload, {
+    secrets,
+  });
 }

package/src/lib/task-progress-tracker.js

@@ -470,6 +470,7 @@ export class TaskProgressTracker {
       guidance:
         message +
         " For an implementation task, make the smallest justified, authorized change and validate it. " +
+        "If the user requested new or updated tests, actual test changes and focused validation remain required; reading tests or passing an existing baseline does not fulfill that request. Name the concrete missing fact before another read. " +
         "For a bug fix, state the observed failure, your leading root-cause hypothesis and the smallest test that can disprove it. Run that focused reproduction or diagnostic next; use its actual output to choose the next step. Do not keep reading adjacent files without naming the specific missing fact. A timeout alone does not establish that increasing the timeout is the fix. " +
         DIAGNOSTIC_WORKFLOW_GUIDANCE +
         " " +

package/src/runtime/agent-core.js

@@ -15405,6 +15405,27 @@ export async function* agentLoop(messages, options) {
       }
     }
     const contextMemoryTrustedSystemIndexes = [];
+    if (Number.isFinite(budget.limit)) {
+      // consume() already charged this dispatch. The current request may still
+      // act even when no further provider request remains. Rebuild this hint
+      // after compaction and rejection-only turns; do not persist it in history.
+      const furtherRequests = budget.remaining();
+      // Keep the stable conversation prefix ahead of this changing counter.
+      // The canonical planner protects the last conversational user bundle
+      // even when trusted ephemeral system guidance follows it.
+      callMessages = [
+        ...callMessages,
+        {
+          role: "system",
+          content:
+            `Execution budget: this request plus ${furtherRequests} further model requests. ` +
+            "For requested changes, reserve requests for implementation, focused validation, and repair or an accurate unfinished-work report. " +
+            "Reading or an existing passing baseline does not deliver requested changes. " +
+            "For research or monitoring, use the remaining requests for evidence and the requested answer; do not create files just to show activity.",
+        },
+      ];
+      contextMemoryTrustedSystemIndexes.push(callMessages.length - 1);
+    }
     if (prActionTask && !prInvestigationExhausted) {
       callMessages = [
         ...callMessages,
@@ -16304,6 +16325,7 @@ export async function* agentLoop(messages, options) {
           tool: toolName,
           result: earlyAuthorityDenial,
           error: earlyAuthorityDenial.error,
+          execution_started: false,
           tool_use_id: call.id,
           turn_id: `${runId}:t${budget.consumed}`,
           permission_decision_id: decision?.id || null,