@tryarcanist/cli 0.1.105 → 0.1.106

package/README.md

@@ -128,7 +128,7 @@ arcanist sessions create your-org/your-repo "verify the deployed change" --cold
 arcanist sessions create your-org/your-repo "retry-safe create" --idempotency-key 1f0e6f1a-...
 ```
 
-`--backend` picks the agent runtime backend: `codex` (default) or `claude_code`. `--model` must be valid for the chosen backend — codex runs OpenAI models (`gpt-5.5` default, `gpt-5.4`), `claude_code` runs Anthropic models (`claude-opus-4-8` default, `claude-sonnet-4-6`) — and the CLI rejects a mismatch before any network call. `claude_code` sessions require an Anthropic API key configured in Settings.
+`--backend` picks the agent runtime backend: `codex` (default) or `claude_code`. `--model` must be valid for the chosen backend — codex runs OpenAI models (`gpt-5.4` default, `gpt-5.5`), `claude_code` runs Anthropic models (`claude-opus-4-8` default, `claude-sonnet-4-6`) — and the CLI rejects a mismatch before any network call. `claude_code` sessions require an Anthropic API key configured in Settings.
 
 `--wait` blocks until the created prompt finishes and exits non-zero if the prompt finishes with `status: failed`, making it suitable for cron or other schedulers that alert on command failure. `--poll-interval <ms>` tunes the completion check frequency.
 

package/dist/index.js

@@ -421,27 +421,29 @@ var SESSION_START_MODEL_IDS_BY_BACKEND = {
   [CLAUDE_CODE_AGENT_RUNTIME_BACKEND]: [AnthropicModel.Opus48, AnthropicModel.Sonnet46]
 };
 var DEFAULT_SESSION_START_MODEL_ID_BY_BACKEND = {
-  [CODEX_AGENT_RUNTIME_BACKEND]: OpenAIModel.GPT55,
+  [CODEX_AGENT_RUNTIME_BACKEND]: OpenAIModel.GPT54,
   [CLAUDE_CODE_AGENT_RUNTIME_BACKEND]: AnthropicModel.Opus48
 };
 var SESSION_START_MODEL_IDS = SESSION_START_MODEL_IDS_BY_BACKEND[CODEX_AGENT_RUNTIME_BACKEND];
 var DEFAULT_SESSION_START_MODEL_ID = DEFAULT_SESSION_START_MODEL_ID_BY_BACKEND[CODEX_AGENT_RUNTIME_BACKEND];
 var MODEL_REGISTRY = [
   {
-    id: OpenAIModel.GPT55,
-    name: "GPT-5.5",
+    id: OpenAIModel.GPT54,
+    name: "GPT-5.4",
     provider: "openai",
     backends: [CODEX_AGENT_RUNTIME_BACKEND],
     contextWindow: 1e6,
+    // Default codex model after the gpt-5.5 downgrade; carries gpt-5.5's prior
+    // "medium" default so default sessions keep the same reasoning effort.
     reasoning: { efforts: ["none", "low", "medium", "high", "xhigh"], default: "medium" }
   },
   {
-    id: OpenAIModel.GPT54,
-    name: "GPT-5.4",
+    id: OpenAIModel.GPT55,
+    name: "GPT-5.5",
     provider: "openai",
     backends: [CODEX_AGENT_RUNTIME_BACKEND],
     contextWindow: 1e6,
-    reasoning: { efforts: ["none", "low", "medium", "high", "xhigh"], default: void 0 }
+    reasoning: { efforts: ["none", "low", "medium", "high", "xhigh"], default: "medium" }
   },
   {
     id: OpenAIModel.GPT54Mini,
@@ -579,6 +581,19 @@ function getSessionStartModelIdsForBackend(backend) {
 function isSessionStartModelAllowedForBackend(modelId, backend) {
   return VALID_SESSION_START_MODEL_IDS_BY_BACKEND[backend].has(modelId);
 }
+var MODEL_TIER_BY_ID = {
+  [OpenAIModel.GPT55]: "frontier",
+  [OpenAIModel.GPT54]: "mid",
+  [AnthropicModel.Opus48]: "frontier",
+  [AnthropicModel.Sonnet46]: "mid"
+};
+var CODEX_MODEL_ID_BY_TIER = {
+  // Single source of truth: the frontier codex model follows the codex default,
+  // so changing the default propagates here automatically. Only used for
+  // non-codex (e.g. claude) parents — codex parents verify on their own model.
+  frontier: DEFAULT_SESSION_START_MODEL_ID_BY_BACKEND[CODEX_AGENT_RUNTIME_BACKEND],
+  mid: OpenAIModel.GPT54
+};
 function getProviderForModel(modelId) {
   return MODEL_PROVIDERS[modelId] ?? "openai";
 }
@@ -750,9 +765,9 @@ function validateUploadedFilePayload(files, existingNames = []) {
     label: "uploaded files",
     normalizeItems: trimNamedItems,
     validateItem: (file) => {
-      const byteLength = new TextEncoder().encode(file.content).byteLength;
-      if (byteLength > MAX_UPLOADED_FILE_SIZE_BYTES) {
-        return `Uploaded file too large: ${file.name} (${byteLength} bytes, max ${MAX_UPLOADED_FILE_SIZE_BYTES})`;
+      const byteLength2 = new TextEncoder().encode(file.content).byteLength;
+      if (byteLength2 > MAX_UPLOADED_FILE_SIZE_BYTES) {
+        return `Uploaded file too large: ${file.name} (${byteLength2} bytes, max ${MAX_UPLOADED_FILE_SIZE_BYTES})`;
       }
       if (hasNullBytes(file.content)) {
         return `Binary files are not supported: ${file.name}`;
@@ -2175,11 +2190,11 @@ function formatStatusLine(status) {
   if (status.sandboxSubstate && status.sandboxSubstate !== "none") substate.push(status.sandboxSubstate);
   if (status.stopMode && status.stopMode !== "none") substate.push(status.stopMode);
   if (status.finalizingStep && status.finalizingStep !== "none") substate.push(status.finalizingStep);
-  const phaseLabel = substate.length > 0 ? `${label}/${substate.join("/")}` : label;
+  const phaseLabel2 = substate.length > 0 ? `${label}/${substate.join("/")}` : label;
   const details = [];
   if (status.title) details.push(status.title);
   if (status.spawnDurationMs != null) details.push(`spawn ${(status.spawnDurationMs / 1e3).toFixed(1)}s`);
-  return details.length > 0 ? `[status] ${phaseLabel} | ${details.join(" | ")}` : `[status] ${phaseLabel}`;
+  return details.length > 0 ? `[status] ${phaseLabel2} | ${details.join(" | ")}` : `[status] ${phaseLabel2}`;
 }
 function advanceStatusDisconnectMask(status, mask, lastView, now) {
   const view = status.phase ? { phase: status.phase, sandboxSubstate: status.sandboxSubstate } : null;
@@ -2541,6 +2556,1103 @@ async function messageCommand(sessionId, promptArg, options = {}, command) {
   console.log(`Message sent to session ${sessionId}.`);
 }
 
+// src/commands/sandbox.ts
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname } from "path";
+
+// ../../shared/github/repo-url.ts
+function parseGithubRepoFullName(value) {
+  const shorthand = value.match(/^([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)$/);
+  if (shorthand) return { owner: shorthand[1], repo: shorthand[2] };
+  const ssh = value.match(/git@[^:]+:([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (ssh) return { owner: ssh[1], repo: ssh[2] };
+  const https = value.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+  if (https) return { owner: https[1], repo: https[2] };
+  return null;
+}
+
+// ../../shared/sandbox-layer/parser.ts
+import { isMap, isScalar, isSeq, parseDocument } from "yaml";
+
+// ../../shared/utils/hex.ts
+function bytesToHex(buf) {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// ../../shared/sandbox-layer/parser.ts
+var textEncoder = new TextEncoder();
+async function computeSha256Hex(message) {
+  const digest = await crypto.subtle.digest("SHA-256", textEncoder.encode(message));
+  return bytesToHex(new Uint8Array(digest));
+}
+var SANDBOX_LAYER_MANIFEST_PATH = ".arcanist/sandbox.yaml";
+var MAX_MANIFEST_BYTES = 64 * 1024;
+var MAX_LAYER_BYTES = 128 * 1024;
+var MAX_RUN_COMMAND_BYTES = 8 * 1024;
+var MAX_SMOKE_COMMANDS = 20;
+var MAX_SMOKE_ARGS = 32;
+var MAX_SMOKE_ARG_BYTES = 512;
+var MAX_DISPLAY_NAME_CHARS = 80;
+var MIN_DISPLAY_NAME_CHARS = 2;
+var MAX_ENV_KEY_CHARS = 80;
+var MAX_ENV_VALUE_BYTES = 2 * 1024;
+var MAX_ENV_VARS = 50;
+var SECRET_PATTERN = /\b(secret|token|password|passwd|private_key|private-key|access_key|access-key|client_secret|client-secret)\b|BEGIN PRIVATE KEY/i;
+var FORBIDDEN_PATHS = [
+  "/app",
+  "/app/start-bridge.sh",
+  "/app/bridge",
+  "/app/scripts",
+  "/workspace",
+  "/usr/local/sbin/arcanist-enforce-egress"
+];
+var FORBIDDEN_TARGETING_OPS = /\b(rm|mv|cp|ln|chmod|chown|truncate|tee)\b|\bsed\s+-i\b|\bcat\s*>/;
+var ENV_KEY_RE = /^[A-Z_][A-Z0-9_]{0,79}$/;
+var SandboxLayerValidationError = class extends Error {
+  issues;
+  path;
+  detail;
+  line;
+  constructor(pathOrIssues, detail, line, field, code = "invalid") {
+    const issues = Array.isArray(pathOrIssues) ? pathOrIssues : [{ path: pathOrIssues, line, field, code, message: detail ?? "invalid sandbox layer source" }];
+    const first = issues[0] ?? { path: "sandbox-layer", message: "invalid sandbox layer source" };
+    super(formatIssue(first));
+    this.name = "SandboxLayerValidationError";
+    this.issues = issues;
+    this.path = first.path;
+    this.detail = first.message;
+    this.line = first.line;
+  }
+};
+function formatIssue(issue2) {
+  return `${issue2.path}${issue2.line ? `:${issue2.line}` : ""}: ${issue2.message}`;
+}
+function issue(path, message, options = {}) {
+  return {
+    path,
+    line: options.line,
+    field: options.field,
+    code: options.code ?? "invalid",
+    message
+  };
+}
+function byteLength(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function rejectSecrets(path, text) {
+  const match = text.match(SECRET_PATTERN);
+  if (match) {
+    throw new SandboxLayerValidationError(
+      path,
+      `sandbox layer source appears to contain a secret-like token: ${match[0]}`
+    );
+  }
+}
+function assertSize(path, text, maxBytes) {
+  if (text.includes("\0")) {
+    throw new SandboxLayerValidationError(path, "file must not contain NUL bytes");
+  }
+  if (byteLength(text) > maxBytes) {
+    throw new SandboxLayerValidationError(path, `file exceeds ${maxBytes} byte limit`);
+  }
+}
+function validateRepoRelativeArcanistPath(path, field = "path") {
+  const normalized = path.trim();
+  if (!normalized) throw new Error(`${field} is required`);
+  if (/^[A-Za-z]:/.test(normalized)) throw new Error(`${field} must be a POSIX repo-relative path`);
+  if (normalized.includes("\\")) throw new Error(`${field} must use POSIX '/' separators`);
+  if (normalized.startsWith("/") || normalized.includes("\0")) throw new Error(`${field} must be repo-relative`);
+  const parts = normalized.split("/");
+  if (parts.some((part) => part === "" || part === "." || part === "..")) {
+    throw new Error(`${field} cannot contain empty, '.', or '..' segments`);
+  }
+  if (!normalized.startsWith(".arcanist/")) throw new Error(`${field} must be under .arcanist/`);
+  return normalized;
+}
+function yamlLineForPath(doc, keyPath) {
+  let node = doc.contents;
+  for (const segment of keyPath) {
+    if (!isMap(node)) return void 0;
+    const pair = node.items.find((item) => isScalar(item.key) && item.key.value === segment);
+    if (!pair) return void 0;
+    node = pair.value;
+  }
+  const range = node?.range;
+  if (!range) return void 0;
+  const before = doc.toString().slice(0, range[0]);
+  return before.split(/\r?\n/).length;
+}
+function assertKnownKeys(path, doc, value) {
+  const issues = [];
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return [issue(path, "manifest must be a YAML object", { code: "manifest_type" })];
+  }
+  const root = value;
+  for (const key of Object.keys(root)) {
+    if (!["version", "name", "layer", "smoke"].includes(key)) {
+      issues.push(
+        issue(
+          path,
+          key === "resources" ? "resources is not supported; resource sizing is Arcanist policy" : `unknown field '${key}'`,
+          {
+            line: yamlLineForPath(doc, [key]),
+            field: key,
+            code: key === "resources" ? "resources_not_allowed" : "unknown_field"
+          }
+        )
+      );
+    }
+  }
+  if (root.layer && typeof root.layer === "object" && !Array.isArray(root.layer)) {
+    for (const key of Object.keys(root.layer)) {
+      if (key !== "dockerfile") {
+        issues.push(
+          issue(path, `unknown field 'layer.${key}'`, {
+            line: yamlLineForPath(doc, ["layer", key]),
+            field: `layer.${key}`,
+            code: "unknown_field"
+          })
+        );
+      }
+    }
+  }
+  if (root.smoke && typeof root.smoke === "object" && !Array.isArray(root.smoke)) {
+    for (const key of Object.keys(root.smoke)) {
+      if (key !== "commands") {
+        issues.push(
+          issue(path, `unknown field 'smoke.${key}'`, {
+            line: yamlLineForPath(doc, ["smoke", key]),
+            field: `smoke.${key}`,
+            code: "unknown_field"
+          })
+        );
+      }
+    }
+  }
+  return issues;
+}
+function parseSandboxLayerManifest(path, text) {
+  assertSize(path, text, MAX_MANIFEST_BYTES);
+  rejectSecrets(path, text);
+  let doc;
+  try {
+    doc = parseDocument(text, { strict: true });
+  } catch (err) {
+    throw new SandboxLayerValidationError(path, `invalid YAML: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (doc.errors.length > 0) {
+    const error = doc.errors[0];
+    throw new SandboxLayerValidationError(path, `invalid YAML: ${error.message}`, error.linePos?.[0]?.line);
+  }
+  const parsed = doc.toJSON();
+  const issues = assertKnownKeys(path, doc, parsed);
+  const raw = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  if (!Object.prototype.hasOwnProperty.call(raw, "version")) {
+    issues.push(issue(path, "version is required", { field: "version", code: "required" }));
+  } else if (raw.version !== 1) {
+    issues.push(
+      issue(path, "version must be exactly 1", {
+        line: yamlLineForPath(doc, ["version"]),
+        field: "version",
+        code: "invalid_version"
+      })
+    );
+  }
+  const name = raw.name == null ? null : typeof raw.name === "string" ? raw.name.trim() : "";
+  if (raw.name != null && (typeof raw.name !== "string" || name === null || name.length < MIN_DISPLAY_NAME_CHARS || name.length > MAX_DISPLAY_NAME_CHARS)) {
+    issues.push(
+      issue(path, "name must be a 2-80 character display name", {
+        line: yamlLineForPath(doc, ["name"]),
+        field: "name",
+        code: "invalid_name"
+      })
+    );
+  }
+  const layer = raw.layer;
+  if (!layer || typeof layer !== "object" || Array.isArray(layer)) {
+    issues.push(
+      issue(path, "layer.dockerfile is required", {
+        line: yamlLineForPath(doc, ["layer"]),
+        field: "layer.dockerfile",
+        code: "required"
+      })
+    );
+  }
+  let normalizedDockerfile;
+  const dockerfile = layer && typeof layer === "object" && !Array.isArray(layer) ? layer.dockerfile : void 0;
+  if (typeof dockerfile !== "string") {
+    issues.push(
+      issue(path, "layer.dockerfile must be a string", {
+        line: yamlLineForPath(doc, ["layer", "dockerfile"]),
+        field: "layer.dockerfile",
+        code: "invalid_type"
+      })
+    );
+    normalizedDockerfile = "";
+  } else {
+    try {
+      normalizedDockerfile = validateRepoRelativeArcanistPath(dockerfile, "layer.dockerfile");
+    } catch (err) {
+      issues.push(
+        issue(path, err instanceof Error ? err.message : String(err), {
+          line: yamlLineForPath(doc, ["layer", "dockerfile"]),
+          field: "layer.dockerfile",
+          code: "invalid_path"
+        })
+      );
+      normalizedDockerfile = "";
+    }
+  }
+  const commandsNode = isMap(doc.contents) ? doc.getIn(["smoke", "commands"], true) : void 0;
+  const rawCommands = raw.smoke?.commands ?? [];
+  const smokeCommands = [];
+  if (!Array.isArray(rawCommands)) {
+    issues.push(
+      issue(path, "smoke.commands must be an array", {
+        line: yamlLineForPath(doc, ["smoke", "commands"]),
+        field: "smoke.commands",
+        code: "invalid_type"
+      })
+    );
+  } else {
+    if (rawCommands.length > MAX_SMOKE_COMMANDS) {
+      issues.push(
+        issue(path, `smoke.commands may contain at most ${MAX_SMOKE_COMMANDS} commands`, {
+          line: yamlLineForPath(doc, ["smoke", "commands"]),
+          field: "smoke.commands",
+          code: "too_many_items"
+        })
+      );
+    }
+    rawCommands.forEach((command, index) => {
+      const commandNode = isSeq(commandsNode) ? commandsNode.items[index] : void 0;
+      const line = commandNode?.range ? text.slice(0, commandNode.range[0]).split(/\r?\n/).length : yamlLineForPath(doc, ["smoke", "commands"]);
+      const field = `smoke.commands.${index}`;
+      if (!Array.isArray(command)) {
+        issues.push(
+          issue(path, "smoke commands must be argument arrays, not shell strings", {
+            line,
+            field,
+            code: "invalid_type"
+          })
+        );
+        return;
+      }
+      if (command.length === 0 || command.length > MAX_SMOKE_ARGS) {
+        issues.push(
+          issue(path, `smoke commands must contain 1-${MAX_SMOKE_ARGS} args`, { line, field, code: "invalid_length" })
+        );
+        return;
+      }
+      const parsedCommand = [];
+      command.forEach((arg, argIndex) => {
+        const argField = `${field}.${argIndex}`;
+        if (typeof arg !== "string" || arg.length === 0 || arg.includes("\0") || /[\r\n]/.test(arg) || byteLength(arg) > MAX_SMOKE_ARG_BYTES) {
+          issues.push(
+            issue(
+              path,
+              `smoke args must be non-empty strings up to ${MAX_SMOKE_ARG_BYTES} bytes with no NUL or newline`,
+              { line, field: argField, code: "invalid_smoke_arg" }
+            )
+          );
+          return;
+        }
+        if (SECRET_PATTERN.test(arg)) {
+          issues.push(
+            issue(path, "smoke args must not contain obvious secret material", {
+              line,
+              field: argField,
+              code: "secret_like"
+            })
+          );
+          return;
+        }
+        parsedCommand.push(arg);
+      });
+      if (parsedCommand.length === command.length) smokeCommands.push(parsedCommand);
+    });
+  }
+  if (issues.length > 0) throw new SandboxLayerValidationError(issues);
+  return { version: 1, name, layer: { dockerfile: normalizedDockerfile }, smoke: { commands: smokeCommands } };
+}
+function splitLogicalInstructions(path, text) {
+  assertSize(path, text, MAX_LAYER_BYTES);
+  rejectSecrets(path, text);
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  const result = [];
+  let current = "";
+  let startLine = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const lineNumber = index + 1;
+    const rawLine = lines[index];
+    const trimmed = rawLine.trim();
+    if (!current && (!trimmed || trimmed.startsWith("#"))) {
+      if (/^#\s*syntax\s*=/i.test(trimmed)) {
+        throw new SandboxLayerValidationError(path, "BuildKit syntax directives are not supported", lineNumber);
+      }
+      continue;
+    }
+    if (/<<\s*[-\w'"]+/.test(rawLine)) {
+      throw new SandboxLayerValidationError(path, "heredocs are not supported in sandbox layer files", lineNumber);
+    }
+    if (!current) startLine = lineNumber;
+    const continued = /\\\s*$/.test(rawLine);
+    current += (current ? " " : "") + rawLine.replace(/\\\s*$/, "").trim();
+    if (byteLength(current) > MAX_LAYER_BYTES) {
+      throw new SandboxLayerValidationError(path, "continued instruction exceeds layer size limit", startLine);
+    }
+    if (!continued) {
+      result.push({ text: current.trim(), startLine, endLine: lineNumber });
+      current = "";
+      startLine = 0;
+    }
+  }
+  if (current) {
+    throw new SandboxLayerValidationError(path, "unterminated line continuation", startLine);
+  }
+  return result;
+}
+function splitEnvTokens(path, body, startLine) {
+  const tokens2 = [];
+  let current = "";
+  let quote = null;
+  for (const char of body) {
+    if (quote) {
+      current += char;
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens2.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (quote) throw new SandboxLayerValidationError(path, "ENV contains an unterminated quote", startLine);
+  if (current) tokens2.push(current);
+  return tokens2;
+}
+function parseEnvValues(path, body, startLine) {
+  const values = {};
+  const tokens2 = splitEnvTokens(path, body, startLine);
+  if (tokens2.length > MAX_ENV_VARS) {
+    throw new SandboxLayerValidationError(path, `ENV may set at most ${MAX_ENV_VARS} variables`, startLine);
+  }
+  for (const token of tokens2) {
+    const separator = token.indexOf("=");
+    if (separator <= 0) {
+      throw new SandboxLayerValidationError(path, "ENV entries must use KEY=value form", startLine);
+    }
+    const key = token.slice(0, separator);
+    let value = token.slice(separator + 1);
+    if (!ENV_KEY_RE.test(key)) {
+      throw new SandboxLayerValidationError(path, `invalid ENV key '${key}'`, startLine);
+    }
+    if (key.length > MAX_ENV_KEY_CHARS) {
+      throw new SandboxLayerValidationError(path, `ENV key '${key}' is too long`, startLine);
+    }
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (!value || value.includes("\0") || /[\r\n]/.test(value) || byteLength(value) > MAX_ENV_VALUE_BYTES) {
+      throw new SandboxLayerValidationError(
+        path,
+        `ENV value for '${key}' must be 1-${MAX_ENV_VALUE_BYTES} bytes with no NUL or newline`,
+        startLine
+      );
+    }
+    if (SECRET_PATTERN.test(value)) {
+      throw new SandboxLayerValidationError(
+        path,
+        `ENV value for '${key}' appears to contain obvious secret material`,
+        startLine
+      );
+    }
+    values[key] = value;
+  }
+  if (Object.keys(values).length === 0) {
+    throw new SandboxLayerValidationError(path, "ENV must set at least one value", startLine);
+  }
+  return values;
+}
+function assertRunSafety(path, command, startLine) {
+  if (byteLength(command) > MAX_RUN_COMMAND_BYTES) {
+    throw new SandboxLayerValidationError(path, `RUN command exceeds ${MAX_RUN_COMMAND_BYTES} byte limit`, startLine);
+  }
+  if (/(^|\s)--mount=/.test(command)) {
+    throw new SandboxLayerValidationError(path, "BuildKit RUN --mount is not supported", startLine);
+  }
+  if (SECRET_PATTERN.test(command)) {
+    throw new SandboxLayerValidationError(path, "RUN command appears to contain obvious secret material", startLine);
+  }
+  const lower = command.toLowerCase();
+  const targetsForbiddenPath = FORBIDDEN_PATHS.some((forbidden) => lower.includes(forbidden.toLowerCase()));
+  if (targetsForbiddenPath && FORBIDDEN_TARGETING_OPS.test(lower)) {
+    throw new SandboxLayerValidationError(path, "RUN modifies an Arcanist-owned runtime path", startLine);
+  }
+}
+function parseSandboxLayerDockerfile(path, text) {
+  const instructions = splitLogicalInstructions(path, text);
+  return instructions.map((entry) => {
+    const match = entry.text.match(/^([A-Za-z]+)\s*(.*)$/s);
+    if (!match) {
+      throw new SandboxLayerValidationError(path, "invalid Dockerfile instruction", entry.startLine);
+    }
+    const instruction = match[1].toUpperCase();
+    const body = match[2].trim();
+    if (instruction === "RUN") {
+      if (!body) throw new SandboxLayerValidationError(path, "RUN must not be empty", entry.startLine);
+      assertRunSafety(path, body, entry.startLine);
+      return { kind: "run", command: body, startLine: entry.startLine, endLine: entry.endLine };
+    }
+    if (instruction === "ENV") {
+      return {
+        kind: "env",
+        values: parseEnvValues(path, body, entry.startLine),
+        startLine: entry.startLine,
+        endLine: entry.endLine
+      };
+    }
+    throw new SandboxLayerValidationError(
+      path,
+      `${instruction} is not supported in Arcanist sandbox layer files. V1 layers support only RUN and ENV.`,
+      entry.startLine
+    );
+  });
+}
+function normalizeSandboxLayerInstructions(instructions) {
+  return JSON.stringify(
+    instructions.map((instruction) => {
+      if (instruction.kind === "run") return { kind: "run", command: instruction.command };
+      return {
+        kind: "env",
+        values: Object.fromEntries(
+          Object.entries(instruction.values).sort(([left], [right]) => left.localeCompare(right))
+        )
+      };
+    })
+  );
+}
+function sortJsonValue(value) {
+  if (Array.isArray(value)) return value.map(sortJsonValue);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, sortJsonValue(entry)])
+  );
+}
+function canonicalSandboxLayerSourceJson(input) {
+  return JSON.stringify(
+    sortJsonValue({
+      schemaVersion: 1,
+      manifest: {
+        version: input.manifest.version,
+        name: input.manifest.name,
+        layerDockerfile: input.manifest.layer.dockerfile,
+        smokeCommands: input.manifest.smoke.commands
+      },
+      layer: JSON.parse(normalizeSandboxLayerInstructions(input.instructions)),
+      buildIdentity: input.buildIdentity ?? null
+    })
+  );
+}
+async function parseSandboxLayerSource(input) {
+  const manifest = parseSandboxLayerManifest(input.manifestPath, input.manifestText);
+  if (manifest.layer.dockerfile !== input.layerPath) {
+    throw new SandboxLayerValidationError(
+      input.manifestPath,
+      `layer.dockerfile must match fetched layer path '${input.layerPath}'`,
+      void 0,
+      "layer.dockerfile",
+      "layer_path_mismatch"
+    );
+  }
+  const instructions = parseSandboxLayerDockerfile(input.layerPath, input.layerText);
+  const canonicalSource = canonicalSandboxLayerSourceJson({
+    manifest,
+    instructions,
+    buildIdentity: input.buildIdentity
+  });
+  return {
+    manifest: {
+      version: manifest.version,
+      name: manifest.name,
+      layerDockerfile: manifest.layer.dockerfile,
+      smokeCommands: manifest.smoke.commands
+    },
+    layer: { instructions },
+    hashes: {
+      manifestHash: await computeSha256Hex(input.manifestText),
+      layerHash: await computeSha256Hex(input.layerText),
+      normalizedSourceHash: await computeSha256Hex(canonicalSource)
+    }
+  };
+}
+
+// src/commands/sandbox.ts
+var DEFAULT_MANIFEST_PATH = SANDBOX_LAYER_MANIFEST_PATH;
+var DEFAULT_POLL_INTERVAL_MS = 2500;
+var TERMINAL_BUILD_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "canceled"]);
+function git(args) {
+  try {
+    return execFileSync("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  } catch (err) {
+    throw new CliError("user", `git ${args.join(" ")} failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function currentRepo() {
+  const remote = git(["remote", "get-url", "origin"]);
+  const parsed = parseGithubRepoFullName(remote);
+  if (!parsed) throw new CliError("user", "origin remote must point at a GitHub repository");
+  return { owner: parsed.owner, repo: parsed.repo };
+}
+function currentRef() {
+  return git(["rev-parse", "--abbrev-ref", "HEAD"]);
+}
+function assertCleanAndPushed() {
+  const dirty = git(["status", "--porcelain"]);
+  if (dirty) throw new CliError("user", "Sandbox layer source must be committed before build.");
+  const upstream = git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]);
+  const ahead = git(["rev-list", "--count", `${upstream}..HEAD`]);
+  if (ahead !== "0")
+    throw new CliError("user", "Current commit is not pushed; push before building the sandbox layer.");
+}
+function assertManifestExists(path) {
+  if (!existsSync(path)) throw new CliError("user", `Missing sandbox manifest: ${path}`);
+}
+function parseRepoArg(value, fallback) {
+  if (!value) return fallback();
+  const parsed = parseGithubRepoFullName(value);
+  if (!parsed) throw new CliError("user", "repo must be owner/name or a GitHub URL");
+  return { owner: parsed.owner, repo: parsed.repo };
+}
+function repoPath(repo) {
+  return `${repo.owner}/${repo.repo}`;
+}
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+async function resolveBusinessId(config, options) {
+  if (options.business && options.business.trim()) return options.business.trim();
+  const whoami = await apiFetch(config, "/api/auth/whoami");
+  if (whoami.businessId && whoami.businessId.trim()) return whoami.businessId;
+  throw new CliError("user", "--business is required when the authenticated token has no business context.");
+}
+function parsePollInterval2(value) {
+  if (!value) return DEFAULT_POLL_INTERVAL_MS;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 250) {
+    throw new CliError("user", "--poll-interval must be an integer >= 250.");
+  }
+  return parsed;
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function printBuildRequest(buildRequest) {
+  console.log(
+    [
+      `Build ${buildRequest.id} is ${buildRequest.status}.`,
+      buildRequest.sourceRepo ? `source=${buildRequest.sourceRepo}` : null,
+      buildRequest.targetRepo ? `target=${buildRequest.targetRepo}` : null,
+      buildRequest.commitSha ? `commit=${buildRequest.commitSha}` : null,
+      buildRequest.resourceProfileKey ? `profile=${buildRequest.resourceProfileKey}` : null,
+      buildRequest.createdBy ? `builtBy=${buildActorLabel(buildRequest.createdBy)}` : null
+    ].filter(Boolean).join(" ")
+  );
+}
+function buildActorLabel(actor) {
+  if (!actor) return "unknown";
+  if (actor.login) return `@${actor.login}`;
+  if (actor.name) return actor.name;
+  return `User ${actor.userId}`;
+}
+function phaseLabel(phase) {
+  return phase === "provider_build" ? "provider build" : phase;
+}
+function printActiveTemplateStatus(buildRequest) {
+  if (buildRequest.status === "completed") {
+    const template = buildRequest.activeTemplateRef ?? buildRequest.providerArtifactRef;
+    console.log(template ? `Active template updated to ${template}.` : "Active: yes");
+    return;
+  }
+  if (buildRequest.activeTemplateRef) {
+    console.log("Active template unchanged; previous successful sandbox remains active.");
+  } else {
+    console.log("No previous active sandbox; sessions will use Arcanist default.");
+  }
+}
+function printTerminalBuildSummary(buildRequest) {
+  if (buildRequest.status === "completed") {
+    console.log("Sandbox build completed.");
+    if (buildRequest.sourceRepo) console.log(`Source: ${buildRequest.sourceRepo}`);
+    if (buildRequest.commitSha) console.log(`Commit: ${buildRequest.commitSha}`);
+    if (buildRequest.baseTemplateRef && buildRequest.baseVersion) {
+      console.log(`Built from: ${buildRequest.baseTemplateRef} @ ${buildRequest.baseVersion}`);
+    }
+    if (buildRequest.createdBy) console.log(`Built by: ${buildActorLabel(buildRequest.createdBy)}`);
+    const template = buildRequest.providerArtifactRef ?? buildRequest.activeTemplateRef;
+    if (template) console.log(`Template: ${template}`);
+    console.log("Smoke: passed");
+    console.log("Active: yes");
+    printActiveTemplateStatus(buildRequest);
+    return;
+  }
+  const failure = buildRequest.failureSummary;
+  const phase = failure ? phaseLabel(failure.phase) : buildRequest.status;
+  console.log(`Sandbox build failed during ${phase}.`);
+  if (buildRequest.createdBy) console.log(`Built by: ${buildActorLabel(buildRequest.createdBy)}`);
+  if (failure?.command) console.log(`Command: ${failure.command}`);
+  if (failure?.exitCode !== void 0) console.log(`Exit code: ${failure.exitCode}`);
+  console.log(`Reason: ${failure?.reason ?? `Build finished with status ${buildRequest.status}`}`);
+  if (failure?.stdoutPreview) console.log(`Stdout: ${failure.stdoutPreview}`);
+  if (failure?.stderrPreview) console.log(`Stderr: ${failure.stderrPreview}`);
+  printActiveTemplateStatus(buildRequest);
+}
+function printBuildHistory(builds) {
+  if (builds.length === 0) {
+    console.log("No sandbox builds found.");
+    return;
+  }
+  for (const build of builds) {
+    console.log(
+      [
+        `Build ${build.id} is ${build.status}.`,
+        `source=${build.sourceRepo}`,
+        `commit=${build.commitSha}`,
+        `profile=${build.resourceProfileKey}`,
+        build.templateId ? `template=${build.templateId}` : null,
+        `base=${build.baseTemplateRef}@${build.baseVersion}`,
+        `builtBy=${buildActorLabel(build.createdBy)}`
+      ].filter(Boolean).join(" ")
+    );
+  }
+}
+function selectionTierLabel(tier) {
+  if (tier === "repo_local") return "repo-local";
+  if (tier === "repo_assignment") return "assigned";
+  return "workspace default";
+}
+function printSandboxStatus(payload) {
+  if (payload.selection) {
+    console.log(`Using ${selectionTierLabel(payload.selection.tier)} sandbox.`);
+    console.log(`Template: ${payload.selection.templateId}`);
+    console.log(`Source: ${payload.selection.sourceRepo}`);
+    console.log(`Commit: ${payload.selection.commitSha}`);
+    console.log(`Profile: ${payload.selection.resourceProfileKey}`);
+    console.log(`Built from: ${payload.selection.baseTemplateRef} @ ${payload.selection.baseVersion}`);
+    console.log(`Base status: ${payload.selection.baseStatus}`);
+    console.log(`Built by: ${buildActorLabel(payload.selection.createdBy)}`);
+    return;
+  }
+  console.log("Using Arcanist default sandbox.");
+  if (payload.fallback?.templateId) console.log(`Template: ${payload.fallback.templateId}`);
+  if (payload.latestRepoBuild) {
+    console.log(`Latest custom build: ${payload.latestRepoBuild.status}`);
+    console.log(`Commit: ${payload.latestRepoBuild.commitSha}`);
+    console.log(`Profile: ${payload.latestRepoBuild.resourceProfileKey}`);
+    console.log(`Built from: ${payload.latestRepoBuild.baseTemplateRef} @ ${payload.latestRepoBuild.baseVersion}`);
+    console.log(`Built by: ${buildActorLabel(payload.latestRepoBuild.createdBy)}`);
+  }
+}
+function printLogs(logs) {
+  for (const log of logs) {
+    console.log(log.message);
+  }
+}
+function buildLogsPath(businessId, buildId, options = {}) {
+  const params = new URLSearchParams();
+  if (options.afterSequence != null) params.set("afterSequence", String(options.afterSequence));
+  if (options.limit != null) params.set("limit", String(options.limit));
+  const suffix = params.toString() ? `?${params.toString()}` : "";
+  return `/api/businesses/${encodePathSegment(businessId)}/sandbox-layer/build-requests/${encodePathSegment(
+    buildId
+  )}/logs${suffix}`;
+}
+async function waitForBuild(config, businessId, buildId, options) {
+  let afterSequence;
+  for (; ; ) {
+    if (options.follow) {
+      const logs = await apiFetch(config, buildLogsPath(businessId, buildId, { afterSequence }));
+      if (logs.logs.length > 0) {
+        if (options.json) writeJson({ ok: true, logs: logs.logs });
+        else printLogs(logs.logs);
+        afterSequence = logs.logs[logs.logs.length - 1].sequence;
+      }
+    }
+    const status = await apiFetch(
+      config,
+      `/api/businesses/${encodePathSegment(businessId)}/sandbox-layer/build-requests/${encodePathSegment(buildId)}`
+    );
+    if (TERMINAL_BUILD_STATUSES.has(status.buildRequest.status)) {
+      return status.buildRequest;
+    }
+    await sleep2(options.pollIntervalMs);
+  }
+}
+function formatValidationPayload(input) {
+  return {
+    ok: true,
+    manifestPath: input.manifestPath,
+    layerPath: input.layerPath,
+    normalizedSourceHash: input.parsed.hashes.normalizedSourceHash,
+    instructionCount: input.parsed.layer.instructions.length,
+    smokeCommandCount: input.parsed.manifest.smokeCommands.length,
+    diagnostics: []
+  };
+}
+function nextBuildCommand(manifestPath) {
+  try {
+    const repo = currentRepo();
+    const manifestArg = manifestPath === DEFAULT_MANIFEST_PATH ? "" : ` --manifest ${manifestPath}`;
+    return `arcanist sandbox build ${repoPath(repo)} --wait --follow${manifestArg}`;
+  } catch {
+    return "configure a GitHub origin, then run arcanist sandbox build <owner/repo> --wait --follow";
+  }
+}
+function handleValidationError(err, options, command) {
+  if (err instanceof SandboxLayerValidationError) {
+    const payload = { ok: false, diagnostics: err.issues };
+    if (isJson(command, options)) {
+      writeJson(payload);
+      process.exitCode = 1;
+      return;
+    }
+    throw new CliError(
+      "user",
+      err.issues.map((issue2) => `${issue2.path}${issue2.line ? `:${issue2.line}` : ""}: ${issue2.message}`).join("\n")
+    );
+  }
+  throw err;
+}
+function sourceBody(sourceRepo, manifestPath) {
+  return {
+    sourceRepoOwner: sourceRepo.owner,
+    sourceRepoName: sourceRepo.repo,
+    manifestPath
+  };
+}
+async function sandboxInitCommand(options = {}, command) {
+  const runtime = getRuntimeOptions(command, options);
+  if (existsSync(DEFAULT_MANIFEST_PATH)) throw new CliError("conflict", `${DEFAULT_MANIFEST_PATH} already exists`);
+  const layerPath = ".arcanist/sandbox.layer.Dockerfile";
+  if (existsSync(layerPath)) throw new CliError("conflict", `${layerPath} already exists`);
+  mkdirSync2(dirname(DEFAULT_MANIFEST_PATH), { recursive: true });
+  writeFileSync2(
+    DEFAULT_MANIFEST_PATH,
+    [
+      "version: 1",
+      "layer:",
+      "  dockerfile: .arcanist/sandbox.layer.Dockerfile",
+      "smoke:",
+      "  commands:",
+      '    - ["bash", "-lc", "command -v git && command -v python3"]',
+      ""
+    ].join("\n"),
+    "utf8"
+  );
+  writeFileSync2(
+    layerPath,
+    [
+      "# Only RUN and ENV instructions are supported.",
+      "# Example:",
+      "# RUN apt-get update && apt-get install -y --no-install-recommends ripgrep && rm -rf /var/lib/apt/lists/*",
+      ""
+    ].join("\n"),
+    "utf8"
+  );
+  const payload = { ok: true, manifestPath: DEFAULT_MANIFEST_PATH, layerPath };
+  if (isJson(command, runtime)) {
+    writeJson(payload);
+    return;
+  }
+  console.log(`Created ${DEFAULT_MANIFEST_PATH} and ${layerPath}`);
+}
+async function sandboxValidateCommand(options = {}, command) {
+  const manifestPath = options.manifest ?? DEFAULT_MANIFEST_PATH;
+  assertManifestExists(manifestPath);
+  const manifestText = readFileSync2(manifestPath, "utf8");
+  let layerPath;
+  try {
+    layerPath = parseSandboxLayerManifest(manifestPath, manifestText).layer.dockerfile;
+    assertManifestExists(layerPath);
+    const layerText = readFileSync2(layerPath, "utf8");
+    const parsed = await parseSandboxLayerSource({ manifestPath, manifestText, layerPath, layerText });
+    const payload = formatValidationPayload({ manifestPath, layerPath, parsed });
+    if (isJson(command, options)) {
+      writeJson(payload);
+      return;
+    }
+    console.log("Valid sandbox template.");
+    console.log(`Manifest: ${payload.manifestPath}`);
+    console.log(`Layer: ${payload.layerPath}`);
+    console.log(`Normalized source hash: ${payload.normalizedSourceHash}`);
+    console.log(`Instructions: ${payload.instructionCount}`);
+    console.log(`Smoke commands: ${payload.smokeCommandCount}`);
+    console.log(`Next: ${nextBuildCommand(manifestPath)}`);
+  } catch (err) {
+    handleValidationError(err, options, command);
+  }
+}
+async function sandboxBuildCommand(sourceRepoArg, options = {}, command) {
+  const runtime = getRuntimeOptions(command, options);
+  const config = requireConfig(runtime);
+  const manifestPath = options.manifest ?? DEFAULT_MANIFEST_PATH;
+  assertManifestExists(manifestPath);
+  if (!options.ref) assertCleanAndPushed();
+  const sourceRepo = parseRepoArg(sourceRepoArg, currentRepo);
+  const targetRepo = options.targetRepo ? parseRepoArg(options.targetRepo, currentRepo) : null;
+  const businessId = await resolveBusinessId(config, options);
+  const ref = options.ref ?? currentRef();
+  const payload = await apiFetch(
+    config,
+    `/api/businesses/${encodePathSegment(businessId)}/repos/${encodePathSegment(sourceRepo.owner)}/${encodePathSegment(
+      sourceRepo.repo
+    )}/sandbox-layer/build-requests`,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        ref,
+        manifestPath,
+        ...targetRepo ? { targetRepo: { owner: targetRepo.owner, name: targetRepo.repo } } : {}
+      })
+    }
+  );
+  if (isJson(command, options)) writeJson(payload);
+  else printBuildRequest(payload.buildRequest);
+  if (!options.wait && !options.follow) return;
+  const json = isJson(command, options);
+  const finalBuild = await waitForBuild(config, businessId, payload.buildRequest.id, {
+    follow: options.follow,
+    pollIntervalMs: parsePollInterval2(options.pollInterval),
+    json
+  });
+  if (json) writeJson({ ok: true, buildRequest: finalBuild });
+  else printTerminalBuildSummary(finalBuild);
+  if (finalBuild.status !== "completed") {
+    process.exitCode = 1;
+  }
+}
+async function sandboxStatusCommand(repoArg, options = {}, command) {
+  const runtime = getRuntimeOptions(command, options);
+  const config = requireConfig(runtime);
+  const businessId = await resolveBusinessId(config, options);
+  const repo = parseRepoArg(repoArg, currentRepo);
+  const payload = await apiFetch(
+    config,
+    `/api/businesses/${encodePathSegment(businessId)}/repos/${encodePathSegment(repo.owner)}/${encodePathSegment(
+      repo.repo
+    )}/sandbox-layer/resolution`
+  );
+  if (isJson(command, options)) {
+    writeJson(payload);
+    return;
+  }
+  printSandboxStatus(payload);
+}
+async function sandboxHistoryCommand(sourceRepoArg, options = {}, command) {
+  const runtime = getRuntimeOptions(command, options);
+  const config = requireConfig(runtime);
+  const businessId = await resolveBusinessId(config, options);
+  const sourceRepo = parseRepoArg(sourceRepoArg, currentRepo);
+  const params = new URLSearchParams({ sourceRepo: repoPath(sourceRepo) });
+  if (options.targetRepo) params.set("targetRepo", repoPath(parseRepoArg(options.targetRepo, currentRepo)));
+  if (options.status) params.set("status", options.status);
+  if (options.limit) {
+    const limit = Number(options.limit);
+    if (!Number.isInteger(limit) || limit < 1) {
+      throw new CliError("user", "--limit must be a positive integer.");
+    }
+    params.set("limit", String(limit));
+  }
+  const payload = await apiFetch(
+    config,
+    `/api/businesses/${encodePathSegment(businessId)}/sandbox-layer/build-requests?${params.toString()}`
+  );
+  if (isJson(command, options)) {
+    writeJson(payload);
+    return;
+  }
+  printBuildHistory(payload.builds);
+}
+async function sandboxRebuildStaleCommand(options = {}, command) {
+  const runtime = getRuntimeOptions(command, options);
+  const config = requireConfig(runtime);
+  if (!options.dryRun && !options.yes) {
+    throw new CliError("user", "Use --dry-run to preview or --yes to start a rebuild campaign.");
+  }
+  if (options.all && options.business) {
+    throw new CliError("user", "Use either --all or --business, not both.");
+  }
+  const businessId = options.all ? null : await resolveBusinessId(config, options);
+  let payload = await apiFetch(config, "/api/admin/sandbox-layer/rebuild-campaigns", {
+    method: "POST",
+    body: JSON.stringify({
+      scope: options.all ? "all" : "business",
+      ...businessId ? { businessId } : {},
+      reason: "base_update",
+      dryRun: Boolean(options.dryRun)
+    })
+  }).catch((error) => {
+    if (error instanceof CliError && /403|Forbidden/.test(error.message)) {
+      throw new CliError("auth", "Only Arcanist internal admins can rebuild stale sandbox layers.");
+    }
+    throw error;
+  });
+  if (options.follow && !options.dryRun) {
+    payload = await followRebuildCampaign(config, payload.campaign.id);
+  }
+  if (isJson(command, options)) {
+    writeJson(payload);
+    return;
+  }
+  printRebuildCampaign(payload);
+}
+async function followRebuildCampaign(config, campaignId) {
+  for (; ; ) {
+    const payload = await apiFetch(
+      config,
+      `/api/admin/sandbox-layer/rebuild-campaigns/${encodePathSegment(campaignId)}`
+    );
+    if (isCampaignTerminal(payload.campaign.status)) return payload;
+    await sleep2(DEFAULT_POLL_INTERVAL_MS);
+  }
+}
+function isCampaignTerminal(status) {
+  return status === "completed" || status === "completed_with_failures" || status === "failed";
+}
+function printRebuildCampaign(payload) {
+  console.log(`Campaign: ${payload.campaign.id}`);
+  console.log(`Status: ${payload.campaign.status}`);
+  console.log(`Active artifacts scanned: ${payload.campaign.summary.activeArtifactsScanned}`);
+  console.log(`Stale artifacts found: ${payload.campaign.summary.staleArtifactsFound}`);
+  console.log(`Current artifacts skipped: ${payload.campaign.summary.currentArtifactsSkipped}`);
+  console.log(`Missing installation skips: ${payload.campaign.summary.missingInstallationSkips}`);
+  console.log(`Source unavailable skips: ${payload.campaign.summary.sourceUnavailableSkips}`);
+  console.log(`Unversioned base skips: ${payload.campaign.summary.unversionedBaseSkips}`);
+  console.log(`Active changed skips: ${payload.campaign.summary.activeChangedSkips}`);
+  console.log(`Failed items: ${payload.campaign.summary.failedItems}`);
+  console.log(`Promoted items: ${payload.campaign.summary.promotedItems}`);
+  console.log(`Builds queued: ${payload.campaign.summary.buildsQueued}`);
+  if (payload.campaign.status === "completed_with_failures" || payload.campaign.status === "failed") {
+    console.log("Previous active templates remain active for failed or skipped rebuild items.");
+  }
+}
+async function sandboxLogsCommand(buildId, options = {}, command) {
+  const runtime = getRuntimeOptions(command, options);
+  const config = requireConfig(runtime);
+  const businessId = await resolveBusinessId(config, options);
+  let afterSequence = options.afterSequence == null ? void 0 : Number(options.afterSequence);
+  if (afterSequence != null && (!Number.isInteger(afterSequence) || afterSequence < 0)) {
+    throw new CliError("user", "--after-sequence must be a non-negative integer.");
+  }
+  const limit = options.limit == null ? void 0 : Number(options.limit);
+  if (limit != null && (!Number.isInteger(limit) || limit < 1)) {
+    throw new CliError("user", "--limit must be a positive integer.");
+  }
+  for (; ; ) {
+    const payload = await apiFetch(
+      config,
+      buildLogsPath(businessId, buildId, { afterSequence, limit })
+    );
+    if (isJson(command, options)) writeJson(payload);
+    else printLogs(payload.logs);
+    if (!options.follow) return;
+    if (payload.logs.length > 0) afterSequence = payload.logs[payload.logs.length - 1].sequence;
+    await sleep2(parsePollInterval2(options.pollInterval));
+  }
+}
+async function sandboxAssignDefaultCommand(sourceRepoArg, options = {}, command) {
+  const runtime = getRuntimeOptions(command, options);
+  const config = requireConfig(runtime);
+  const businessId = await resolveBusinessId(config, options);
+  const sourceRepo = parseRepoArg(sourceRepoArg, currentRepo);
+  const manifestPath = options.manifest ?? DEFAULT_MANIFEST_PATH;
+  const payload = await apiFetch(
+    config,
+    `/api/businesses/${encodePathSegment(businessId)}/sandbox-layer/default-source`,
+    { method: "PUT", body: JSON.stringify(sourceBody(sourceRepo, manifestPath)) }
+  );
+  if (isJson(command, options)) {
+    writeJson(payload);
+    return;
+  }
+  console.log(`Set default sandbox layer source to ${repoPath(sourceRepo)}.`);
+  console.log(
+    `Build missing target coverage with: arcanist sandbox build ${repoPath(sourceRepo)} --business ${businessId}`
+  );
+}
+async function sandboxAssignRepoCommand(targetRepoArg, sourceRepoArg, options = {}, command) {
+  const runtime = getRuntimeOptions(command, options);
+  const config = requireConfig(runtime);
+  const businessId = await resolveBusinessId(config, options);
+  const targetRepo = parseRepoArg(targetRepoArg, currentRepo);
+  const sourceRepo = parseRepoArg(sourceRepoArg, currentRepo);
+  const manifestPath = options.manifest ?? DEFAULT_MANIFEST_PATH;
+  const payload = await apiFetch(
+    config,
+    `/api/businesses/${encodePathSegment(businessId)}/repos/${encodePathSegment(targetRepo.owner)}/${encodePathSegment(
+      targetRepo.repo
+    )}/sandbox-layer/assignment`,
+    { method: "PUT", body: JSON.stringify(sourceBody(sourceRepo, manifestPath)) }
+  );
+  if (isJson(command, options)) {
+    writeJson(payload);
+    return;
+  }
+  console.log(`Assigned ${repoPath(sourceRepo)} as sandbox layer source for ${repoPath(targetRepo)}.`);
+  console.log(
+    `Build target coverage with: arcanist sandbox build ${repoPath(sourceRepo)} --target-repo ${repoPath(
+      targetRepo
+    )} --business ${businessId}`
+  );
+}
+async function sandboxUnassignDefaultCommand(options = {}, command) {
+  const runtime = getRuntimeOptions(command, options);
+  const config = requireConfig(runtime);
+  const businessId = await resolveBusinessId(config, options);
+  if (!options.yes) await confirmOrThrow("Clear the business default sandbox layer source?");
+  const payload = await apiFetch(
+    config,
+    `/api/businesses/${encodePathSegment(businessId)}/sandbox-layer/default-source`,
+    { method: "DELETE" }
+  );
+  if (isJson(command, options)) {
+    writeJson(payload);
+    return;
+  }
+  console.log("Cleared default sandbox layer source.");
+}
+async function sandboxUnassignRepoCommand(targetRepoArg, options = {}, command) {
+  const runtime = getRuntimeOptions(command, options);
+  const config = requireConfig(runtime);
+  const businessId = await resolveBusinessId(config, options);
+  const targetRepo = parseRepoArg(targetRepoArg, currentRepo);
+  if (!options.yes) await confirmOrThrow(`Clear sandbox layer assignment for ${repoPath(targetRepo)}?`);
+  const payload = await apiFetch(
+    config,
+    `/api/businesses/${encodePathSegment(businessId)}/repos/${encodePathSegment(targetRepo.owner)}/${encodePathSegment(
+      targetRepo.repo
+    )}/sandbox-layer/assignment`,
+    { method: "DELETE" }
+  );
+  if (isJson(command, options)) {
+    writeJson(payload);
+    return;
+  }
+  console.log(`Cleared sandbox layer assignment for ${repoPath(targetRepo)}.`);
+}
+
 // src/commands/sessions.ts
 async function listSessionsCommand(options, command) {
   const runtime = getRuntimeOptions(command, options);
@@ -2706,8 +3818,8 @@ function parseStopBlocked(err) {
 }
 
 // src/commands/test-creds.ts
-import { readFileSync as readFileSync2 } from "fs";
-function parseRepoArg(repo) {
+import { readFileSync as readFileSync3 } from "fs";
+function parseRepoArg2(repo) {
   const trimmed = repo.trim();
   const slashIndex = trimmed.indexOf("/");
   if (slashIndex <= 0 || slashIndex === trimmed.length - 1) {
@@ -2724,13 +3836,13 @@ function readValue(options) {
     throw new CliError("user", "Provide exactly one of --value, --value-file, or --value-stdin.");
   }
   if (options.value !== void 0) return options.value;
-  const raw = options.valueFile ? readFileSync2(options.valueFile, "utf8") : readFileSync2(0, "utf8");
+  const raw = options.valueFile ? readFileSync3(options.valueFile, "utf8") : readFileSync3(0, "utf8");
   return raw.replace(/\r?\n$/, "");
 }
 async function listTestCredentialsCommand(repo, options, command) {
   const runtime = getRuntimeOptions(command, options);
   const config = requireConfig(runtime);
-  const repoArg = parseRepoArg(repo);
+  const repoArg = parseRepoArg2(repo);
   const payload = await apiFetch(config, basePath(options.business, repoArg));
   if (isJson(command, options)) {
     writeJson(payload);
@@ -2748,7 +3860,7 @@ async function listTestCredentialsCommand(repo, options, command) {
 async function setTestCredentialCommand(repo, name, options, command) {
   const runtime = getRuntimeOptions(command, options);
   const config = requireConfig(runtime);
-  const repoArg = parseRepoArg(repo);
+  const repoArg = parseRepoArg2(repo);
   const value = readValue(options);
   const payload = await apiFetch(
     config,
@@ -2766,12 +3878,12 @@ async function deleteTestCredentialCommand(repo, name, options, command) {
     throw new CliError("user", "`test-creds delete --json` requires --yes.");
   }
   if (options.yes !== true) {
-    const repoArg2 = parseRepoArg(repo);
+    const repoArg2 = parseRepoArg2(repo);
     await confirmOrThrow(`Delete test credential '${name}' for ${repoArg2.owner}/${repoArg2.name}?`);
   }
   const runtime = getRuntimeOptions(command, options);
   const config = requireConfig(runtime);
-  const repoArg = parseRepoArg(repo);
+  const repoArg = parseRepoArg2(repo);
   const payload = await apiFetch(
     config,
     `${basePath(options.business, repoArg)}/${encodeURIComponent(name)}`,
@@ -3016,6 +4128,22 @@ Examples:
   arcanist sessions usage <session-id> --json
 `
 ).action((sessionId, options, command) => usageCommand(sessionId, options, command));
+var sandbox = program.command("sandbox").description("Sandbox layer commands");
+sandbox.command("init").description("Create sandbox layer source files").action((options, command) => sandboxInitCommand(options, command));
+sandbox.command("validate").description("Validate local sandbox layer source files").option("--manifest <path>", "Manifest path", ".arcanist/sandbox.yaml").action((options, command) => sandboxValidateCommand(options, command));
+sandbox.command("build").description("Build a repo-sourced sandbox layer").argument("[source-repo]", "Source repository owner/name; defaults to current git remote").option("--manifest <path>", "Manifest path", ".arcanist/sandbox.yaml").option("--ref <ref>", "Git ref to build").option("--target-repo <repo>", "Target repository owner/name for resource-profile coverage").option("--business <id>", "Business ID; defaults to authenticated user's business").option("--wait", "Wait for the build to finish").option("--follow", "Follow logs while waiting").option("--poll-interval <ms>", "Polling interval in milliseconds").action((sourceRepo, options, command) => sandboxBuildCommand(sourceRepo, options, command));
+sandbox.command("status").description("Show sandbox layer status").argument("[repo]", "Repository owner/name; defaults to current git remote").option("--business <id>", "Business ID; defaults to authenticated user's business").action((repo, options, command) => sandboxStatusCommand(repo, options, command));
+sandbox.command("history").description("Show sandbox layer build history").argument("[source-repo]", "Source repository owner/name; defaults to current git remote").option("--business <id>", "Business ID; defaults to authenticated user's business").option("--target-repo <repo>", "Target repository owner/name for resource-profile coverage").option("--status <status>", "Filter by build status").option("--limit <n>", "Maximum builds to return").action((sourceRepo, options, command) => sandboxHistoryCommand(sourceRepo, options, command));
+sandbox.command("logs").description("Print sandbox layer build logs").argument("<build-id>", "Build ID").option("--business <id>", "Business ID; defaults to authenticated user's business").option("--follow", "Follow logs").option("--after-sequence <n>", "Return logs after this sequence").option("--limit <n>", "Maximum log chunks to return").option("--poll-interval <ms>", "Polling interval in milliseconds").action((buildId, options, command) => sandboxLogsCommand(buildId, options, command));
+sandbox.command("rebuild-stale").description("Create stale sandbox template rebuild campaigns").option("--business <id>", "Business ID to scan; defaults to authenticated user's business").option("--all", "Scan all businesses").option("--dry-run", "Preview stale rebuilds without queueing provider builds").option("--yes", "Start a rebuild campaign").option("--follow", "Follow campaign progress").action((options, command) => sandboxRebuildStaleCommand(options, command));
+var sandboxAssign = sandbox.command("assign").description("Assign sandbox layer sources");
+sandboxAssign.command("default").description("Set the business default sandbox layer source").argument("<source-repo>", "Source repository owner/name").option("--manifest <path>", "Manifest path", ".arcanist/sandbox.yaml").option("--business <id>", "Business ID; defaults to authenticated user's business").action((sourceRepo, options, command) => sandboxAssignDefaultCommand(sourceRepo, options, command));
+sandboxAssign.command("repo").description("Assign a sandbox layer source to one target repo").argument("<target-repo>", "Target repository owner/name").argument("<source-repo>", "Source repository owner/name").option("--manifest <path>", "Manifest path", ".arcanist/sandbox.yaml").option("--business <id>", "Business ID; defaults to authenticated user's business").action(
+  (targetRepo, sourceRepo, options, command) => sandboxAssignRepoCommand(targetRepo, sourceRepo, options, command)
+);
+var sandboxUnassign = sandbox.command("unassign").description("Remove sandbox layer source assignments");
+sandboxUnassign.command("default").description("Clear the business default sandbox layer source").option("--business <id>", "Business ID; defaults to authenticated user's business").option("--yes", "Skip confirmation").action((options, command) => sandboxUnassignDefaultCommand(options, command));
+sandboxUnassign.command("repo").description("Clear a target repo sandbox layer assignment").argument("<target-repo>", "Target repository owner/name").option("--business <id>", "Business ID; defaults to authenticated user's business").option("--yes", "Skip confirmation").action((targetRepo, options, command) => sandboxUnassignRepoCommand(targetRepo, options, command));
 var tokens = program.command("tokens").description("CLI token commands");
 tokens.command("list").description("List CLI tokens").option("--limit <n>", "Maximum tokens to return").option("--cursor <cursor>", "Pagination cursor").action((options, command) => listTokensCommand(options, command));
 tokens.command("create").description("Create a CLI token and print it once").option("--scope <scope>", "Token scope: read or write", "read").option("--expires-in-days <days>", "Token expiry in days").addHelpText(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryarcanist/cli",
-  "version": "0.1.105",
+  "version": "0.1.106",
   "description": "CLI for Arcanist — create and manage coding agent sessions",
   "type": "module",
   "bin": {
@@ -28,7 +28,8 @@
   "homepage": "https://www.tryarcanist.com",
   "license": "MIT",
   "dependencies": {
-    "commander": "^12.1.0"
+    "commander": "^12.1.0",
+    "yaml": "^2.8.3"
   },
   "devDependencies": {
     "tsup": "^8.0.0",