@odla-ai/cli 0.16.2 → 0.16.4

package/dist/{chunk-PQX6SKYJ.js → chunk-GAFC4EPJ.js}

@@ -1775,12 +1775,16 @@ async function defaultReadOrigin(cwd) {
 }
 
 // src/code-runtime-config.ts
-var CODE_PI_IMAGE = "ghcr.io/cory/odla-pi-agent@sha256:e7858b4f0291543171b2659b47c5d00f97acc4767cafd9b74ae5228899e0cde4";
+var CODE_PI_IMAGE = "odla-ai/pi-agent:embedded";
+var CODE_NODE_IMAGE = "node:24-alpine@sha256:a0b9bf06e4e6193cf7a0f58816cc935ff8c2a908f81e6f1a95432d679c54fbfd";
 var CODE_BUILD_RECIPES = Object.freeze([{
   id: "odla-code-contracts",
-  image: "node:24-alpine@sha256:a0b9bf06e4e6193cf7a0f58816cc935ff8c2a908f81e6f1a95432d679c54fbfd",
+  image: CODE_NODE_IMAGE,
   command: [
     "node",
+    // The clean source mount deliberately has no node_modules. Reuse the
+    // semver copy inside this digest-pinned npm image without network access.
+    "--import=data:text/javascript,import%20Module%20from%20%22node%3Amodule%22%3Bprocess.env.NODE_PATH%3D%22%2Fusr%2Flocal%2Flib%2Fnode_modules%2Fnpm%2Fnode_modules%22%3BModule._initPaths%28%29",
     "--test",
     "scripts/lib/directories.test.mjs",
     "scripts/lib/internal-deps.test.mjs",
@@ -1795,15 +1799,95 @@ var CODE_BUILD_RECIPES = Object.freeze([{
   pids: 128
 }]);
 
+// src/code-images.ts
+import { spawn as spawn2 } from "child_process";
+import { createHash } from "crypto";
+import { copyFile, mkdtemp, readFile, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import { fileURLToPath } from "url";
+var runCodeImageCommand = (command, args, stdio) => new Promise((accept, reject) => {
+  const child = spawn2(command, [...args], { shell: false, stdio });
+  child.once("error", reject);
+  child.once("exit", (code, signal) => {
+    if (code === 0) accept();
+    else reject(new Error(`${command} ${args.join(" ")} exited ${code ?? signal ?? "without a status"}`));
+  });
+});
+async function prepareCodeImages(engine, images, run = runCodeImageCommand, buildEmbedded = buildEmbeddedPiImage, nameEmbedded = embeddedPiImageName) {
+  if (engine === "container") {
+    try {
+      await run(engine, ["system", "start"], "inherit");
+    } catch {
+      throw new Error("Apple container could not start; run `container system start` once to complete its lightweight VM setup, then retry");
+    }
+  }
+  const prepared = [];
+  for (const image of images) {
+    const runtimeImage = image === CODE_PI_IMAGE ? await nameEmbedded() : image;
+    const inspectArgs = ["image", "inspect", runtimeImage];
+    try {
+      await run(engine, inspectArgs, "ignore");
+      prepared.push(runtimeImage);
+      continue;
+    } catch {
+    }
+    if (image === CODE_PI_IMAGE) {
+      try {
+        await buildEmbedded(engine, runtimeImage, run);
+      } catch (error) {
+        const detail = error instanceof Error && error.message ? `: ${error.message}` : "";
+        throw new Error(`could not prepare CLI-embedded Code image${detail}`);
+      }
+      prepared.push(runtimeImage);
+      continue;
+    }
+    const args = engine === "container" ? ["image", "pull", image] : ["pull", image];
+    try {
+      await run(engine, args, "inherit");
+    } catch (error) {
+      const detail = error instanceof Error && error.message ? `: ${error.message}` : "";
+      throw new Error(`could not prepare pinned Code image ${image}${detail}`);
+    }
+    prepared.push(image);
+  }
+  return prepared;
+}
+function embeddedPiAssetPath() {
+  return fileURLToPath(new URL("./runtime/pi-agent.js", import.meta.url));
+}
+async function embeddedPiImageName() {
+  const bundle = await readFile(embeddedPiAssetPath()).catch(() => {
+    throw new Error("CLI-embedded Pi runtime is missing; reinstall this exact @odla-ai/cli version");
+  });
+  return `odla-ai/pi-agent:embedded-sha256-${createHash("sha256").update(bundle).digest("hex")}`;
+}
+async function buildEmbeddedPiImage(engine, image, run) {
+  const context = await mkdtemp(join2(tmpdir(), "odla-code-pi-"));
+  try {
+    await copyFile(embeddedPiAssetPath(), join2(context, "pi-agent.js"));
+    await writeFile(join2(context, "Dockerfile"), [
+      `FROM ${CODE_NODE_IMAGE}`,
+      "COPY pi-agent.js /opt/odla/pi-agent.js",
+      "WORKDIR /workspace",
+      'ENTRYPOINT ["node", "/opt/odla/pi-agent.js"]',
+      ""
+    ].join("\n"), { mode: 384 });
+    await run(engine, ["build", "--tag", image, context], "inherit");
+  } finally {
+    await rm(context, { recursive: true, force: true });
+  }
+}
+
 // src/code-connect.ts
 import { existsSync as existsSync4 } from "fs";
 import { cpus, hostname, totalmem } from "os";
 import { resolve as resolve5 } from "path";
 
-// ../harness/dist/chunk-7SN5SG4N.js
+// ../harness/dist/chunk-QTUEF2HZ.js
 var HARNESS_PROTOCOL_VERSION = 1;
 
-// ../harness/dist/chunk-HX4QYGWE.js
+// ../harness/dist/chunk-GE6CCN7W.js
 var CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/;
 var HarnessProtocolError = class extends Error {
   name = "HarnessProtocolError";
@@ -1881,21 +1965,21 @@ function encodeAgentInput(message2) {
 `;
 }
 
-// ../harness/dist/chunk-QWWRL7M4.js
-import { execFile as execFile2, spawn as spawn2 } from "child_process";
+// ../harness/dist/chunk-NOBK6PCT.js
+import { execFile as execFile2, spawn as spawn3 } from "child_process";
 import { constants } from "fs";
 import { access } from "fs/promises";
-import { delimiter, join as join2 } from "path";
+import { delimiter, join as join3 } from "path";
 import { getgid, getuid } from "process";
-import { mkdir, mkdtemp, realpath, rm, writeFile } from "fs/promises";
-import { tmpdir } from "os";
+import { mkdir, mkdtemp as mkdtemp2, realpath, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
 import { join as join22, resolve as resolve3, sep } from "path";
 import { spawn as spawn22 } from "child_process";
 import { isAbsolute as isAbsolute3 } from "path";
-import { chmod, copyFile, lstat, mkdir as mkdir2, mkdtemp as mkdtemp2, readdir, realpath as realpath2, rm as rm2, stat } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { basename, join as join3, relative as relative2, resolve as resolve22, sep as sep2 } from "path";
-import { spawn as spawn3 } from "child_process";
+import { chmod, copyFile as copyFile2, lstat, mkdir as mkdir2, mkdtemp as mkdtemp22, readdir, realpath as realpath2, rm as rm22, stat } from "fs/promises";
+import { tmpdir as tmpdir22 } from "os";
+import { basename, join as join32, relative as relative2, resolve as resolve22, sep as sep2 } from "path";
+import { spawn as spawn32 } from "child_process";
 var DIGEST_IMAGE = /^[a-z0-9][a-z0-9._/-]*(?::[a-zA-Z0-9._-]+)?@sha256:[0-9a-f]{64}$/;
 function assertPinnedImage(image) {
   if (!DIGEST_IMAGE.test(image)) throw new TypeError("container image must be pinned by sha256 digest");
@@ -1903,7 +1987,7 @@ function assertPinnedImage(image) {
 async function commandAvailable(engine) {
   for (const directory of (process.env.PATH ?? "").split(delimiter).filter(Boolean)) {
     try {
-      await access(join2(directory, engine), constants.X_OK);
+      await access(join3(directory, engine), constants.X_OK);
       return true;
     } catch {
     }
@@ -1934,7 +2018,7 @@ async function selectContainerEngine(requested = "auto", options = {}) {
     throw new TypeError("no rootless Podman found; install Podman or explicitly choose --engine docker after reviewing its daemon boundary");
   }
   if (platform === "darwin") {
-    throw new TypeError("no Apple container or Podman Machine found; install one or explicitly choose --engine docker");
+    throw new TypeError("Apple container is not installed; on Apple Silicon macOS 26 run `brew install container`, then retry (Podman Machine is the fallback)");
   }
   throw new TypeError("no supported container engine found");
 }
@@ -2027,7 +2111,7 @@ async function runContainerAttempt(options) {
   await verifyContainerEngineBoundary(options.engine);
   const args = buildContainerRunArgs(options);
   const name = containerName(args);
-  const child = spawn2(options.engine, args, { stdio: ["pipe", "pipe", "pipe"], shell: false });
+  const child = spawn3(options.engine, args, { stdio: ["pipe", "pipe", "pipe"], shell: false });
   let stderr = "";
   let outputBytes = 0;
   let complete = null;
@@ -2045,7 +2129,7 @@ async function runContainerAttempt(options) {
       child.stdin.write(encodeAgentInput(cancel));
     }
     const removeArgs = options.engine === "container" ? ["delete", "--force", name] : ["rm", "-f", name];
-    const killer = spawn2(options.engine, removeArgs, { stdio: "ignore", shell: false });
+    const killer = spawn3(options.engine, removeArgs, { stdio: "ignore", shell: false });
     killer.unref();
   };
   const abort = () => stop("runner_cancelled");
@@ -2198,7 +2282,7 @@ async function materializeGitTree(source, commitSha, options = {}) {
     return match && allowedWorkspacePath(match[3]) ? [{ mode: match[1], hash: match[2], path: match[3] }] : [];
   });
   if (entries.length > maxFiles) throw new Error(`workspace exceeds ${maxFiles} files`);
-  const root = await mkdtemp(join22(options.tempRoot ?? tmpdir(), "odla-git-tree-"));
+  const root = await mkdtemp2(join22(options.tempRoot ?? tmpdir2(), "odla-git-tree-"));
   const targetRoot = join22(root, "source");
   await mkdir(targetRoot);
   let byteCount = 0;
@@ -2211,17 +2295,17 @@ async function materializeGitTree(source, commitSha, options = {}) {
       const target = resolve3(targetRoot, entry.path);
       if (!target.startsWith(`${resolve3(targetRoot)}${sep}`)) throw new TypeError("Git tree path escapes workspace");
       await mkdir(resolve3(target, ".."), { recursive: true });
-      await writeFile(target, content, { flag: "wx", mode: entry.mode === "100755" ? 493 : 420 });
+      await writeFile2(target, content, { flag: "wx", mode: entry.mode === "100755" ? 493 : 420 });
     }
     return {
       root,
       sourceDir: targetRoot,
       fileCount: entries.length,
       byteCount,
-      cleanup: () => rm(root, { recursive: true, force: true })
+      cleanup: () => rm2(root, { recursive: true, force: true })
     };
   } catch (error) {
-    await rm(root, { recursive: true, force: true });
+    await rm2(root, { recursive: true, force: true });
     throw error;
   }
 }
@@ -2232,7 +2316,7 @@ async function sourceFiles(sourceDir, maxFiles, maxBytes) {
     for (const entry of await readdir(dir, { withFileTypes: true })) {
       if (entry.isDirectory() && SKIP_WORKSPACE_DIRS.has(entry.name)) continue;
       if (!entry.isDirectory() && SECRET_WORKSPACE_FILE.test(entry.name)) continue;
-      const path = join3(dir, entry.name);
+      const path = join32(dir, entry.name);
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) {
         await walk(path);
@@ -2255,7 +2339,7 @@ async function sourceFiles(sourceDir, maxFiles, maxBytes) {
   return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 }
 async function gitSourceFiles(sourceDir, maxFiles, maxBytes) {
-  const child = spawn3("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+  const child = spawn32("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd: sourceDir,
     stdio: ["ignore", "pipe", "pipe"],
     shell: false
@@ -2302,14 +2386,14 @@ async function gitSourceFiles(sourceDir, maxFiles, maxBytes) {
 }
 async function copyTree(files, destination) {
   for (const file of files) {
-    const target = join3(destination, file.relativePath);
+    const target = join32(destination, file.relativePath);
     await mkdir2(resolve22(target, ".."), { recursive: true });
-    await copyFile(file.source, target);
+    await copyFile2(file.source, target);
     await chmod(target, file.mode);
   }
 }
 async function captureGitDiff(root, maxBytes) {
-  const child = spawn3("git", [
+  const child = spawn32("git", [
     "diff",
     "--no-index",
     "--binary",
@@ -2345,9 +2429,9 @@ async function stageWorkspace(source, options = {}) {
   const sourceDir = await realpath2(resolve22(source));
   const sourceStat = await stat(sourceDir);
   if (!sourceStat.isDirectory()) throw new TypeError("workspace source must be a directory");
-  const root = await mkdtemp2(join3(options.tempRoot ?? tmpdir2(), "odla-harness-"));
-  const baselineDir = join3(root, "baseline");
-  const workspaceDir = join3(root, "workspace");
+  const root = await mkdtemp22(join32(options.tempRoot ?? tmpdir22(), "odla-harness-"));
+  const baselineDir = join32(root, "baseline");
+  const workspaceDir = join32(root, "workspace");
   await Promise.all([mkdir2(baselineDir), mkdir2(workspaceDir)]);
   try {
     const maxFiles = options.maxFiles ?? 2e4;
@@ -2361,10 +2445,10 @@ async function stageWorkspace(source, options = {}) {
       fileCount: files.length,
       byteCount: files.reduce((sum, file) => sum + file.bytes, 0),
       patch: (maxBytes2) => captureGitDiff(root, maxBytes2),
-      cleanup: () => rm2(root, { recursive: true, force: true })
+      cleanup: () => rm22(root, { recursive: true, force: true })
     };
   } catch (error) {
-    await rm2(root, { recursive: true, force: true });
+    await rm22(root, { recursive: true, force: true });
     throw error;
   }
 }
@@ -2377,9 +2461,9 @@ async function stageWorkspacePair(baselineSource, workspaceSource, options = {})
     sourceFiles(baselineDirSource, maxFiles, maxBytes),
     sourceFiles(workspaceDirSource, maxFiles, maxBytes)
   ]);
-  const root = await mkdtemp2(join3(options.tempRoot ?? tmpdir2(), "odla-harness-"));
-  const baselineDir = join3(root, "baseline");
-  const workspaceDir = join3(root, "workspace");
+  const root = await mkdtemp22(join32(options.tempRoot ?? tmpdir22(), "odla-harness-"));
+  const baselineDir = join32(root, "baseline");
+  const workspaceDir = join32(root, "workspace");
   await Promise.all([mkdir2(baselineDir), mkdir2(workspaceDir)]);
   try {
     await Promise.all([copyTree(baselineFiles, baselineDir), copyTree(workspaceFiles, workspaceDir)]);
@@ -2390,17 +2474,17 @@ async function stageWorkspacePair(baselineSource, workspaceSource, options = {})
       fileCount: workspaceFiles.length,
       byteCount: workspaceFiles.reduce((sum, file) => sum + file.bytes, 0),
       patch: (maxPatchBytes) => captureGitDiff(root, maxPatchBytes),
-      cleanup: () => rm2(root, { recursive: true, force: true })
+      cleanup: () => rm22(root, { recursive: true, force: true })
     };
   } catch (error) {
-    await rm2(root, { recursive: true, force: true });
+    await rm22(root, { recursive: true, force: true });
     throw error;
   }
 }
 
-// ../harness/dist/chunk-T2RD6ZAW.js
-import { createHash } from "crypto";
-import { readFile, readdir as readdir2 } from "fs/promises";
+// ../harness/dist/chunk-6J2ZETST.js
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
 import { relative as relative3, resolve as resolve4 } from "path";
 
 // ../camel/dist/chunk-7FHPOQVP.js
@@ -2735,21 +2819,21 @@ function validateSnapshot(snapshot, limits) {
   }
 }
 
-// ../harness/dist/chunk-T2RD6ZAW.js
+// ../harness/dist/chunk-6J2ZETST.js
 import { spawn as spawn4 } from "child_process";
 import { lstat as lstat2 } from "fs/promises";
 import { resolve as resolve23, sep as sep3 } from "path";
 import { spawn as spawn23 } from "child_process";
 import { getgid as getgid2, getuid as getuid2 } from "process";
 import { randomUUID } from "crypto";
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash22, randomUUID as randomUUID2 } from "crypto";
 import { createReadStream } from "fs";
 import { lstat as lstat22 } from "fs/promises";
 import { join as join4 } from "path";
-import { mkdir as mkdir3, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
 import { dirname as dirname4, join as join23, resolve as resolve32, sep as sep22 } from "path";
-import { readFile as readFile2, readdir as readdir22, stat as stat2 } from "fs/promises";
+import { readFile as readFile22, readdir as readdir22, stat as stat2 } from "fs/promises";
 import { relative as relative22, resolve as resolve42 } from "path";
 
 // ../camel/dist/chunk-LAXU2AVK.js
@@ -3028,7 +3112,7 @@ function looksLikeDestination(value) {
   return /^(?:[a-z][a-z0-9+.-]*:\/\/|\/|\\\\)/i.test(text) || /^[\w.-]+\.[a-z]{2,}(?:[/:]|$)/i.test(text);
 }
 
-// ../harness/dist/chunk-T2RD6ZAW.js
+// ../harness/dist/chunk-6J2ZETST.js
 import { createHash as createHash3 } from "crypto";
 async function digestStagedWorkspace(root, limits) {
   const files = [];
@@ -3045,10 +3129,10 @@ async function digestStagedWorkspace(root, limits) {
     }
   };
   await walk(resolve4(root));
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   let bytes = 0;
   for (const file of files.sort((left, right) => left.path.localeCompare(right.path))) {
-    const content = await readFile(file.target);
+    const content = await readFile2(file.target);
     bytes += Buffer.byteLength(file.path) + content.byteLength;
     if (bytes > limits.maxBytes) throw new TypeError("workspace digest exceeds its byte bound");
     hash.update(`${Buffer.byteLength(file.path)}:${file.path}:${content.byteLength}:`);
@@ -3682,7 +3766,7 @@ async function inspectArtifacts(workspaceDir, recipe2) {
 }
 function hashFile(path) {
   return new Promise((accept, reject) => {
-    const hash = createHash2("sha256");
+    const hash = createHash22("sha256");
     const stream = createReadStream(path);
     stream.on("data", (chunk) => {
       hash.update(chunk);
@@ -3740,7 +3824,7 @@ function digestJson(value) {
   return digestBytes(JSON.stringify(value));
 }
 function digestBytes(value) {
-  return `sha256:${createHash2("sha256").update(value).digest("hex")}`;
+  return `sha256:${createHash22("sha256").update(value).digest("hex")}`;
 }
 function integer(value, minimum, maximum) {
   return Number.isSafeInteger(value) && value >= minimum && value <= maximum;
@@ -3861,7 +3945,7 @@ async function materializeCodeRuntimeSource(snapshot, tempRoot = tmpdir3()) {
       const target = resolve32(sourceDir, file.path);
       if (!target.startsWith(`${resolve32(sourceDir)}${sep22}`)) throw new TypeError("Code source path escapes its root");
       await mkdir3(dirname4(target), { recursive: true });
-      await writeFile2(target, file.content, { flag: "wx", mode: 420 });
+      await writeFile3(target, file.content, { flag: "wx", mode: 420 });
     }
     for (const reference of snapshot.references ?? []) {
       validateAlias(reference.alias);
@@ -3876,7 +3960,7 @@ async function materializeCodeRuntimeSource(snapshot, tempRoot = tmpdir3()) {
         const target = resolve32(sourceDir, path);
         if (!target.startsWith(`${resolve32(sourceDir)}${sep22}`)) throw new TypeError("Code reference path escapes its root");
         await mkdir3(dirname4(target), { recursive: true });
-        await writeFile2(target, file.content, { flag: "wx", mode: 292 });
+        await writeFile3(target, file.content, { flag: "wx", mode: 292 });
       }
     }
     return { sourceDir, cleanup: () => rm3(root, { recursive: true, force: true }) };
@@ -3903,7 +3987,7 @@ async function attachCodeRuntimeReferences(workspace, references) {
         const target = resolve32(root, path);
         if (!target.startsWith(`${resolve32(root)}${sep22}`)) throw new TypeError("Code reference path escapes its root");
         await mkdir3(dirname4(target), { recursive: true });
-        await writeFile2(target, file.content, { flag: "wx", mode: 292 });
+        await writeFile3(target, file.content, { flag: "wx", mode: 292 });
       }
     }
   }
@@ -4093,7 +4177,7 @@ async function read(context, request, options, policy) {
   if (!info.isFile() || info.size > Math.max(options.maxReadBytes ?? 128 * 1024, 2 * 1024 * 1024)) {
     throw new TypeError("file is not a bounded regular source file");
   }
-  const source = await readFile2(target);
+  const source = await readFile22(target);
   if (source.includes(0)) throw new TypeError("binary files are not readable through this tool");
   const lines = source.toString("utf8").split("\n");
   const content = lines.slice(startLine - 1, endLine).join("\n");
@@ -4219,6 +4303,7 @@ function codeCommandMetadata(payload, resume) {
   const role = payload.role;
   const title = payload.title;
   const prompt = payload.prompt;
+  const maxTokensPerInteraction = payload.maxTokensPerInteraction ?? 32e3;
   if (role !== "coding" && role !== "review" || typeof title !== "string" || typeof prompt !== "string") {
     throw new TypeError(`invalid Code ${resume ? "resume" : "start"} metadata`);
   }
@@ -4230,10 +4315,14 @@ function codeCommandMetadata(payload, resume) {
   if (typeof repository !== "string" || !repository.includes("/") || typeof baseCommitSha !== "string" || !/^[0-9a-f]{40}$/.test(baseCommitSha) || typeof sourceTreeDigest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(sourceTreeDigest)) {
     throw new TypeError(`invalid Code ${resume ? "resume" : "start"} trusted base`);
   }
+  if (!Number.isSafeInteger(maxTokensPerInteraction) || Number(maxTokensPerInteraction) < 4e3 || Number(maxTokensPerInteraction) > 2e5) {
+    throw new TypeError(`invalid Code ${resume ? "resume" : "start"} interaction token limit`);
+  }
   return {
     role,
     title,
     prompt,
+    maxTokensPerInteraction: Number(maxTokensPerInteraction),
     planningInputDigest: typeof planning === "string" && /^sha256:[0-9a-f]{64}$/.test(planning) ? planning : null,
     attestationDigest: typeof attestation === "string" ? attestation : "resume",
     repository,
@@ -4309,6 +4398,57 @@ function createCodeRuntimeToolBroker(input, lease, role) {
   });
   return role === "coding" ? broker : { execute: (context, request) => request.tool === "sandbox.read" ? broker.execute(context, request) : Promise.resolve({ requestId: request.requestId, ok: false, content: "review sessions are read-only" }) };
 }
+async function handleCodeRuntimeInference(input) {
+  const { command, metadata: metadata2, request, state } = input;
+  if (state.tokens >= metadata2.maxTokensPerInteraction) {
+    if (!state.noticeEmitted) {
+      state.noticeEmitted = true;
+      await input.event({
+        type: "message",
+        actor: "system",
+        body: `Pi paused at the ${metadata2.maxTokensPerInteraction.toLocaleString("en-US")}-token per-interaction limit. Send a new instruction to continue.`
+      }).catch(() => void 0);
+    }
+    return {
+      protocolVersion: HARNESS_PROTOCOL_VERSION,
+      type: "inference.response",
+      requestId: request.requestId,
+      response: {
+        id: `budget:${command.commandId}`,
+        provider: "openai",
+        model: "interaction-budget",
+        role: "assistant",
+        content: [{ type: "text", text: "Pause now. The owner-set token limit for this interaction has been reached." }],
+        stopReason: "end_turn",
+        usage: { inputTokens: 0, outputTokens: 0 }
+      }
+    };
+  }
+  const startedAt = Date.now();
+  const response2 = await input.control.infer(command.sessionId, {
+    requestId: request.requestId,
+    interactionId: command.commandId,
+    call: request.call
+  });
+  state.tokens += response2.receipt.inputTokens + response2.receipt.outputTokens;
+  await input.event({
+    type: "usage",
+    provider: response2.receipt.provider,
+    model: response2.receipt.model,
+    inputTokens: response2.receipt.inputTokens,
+    outputTokens: response2.receipt.outputTokens,
+    durationMs: Date.now() - startedAt,
+    interactionId: command.commandId,
+    interactionTokens: state.tokens,
+    interactionMaxTokens: metadata2.maxTokensPerInteraction
+  }).catch(() => void 0);
+  return {
+    protocolVersion: HARNESS_PROTOCOL_VERSION,
+    type: "inference.response",
+    requestId: request.requestId,
+    response: response2.response
+  };
+}
 async function appendCodeRuntimeEvent(control, command, event, refs) {
   const eventId = `${command.commandId.slice(0, 45)}:${refs.length + 1}`;
   refs.push(eventId);
@@ -4338,6 +4478,7 @@ function runtimeResultError(value) {
 var CodePiRuntimeEngine = class {
   constructor(options) {
     this.options = options;
+    if (options.imageAuthorization === "cli_embedded" && !/^odla-ai\/pi-agent:embedded-sha256-[0-9a-f]{64}$/.test(options.image)) throw new TypeError("CLI-embedded Pi image must use its content-addressed local tag");
     this.#run = options.runAttempt ?? runContainerAttempt;
     this.#buildPolicyDigest = digestRuntimeValue(JSON.stringify(options.recipes));
     this.#checkpoints = new CodeRuntimeCheckpointManager({
@@ -4420,6 +4561,7 @@ var CodePiRuntimeEngine = class {
       acknowledged: false,
       role: metadata2.role,
       title: metadata2.title,
+      maxTokensPerInteraction: metadata2.maxTokensPerInteraction,
       baseCommitSha: metadata2.baseCommitSha,
       repository: metadata2.repository,
       sourceTreeDigest: metadata2.sourceTreeDigest,
@@ -4456,6 +4598,11 @@ var CodePiRuntimeEngine = class {
     if (!active || typeof prompt !== "string" || !prompt.trim() || prompt.length > 2e4) {
       throw new TypeError("prompt requires an active Code session and bounded text");
     }
+    const requestedLimit = command.payload.maxTokensPerInteraction ?? active.maxTokensPerInteraction;
+    if (!Number.isSafeInteger(requestedLimit) || Number(requestedLimit) < 4e3 || Number(requestedLimit) > 2e5) {
+      throw new TypeError("prompt requires a valid interaction token limit");
+    }
+    active.maxTokensPerInteraction = Number(requestedLimit);
     await active.done;
     active.abort = new AbortController();
     active.acknowledged = false;
@@ -4464,6 +4611,7 @@ var CodePiRuntimeEngine = class {
       role: active.role,
       title: active.title,
       prompt,
+      maxTokensPerInteraction: active.maxTokensPerInteraction,
       planningInputDigest: active.planningInputDigest,
       attestationDigest: "follow-up",
       repository: active.repository,
@@ -4492,9 +4640,11 @@ var CodePiRuntimeEngine = class {
     }, lease, metadata2.role);
     const startedAt = Date.now();
     let completionSeen = false;
+    const interaction = { tokens: 0, noticeEmitted: false };
     const result = await this.#run({
       engine: this.options.engine,
       image: this.options.image,
+      allowUnpinnedImage: this.options.imageAuthorization === "cli_embedded",
       workspaceDir: active.workspace.workspaceDir,
       workspaceAccess: "none",
       task: lease.task,
@@ -4507,25 +4657,18 @@ var CodePiRuntimeEngine = class {
       }, active.conversationRefs),
       onMessage: async (output) => {
         if (output.type === "inference.request") {
-          const inferenceStarted = Date.now();
-          const response2 = await this.options.control.infer(command.sessionId, {
-            requestId: output.requestId,
-            call: output.call
+          return handleCodeRuntimeInference({
+            command,
+            metadata: metadata2,
+            request: output,
+            state: interaction,
+            control: this.options.control,
+            event: (event) => this.#event(
+              command,
+              event,
+              active.conversationRefs
+            )
           });
-          await this.#event(command, {
-            type: "usage",
-            provider: response2.receipt.provider,
-            model: response2.receipt.model,
-            inputTokens: response2.receipt.inputTokens,
-            outputTokens: response2.receipt.outputTokens,
-            durationMs: Date.now() - inferenceStarted
-          }, active.conversationRefs).catch(() => void 0);
-          return {
-            protocolVersion: HARNESS_PROTOCOL_VERSION,
-            type: "inference.response",
-            requestId: output.requestId,
-            response: response2.response
-          };
         }
         if (output.type === "tool.request") {
           const toolStarted = Date.now();
@@ -4795,20 +4938,6 @@ function digestText(value) {
   return `sha256:${createHash4("sha256").update(value).digest("hex")}`;
 }
 
-// src/code-images.ts
-import { execFile as execFile4 } from "child_process";
-async function prepareCodeImages(engine, images) {
-  for (const image of images) {
-    await new Promise((accept, reject) => {
-      const args = engine === "container" ? ["image", "pull", image] : ["pull", image];
-      execFile4(engine, args, { encoding: "utf8", maxBuffer: 2 * 1024 * 1024, timeout: 10 * 6e4 }, (error) => {
-        if (error) reject(new Error(`could not prepare pinned Code image ${image}`));
-        else accept();
-      });
-    });
-  }
-}
-
 // src/code-connect.ts
 async function codeConnect(options) {
   const cwd = options.cwd ?? process.cwd();
@@ -4841,10 +4970,11 @@ async function codeConnect(options) {
   const out = options.stdout ?? console;
   const doFetch = options.fetch ?? fetch;
   const engine = await (options.selectEngine ?? selectContainerEngine)(options.engine ?? "auto");
-  await (options.prepareImages ?? prepareCodeImages)(engine, [
-    CODE_PI_IMAGE,
-    ...new Set(CODE_BUILD_RECIPES.map((recipe2) => recipe2.image))
-  ]);
+  const [piImage] = await (options.prepareImages ?? prepareCodeImages)(
+    engine,
+    [CODE_PI_IMAGE, ...new Set(CODE_BUILD_RECIPES.map((recipe2) => recipe2.image))]
+  );
+  if (!piImage || !/^odla-ai\/pi-agent:embedded-sha256-[0-9a-f]{64}$/.test(piImage)) throw new Error("Code image preflight did not produce the content-addressed embedded Pi runtime");
   const hostPlatform = process.platform === "darwin" ? "macos" : "linux";
   const hostName = (options.name ?? hostname()).trim();
   if (!hostName || hostName.length > 120) throw new Error("--name must contain 1 to 120 characters");
@@ -4888,7 +5018,8 @@ async function codeConnect(options) {
       source: descriptor2,
       images: {
         ready: true,
-        pi: CODE_PI_IMAGE,
+        pi: piImage,
+        piSource: "cli_embedded",
         recipes: CODE_BUILD_RECIPES.map((recipe2) => ({ id: recipe2.id, image: recipe2.image }))
       }
     };
@@ -4903,6 +5034,7 @@ async function codeConnect(options) {
       engine,
       capabilities,
       localSource,
+      piImage,
       heartbeatMs,
       once: options.once === true,
       signal: options.signal,
@@ -4932,7 +5064,8 @@ async function runCodeRuntime(input) {
   const commandEngine = new CodePiRuntimeEngine({
     control,
     engine: input.engine,
-    image: CODE_PI_IMAGE,
+    image: input.piImage ?? input.capabilities.images.pi,
+    imageAuthorization: "cli_embedded",
     recipes: CODE_BUILD_RECIPES,
     recipeAuthorization: "registered_recipe",
     localSource: input.localSource,
@@ -6310,7 +6443,7 @@ function securityExecutionDigest(value) {
 import { existsSync as existsSync8, lstatSync, mkdirSync as mkdirSync3, readFileSync as readFileSync6, readdirSync, writeFileSync as writeFileSync3 } from "fs";
 import { homedir } from "os";
 import { dirname as dirname6, isAbsolute as isAbsolute5, join as join7, relative as relative5, resolve as resolve9, sep as sep5 } from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/skill-adapters.ts
 var PROJECT_INSTRUCTIONS = `<!-- odla-ai agent setup:start -->
@@ -6366,7 +6499,7 @@ runbook. Do not substitute a remote documentation page for the installed copy.
 var AGENT_HARNESSES = ["claude", "codex", "cursor", "copilot", "gemini", "agents"];
 function installSkill(options = {}) {
   const out = options.stdout ?? console;
-  const sourceDir = options.sourceDir ?? fileURLToPath(new URL("../skills", import.meta.url));
+  const sourceDir = options.sourceDir ?? fileURLToPath2(new URL("../skills", import.meta.url));
   const files = listFiles(sourceDir);
   if (files.length === 0) throw new Error(`no bundled skills found at ${sourceDir}`);
   const harnesses = normalizeHarnesses(options.harnesses, options.global === true);
@@ -7753,6 +7886,7 @@ export {
   inferGitHubRepository,
   CODE_PI_IMAGE,
   CODE_BUILD_RECIPES,
+  prepareCodeImages,
   codeConnect,
   runCodeRuntime,
   doctor,
@@ -7776,4 +7910,4 @@ export {
   exitCodeFor,
   runCli
 };
-//# sourceMappingURL=chunk-PQX6SKYJ.js.map
+//# sourceMappingURL=chunk-GAFC4EPJ.js.map