@moxt-ai/cli 0.3.3-moxt-run.1 → 0.4.0-beta.0

package/dist/index.js

@@ -4,10 +4,203 @@
 import updateNotifier from "update-notifier";
 
 // src/program.ts
-import { Command } from "commander";
+import { Command as Command2 } from "commander";
+
+// src/utils/output.ts
+var colors = {
+  bold: "\x1B[1m",
+  blue: "\x1B[1;34m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  reset: "\x1B[0m"
+};
+function print(message) {
+  console.log(message);
+}
+function printError(message) {
+  console.error(`${colors.red}${message}${colors.reset}`);
+}
+
+// src/utils/runtime-context.ts
+var DEFAULT_USER_HOST = "api.moxt.ai";
+var SANDBOX_ENV_KEYS = [
+  "BASE_API_HOST",
+  "SANDBOX_TOOL_API_TOKEN",
+  "MOXT_REPO_PAYLOAD",
+  "MOXT_WORKSPACE_ID"
+];
+var RuntimeContextError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RuntimeContextError";
+  }
+};
+function resolveRuntimeContext(env = process.env) {
+  if (hasAnySandboxEnv(env)) {
+    return resolveSandboxRuntimeContext(env);
+  }
+  const apiKey = readNonEmptyEnv(env, "MOXT_API_KEY");
+  if (apiKey) {
+    return {
+      mode: "user",
+      host: readNonEmptyEnv(env, "MOXT_HOST") ?? DEFAULT_USER_HOST,
+      apiKey
+    };
+  }
+  throw new RuntimeContextError("Missing auth. Set sandbox environment variables or MOXT_API_KEY.");
+}
+function resolveSandboxRuntimeContext(env = process.env) {
+  const missingKeys = SANDBOX_ENV_KEYS.filter((key) => !readNonEmptyEnv(env, key));
+  if (missingKeys.length > 0) {
+    throw new RuntimeContextError(`Incomplete sandbox environment. Missing: ${missingKeys.join(", ")}.`);
+  }
+  return {
+    mode: "sandbox",
+    baseApiHost: normalizeBaseApiHost(readRequiredEnv(env, "BASE_API_HOST")),
+    sandboxToolApiToken: readRequiredEnv(env, "SANDBOX_TOOL_API_TOKEN"),
+    workspaceId: readRequiredEnv(env, "MOXT_WORKSPACE_ID"),
+    repoPayload: parseRepoPayload(readRequiredEnv(env, "MOXT_REPO_PAYLOAD"))
+  };
+}
+function parseRepoPayload(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new RuntimeContextError(`MOXT_REPO_PAYLOAD must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(parsed)) {
+    throw new RuntimeContextError("MOXT_REPO_PAYLOAD must be a JSON object.");
+  }
+  const personal = parseRepoEntry(parsed.personal, "personal");
+  const teamsValue = parsed.teams;
+  if (!Array.isArray(teamsValue)) {
+    throw new RuntimeContextError("MOXT_REPO_PAYLOAD.teams must be an array.");
+  }
+  const teams = teamsValue.map((entry, index) => parseRepoEntry(entry, `teams[${index}]`));
+  const workspace = parsed.workspace == null ? null : parseRepoEntry(parsed.workspace, "workspace");
+  return { personal, teams, workspace };
+}
+function normalizeBaseApiHost(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new RuntimeContextError("BASE_API_HOST must not be empty.");
+  }
+  return trimmed.replace(/\/+$/, "");
+}
+function hasAnySandboxEnv(env) {
+  return SANDBOX_ENV_KEYS.some((key) => readNonEmptyEnv(env, key) !== void 0);
+}
+function readRequiredEnv(env, key) {
+  const value = readNonEmptyEnv(env, key);
+  if (!value) {
+    throw new RuntimeContextError(`${key} is required.`);
+  }
+  return value;
+}
+function readNonEmptyEnv(env, key) {
+  const value = env[key];
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function parseRepoEntry(value, path2) {
+  if (!isRecord(value)) {
+    throw new RuntimeContextError(`MOXT_REPO_PAYLOAD.${path2} must be an object.`);
+  }
+  const repoId = readStringField(value, "repoId", path2);
+  const name = readStringField(value, "name", path2);
+  return { repoId, name };
+}
+function readStringField(record2, field, path2) {
+  const value = record2[field];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new RuntimeContextError(`MOXT_REPO_PAYLOAD.${path2}.${field} must be a non-empty string.`);
+  }
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/utils/sandbox-path.ts
+var WorkspacePathError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorkspacePathError";
+  }
+};
+function resolveWorkspacePath(repoPayload, workspacePath) {
+  const normalizedPath = normalizeWorkspacePath(workspacePath);
+  const [repoName, ...repoPathParts] = normalizedPath.split("/");
+  const repoEntries = listRepoEntries(repoPayload);
+  const repo = repoEntries.find((entry) => entry.name === repoName);
+  if (!repo) {
+    throw new WorkspacePathError(`Workspace path must start with one of: ${repoEntries.map((entry) => entry.name).join(", ")}.`);
+  }
+  return {
+    repoId: repo.repoId,
+    repoName: repo.name,
+    repoPath: repoPathParts.join("/")
+  };
+}
+function listRepoEntries(repoPayload) {
+  return [
+    repoPayload.personal,
+    ...repoPayload.teams,
+    ...repoPayload.workspace ? [repoPayload.workspace] : []
+  ];
+}
+function normalizeWorkspacePath(workspacePath) {
+  const trimmed = workspacePath.trim();
+  if (!trimmed) {
+    throw new WorkspacePathError("Workspace path must not be empty.");
+  }
+  if (trimmed.startsWith("/")) {
+    throw new WorkspacePathError("Workspace path must be relative.");
+  }
+  const parts = trimmed.split("/").filter((part) => part.length > 0 && part !== ".");
+  if (parts.length === 0) {
+    throw new WorkspacePathError("Workspace path must include a repo name.");
+  }
+  if (parts.some((part) => part === "..")) {
+    throw new WorkspacePathError('Workspace path must not contain "..".');
+  }
+  return parts.join("/");
+}
+
+// src/commands/auth.ts
+function registerAuthCommand(program2) {
+  const auth = program2.command("auth").description("Authentication utilities");
+  auth.command("status").description("Show CLI authentication mode").action(() => {
+    try {
+      const context = resolveRuntimeContext();
+      if (context.mode === "sandbox") {
+        print(`${colors.bold}Mode${colors.reset}: sandbox`);
+        print(`${colors.bold}Workspace${colors.reset}: ${context.workspaceId}`);
+        print(`${colors.bold}Base API${colors.reset}: ${context.baseApiHost}`);
+        print(`${colors.bold}Repos${colors.reset}:`);
+        for (const repo of listRepoEntries(context.repoPayload)) {
+          print(`  ${repo.name}	${repo.repoId}`);
+        }
+        return;
+      }
+      print(`${colors.bold}Mode${colors.reset}: user`);
+      print(`${colors.bold}Host${colors.reset}: ${context.host}`);
+    } catch (error) {
+      if (error instanceof RuntimeContextError) {
+        printError(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+}
 
 // src/commands/file.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
 
 // src/utils/file-selector.ts
 var SpaceOptionsError = class extends Error {
@@ -149,7 +342,7 @@ function getApiKeyOrUndefined() {
 
 // src/utils/http.ts
 function getUserAgent() {
-  return `moxt-cli/${"0.3.3-moxt-run.1"} (${platform()}/${arch()}) node/${process.versions.node}`;
+  return `moxt-cli/${"0.4.0-beta.0"} (${platform()}/${arch()}) node/${process.versions.node}`;
 }
 async function fetchApi(method, path2, body) {
   const apiKey = getApiKey();
@@ -202,23 +395,6 @@ async function httpRaw(method, path2, body) {
   };
 }
 
-// src/utils/output.ts
-var colors = {
-  bold: "\x1B[1m",
-  blue: "\x1B[1;34m",
-  green: "\x1B[32m",
-  red: "\x1B[31m",
-  cyan: "\x1B[36m",
-  dim: "\x1B[2m",
-  reset: "\x1B[0m"
-};
-function print(message) {
-  console.log(message);
-}
-function printError(message) {
-  console.error(`${colors.red}${message}${colors.reset}`);
-}
-
 // src/utils/search-options.ts
 var SearchOptionsError = class extends Error {
   constructor(message) {
@@ -272,6 +448,209 @@ function runOrExit(fn) {
   }
 }
 
+// src/utils/sandbox-client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var SandboxApiError = class extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`Sandbox API request failed with ${status}: ${body}`);
+    this.name = "SandboxApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var SandboxMoxtClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  async request(method, path2, body, options = {}) {
+    const signal = AbortSignal.timeout(options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const response = await fetch(`${this.context.baseApiHost}${path2}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.context.sandboxToolApiToken}`
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      signal
+    });
+    const contentType = response.headers.get("content-type");
+    const data = contentType?.includes("application/json") ? await response.json() : await response.text();
+    if (!response.ok) {
+      throw new SandboxApiError(response.status, typeof data === "string" ? data : JSON.stringify(data));
+    }
+    return {
+      status: response.status,
+      data
+    };
+  }
+};
+
+// src/utils/sandbox-file.ts
+import { createHash } from "crypto";
+var MFS_FILE_TYPE_REGULAR = 1;
+var MFS_FILE_SIZE_LIMIT_BYTES = 10 * 1024 * 1024;
+var MFS_FILE_SIZE_LIMIT_LABEL = `${MFS_FILE_SIZE_LIMIT_BYTES / (1024 * 1024)}MB`;
+var SandboxFileError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SandboxFileError";
+  }
+  code;
+};
+async function readSandboxFile(context, workspacePath) {
+  const resolved = resolveSandboxFilePath(context, workspacePath);
+  const tree = await fetchRepoTree(context, resolved);
+  const entry = findTreeEntry(tree, resolved);
+  if (!entry) {
+    throw new SandboxFileError(`${workspacePath} does not exist`, "not-found");
+  }
+  if (entry.type === "tree") {
+    throw new SandboxFileError(`${workspacePath} is a directory`, "directory");
+  }
+  if (!entry.sha) {
+    throw new SandboxFileError(`${workspacePath} does not have downloadable content`, "remote");
+  }
+  if (entry.size !== null && entry.size > MFS_FILE_SIZE_LIMIT_BYTES) {
+    throw new SandboxFileError(`File too large (max ${MFS_FILE_SIZE_LIMIT_LABEL}): ${workspacePath}`, "too-large");
+  }
+  const client = new SandboxMoxtClient(context);
+  const presign = await client.request(
+    "POST",
+    `/agent/api/pipeline-sandbox/mfs/${encodeURIComponent(resolved.repoId)}/presign-download`,
+    { hashes: [entry.sha] }
+  );
+  const url = presign.data.urls[entry.sha];
+  if (!url) {
+    throw new SandboxFileError(`No download URL returned for ${workspacePath}`, "remote");
+  }
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new SandboxFileError(`Download failed [${response.status}]`, "remote");
+  }
+  const content = await response.text();
+  const data = Buffer.from(content, "utf8");
+  if (data.length > MFS_FILE_SIZE_LIMIT_BYTES) {
+    throw new SandboxFileError(`File too large (max ${MFS_FILE_SIZE_LIMIT_LABEL}): ${workspacePath}`, "too-large");
+  }
+  const actualSha = createHash("sha256").update(data).digest("hex");
+  if (actualSha !== entry.sha) {
+    throw new SandboxFileError(`Downloaded content hash mismatch: ${workspacePath}`, "remote");
+  }
+  return {
+    path: workspacePath,
+    content,
+    sha: entry.sha,
+    size: data.length,
+    fileId: entry.fileId,
+    fileType: entry.fileType
+  };
+}
+async function writeSandboxFile(context, workspacePath, content, policy) {
+  const data = Buffer.from(content, "utf8");
+  if (data.length > MFS_FILE_SIZE_LIMIT_BYTES) {
+    throw new SandboxFileError(`File too large (max ${MFS_FILE_SIZE_LIMIT_LABEL}): ${workspacePath}`, "too-large");
+  }
+  const resolved = resolveSandboxFilePath(context, workspacePath);
+  const tree = await fetchRepoTree(context, resolved);
+  const existing = findTreeEntry(tree, resolved);
+  if (existing?.type === "tree") {
+    throw new SandboxFileError(`${workspacePath} is a directory`, "directory");
+  }
+  if (existing && !existing.sha) {
+    throw new SandboxFileError(`${workspacePath} does not have base content hash`, "remote");
+  }
+  const baseContentHash = resolveBaseContentHash(workspacePath, existing, policy);
+  const contentHash = createHash("sha256").update(data).digest("hex");
+  const client = new SandboxMoxtClient(context);
+  const presign = await client.request(
+    "POST",
+    `/agent/api/pipeline-sandbox/mfs/${encodeURIComponent(resolved.repoId)}/presign-upload`,
+    { hashes: [contentHash] }
+  );
+  const uploadUrl = presign.data.urls[contentHash];
+  if (!uploadUrl) {
+    throw new SandboxFileError(`No upload URL returned for ${workspacePath}`, "remote");
+  }
+  const upload = await fetch(uploadUrl, {
+    method: "PUT",
+    headers: { "Content-Type": "application/octet-stream" },
+    body: new Uint8Array(data)
+  });
+  if (!upload.ok) {
+    throw new SandboxFileError(`Upload failed [${upload.status}]`, "remote");
+  }
+  const action = existing ? "update" : "create";
+  await client.request(
+    "POST",
+    "/agent/api/pipeline-sandbox/mfs-workspace/unified-push",
+    {
+      message: `moxt file write ${workspacePath}`,
+      repoPushes: [
+        {
+          repoId: resolved.repoId,
+          changes: [
+            {
+              action,
+              ...existing?.fileId ? { fileId: existing.fileId } : {},
+              path: resolved.repoPath,
+              contentHash,
+              ...baseContentHash ? { baseContentHash } : {},
+              size: data.length,
+              fileType: MFS_FILE_TYPE_REGULAR
+            }
+          ]
+        }
+      ],
+      crossRepoMoves: []
+    }
+  );
+  return { path: workspacePath, created: !existing };
+}
+function resolveBaseContentHash(workspacePath, existing, policy) {
+  if (policy.type === "force") return void 0;
+  if (policy.type === "use-current-sha") return existing?.sha ?? void 0;
+  if (policy.type === "create-only") {
+    if (!existing) return void 0;
+    throw new SandboxFileError(
+      `Existing file requires --base-sha or --force: ${workspacePath} (actual ${existing.sha})`,
+      "conflict"
+    );
+  }
+  if (existing?.sha === policy.sha) return policy.sha;
+  throw new SandboxFileError(
+    `File version conflict: ${workspacePath} (expected ${policy.sha}, actual ${existing?.sha ?? "missing"})`,
+    "conflict"
+  );
+}
+function resolveSandboxFilePath(context, workspacePath) {
+  let resolved;
+  try {
+    resolved = resolveWorkspacePath(context.repoPayload, workspacePath);
+  } catch (error) {
+    throw new SandboxFileError(error instanceof Error ? error.message : String(error), "invalid-path");
+  }
+  if (!resolved.repoPath) {
+    throw new SandboxFileError(`${workspacePath} is a directory`, "directory");
+  }
+  return resolved;
+}
+async function fetchRepoTree(context, resolved) {
+  const client = new SandboxMoxtClient(context);
+  const params = new URLSearchParams({ entryFilter: "paths", path: resolved.repoPath });
+  const response = await client.request(
+    "GET",
+    `/agent/api/pipeline-sandbox/mfs/${encodeURIComponent(resolved.repoId)}/tree?${params.toString()}`
+  );
+  return response.data;
+}
+function findTreeEntry(tree, resolved) {
+  return tree.entries.find((entry) => entry.path === resolved.repoPath);
+}
+
 // src/utils/spinner.ts
 var frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var intervalId = null;
@@ -294,6 +673,23 @@ function stopSpinner(success, message) {
 `);
 }
 
+// src/utils/write-content.ts
+import * as fs from "fs";
+function readWriteCommandContentOrExit(options, readContentFile, readStdin = () => fs.readFileSync(0, "utf8")) {
+  const inputModes = [options.content !== void 0, options.contentFile !== void 0, options.stdin === true].filter(Boolean);
+  if (inputModes.length > 1) {
+    printError("Only one of --content, --content-file, or --stdin can be used");
+    process.exit(1);
+  }
+  if (options.content !== void 0) {
+    return options.content;
+  }
+  if (options.contentFile !== void 0) {
+    return readContentFile(options.contentFile);
+  }
+  return readStdin();
+}
+
 // src/commands/file.ts
 function addSpaceOptions(cmd) {
   return cmd.requiredOption("-w, --workspace <workspaceId>", "Workspace ID").option("-s, --space <name>", "Space name (personal or teamspace name)").option("--personal", "Use personal space (default)").option("--team-space-id <teamSpaceId>", "Team space ID").option("--teammate-id <teammateId>", "Teammate ID (teammate space)");
@@ -392,7 +788,39 @@ function registerFileCommand(program2) {
       }
     }
   });
-  file.command("read").description("Read file content").option("-w, --workspace <workspaceId>", "Workspace ID").option("-s, --space <name>", "Space name (personal or teamspace name)").option("--personal", "Use personal space (default)").option("--team-space-id <teamSpaceId>", "Team space ID").option("--teammate-id <teammateId>", "Teammate ID (teammate space)").option("-p, --path <path>", "File path").option("-u, --url <url>", "Moxt file URL (e.g., https://moxt.ai/w/{workspaceId}/{fileId})").action(async (options) => {
+  file.command("read").description("Read file content").argument("[workspacePath]", "Workspace path in sandbox mode, e.g. personal/docs/readme.md").option("-w, --workspace <workspaceId>", "Workspace ID").option("-s, --space <name>", "Space name (personal or teamspace name)").option("--personal", "Use personal space (default)").option("--team-space-id <teamSpaceId>", "Team space ID").option("--teammate-id <teammateId>", "Teammate ID (teammate space)").option("-p, --path <path>", "File path").option("-u, --url <url>", "Moxt file URL (e.g., https://moxt.ai/w/{workspaceId}/{fileId})").option("--json", "Print sandbox file content and metadata as JSON").action(async (workspacePath, options) => {
+    const sandboxRuntime = resolveSandboxRuntimeContextOrExit();
+    if (sandboxRuntime) {
+      if (options.url) {
+        printError("--url cannot be used in sandbox mode");
+        process.exit(1);
+      }
+      const path2 = workspacePath ?? options.path;
+      if (!path2) {
+        printError("Workspace path is required in sandbox mode");
+        process.exit(1);
+      }
+      if (!options.json) startSpinner("Reading file...");
+      try {
+        const result = await readSandboxFile(sandboxRuntime, path2);
+        if (options.json) {
+          print(JSON.stringify(result, null, 2));
+        } else {
+          stopSpinner(true, "Done");
+          print(result.content);
+        }
+      } catch (error) {
+        handleSandboxFileError(error, path2);
+      }
+      return;
+    }
+    if (options.json) {
+      printError("--json is only available for sandbox workspace paths");
+      process.exit(1);
+    }
+    if (workspacePath && !options.path) {
+      options.path = workspacePath;
+    }
     const mode = runOrExit(() => resolveReadMode(options));
     startSpinner("Reading file...");
     let response;
@@ -428,29 +856,37 @@ function registerFileCommand(program2) {
     stopSpinner(true, "Done");
     print(content ?? "");
   });
-  file.command("put").description("Upload a file").option("-w, --workspace <workspaceId>", "Workspace ID").option("-s, --space <name>", "Space name (personal or teamspace name)").option("--personal", "Use personal space (default)").option("--team-space-id <teamSpaceId>", "Team space ID").option("--teammate-id <teammateId>", "Teammate ID (teammate space)").option("-p, --path <path>", "Remote file path").option("-u, --url <url>", "Moxt file URL (e.g., https://moxt.ai/w/{workspaceId}/{fileId})").requiredOption("-l, --local-path <localPath>", "Local file path").option("-r, --recursive", "Create parent directories if needed").action(
-    async (options) => {
-      const mode = runOrExit(() => resolveWriteMode(options));
-      if (!fs.existsSync(options.localPath)) {
-        print(`${colors.red}\u2620 Local file not found: ${options.localPath}${colors.reset}`);
-        process.exit(1);
-      }
-      const stats = fs.statSync(options.localPath);
-      if (!stats.isFile()) {
-        print(`${colors.red}\u2620 Not a file: ${options.localPath}${colors.reset}`);
-        process.exit(1);
-      }
-      const maxSize = 10 * 1024 * 1024;
-      if (stats.size > maxSize) {
-        print(`${colors.red}\u2620 File too large (max 10MB): ${options.localPath}${colors.reset}`);
-        process.exit(1);
+  file.command("put").description("Upload a file").argument("[workspacePath]", "Workspace path in sandbox mode, e.g. personal/docs/readme.md").option("-w, --workspace <workspaceId>", "Workspace ID").option("-s, --space <name>", "Space name (personal or teamspace name)").option("--personal", "Use personal space (default)").option("--team-space-id <teamSpaceId>", "Team space ID").option("--teammate-id <teammateId>", "Teammate ID (teammate space)").option("-p, --path <path>", "Remote file path").option("-u, --url <url>", "Moxt file URL (e.g., https://moxt.ai/w/{workspaceId}/{fileId})").requiredOption("-l, --local-path <localPath>", "Local file path").option("-r, --recursive", "Create parent directories if needed").action(
+    async (workspacePath, options) => {
+      const sandboxRuntime = resolveSandboxRuntimeContextOrExit();
+      if (sandboxRuntime) {
+        if (options.url) {
+          printError("--url cannot be used in sandbox mode");
+          process.exit(1);
+        }
+        const path2 = workspacePath ?? options.path;
+        if (!path2) {
+          printError("Workspace path is required in sandbox mode");
+          process.exit(1);
+        }
+        const { content: content2 } = readLocalTextFileOrExit(options.localPath);
+        startSpinner("Uploading...");
+        try {
+          const response2 = await writeSandboxFile(sandboxRuntime, path2, content2, {
+            type: "use-current-sha"
+          });
+          const action2 = response2.created ? "Created" : "Updated";
+          stopSpinner(true, `${action2}: ${response2.path}`);
+        } catch (error) {
+          handleSandboxFileError(error, path2);
+        }
+        return;
       }
-      const buffer2 = fs.readFileSync(options.localPath);
-      if (isBinaryContent(buffer2)) {
-        print(`${colors.red}\u2620 Binary files are not allowed. Only text files can be uploaded.${colors.reset}`);
-        process.exit(1);
+      if (workspacePath && !options.path) {
+        options.path = workspacePath;
       }
-      const content = buffer2.toString("utf8");
+      const mode = runOrExit(() => resolveWriteMode(options));
+      const { content } = readLocalTextFileOrExit(options.localPath);
       startSpinner("Uploading...");
       let response;
       let displayPath;
@@ -492,6 +928,23 @@ function registerFileCommand(program2) {
       stopSpinner(true, `${action}: ${response.data.path}`);
     }
   );
+  file.command("write").description("Write file content in sandbox mode").argument("<workspacePath>", "Workspace path, e.g. personal/docs/readme.md").option("--content <content>", "Text content to write").option("--content-file <contentFile>", "Local text file to write").option("--stdin", "Read text content from stdin (default)").option("--base-sha <sha>", "Write only if the remote file still has this SHA").option("--force", "Overwrite an existing remote file without a version condition").action(async (workspacePath, options) => {
+    const runtime = resolveSandboxRuntimeContextOrExit();
+    if (!runtime) {
+      printError("file write is only available in sandbox mode");
+      process.exit(1);
+    }
+    const policy = resolveSandboxFileWritePolicyOrExit(options);
+    const content = readWriteCommandContentOrExit(options, (path2) => readLocalTextFileOrExit(path2).content);
+    startSpinner("Writing file...");
+    try {
+      const response = await writeSandboxFile(runtime, workspacePath, content, policy);
+      const action = response.created ? "Created" : "Updated";
+      stopSpinner(true, `${action}: ${response.path}`);
+    } catch (error) {
+      handleSandboxFileError(error, workspacePath);
+    }
+  });
   addSpaceOptions(
     file.command("mkdir").description("Create a directory").requiredOption("-p, --path <path>", "Directory path").option("-r, --recursive", "Create parent directories if needed")
   ).action(
@@ -549,6 +1002,82 @@ function registerFileCommand(program2) {
     }
   );
 }
+function resolveSandboxFileWritePolicyOrExit(options) {
+  if (options.baseSha && options.force) {
+    printError("Only one of --base-sha or --force can be used");
+    process.exit(1);
+  }
+  if (options.baseSha) {
+    if (!/^[a-f0-9]{64}$/.test(options.baseSha)) {
+      printError("--base-sha must be a lowercase SHA-256 hash");
+      process.exit(1);
+    }
+    return { type: "base-sha", sha: options.baseSha };
+  }
+  return options.force ? { type: "force" } : { type: "create-only" };
+}
+function resolveRuntimeContextOrExit() {
+  try {
+    return resolveRuntimeContext();
+  } catch (error) {
+    if (error instanceof RuntimeContextError) {
+      printError(error.message);
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+function resolveSandboxRuntimeContextOrExit() {
+  if (!SANDBOX_ENV_KEYS.some((key) => (process.env[key] ?? "").trim().length > 0)) {
+    return void 0;
+  }
+  const context = resolveRuntimeContextOrExit();
+  return context.mode === "sandbox" ? context : void 0;
+}
+function readLocalTextFileOrExit(localPath) {
+  if (!fs2.existsSync(localPath)) {
+    print(`${colors.red}\u2620 Local file not found: ${localPath}${colors.reset}`);
+    process.exit(1);
+  }
+  const stats = fs2.statSync(localPath);
+  if (!stats.isFile()) {
+    print(`${colors.red}\u2620 Not a file: ${localPath}${colors.reset}`);
+    process.exit(1);
+  }
+  if (stats.size > MFS_FILE_SIZE_LIMIT_BYTES) {
+    print(`${colors.red}\u2620 File too large (max ${MFS_FILE_SIZE_LIMIT_LABEL}): ${localPath}${colors.reset}`);
+    process.exit(1);
+  }
+  const buffer2 = fs2.readFileSync(localPath);
+  if (isBinaryContent(buffer2)) {
+    print(`${colors.red}\u2620 Binary files are not allowed. Only text files can be uploaded.${colors.reset}`);
+    process.exit(1);
+  }
+  return { content: buffer2.toString("utf8") };
+}
+function handleSandboxFileError(error, displayPath) {
+  stopSpinner(false, "Failed");
+  if (error instanceof SandboxFileError) {
+    if (error.code === "not-found") {
+      print(`${colors.red}\u2620 ${displayPath} does not exist${colors.reset}`);
+    } else if (error.code === "directory") {
+      print(`${colors.red}\u2620 ${displayPath} is a directory${colors.reset}`);
+    } else {
+      printError(error.message);
+    }
+    process.exit(1);
+  }
+  if (error instanceof SandboxApiError) {
+    printError(`Sandbox API error [${error.status}]: ${error.body}`);
+    process.exit(1);
+  }
+  if (error instanceof Error) {
+    printError(`Sandbox file operation failed: ${error.message}`);
+    process.exit(1);
+  }
+  printError(`Sandbox file operation failed: ${String(error)}`);
+  process.exit(1);
+}
 
 // src/commands/memory.ts
 function registerMemoryCommand(program2) {
@@ -744,2142 +1273,1343 @@ function registerMiniappCommand(program2) {
   });
 }
 
-// src/run/run-agent.ts
-import { spawn } from "child_process";
-import { closeSync as closeSync2, fstatSync, openSync as openSync2, readSync as readSync2 } from "fs";
-import { homedir as homedir2 } from "os";
+// src/commands/pull.ts
+import { isAbsolute as isAbsolute3 } from "path";
+import { Option } from "commander";
 
-// src/run/capture.ts
+// src/utils/sandbox-pull.ts
+import { createHash as createHash2 } from "crypto";
+import { lstat, mkdir as mkdir2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, relative, resolve } from "path";
+
+// src/utils/checkout-state.ts
 import { randomUUID } from "crypto";
-import { access, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
 import { homedir } from "os";
-import { join, posix, win32 } from "path";
-var DATA_FILE_TARGET_BYTES = 1024 * 1024;
-var RUNLOG_DIRECTORY_MARKER = ".runlog";
-var RUNLOG_DIRECTORY_MARKER_SCHEMA = "runlog.directory.v1";
-var RUNLOG_MANAGED_OUTPUT_NAMES = /* @__PURE__ */ new Set([
-  ".DS_Store",
-  RUNLOG_DIRECTORY_MARKER,
-  "events",
-  "events.jsonl",
-  "run.json",
-  "state.json",
-  "transcript",
-  "transcript.jsonl",
-  "upload.json"
-]);
-var RUNLOG_METADATA_SCHEMAS = {
-  "run.json": "runlog.capture.v1",
-  "state.json": "runlog.state.v1",
-  "upload.json": "runlog.upload.v1"
-};
-var RUNLOG_METADATA_FILE_NAMES = Object.keys(RUNLOG_METADATA_SCHEMAS);
-var CaptureOutputPrepareError = class extends Error {
-  path;
-  constructor(path2, cause) {
-    super(errorMessage(cause));
-    this.name = "CaptureOutputPrepareError";
-    this.path = path2;
-    this.cause = cause;
+import { dirname, isAbsolute, join, posix } from "path";
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+var CheckoutStateError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CheckoutStateError";
   }
 };
-function defaultCaptureOutputRoot(home = homedir(), env = process.env, nodePlatform = process.platform) {
-  const pathJoin = nodePlatform === "win32" ? win32.join : posix.join;
-  if (nodePlatform === "darwin") {
-    return pathJoin(home, "Library", "Application Support", "moxt", "runs");
-  }
-  if (nodePlatform === "win32") {
-    return pathJoin(env.LOCALAPPDATA ?? pathJoin(home, "AppData", "Local"), "Moxt", "runs");
-  }
-  return pathJoin(env.XDG_DATA_HOME ?? pathJoin(home, ".local", "share"), "moxt", "runs");
-}
-function withDefaultCaptureOutput(env, home = homedir()) {
-  const { outputDir, outputRoot } = captureEnvPaths(env);
-  if (hasValue(outputDir) || hasValue(outputRoot)) {
-    return env;
-  }
-  return {
-    ...env,
-    MOXT_RUN_OUTPUT_ROOT: defaultCaptureOutputRoot(home, env)
-  };
+function getCheckoutStatePath() {
+  return join(homedir(), ".moxt", "checkout-state.json");
 }
-async function prepareCaptureOutputs(env, runId) {
-  const { outputDir, outputRoot } = captureEnvPaths(env);
-  if (hasValue(outputDir)) {
-    await prepareOutputPath(outputDir, () => prepareCaptureDirectory(outputDir));
+async function loadCheckoutState(statePath = getCheckoutStatePath()) {
+  let raw;
+  try {
+    raw = await readFile(statePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    throw new CheckoutStateError(`Failed to read checkout state: ${errorMessage(error)}`);
   }
-  if (hasValue(outputRoot)) {
-    const runDir = join(outputRoot, runId);
-    await prepareOutputPath(runDir, () => prepareCaptureDirectory(runDir));
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new CheckoutStateError(`Checkout state is not valid JSON: ${statePath}`);
   }
+  return validateCheckoutState(value);
 }
-function captureOutputDirectories(env, runId) {
-  const { outputDir, outputRoot } = captureEnvPaths(env);
-  const dirs = /* @__PURE__ */ new Set();
-  if (hasValue(outputDir)) {
-    dirs.add(outputDir);
-  }
-  if (hasValue(outputRoot)) {
-    dirs.add(join(outputRoot, runId));
+async function saveCheckoutState(state, statePath = getCheckoutStatePath()) {
+  const validState = validateCheckoutState(state);
+  const stateDir = dirname(statePath);
+  const temporaryPath = `${statePath}.${process.pid}.${randomUUID()}.tmp`;
+  await mkdir(stateDir, { recursive: true });
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify(validState, null, 2)}
+`, { mode: 384 });
+    await rename(temporaryPath, statePath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true });
+    throw new CheckoutStateError(`Failed to save checkout state: ${errorMessage(error)}`);
   }
-  return [...dirs];
 }
-async function emitOpenCaptureDirectories(env, runId, capturedAt) {
-  await Promise.all(
-    captureOutputDirectories(env, runId).map(async (outputDir) => {
-      await writeCaptureUploadFile(outputDir, runId);
-      await writeCaptureStateFile(outputDir, runId, "open", capturedAt);
-    })
+function isCheckoutPathIncluded(state, workspacePath) {
+  if (state.mode === "full") return true;
+  return state.checkedOutScopes.some(
+    (scope) => workspacePath === scope || workspacePath.startsWith(`${scope}/`)
   );
 }
-async function finalizeCaptureDirectories(payload, env, runId, capturedAt, files) {
-  await Promise.all(
-    captureOutputDirectories(env, runId).map(async (outputDir) => {
-      await writeCaptureRunFile(outputDir, payload, runId, files);
-      await writeCaptureUploadFile(outputDir, runId);
-      await writeCaptureStateFile(outputDir, runId, "closed", capturedAt);
-    })
+function doesCheckoutPathIntersect(state, workspacePath) {
+  if (state.mode === "full") return true;
+  return state.checkedOutScopes.some(
+    (scope) => workspacePath === scope || workspacePath.startsWith(`${scope}/`) || scope.startsWith(`${workspacePath}/`)
   );
 }
-function createCaptureRunId(startedAt, agent) {
-  const timestamp = startedAt.replaceAll(/[^A-Za-z0-9]/g, "-");
-  const suffix = randomUUID().replaceAll("-", "").slice(0, 8);
-  return agent === void 0 ? `${timestamp}-${suffix}` : `${timestamp}-${agent}-${suffix}`;
-}
-async function writeCaptureDirectoryPayload(payload, env, runId, capturedAt) {
-  const hasTranscript = payload.transcript_redacted !== void 0;
-  const transcript = hasTranscript ? normalizeJsonl(payload.transcript_redacted ?? "") : "";
-  const transcriptChunks = hasTranscript ? chunkJsonl(transcript, "transcript", "transcript") : [];
-  const eventChunks = hasTranscript ? chunkJsonl(serializeEventsFromTranscript(transcript, 1, payload.run.agent).text, "events", "events") : [];
-  await Promise.all(
-    captureOutputDirectories(env, runId).map(async (outputDir) => {
-      await prepareCaptureDirectory(outputDir);
-      if (hasTranscript) {
-        await writeChunks(outputDir, eventChunks);
-        await writeChunks(outputDir, transcriptChunks);
-      }
-      await writeCaptureRunFile(outputDir, payload, runId, {
-        events: eventChunks.map(withoutContent),
-        transcript: transcriptChunks.map(withoutContent)
-      });
-      await writeCaptureUploadFile(outputDir, runId);
-      await writeCaptureStateFile(outputDir, runId, "closed", capturedAt);
-    })
+function validateCheckoutState(value) {
+  const state = requireRecord(value, "Checkout state");
+  if (state.version !== 1) {
+    throw new CheckoutStateError(`Unsupported checkout state version: ${String(state.version)}`);
+  }
+  const workspaceId = requireNonEmptyString(state.workspaceId, "workspaceId");
+  const checkoutRoot = requireNonEmptyString(state.checkoutRoot, "checkoutRoot");
+  if (!isAbsolute(checkoutRoot)) throw new CheckoutStateError("checkoutRoot must be an absolute path");
+  if (state.mode !== "partial" && state.mode !== "full") {
+    throw new CheckoutStateError("mode must be partial or full");
+  }
+  if (!Array.isArray(state.checkedOutScopes)) {
+    throw new CheckoutStateError("checkedOutScopes must be an array");
+  }
+  const checkedOutScopes = state.checkedOutScopes.map(
+    (scope, index) => requireWorkspacePath(scope, `checkedOutScopes[${index}]`)
   );
-}
-function serializeEventsFromTranscript(transcript, startSeq, agent = "claude") {
-  const events = normalizeEvents(transcript, startSeq, agent);
+  if (new Set(checkedOutScopes).size !== checkedOutScopes.length) {
+    throw new CheckoutStateError("checkedOutScopes must not contain duplicates");
+  }
+  const reposValue = requireRecord(state.repos, "repos");
+  const repos = {};
+  for (const [repoId, rawRepo] of Object.entries(reposValue)) {
+    requireNonEmptyString(repoId, "repo id");
+    const repo = requireRecord(rawRepo, `repos.${repoId}`);
+    const name = requireRepoName(repo.name, `repos.${repoId}.name`);
+    repos[repoId] = {
+      name,
+      treeSha: requireNonEmptyString(repo.treeSha, `repos.${repoId}.treeSha`)
+    };
+  }
+  const filesValue = requireRecord(state.files, "files");
+  const files = {};
+  for (const [workspacePath, rawFile] of Object.entries(filesValue)) {
+    requireWorkspacePath(workspacePath, `files.${workspacePath}`);
+    const file = requireRecord(rawFile, `files.${workspacePath}`);
+    const repoId = requireNonEmptyString(file.repoId, `files.${workspacePath}.repoId`);
+    const repo = repos[repoId];
+    if (!repo) throw new CheckoutStateError(`File references unknown repo: ${workspacePath}`);
+    const repoPath = requireWorkspacePath(file.repoPath, `files.${workspacePath}.repoPath`);
+    if (workspacePath !== `${repo.name}/${repoPath}`) {
+      throw new CheckoutStateError(`File path does not match its repo: ${workspacePath}`);
+    }
+    const fileId = file.fileId === null ? null : requireNonEmptyString(file.fileId, `files.${workspacePath}.fileId`);
+    const sha = requireNonEmptyString(file.sha, `files.${workspacePath}.sha`);
+    if (!/^[a-f0-9]{64}$/.test(sha)) throw new CheckoutStateError(`Invalid file SHA: ${workspacePath}`);
+    files[workspacePath] = {
+      repoId,
+      repoPath,
+      fileId,
+      sha,
+      size: requireNonNegativeInteger(file.size, `files.${workspacePath}.size`),
+      fileType: requireNonNegativeInteger(file.fileType, `files.${workspacePath}.fileType`)
+    };
+  }
   return {
-    text: serializeEvents(events),
-    nextSeq: startSeq + events.length
+    version: 1,
+    workspaceId,
+    checkoutRoot,
+    mode: state.mode,
+    checkedOutScopes,
+    repos,
+    files
   };
 }
-function normalizeJsonl(text) {
-  if (text === "") {
-    return "";
-  }
-  return text.endsWith("\n") ? text : `${text}
-`;
-}
-async function prepareCaptureDirectory(outputDir) {
-  await mkdir(outputDir, { recursive: true });
-  await assertMoxtManagedOutputDir(outputDir);
-  await Promise.all([
-    rm(join(outputDir, RUNLOG_DIRECTORY_MARKER), { force: true }),
-    rm(join(outputDir, "run.json"), { force: true }),
-    rm(join(outputDir, "state.json"), { force: true }),
-    rm(join(outputDir, "upload.json"), { force: true }),
-    rm(join(outputDir, "events.jsonl"), { force: true }),
-    rm(join(outputDir, "transcript.jsonl"), { force: true }),
-    rm(join(outputDir, "events"), { recursive: true, force: true }),
-    rm(join(outputDir, "transcript"), { recursive: true, force: true })
-  ]);
-  await writeRunlogDirectoryMarker(outputDir);
-  await mkdir(join(outputDir, "events"), { recursive: true });
-  await mkdir(join(outputDir, "transcript"), { recursive: true });
-}
-async function assertMoxtManagedOutputDir(outputDir) {
-  const entries = await readdir(outputDir);
-  const unmanaged = entries.filter((entry) => !RUNLOG_MANAGED_OUTPUT_NAMES.has(entry));
-  if (unmanaged.length > 0) {
-    throw new Error(`refusing to use run output directory with unmanaged files: ${unmanaged.slice(0, 5).join(", ")}`);
-  }
-  const meaningfulEntries = entries.filter((entry) => entry !== ".DS_Store");
-  if (meaningfulEntries.length === 0) {
-    return;
+function requireRecord(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new CheckoutStateError(`${field} must be an object`);
   }
-  if (!entries.includes(RUNLOG_DIRECTORY_MARKER)) {
-    throw new Error("refusing to use run output directory without ownership marker");
+  return value;
+}
+function requireNonEmptyString(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new CheckoutStateError(`${field} must be a non-empty string`);
   }
-  await assertRunlogDirectoryMarker(outputDir);
-  const metadataEntries = RUNLOG_METADATA_FILE_NAMES.filter((entry) => entries.includes(entry));
-  if (metadataEntries.length === 0) {
-    return;
+  return value;
+}
+function requireWorkspacePath(value, field) {
+  const path2 = requireNonEmptyString(value, field);
+  if (path2.includes("\\") || path2.includes("\0") || posix.isAbsolute(path2) || posix.normalize(path2) !== path2) {
+    throw new CheckoutStateError(`${field} must be a normalized relative path`);
   }
-  const runIds = await Promise.all(
-    metadataEntries.map((entry) => readRunlogMetadataRunId(outputDir, entry))
-  );
-  const uniqueRunIds = new Set(runIds);
-  if (uniqueRunIds.size > 1) {
-    throw new Error("refusing to use run output directory with mismatched run metadata");
+  return path2;
+}
+function requireRepoName(value, field) {
+  const name = requireWorkspacePath(value, field);
+  if (name.includes("/")) throw new CheckoutStateError(`${field} must be a single path segment`);
+  return name;
+}
+function requireNonNegativeInteger(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new CheckoutStateError(`${field} must be a non-negative integer`);
   }
+  return value;
 }
-async function readRunlogMetadataRunId(outputDir, fileName) {
-  let parsed;
-  try {
-    parsed = JSON.parse(await readFile(join(outputDir, fileName), "utf8"));
-  } catch (error) {
-    throw new Error(`invalid ${fileName}: ${errorMessage(error)}`);
-  }
-  const value = objectValue(parsed);
-  if (value === null) {
-    throw new Error(`invalid ${fileName}: expected object`);
-  }
-  if (value.schema_version !== RUNLOG_METADATA_SCHEMAS[fileName]) {
-    throw new Error(`invalid ${fileName}: unexpected schema_version`);
-  }
-  if (typeof value.run_id !== "string" || value.run_id.trim() === "") {
-    throw new Error(`invalid ${fileName}: missing run_id`);
-  }
-  return value.run_id;
-}
-async function assertRunlogDirectoryMarker(outputDir) {
-  let parsed;
-  try {
-    parsed = JSON.parse(await readFile(join(outputDir, RUNLOG_DIRECTORY_MARKER), "utf8"));
-  } catch (error) {
-    throw new Error(`invalid ${RUNLOG_DIRECTORY_MARKER}: ${errorMessage(error)}`);
-  }
-  const value = objectValue(parsed);
-  if (value?.schema_version !== RUNLOG_DIRECTORY_MARKER_SCHEMA) {
-    throw new Error(`invalid ${RUNLOG_DIRECTORY_MARKER}: unexpected schema_version`);
-  }
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
 }
-async function prepareOutputPath(path2, prepare = async () => {
-  await mkdir(path2, { recursive: true });
-}) {
-  try {
-    await prepare();
-  } catch (error) {
-    throw new CaptureOutputPrepareError(path2, error);
-  }
-}
-async function writeCaptureRunFile(outputDir, payload, runId, files) {
-  const runFile = {
-    schema_version: "runlog.capture.v1",
-    run_id: runId,
-    run: payload.run,
-    recording: payload.recording,
-    repo: payload.repo,
-    ...payload.redaction_failed ? { redaction_failed: true } : {},
-    files: {
-      state: "state.json",
-      upload: "upload.json",
-      events: files.events,
-      transcript: files.transcript
-    }
-  };
-  await writeFile(join(outputDir, "run.json"), `${JSON.stringify(runFile, null, 2)}
-`, "utf8");
-}
-async function writeRunlogDirectoryMarker(outputDir) {
-  await writeFile(
-    join(outputDir, RUNLOG_DIRECTORY_MARKER),
-    `${JSON.stringify({ schema_version: RUNLOG_DIRECTORY_MARKER_SCHEMA }, null, 2)}
-`,
-    "utf8"
-  );
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
 }
-async function writeCaptureUploadFile(outputDir, runId) {
-  const path2 = join(outputDir, "upload.json");
-  try {
-    await access(path2);
-    return;
-  } catch {
+
+// src/utils/sandbox-pull.ts
+var SandboxPullError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SandboxPullError";
   }
-  const uploadFile2 = {
-    schema_version: "runlog.upload.v1",
-    run_id: runId,
-    status: "pending",
-    files: {}
-  };
-  await writeFile(path2, `${JSON.stringify(uploadFile2, null, 2)}
-`, "utf8");
-}
-async function writeCaptureStateFile(outputDir, runId, status, capturedAt) {
-  const stateFile = {
-    schema_version: "runlog.state.v1",
-    run_id: runId,
-    status,
-    updated_at: capturedAt
-  };
-  await writeFile(join(outputDir, "state.json"), `${JSON.stringify(stateFile, null, 2)}
-`, "utf8");
-}
-async function writeChunks(outputDir, chunks) {
-  await Promise.all(chunks.map((chunk) => writeFile(join(outputDir, chunk.path), chunk.content, "utf8")));
-}
-function withoutContent(chunk) {
-  return {
-    path: chunk.path,
-    bytes: chunk.bytes,
-    lines: chunk.lines,
-    oversized_line: chunk.oversized_line
-  };
-}
-function captureEnvPaths(env) {
-  const { MOXT_RUN_OUTPUT_DIR: outputDir, MOXT_RUN_OUTPUT_ROOT: outputRoot } = env;
-  return { outputDir, outputRoot };
-}
-function chunkJsonl(text, dir, prefix) {
-  if (text === "") {
-    return [];
-  }
-  const chunks = [];
-  let content = "";
-  let bytes = 0;
-  let lines = 0;
-  let oversizedLine = false;
-  const flush2 = () => {
-    if (content === "") {
-      return;
+  code;
+};
+async function pullSandboxWorkspace(context, targetDir, options = {}) {
+  const resolvedTargetDir = resolve(targetDir);
+  const repos = listRepoEntries(context.repoPayload);
+  const previousState = await loadCheckoutState();
+  const compatibleState = resolveCompatibleState(previousState, context, resolvedTargetDir, repos);
+  const previousFiles = compatibleState?.files ?? {};
+  const selection = resolvePullSelection(context, options.scopes);
+  const repoById = new Map(selection.repos.map((repo) => [repo.repoId, repo]));
+  const tree = await fetchWorkspaceTree(context, selection);
+  const stateRepos = resolveStateRepos(tree, selection.repos);
+  const entries = [...tree.entries].sort((a, b) => a.prefixedPath.localeCompare(b.prefixedPath));
+  const directoryPaths = selection.repos.map((repo) => ({
+    workspacePath: repo.name,
+    localPath: resolveSafeLocalPath(resolvedTargetDir, repo.name, "")
+  }));
+  const blobEntries = [];
+  const remoteBlobPaths = /* @__PURE__ */ new Set();
+  const remotePaths = /* @__PURE__ */ new Set();
+  const matchedScopes = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const repo = repoById.get(entry.repoId);
+    if (!repo) {
+      throw new SandboxPullError(`Remote tree returned unknown repo: ${entry.repoId}`, "remote");
     }
-    const index = String(chunks.length + 1).padStart(6, "0");
-    chunks.push({
-      path: `${dir}/${prefix}-${index}.jsonl`,
-      content,
-      bytes,
-      lines,
-      oversized_line: oversizedLine
-    });
-    content = "";
-    bytes = 0;
-    lines = 0;
-    oversizedLine = false;
-  };
-  for (const line of jsonlLines(text)) {
-    const lineBytes = Buffer.byteLength(line);
-    if (lineBytes > DATA_FILE_TARGET_BYTES) {
-      flush2();
-      content = line;
-      bytes = lineBytes;
-      lines = 1;
-      oversizedLine = true;
-      flush2();
-      continue;
+    const expectedWorkspacePath = entry.path ? `${repo.name}/${entry.path}` : repo.name;
+    if (entry.prefixedPath !== expectedWorkspacePath) {
+      throw new SandboxPullError(`Remote tree returned inconsistent path: ${entry.prefixedPath}`, "remote");
     }
-    if (bytes > 0 && bytes + lineBytes > DATA_FILE_TARGET_BYTES) {
-      flush2();
+    if (remotePaths.has(expectedWorkspacePath)) {
+      throw new SandboxPullError(`Remote tree returned duplicate path: ${expectedWorkspacePath}`, "remote");
     }
-    content += line;
-    bytes += lineBytes;
-    lines += 1;
-  }
-  flush2();
-  return chunks;
-}
-function jsonlLines(text) {
-  const normalized = normalizeJsonl(text);
-  if (normalized === "") {
-    return [];
-  }
-  return normalized.slice(0, -1).split("\n").map((line) => `${line}
-`);
-}
-function serializeEvents(events) {
-  if (events.length === 0) {
-    return "";
-  }
-  return `${events.map((event) => JSON.stringify(event)).join("\n")}
-`;
-}
-function normalizeEvents(transcript, startSeq, agent) {
-  const events = [];
-  for (const line of transcript.split("\n")) {
-    if (line.trim() === "") {
+    remotePaths.add(expectedWorkspacePath);
+    const localPath = resolveSafeLocalPath(resolvedTargetDir, repo.name, entry.path);
+    for (const scope of selection.scopes) {
+      if (pathIsIncluded(scope, expectedWorkspacePath)) matchedScopes.add(scope);
+    }
+    if (!selection.scopes.some((scope) => pathsIntersect(scope, expectedWorkspacePath))) continue;
+    if (entry.type === "tree") {
+      directoryPaths.push({ workspacePath: entry.prefixedPath, localPath });
       continue;
     }
-    const raw = parseTranscriptLine(line);
-    const event = agent === "codex" ? normalizeCodexEvent(raw, startSeq + events.length) : normalizeClaudeEvent(raw, startSeq + events.length);
-    if (event !== null) {
-      events.push(event);
+    if (!entry.sha) {
+      throw new SandboxPullError(`${entry.prefixedPath} does not have downloadable content`, "remote");
     }
-  }
-  return events;
-}
-function normalizeClaudeEvent(raw, seq) {
-  if (raw === null) {
-    return null;
-  }
-  const timestamp = stringValue(raw.timestamp);
-  if (raw.type === "user") {
-    const message = messageValue(raw.message);
-    const text = textFromContent(message?.content);
-    if (text === "") {
-      return null;
+    if (entry.fileId !== null && (typeof entry.fileId !== "string" || entry.fileId.length === 0)) {
+      throw new SandboxPullError(`${entry.prefixedPath} has invalid file metadata`, "remote");
     }
-    return {
-      schema_version: "runlog.events.v1",
-      seq,
-      type: "user_message",
-      ...timestamp === void 0 ? {} : { timestamp },
-      text
-    };
-  }
-  if (raw.type === "assistant") {
-    const message = messageValue(raw.message);
-    const text = textFromContent(message?.content);
-    if (text === "") {
-      return null;
+    if (entry.fileType !== null && (!Number.isInteger(entry.fileType) || entry.fileType < 0)) {
+      throw new SandboxPullError(`${entry.prefixedPath} has invalid file metadata`, "remote");
     }
-    const usage = usageValue(message?.usage);
-    const model = stringValue(message?.model);
-    const inputTokens = numberValue(usage?.input_tokens);
-    const outputTokens = numberValue(usage?.output_tokens);
-    return {
-      schema_version: "runlog.events.v1",
-      seq,
-      type: "assistant_message",
-      ...timestamp === void 0 ? {} : { timestamp },
-      ...model === void 0 ? {} : { model },
-      text,
-      ...inputTokens === void 0 ? {} : { input_tokens: inputTokens },
-      ...outputTokens === void 0 ? {} : { output_tokens: outputTokens }
-    };
-  }
-  if (raw.type === "system" && raw.subtype === "turn_duration") {
-    const durationMs = numberValue(raw.durationMs);
-    const messageCount = numberValue(raw.messageCount);
-    return {
-      schema_version: "runlog.events.v1",
-      seq,
-      type: "turn_summary",
-      ...timestamp === void 0 ? {} : { timestamp },
-      ...durationMs === void 0 ? {} : { duration_ms: durationMs },
-      ...messageCount === void 0 ? {} : { message_count: messageCount }
-    };
-  }
-  return null;
-}
-function normalizeCodexEvent(raw, seq) {
-  if (raw === null || raw.type !== "event_msg") {
-    return null;
-  }
-  const timestamp = stringValue(raw.timestamp);
-  const payload = codexPayloadValue(raw.payload);
-  const payloadType = stringValue(payload?.type);
-  if (payloadType === "user_message") {
-    const text = stringValue(payload?.message) ?? "";
-    if (text === "") {
-      return null;
+    if (entry.size !== null && (!Number.isInteger(entry.size) || entry.size < 0)) {
+      throw new SandboxPullError(`${entry.prefixedPath} has invalid file metadata`, "remote");
     }
-    return {
-      schema_version: "runlog.events.v1",
-      seq,
-      type: "user_message",
-      ...timestamp === void 0 ? {} : { timestamp },
-      text
-    };
-  }
-  if (payloadType === "agent_message") {
-    const text = stringValue(payload?.message) ?? "";
-    if (text === "") {
-      return null;
+    if (entry.size !== null && entry.size > MFS_FILE_SIZE_LIMIT_BYTES) {
+      throw new SandboxPullError(`File too large (max ${MFS_FILE_SIZE_LIMIT_LABEL}): ${entry.prefixedPath}`, "too-large");
     }
-    return {
-      schema_version: "runlog.events.v1",
-      seq,
-      type: "assistant_message",
-      ...timestamp === void 0 ? {} : { timestamp },
-      text
-    };
+    remoteBlobPaths.add(entry.prefixedPath);
+    blobEntries.push({ entry, localPath });
   }
-  if (payloadType === "task_complete") {
-    const durationMs = numberValue(payload?.duration_ms);
-    return {
-      schema_version: "runlog.events.v1",
-      seq,
-      type: "turn_summary",
-      ...timestamp === void 0 ? {} : { timestamp },
-      ...durationMs === void 0 ? {} : { duration_ms: durationMs }
-    };
+  if (selection.mode === "partial") {
+    for (const scope of selection.scopes) {
+      const repoRoot = selection.repos.some((repo) => repo.name === scope);
+      const previouslyTracked = Object.keys(previousFiles).some((workspacePath) => pathIsIncluded(scope, workspacePath));
+      if (!repoRoot && !matchedScopes.has(scope) && !previouslyTracked) {
+        throw new SandboxPullError(`Workspace path does not exist: ${scope}`, "invalid-path");
+      }
+    }
   }
-  return null;
-}
-function parseTranscriptLine(line) {
-  try {
-    const value = JSON.parse(line);
-    return isObject(value) ? value : null;
-  } catch {
-    return null;
+  const plannedBlobs = [];
+  for (const { entry, localPath } of blobEntries) {
+    plannedBlobs.push({
+      entry,
+      localPath,
+      shouldWrite: await shouldWritePulledFile(
+        localPath,
+        requireBlobSha(entry),
+        entry.prefixedPath,
+        previousFiles[entry.prefixedPath],
+        Boolean(options.force)
+      )
+    });
   }
-}
-function textFromContent(content) {
-  if (typeof content === "string") {
-    return content;
+  const plannedDeletions = await planRemoteDeletions(
+    compatibleState,
+    selection,
+    resolvedTargetDir,
+    remoteBlobPaths,
+    Boolean(options.force)
+  );
+  for (const directory of directoryPaths) {
+    await assertCanCreateDirectory(directory.localPath, directory.workspacePath);
   }
-  if (!Array.isArray(content)) {
-    return "";
+  const blobsToDownload = plannedBlobs.filter((planned) => planned.shouldWrite);
+  const downloadUrls = await presignDownloads(context, blobsToDownload.map(({ entry }) => entry));
+  const downloadedEntries = [];
+  for (const planned of blobsToDownload) {
+    const { entry, localPath } = planned;
+    const remoteContent = await downloadBlob(entry, downloadUrls);
+    downloadedEntries.push({ ...planned, content: remoteContent });
   }
-  return content.map((part) => {
-    const contentPart = contentPartValue(part);
-    if (contentPart?.type !== "text") {
-      return "";
-    }
-    return stringValue(contentPart.text) ?? "";
-  }).filter((text) => text !== "").join("\n");
-}
-function messageValue(value) {
-  return isObject(value) ? value : void 0;
-}
-function codexPayloadValue(value) {
-  return isObject(value) ? value : void 0;
-}
-function usageValue(value) {
-  return isObject(value) ? value : void 0;
-}
-function contentPartValue(value) {
-  return isObject(value) ? value : void 0;
-}
-function stringValue(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function numberValue(value) {
-  return typeof value === "number" ? value : void 0;
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function hasValue(value) {
-  return value !== void 0 && value !== "";
-}
-function errorMessage(error) {
-  if (error instanceof Error && error.message !== "") {
-    return error.message;
+  for (const deletion of plannedDeletions) {
+    await rm2(deletion.localPath);
   }
-  return String(error);
-}
-function objectValue(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-}
-
-// src/run/redaction.ts
-import { createHmac } from "crypto";
-var SECRET_RULES = [
-  {
-    name: "private_key",
-    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
-    replacement: (value, salt) => `<REDACTED:private_key:${tag(value, salt)}>`
-  },
-  {
-    name: "bearer",
-    pattern: /Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
-    replacement: (value, salt) => `<REDACTED:bearer:${tag(value, salt)}>`
-  },
-  {
-    name: "basic",
-    pattern: /Basic\s+[A-Za-z0-9+/=-]+/gi,
-    replacement: (value, salt) => `<REDACTED:basic:${tag(value, salt)}>`
-  },
-  {
-    name: "jwt",
-    pattern: /eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
-    replacement: (value, salt) => `<REDACTED:jwt:${tag(value, salt)}>`
-  },
-  {
-    name: "github",
-    pattern: /github_pat_[A-Za-z0-9_]{20,}/g,
-    replacement: (value, salt) => `<REDACTED:github:${tag(value, salt)}>`
-  },
-  {
-    name: "github",
-    pattern: /github_pat_[A-Za-z0-9_]{4,}(?:\u2026|\.{3})/g,
-    replacement: (value, salt) => `<REDACTED:github:${tag(value, salt)}>`
-  },
-  {
-    name: "github",
-    pattern: /gh[opsu]_[A-Za-z0-9_]{8,}/g,
-    replacement: (value, salt) => `<REDACTED:github:${tag(value, salt)}>`
-  },
-  {
-    name: "github",
-    pattern: /gh[opsu]_[A-Za-z0-9_]{4,}(?:\u2026|\.{3})/g,
-    replacement: (value, salt) => `<REDACTED:github:${tag(value, salt)}>`
-  },
-  {
-    name: "openai",
-    pattern: /sk-(?:proj-)?[A-Za-z0-9_-]{20,}/g,
-    replacement: (value, salt) => `<REDACTED:openai:${tag(value, salt)}>`
-  },
-  {
-    name: "openai",
-    pattern: /sk-(?:proj-)?[A-Za-z0-9_-]{4,}(?:\u2026|\.{3})/g,
-    replacement: (value, salt) => `<REDACTED:openai:${tag(value, salt)}>`
-  },
-  {
-    name: "slack",
-    pattern: /xox[baprs]-[A-Za-z0-9-]{10,}/g,
-    replacement: (value, salt) => `<REDACTED:slack:${tag(value, salt)}>`
-  },
-  {
-    name: "stripe",
-    pattern: /(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{10,}/g,
-    replacement: (value, salt) => `<REDACTED:stripe:${tag(value, salt)}>`
-  },
-  {
-    name: "aws_key",
-    pattern: /(?:AKIA|ASIA)[0-9A-Z]{16}/g,
-    replacement: (value, salt) => `<REDACTED:aws_key:${tag(value, salt)}>`
-  },
-  {
-    name: "aws_key",
-    pattern: /(?:AKIA|ASIA)[0-9A-Z]{4,}(?:\u2026|\.{3})/g,
-    replacement: (value, salt) => `<REDACTED:aws_key:${tag(value, salt)}>`
+  for (const directory of directoryPaths) {
+    await mkdir2(directory.localPath, { recursive: true });
   }
-];
-var FIELD_QUOTED_PATTERN = /(["']?(?:password|passwd|pwd|secret|client_secret|token|access_token|refresh_token|authorization|cookie|set-cookie|api_key|apikey|private_key)["']?\s*[:=]\s*)(["'])(?:\\.|(?!\2)[\s\S])*?\2/gi;
-var FIELD_UNQUOTED_PATTERN = /(["']?(?:password|passwd|pwd|secret|client_secret|token|access_token|refresh_token|cookie|set-cookie|api_key|apikey|private_key)["']?\s*[:=]\s*)[^"',\n}\s]+/gi;
-function redactText(text, salt = "moxt-run-local-salt") {
-  const hitCounts = /* @__PURE__ */ new Map();
-  let redacted = text;
-  for (const rule of SECRET_RULES) {
-    redacted = redacted.replace(rule.pattern, (value) => {
-      addHit(hitCounts, rule.name);
-      return rule.replacement(value, salt);
-    });
+  for (const downloaded of downloadedEntries) {
+    await writePulledFile(downloaded.localPath, downloaded.content);
   }
-  redacted = redacted.replace(FIELD_QUOTED_PATTERN, (_match, prefix, quote) => {
-    addHit(hitCounts, "field");
-    return `${prefix}${quote}<REDACTED:field>${quote}`;
-  }).replace(FIELD_UNQUOTED_PATTERN, (_match, prefix) => {
-    addHit(hitCounts, "field");
-    return `${prefix}<REDACTED:field>`;
-  });
+  const downloadedContentByPath = new Map(
+    downloadedEntries.map(({ entry, content }) => [entry.prefixedPath, content])
+  );
+  const pulledFiles = Object.fromEntries(await Promise.all(plannedBlobs.map(async ({ entry, localPath }) => {
+    const content = downloadedContentByPath.get(entry.prefixedPath);
+    return [
+      entry.prefixedPath,
+      {
+        repoId: entry.repoId,
+        repoPath: entry.path,
+        fileId: entry.fileId,
+        sha: requireBlobSha(entry),
+        size: content?.length ?? entry.size ?? previousFiles[entry.prefixedPath]?.size ?? await localFileSize(localPath, entry.prefixedPath),
+        fileType: entry.fileType ?? 1
+      }
+    ];
+  })));
+  await saveCheckoutState(buildNextCheckoutState({
+    context,
+    checkoutRoot: resolvedTargetDir,
+    allRepos: repos,
+    selection,
+    previousState: compatibleState,
+    pulledRepos: stateRepos,
+    pulledFiles
+  }));
   return {
-    text: redacted,
-    hits: [...hitCounts.entries()].map(([rule, count]) => ({ rule, count }))
+    fileCount: blobEntries.length,
+    targetDir: resolvedTargetDir
   };
 }
-function tag(value, salt) {
-  return createHmac("sha256", salt).update(value).digest("hex").slice(0, 8);
-}
-function addHit(hitCounts, rule) {
-  hitCounts.set(rule, (hitCounts.get(rule) ?? 0) + 1);
+function resolveCompatibleState(state, context, checkoutRoot, repos) {
+  if (!state || state.workspaceId !== context.workspaceId || state.checkoutRoot !== checkoutRoot) return void 0;
+  const currentRepos = new Map(repos.map((repo) => [repo.repoId, repo.name]));
+  const stateMatchesRepos = Object.entries(state.repos).every(
+    ([repoId, repo]) => currentRepos.get(repoId) === repo.name
+  );
+  return stateMatchesRepos ? state : void 0;
 }
-
-// src/run/sanitize.ts
-function stripRemoteCredentials(remote) {
-  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(remote)) {
-    return remote;
-  }
-  try {
-    const url = new URL(remote);
-    url.username = "";
-    url.password = "";
-    return url.toString();
-  } catch {
-    return remote;
+function resolvePullSelection(context, requestedScopes) {
+  const repos = listRepoEntries(context.repoPayload);
+  if (!requestedScopes || requestedScopes.length === 0) {
+    return { mode: "full", scopes: repos.map((repo) => repo.name), repos };
   }
-}
-function sanitizeRepo(repo) {
-  if (repo === null) return null;
+  const resolvedScopes = requestedScopes.map((scope) => {
+    const resolved = resolveWorkspacePath(context.repoPayload, scope);
+    return {
+      path: resolved.repoPath ? `${resolved.repoName}/${resolved.repoPath}` : resolved.repoName,
+      repoId: resolved.repoId
+    };
+  });
+  const scopes = collapseScopes(resolvedScopes.map((scope) => scope.path));
+  const repoIds = new Set(resolvedScopes.map((scope) => scope.repoId));
   return {
-    ...repo,
-    remote: stripRemoteCredentials(repo.remote)
+    mode: "partial",
+    scopes,
+    repos: repos.filter((repo) => repoIds.has(repo.repoId))
   };
 }
-
-// src/run/session.ts
-import { existsSync as existsSync2, readdirSync, statSync as statSync2 } from "fs";
-import { join as join2 } from "path";
-var SESSION_START_TOLERANCE_MS = 1e3;
-function snapshotJsonl(root) {
-  const snapshot = /* @__PURE__ */ new Map();
-  if (!existsSync2(root)) {
-    return snapshot;
-  }
-  collectJsonl(root, snapshot);
-  return snapshot;
-}
-function matchSession(before, after, startedAtMs, options = {}) {
-  const candidates = [];
-  for (const [path2, current2] of after.entries()) {
-    const previous = before.get(path2);
-    if (previous === void 0) {
-      if (wasChangedAfterStart(current2, startedAtMs)) {
-        candidates.push({ path: path2, startOffset: 0 });
-      }
-      continue;
-    }
-    if (!options.newFilesOnly && current2.size > previous.size) {
-      candidates.push({ path: path2, startOffset: previous.size });
-    }
-  }
-  if (candidates.length === 0) {
-    return { match: "none", sessionFile: null, startOffset: 0 };
-  }
-  const trustedCandidates = options.isCandidate === void 0 ? candidates : candidates.filter((candidate) => options.isCandidate?.(candidate.path));
-  if (trustedCandidates.length === 0) {
-    return { match: "none", sessionFile: null, startOffset: 0 };
-  }
-  if (trustedCandidates.length === 1) {
-    const [candidate] = trustedCandidates;
-    if (candidate !== void 0) {
-      return {
-        match: "unique",
-        sessionFile: candidate.path,
-        startOffset: candidate.startOffset
-      };
-    }
-  }
-  return { match: "ambiguous", sessionFile: null, startOffset: 0 };
-}
-function matchKnownSessionFile(before, after, sessionFile) {
-  const current2 = after.get(sessionFile);
-  if (current2 === void 0) {
-    return { match: "none", sessionFile: null, startOffset: 0 };
-  }
-  const previous = before.get(sessionFile);
-  if (previous !== void 0 && current2.size <= previous.size) {
-    return { match: "none", sessionFile: null, startOffset: 0 };
+function buildNextCheckoutState(input) {
+  const { context, checkoutRoot, allRepos, selection, previousState, pulledRepos, pulledFiles } = input;
+  if (selection.mode === "full") {
+    return {
+      version: 1,
+      workspaceId: context.workspaceId,
+      checkoutRoot,
+      mode: "full",
+      checkedOutScopes: selection.scopes,
+      repos: pulledRepos,
+      files: pulledFiles
+    };
   }
+  const previousFiles = previousState?.files ?? {};
+  const preservedFiles = Object.fromEntries(
+    Object.entries(previousFiles).filter(
+      ([workspacePath]) => !selection.scopes.some((scope) => pathIsIncluded(scope, workspacePath))
+    )
+  );
+  const checkedOutScopes = collapseScopes([...previousState?.checkedOutScopes ?? [], ...selection.scopes]);
+  const mode = allRepos.every((repo) => checkedOutScopes.includes(repo.name)) ? "full" : "partial";
   return {
-    match: "unique",
-    sessionFile,
-    startOffset: previous?.size ?? 0
+    version: 1,
+    workspaceId: context.workspaceId,
+    checkoutRoot,
+    mode,
+    checkedOutScopes,
+    repos: { ...previousState?.repos ?? {}, ...pulledRepos },
+    files: { ...preservedFiles, ...pulledFiles }
   };
 }
-function recordingFromSessionMatch(match) {
-  switch (match) {
-    case "unique":
-      return { found_chat: true, quality: "complete" };
-    case "none":
-      return { found_chat: false, quality: "not_found" };
-    case "ambiguous":
-      return { found_chat: false, quality: "uncertain" };
-    case "prep_failed":
-      return { found_chat: false, quality: "unavailable" };
-  }
-}
-function collectJsonl(dir, snapshot) {
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const path2 = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      collectJsonl(path2, snapshot);
-      continue;
+function collapseScopes(scopes) {
+  const result = [];
+  for (const scope of scopes) {
+    if (result.some((existing) => pathIsIncluded(existing, scope))) continue;
+    for (let index = result.length - 1; index >= 0; index--) {
+      if (pathIsIncluded(scope, result[index])) result.splice(index, 1);
     }
-    if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
-      continue;
-    }
-    const stat2 = statSync2(path2);
-    snapshot.set(path2, {
-      mtimeMs: stat2.mtimeMs,
-      size: stat2.size
-    });
+    result.push(scope);
   }
+  return result;
 }
-function wasChangedAfterStart(current2, startedAtMs) {
-  return current2.mtimeMs >= startedAtMs - SESSION_START_TOLERANCE_MS;
+function pathsIntersect(left, right) {
+  return pathIsIncluded(left, right) || pathIsIncluded(right, left);
 }
-
-// src/run/status.ts
-var SIGNAL_NUMBERS = /* @__PURE__ */ new Map([
-  ["SIGHUP", 1],
-  ["SIGINT", 2],
-  ["SIGQUIT", 3],
-  ["SIGKILL", 9],
-  ["SIGTERM", 15]
-]);
-function signalNumber(signal) {
-  return SIGNAL_NUMBERS.get(signal) ?? 0;
-}
-function classifyExit(event, observedSignals) {
-  if (event.errorCode !== void 0) {
-    return {
-      code: event.errorCode === "ENOENT" ? 127 : 126,
-      status: "unknown"
-    };
-  }
-  if (event.signal !== null) {
-    return {
-      code: 128 + signalNumber(event.signal),
-      status: "cancelled"
-    };
-  }
-  if (event.code !== null) {
-    if (event.code === 0) {
-      return { code: 0, status: "completed" };
-    }
-    const signal = event.code - 128;
-    return {
-      code: event.code,
-      status: event.code > 128 && observedSignals.has(signal) ? "cancelled" : "failed"
-    };
-  }
-  return { code: 1, status: "unknown" };
+function pathIsIncluded(scope, workspacePath) {
+  return workspacePath === scope || workspacePath.startsWith(`${scope}/`);
 }
-
-// src/run/live-capture.ts
-import { appendFile, open, writeFile as writeFile2 } from "fs/promises";
-import { join as join3 } from "path";
-var DATA_FILE_TARGET_BYTES2 = 1024 * 1024;
-var LIVE_CAPTURE_INTERVAL_MS = 250;
-function createLiveCapture(options) {
-  return new LiveCaptureRecorder(options);
-}
-var LiveCaptureRecorder = class {
-  enabled;
-  outputs;
-  env;
-  runId;
-  agent;
-  startedAt;
-  sessions;
-  before;
-  baselineOk;
-  startedAtMs;
-  knownSessionFile;
-  isSessionCandidate;
-  newSessionFilesOnly;
-  openSessionFile;
-  timer;
-  pollInFlight = null;
-  sessionFile = null;
-  readOffset = 0;
-  pendingText = "";
-  nextSeq = 1;
-  sessionMatch;
-  captureFailed = false;
-  constructor(options) {
-    const outputDirs = captureOutputDirectories(options.env, options.runId);
-    this.enabled = outputDirs.length > 0;
-    this.outputs = outputDirs.map((outputDir) => new CaptureDirectoryOutput(outputDir));
-    this.env = options.env;
-    this.runId = options.runId;
-    this.agent = options.agent;
-    this.startedAt = options.startedAt;
-    this.sessions = options.sessions;
-    this.before = options.before;
-    this.baselineOk = options.baselineOk;
-    this.startedAtMs = options.startedAtMs;
-    this.knownSessionFile = options.knownSessionFile;
-    this.isSessionCandidate = options.isSessionCandidate;
-    this.newSessionFilesOnly = options.newSessionFilesOnly ?? false;
-    this.openSessionFile = options.openSessionFile;
-    this.sessionMatch = options.baselineOk ? "none" : "prep_failed";
-  }
-  async start() {
-    if (!this.enabled) {
-      return;
-    }
-    await emitOpenCaptureDirectories(this.env, this.runId, this.startedAt);
-    if (this.baselineOk) {
-      this.timer = setInterval(() => {
-        this.queuePoll();
-      }, LIVE_CAPTURE_INTERVAL_MS);
+function resolveStateRepos(tree, repos) {
+  const knownRepoIds = new Set(repos.map((repo) => repo.repoId));
+  for (const repoId of Object.keys(tree.repos)) {
+    if (!knownRepoIds.has(repoId)) {
+      throw new SandboxPullError(`Remote tree returned unknown repo: ${repoId}`, "remote");
     }
   }
-  async stop() {
-    if (!this.enabled) {
-      return;
-    }
-    if (this.timer !== void 0) {
-      clearInterval(this.timer);
-      this.timer = void 0;
+  return Object.fromEntries(repos.map((repo) => {
+    const remoteRepo = tree.repos[repo.repoId];
+    if (!remoteRepo) {
+      throw new SandboxPullError(`Remote tree did not return repo: ${repo.repoId}`, "remote");
     }
-    if (this.pollInFlight !== null) {
-      await this.pollInFlight;
+    if (remoteRepo.prefix !== repo.name) {
+      throw new SandboxPullError(`Remote tree returned unexpected prefix for repo ${repo.repoId}`, "remote");
     }
-    await this.poll();
-    await this.flushPendingText();
-  }
-  async finalize(payload, capturedAt) {
-    if (!this.enabled) {
-      return;
+    if (typeof remoteRepo.sha !== "string" || remoteRepo.sha.length === 0) {
+      throw new SandboxPullError(`Remote tree did not return a version for repo ${repo.repoId}`, "remote");
     }
-    if (!isCompleteRecording(payload)) {
-      await Promise.all(this.outputs.map((output) => output.invalidate()));
+    return [repo.repoId, { name: repo.name, treeSha: remoteRepo.sha }];
+  }));
+}
+async function fetchWorkspaceTree(context, selection) {
+  const client = new SandboxMoxtClient(context);
+  const results = await Promise.all(selection.repos.map(async (repo) => {
+    const filter = resolveRepoTreeFilter(repo, selection);
+    const params = new URLSearchParams({ entryFilter: filter.type });
+    if (filter.type === "paths") {
+      for (const path2 of filter.paths) params.append("path", path2);
     }
-    await finalizeCaptureDirectories(this.directoryPayload(payload), this.env, this.runId, capturedAt, this.files());
+    const response = await client.request(
+      "GET",
+      `/agent/api/pipeline-sandbox/mfs/${encodeURIComponent(repo.repoId)}/tree?${params.toString()}`
+    );
+    return { repo, tree: response.data };
+  }));
+  return {
+    repos: Object.fromEntries(
+      results.map(({ repo, tree }) => [repo.repoId, { sha: tree.sha, prefix: repo.name }])
+    ),
+    entries: results.flatMap(
+      ({ repo, tree }) => tree.entries.map((entry) => ({
+        ...entry,
+        repoId: repo.repoId,
+        prefixedPath: entry.path ? `${repo.name}/${entry.path}` : repo.name
+      }))
+    )
+  };
+}
+function resolveRepoTreeFilter(repo, selection) {
+  if (selection.mode === "full") return { type: "all" };
+  const repoPaths = [];
+  for (const scope of selection.scopes) {
+    if (scope === repo.name) return { type: "all" };
+    if (scope.startsWith(`${repo.name}/`)) repoPaths.push(scope.slice(repo.name.length + 1));
   }
-  queuePoll() {
-    if (this.pollInFlight !== null) {
-      return;
-    }
-    this.pollInFlight = this.poll().finally(() => {
-      this.pollInFlight = null;
-    });
+  if (repoPaths.length === 0) {
+    throw new SandboxPullError(`No pull scope resolved for repo: ${repo.name}`, "invalid-path");
   }
-  async poll() {
-    if (!this.baselineOk || this.captureFailed) {
-      return;
-    }
-    try {
-      const snapshot = snapshotJsonl(this.sessions);
-      if (this.sessionFile === null) {
-        if (this.knownSessionFile !== void 0) {
-          const matched2 = matchKnownSessionFile(this.before, snapshot, this.knownSessionFile);
-          if (matched2.match === "unique" && matched2.sessionFile !== null) {
-            this.sessionMatch = matched2.match;
-            this.sessionFile = matched2.sessionFile;
-            this.readOffset = matched2.startOffset;
-            await this.captureNewText();
-            return;
-          }
-        }
-        const opened = this.openSessionFile?.() ?? { match: "none" };
-        if (opened.match === "ambiguous") {
-          this.sessionMatch = "ambiguous";
-          return;
-        }
-        if (opened.match === "unique") {
-          const matched2 = matchKnownSessionFile(this.before, snapshot, opened.sessionFile);
-          this.sessionMatch = matched2.match;
-          if (matched2.match === "unique" && matched2.sessionFile !== null) {
-            this.sessionFile = matched2.sessionFile;
-            this.readOffset = matched2.startOffset;
-            await this.captureNewText();
-          }
-          return;
-        }
-        const matched = matchSession(this.before, snapshot, this.startedAtMs, this.matchOptions());
-        this.sessionMatch = matched.match;
-        if (matched.match !== "unique" || matched.sessionFile === null) {
-          return;
-        }
-        this.sessionFile = matched.sessionFile;
-        this.readOffset = matched.startOffset;
+  return { type: "paths", paths: repoPaths };
+}
+async function presignDownloads(context, entries) {
+  const client = new SandboxMoxtClient(context);
+  const entriesByRepo = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = entriesByRepo.get(entry.repoId) ?? [];
+    existing.push(entry);
+    entriesByRepo.set(entry.repoId, existing);
+  }
+  const urls = /* @__PURE__ */ new Map();
+  for (const [repoId, repoEntries] of entriesByRepo) {
+    const hashes = [...new Set(repoEntries.map((entry) => entry.sha).filter((sha) => Boolean(sha)))];
+    if (hashes.length === 0) continue;
+    const response = await client.request(
+      "POST",
+      `/agent/api/pipeline-sandbox/mfs/${encodeURIComponent(repoId)}/presign-download`,
+      { hashes }
+    );
+    for (const hash of hashes) {
+      const url = response.data.urls[hash];
+      if (!url) {
+        throw new SandboxPullError(`No download URL returned for ${hash}`, "remote");
       }
-      await this.captureNewText();
-    } catch {
-      this.captureFailed = true;
-    }
-  }
-  async captureNewText() {
-    if (this.sessionFile === null) {
-      return;
-    }
-    const next = await readFileFromOffset(this.sessionFile, this.readOffset);
-    if (next.bytes === 0) {
-      return;
-    }
-    this.readOffset += next.bytes;
-    await this.captureCompleteLines(next.text);
-  }
-  async captureCompleteLines(text) {
-    const combined = `${this.pendingText}${text}`;
-    const lastNewline = combined.lastIndexOf("\n");
-    if (lastNewline === -1) {
-      this.pendingText = combined;
-      return;
+      urls.set(hash, url);
     }
-    const complete = combined.slice(0, lastNewline + 1);
-    this.pendingText = combined.slice(lastNewline + 1);
-    await this.captureTranscriptText(complete);
   }
-  async flushPendingText() {
-    if (this.pendingText === "") {
-      return;
-    }
-    const text = `${this.pendingText}
-`;
-    this.pendingText = "";
-    await this.captureTranscriptText(text);
-  }
-  async captureTranscriptText(text) {
-    const redacted = redactText(text).text;
-    const events = serializeEventsFromTranscript(redacted, this.nextSeq, this.agent);
-    this.nextSeq = events.nextSeq;
-    await Promise.all(
-      this.outputs.map(async (output) => {
-        await output.appendTranscript(redacted);
-        await output.appendEvents(events.text);
-      })
-    );
-  }
-  directoryPayload(payload) {
-    const recording = isCompleteRecording(payload) ? this.sessionFile === null ? payload.recording : recordingFromSessionMatch(this.sessionMatch) : payload.recording;
-    const keepRedactionFailure = this.captureFailed || this.files().transcript.length === 0 && payload.redaction_failed;
-    const { redaction_failed: _redactionFailed, ...rest } = payload;
-    return {
-      ...rest,
-      ...keepRedactionFailure ? { redaction_failed: true } : {},
-      recording
-    };
-  }
-  files() {
-    const [output] = this.outputs;
-    if (output === void 0) {
-      return { events: [], transcript: [] };
-    }
-    return output.files();
+  return urls;
+}
+async function downloadBlob(entry, urls) {
+  const hash = entry.sha;
+  if (!hash) {
+    throw new SandboxPullError(`${entry.prefixedPath} does not have downloadable content`, "remote");
   }
-  matchOptions() {
-    return {
-      ...this.isSessionCandidate === void 0 ? {} : { isCandidate: this.isSessionCandidate },
-      ...this.newSessionFilesOnly ? { newFilesOnly: true } : {}
-    };
+  const url = urls.get(hash);
+  if (!url) {
+    throw new SandboxPullError(`No download URL returned for ${entry.prefixedPath}`, "remote");
   }
-};
-var CaptureDirectoryOutput = class {
-  transcript;
-  events;
-  constructor(outputDir) {
-    this.transcript = new JsonlStreamWriter(outputDir, "transcript", "transcript");
-    this.events = new JsonlStreamWriter(outputDir, "events", "events");
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new SandboxPullError(`Download failed [${response.status}]: ${entry.prefixedPath}`, "remote");
   }
-  async appendTranscript(text) {
-    await this.transcript.appendText(text);
+  const content = Buffer.from(await response.arrayBuffer());
+  if (content.length > MFS_FILE_SIZE_LIMIT_BYTES) {
+    throw new SandboxPullError(`File too large (max ${MFS_FILE_SIZE_LIMIT_LABEL}): ${entry.prefixedPath}`, "too-large");
   }
-  async appendEvents(text) {
-    await this.events.appendText(text);
+  const contentHash = createHash2("sha256").update(content).digest("hex");
+  if (contentHash !== hash) {
+    throw new SandboxPullError(`Downloaded content hash mismatch: ${entry.prefixedPath}`, "remote");
   }
-  async invalidate() {
-    await Promise.all([this.transcript.invalidate(), this.events.invalidate()]);
+  return content;
+}
+async function shouldWritePulledFile(localPath, remoteContentHash, workspacePath, previousFile, force) {
+  const existing = await lstat(localPath).catch((error) => {
+    if (isNodeError2(error) && error.code === "ENOENT") return void 0;
+    throw error;
+  });
+  if (existing && !existing.isFile()) {
+    throw new SandboxPullError(`Refusing to overwrite local path: ${workspacePath}`, "directory-conflict");
+  }
+  if (!existing) {
+    if (force || !previousFile) return true;
+    if (remoteContentHash === previousFile.sha) return false;
+    throw new SandboxPullError(
+      `Local file was deleted but remote file changed: ${workspacePath}`,
+      "file-conflict"
+    );
   }
-  files() {
-    return {
-      events: this.events.files(),
-      transcript: this.transcript.files()
-    };
+  if (force) return true;
+  const localContentHash = await hashLocalFile(localPath);
+  if (localContentHash === remoteContentHash) return false;
+  if (!previousFile) {
+    throw new SandboxPullError(
+      `Refusing to overwrite modified local file: ${workspacePath}. Use --force to overwrite.`,
+      "file-conflict"
+    );
   }
-};
-var JsonlStreamWriter = class {
-  outputDir;
-  dir;
-  prefix;
-  writtenFiles = [];
-  current = null;
-  constructor(outputDir, dir, prefix) {
-    this.outputDir = outputDir;
-    this.dir = dir;
-    this.prefix = prefix;
-  }
-  async appendText(text) {
-    for (const line of jsonlLines2(text)) {
-      await this.appendLine(line);
-    }
-  }
-  async invalidate() {
-    await Promise.all(
-      this.writtenFiles.map(async (file) => {
-        file.bytes = 0;
-        file.lines = 0;
-        file.oversized_line = false;
-        await writeFile2(join3(this.outputDir, file.path), "", "utf8");
-      })
+  const localChanged = localContentHash !== previousFile.sha;
+  const remoteChanged = remoteContentHash !== previousFile.sha;
+  if (!localChanged && remoteChanged) return true;
+  if (localChanged && !remoteChanged) return false;
+  if (localChanged && remoteChanged) {
+    throw new SandboxPullError(
+      `Local and remote file both changed since checkout: ${workspacePath}`,
+      "file-conflict"
     );
-    this.current = null;
-  }
-  files() {
-    return this.writtenFiles.map((file) => ({ ...file }));
-  }
-  async appendLine(line) {
-    const lineBytes = Buffer.byteLength(line);
-    if (lineBytes > DATA_FILE_TARGET_BYTES2) {
-      this.current = null;
-      const file2 = this.createFile();
-      file2.bytes += lineBytes;
-      file2.lines += 1;
-      file2.oversized_line = true;
-      await appendFile(join3(this.outputDir, file2.path), line, "utf8");
-      this.current = null;
-      return;
+  }
+  return false;
+}
+async function planRemoteDeletions(previousState, selection, checkoutRoot, remoteBlobPaths, force) {
+  if (!previousState) return [];
+  const deletions = [];
+  for (const [workspacePath, previousFile] of Object.entries(previousState.files)) {
+    if (!selection.scopes.some((scope) => pathIsIncluded(scope, workspacePath))) continue;
+    if (remoteBlobPaths.has(workspacePath)) continue;
+    const repo = previousState.repos[previousFile.repoId];
+    if (!repo) {
+      throw new SandboxPullError(`Checkout baseline references unknown repo: ${workspacePath}`, "remote");
+    }
+    const localPath = resolveSafeLocalPath(checkoutRoot, repo.name, previousFile.repoPath);
+    const existing = await lstat(localPath).catch((error) => {
+      if (isNodeError2(error) && error.code === "ENOENT") return void 0;
+      throw error;
+    });
+    if (!existing) continue;
+    if (!existing.isFile()) {
+      throw new SandboxPullError(`Refusing to overwrite local path: ${workspacePath}`, "directory-conflict");
+    }
+    if (!force && await hashLocalFile(localPath) !== previousFile.sha) {
+      throw new SandboxPullError(
+        `Remote file was deleted but local file changed: ${workspacePath}`,
+        "file-conflict"
+      );
     }
-    if (this.current !== null && this.current.bytes + lineBytes > DATA_FILE_TARGET_BYTES2) {
-      this.current = null;
-    }
-    const file = this.current ?? this.createFile();
-    file.bytes += lineBytes;
-    file.lines += 1;
-    await appendFile(join3(this.outputDir, file.path), line, "utf8");
-  }
-  createFile() {
-    const index = String(this.writtenFiles.length + 1).padStart(6, "0");
-    const file = {
-      path: `${this.dir}/${this.prefix}-${index}.jsonl`,
-      bytes: 0,
-      lines: 0,
-      oversized_line: false
-    };
-    this.writtenFiles.push(file);
-    this.current = file;
-    return file;
+    deletions.push({ localPath });
   }
-};
-function isCompleteRecording(payload) {
-  return payload.recording.found_chat && payload.recording.quality === "complete";
+  return deletions;
+}
+async function hashLocalFile(localPath) {
+  return createHash2("sha256").update(await readFile2(localPath)).digest("hex");
 }
-function jsonlLines2(text) {
-  if (text === "") {
-    return [];
+async function localFileSize(localPath, workspacePath) {
+  const stats = await lstat(localPath);
+  if (!stats.isFile()) {
+    throw new SandboxPullError(`Cannot determine local file size: ${workspacePath}`, "directory-conflict");
   }
-  const normalized = text.endsWith("\n") ? text : `${text}
-`;
-  return normalized.slice(0, -1).split("\n").map((line) => `${line}
-`);
+  return stats.size;
 }
-async function readFileFromOffset(path2, offset) {
-  const file = await open(path2, "r");
-  try {
-    const stat2 = await file.stat();
-    const length = Math.max(0, stat2.size - offset);
-    if (length === 0) {
-      return { text: "", bytes: 0 };
-    }
-    const buffer2 = Buffer.alloc(length);
-    const result = await file.read(buffer2, 0, length, offset);
-    return { text: buffer2.subarray(0, result.bytesRead).toString("utf8"), bytes: result.bytesRead };
-  } finally {
-    await file.close();
+function requireBlobSha(entry) {
+  if (!entry.sha) {
+    throw new SandboxPullError(`${entry.prefixedPath} does not have downloadable content`, "remote");
   }
+  return entry.sha;
 }
-
-// src/run/moxt-uploader.ts
-import { createHash } from "crypto";
-import { readdir as readdir2, readFile as readFile2, stat, writeFile as writeFile3 } from "fs/promises";
-import { arch as arch2, platform as platform2 } from "os";
-import { join as join4, relative } from "path";
-
-// src/utils/cf-access.ts
-function cloudflareAccessHeaders(env = process.env) {
-  const headers = {};
-  const token = firstValue(env.MOXT_CF_ACCESS_TOKEN, env.CF_ACCESS_TOKEN);
-  if (token !== void 0) {
-    headers["CF-Access-Token"] = token;
+async function assertCanCreateDirectory(localPath, workspacePath) {
+  const existing = await lstat(localPath).catch((error) => {
+    if (isNodeError2(error) && error.code === "ENOENT") return void 0;
+    throw error;
+  });
+  if (existing && !existing.isDirectory()) {
+    throw new SandboxPullError(`Refusing to overwrite local path: ${workspacePath}`, "directory-conflict");
+  }
+}
+async function writePulledFile(localPath, remoteContent) {
+  await mkdir2(dirname2(localPath), { recursive: true });
+  await writeFile2(localPath, remoteContent);
+}
+function resolveSafeLocalPath(targetDir, repoName, repoPath) {
+  const pathParts = [repoName, ...repoPath.split("/").filter((part) => part.length > 0)];
+  if (pathParts.some((part) => part === "." || part === ".." || part.includes("/") || part.includes("\\") || part.includes("\0"))) {
+    throw new SandboxPullError(`Remote path is unsafe: ${[repoName, repoPath].filter(Boolean).join("/")}`, "invalid-path");
   }
-  const clientId = firstValue(env.MOXT_CF_ACCESS_CLIENT_ID, env.CF_ACCESS_CLIENT_ID);
-  const clientSecret = firstValue(env.MOXT_CF_ACCESS_CLIENT_SECRET, env.CF_ACCESS_CLIENT_SECRET);
-  if (clientId !== void 0 && clientSecret !== void 0) {
-    headers["CF-Access-Client-Id"] = clientId;
-    headers["CF-Access-Client-Secret"] = clientSecret;
+  const resolved = resolve(targetDir, ...pathParts);
+  const relativePath = relative(targetDir, resolved);
+  if (relativePath.startsWith("..") || isAbsolute2(relativePath)) {
+    throw new SandboxPullError(`Remote path escapes target directory: ${repoName}/${repoPath}`, "invalid-path");
   }
-  return headers;
+  return resolved;
 }
-function firstValue(...values) {
-  return values.find((value) => value !== void 0 && value !== "");
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
 }
 
-// src/run/moxt-uploader.ts
-var DEFAULT_HOST2 = "api.moxt.ai";
-var DEFAULT_UPLOAD_TIMEOUT_MS = 3e4;
-async function uploadRunArtifacts(options) {
-  const outputDirs = captureOutputDirectories(options.env, options.runId);
-  const failures = [];
-  for (const outputDir of outputDirs) {
+// src/commands/pull.ts
+function registerPullCommand(program2) {
+  program2.command("pull").description("Pull workspace files into the local checkout").argument("[workspacePath]", "Workspace file or directory to pull").option("--all", "Pull the entire workspace").option("--force", "Overwrite changed local files").addOption(new Option("--dir <dir>").hideHelp()).addOption(new Option("--scope <workspacePath>").argParser(collectScope).default([]).hideHelp()).action(async (workspacePath, options) => {
+    const context = resolveSandboxRuntimeContextOrExit2();
     try {
-      await uploadDirectory(outputDir, options.runId, options.upload, options.env);
+      const invocation = await resolvePullInvocation(context, workspacePath, options);
+      const result = await pullSandboxWorkspace(context, invocation.targetDir, {
+        force: Boolean(options.force),
+        scopes: invocation.scopes
+      });
+      print(`Pulled ${result.fileCount} ${result.fileCount === 1 ? "file" : "files"} to ${result.targetDir}`);
     } catch (error) {
-      failures.push(`${outputDir}: ${errorMessage2(error)}`);
+      handlePullError(error);
     }
+  });
+}
+async function resolvePullInvocation(context, argument, options) {
+  const legacyTargetDir = argument && isLegacyTargetDirectory(argument) ? argument : void 0;
+  const workspacePath = legacyTargetDir ? void 0 : argument;
+  if (workspacePath && options.all) {
+    throw new Error("Specify either a workspace path or --all, not both");
   }
-  if (failures.length > 0) {
-    throw new Error(failures.join("; "));
+  if (options.scope.length > 0 && (workspacePath || options.all)) {
+    throw new Error("Legacy --scope cannot be combined with a workspace path or --all");
   }
-}
-async function uploadDirectory(outputDir, runId, config, env) {
-  const files = await discoverUploadFiles(outputDir);
-  const state = await readUploadState(outputDir, runId);
-  for (const file of files) {
-    const previous = state.files[file.artifactPath];
-    if (previous?.status === "uploaded" && previous.sha256 === file.sha256 && previous.bytes === file.bytes) {
-      continue;
-    }
-    const attempts = (previous?.attempts ?? 0) + 1;
-    state.files[file.artifactPath] = {
-      status: "uploading",
-      bytes: file.bytes,
-      sha256: file.sha256,
-      attempts
-    };
-    state.status = "uploading";
-    state.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await writeUploadState(outputDir, state);
-    try {
-      const response = await uploadFile(runId, file, config, env);
-      state.files[file.artifactPath] = {
-        status: "uploaded",
-        bytes: file.bytes,
-        sha256: file.sha256,
-        attempts,
-        uploaded_at: (/* @__PURE__ */ new Date()).toISOString(),
-        ...response.etag === void 0 ? {} : { etag: response.etag }
-      };
-    } catch (error) {
-      state.files[file.artifactPath] = {
-        status: "failed",
-        bytes: file.bytes,
-        sha256: file.sha256,
-        attempts,
-        failed_at: (/* @__PURE__ */ new Date()).toISOString(),
-        error: errorMessage2(error)
-      };
-    }
-    state.status = uploadStatus(
-      state.files,
-      files.map((candidate) => candidate.artifactPath)
-    );
-    state.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await writeUploadState(outputDir, state);
+  if (legacyTargetDir && options.dir) {
+    throw new Error("Specify the local checkout directory only once");
   }
-  state.status = uploadStatus(
-    state.files,
-    files.map((file) => file.artifactPath)
-  );
-  state.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-  await writeUploadState(outputDir, state);
-  if (state.status === "failed") {
-    throw new Error("one or more run files failed to upload");
-  }
-}
-async function discoverUploadFiles(outputDir) {
-  const paths = await uploadPaths(outputDir);
-  const files = await Promise.all(
-    paths.map(async (path2) => {
-      const absolute = join4(outputDir, path2);
-      const content = await readFile2(absolute);
-      return {
-        artifactPath: path2,
-        bytes: content.byteLength,
-        sha256: createHash("sha256").update(content).digest("hex"),
-        contentText: content.toString("utf8")
-      };
-    })
-  );
-  return files.sort((a, b) => a.artifactPath.localeCompare(b.artifactPath));
-}
-async function uploadPaths(outputDir) {
-  const paths = [];
-  for (const name of ["run.json", "state.json"]) {
-    const absolute = join4(outputDir, name);
-    try {
-      const fileStat = await stat(absolute);
-      if (fileStat.isFile()) {
-        paths.push(name);
-      }
-    } catch {
-    }
+  const state = await loadCheckoutState();
+  if (state) validateCheckoutStateContext(state, context);
+  const targetDir = options.dir ?? legacyTargetDir ?? state?.checkoutRoot ?? ".";
+  if (options.all || legacyTargetDir && options.scope.length === 0) {
+    return { targetDir };
   }
-  for (const dir of ["events", "transcript"]) {
-    await collectFiles(outputDir, join4(outputDir, dir), paths);
+  if (workspacePath) return { targetDir, scopes: [workspacePath] };
+  if (options.scope.length > 0) return { targetDir, scopes: options.scope };
+  if (!state || state.checkedOutScopes.length === 0) {
+    throw new Error("Checkout is not initialized. Run moxt pull <workspace-path> or moxt pull --all first.");
   }
-  return paths.sort();
+  return {
+    targetDir: state.checkoutRoot,
+    scopes: state.mode === "full" ? void 0 : state.checkedOutScopes
+  };
 }
-async function collectFiles(outputDir, dir, paths) {
-  let entries;
-  try {
-    entries = await readdir2(dir, { withFileTypes: true });
-  } catch {
-    return;
+function isLegacyTargetDirectory(value) {
+  return value === "." || value.startsWith("./") || value.startsWith("../") || isAbsolute3(value);
+}
+function validateCheckoutStateContext(state, context) {
+  if (state.workspaceId !== context.workspaceId) {
+    throw new Error(`Checkout state belongs to workspace ${state.workspaceId}, not ${context.workspaceId}`);
   }
-  for (const entry of entries) {
-    const absolute = join4(dir, entry.name);
-    if (entry.isDirectory()) {
-      await collectFiles(outputDir, absolute, paths);
-      continue;
+  const currentRepos = new Map(listRepoEntries(context.repoPayload).map((repo) => [repo.repoId, repo.name]));
+  for (const [repoId, repo] of Object.entries(state.repos)) {
+    const currentName = currentRepos.get(repoId);
+    if (!currentName) throw new Error(`Checkout state contains unknown repo: ${repoId}`);
+    if (currentName !== repo.name) {
+      throw new Error(`Checkout state repo name does not match current workspace: ${repo.name}`);
     }
-    if (!entry.isFile()) {
-      continue;
-    }
-    const fileStat = await stat(absolute);
-    if (fileStat.size === 0) {
-      continue;
-    }
-    paths.push(relative(outputDir, absolute).replaceAll("\\", "/"));
   }
 }
-async function uploadFile(runId, file, config, env) {
-  const apiKey = env.MOXT_API_KEY;
-  if (apiKey === void 0 || apiKey === "") {
-    throw new Error("MOXT_API_KEY is required for run upload");
-  }
-  const timeoutMs = config.timeoutMs ?? DEFAULT_UPLOAD_TIMEOUT_MS;
-  const controller = new AbortController();
-  const timeout = setTimeout(() => {
-    controller.abort();
-  }, timeoutMs);
+function collectScope(value, previous) {
+  return [...previous, value];
+}
+function resolveSandboxRuntimeContextOrExit2() {
+  let context;
   try {
-    const response = await fetch(
-      `${apiBaseUrl(env)}/workspaces/${encodeURIComponent(config.workspaceId)}/local-agent-runs/${encodeURIComponent(runId)}/files`,
-      {
-        method: "PUT",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`,
-          "User-Agent": userAgent(),
-          ...cloudflareAccessHeaders(env)
-        },
-        signal: controller.signal,
-        body: JSON.stringify({
-          schema_version: "local_agent_run.upload_file.v1",
-          artifact_path: file.artifactPath,
-          bytes: file.bytes,
-          sha256: file.sha256,
-          encoding: "utf8",
-          content_text: file.contentText
-        })
-      }
-    );
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
-    }
-    const headerEtag = response.headers.get("etag") ?? void 0;
-    const body = await responseJson(response);
-    const { etag: bodyEtagValue } = isObject2(body) ? body : {};
-    const bodyEtag = typeof bodyEtagValue === "string" ? bodyEtagValue : void 0;
-    const etag = bodyEtag ?? headerEtag;
-    return etag === void 0 ? {} : { etag };
+    context = resolveRuntimeContext();
   } catch (error) {
-    if (controller.signal.aborted) {
-      throw new Error(`upload timed out after ${timeoutMs}ms`);
+    if (error instanceof RuntimeContextError) {
+      printError(error.message);
+      process.exit(1);
     }
     throw error;
-  } finally {
-    clearTimeout(timeout);
   }
+  if (context.mode !== "sandbox") {
+    printError("moxt pull is only available in sandbox mode");
+    process.exit(1);
+  }
+  return context;
 }
-async function readUploadState(outputDir, runId) {
-  try {
-    const value = JSON.parse(await readFile2(join4(outputDir, "upload.json"), "utf8"));
-    if (isUploadState(value, runId)) {
-      return value;
+function handlePullError(error) {
+  if (error instanceof Error) {
+    printError(error.message);
+    process.exit(1);
+  }
+  throw error;
+}
+
+// src/utils/sandbox-push.ts
+import { createHash as createHash3 } from "crypto";
+import { lstat as lstat2, readFile as readFile3, readdir } from "fs/promises";
+import { isAbsolute as isAbsolute4, join as join2, relative as relative2, resolve as resolve2 } from "path";
+
+// src/utils/concurrency.ts
+async function runWithConcurrency(items, concurrency, action) {
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new RangeError("Concurrency must be a positive integer");
+  }
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < items.length) {
+      const item = items[nextIndex];
+      nextIndex += 1;
+      await action(item);
     }
-  } catch {
+  }
+  const workerCount = Math.min(concurrency, items.length);
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+}
+
+// src/utils/sandbox-push.ts
+var MFS_FILE_TYPE_REGULAR2 = 1;
+var MAX_CONCURRENT_UPLOADS = 8;
+var SandboxPushError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SandboxPushError";
+  }
+  code;
+};
+async function pushSandboxWorkspace(context, sourceDir, options) {
+  const resolvedSourceDir = resolve2(sourceDir);
+  await assertWorkspaceRoot(resolvedSourceDir);
+  const repos = listRepoEntries(context.repoPayload);
+  for (const repo of repos) {
+    assertSafeRepoName(resolvedSourceDir, repo.name);
+  }
+  const state = await resolveCheckoutState(context, resolvedSourceDir, repos);
+  const checkoutRepos = repos.filter(
+    (repo) => state.repos[repo.repoId] && doesCheckoutPathIntersect(state, repo.name)
+  );
+  if (checkoutRepos.length === 0) {
+    throw new SandboxPushError("Checkout state does not contain a pushable scope", "invalid-path");
+  }
+  const tree = await fetchWorkspaceTree2(context, checkoutRepos);
+  const remoteEntries = indexRemoteEntries(tree, checkoutRepos);
+  const localFiles = await collectLocalFiles(resolvedSourceDir, checkoutRepos, remoteEntries, state);
+  const { changes, reconciledFiles, removedWorkspacePaths } = planChanges(
+    localFiles,
+    remoteEntries,
+    state,
+    checkoutRepos
+  );
+  let pushResponse;
+  if (changes.length > 0) {
+    await uploadChangedFiles(context, changes);
+    pushResponse = await pushChanges(context, checkoutRepos, changes, options.message);
+  }
+  if (changes.length > 0 || reconciledFiles.length > 0 || removedWorkspacePaths.length > 0) {
+    await updateCheckoutState(state, changes, reconciledFiles, removedWorkspacePaths, pushResponse);
   }
   return {
-    schema_version: "runlog.upload.v1",
-    run_id: runId,
-    status: "pending",
-    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    files: {}
+    changes: changes.map((change) => ({ action: change.action, workspacePath: change.workspacePath })),
+    sourceDir: resolvedSourceDir
   };
 }
-async function writeUploadState(outputDir, state) {
-  await writeFile3(join4(outputDir, "upload.json"), `${JSON.stringify(state, null, 2)}
-`, "utf8");
-}
-function uploadStatus(files, expectedPaths) {
-  if (expectedPaths.length === 0) {
-    return "pending";
+async function resolveCheckoutState(context, sourceDir, repos) {
+  const state = await loadCheckoutState();
+  if (!state) {
+    throw new SandboxPushError("Checkout is not initialized. Run moxt pull first.", "invalid-path");
   }
-  const states = expectedPaths.map((path2) => files[path2]?.status ?? "pending");
-  if (states.some((status) => status === "failed")) {
-    return "failed";
-  }
-  if (states.every((status) => status === "uploaded")) {
-    return "uploaded";
+  if (state.workspaceId !== context.workspaceId) {
+    throw new SandboxPushError(
+      `Checkout state belongs to workspace ${state.workspaceId}, not ${context.workspaceId}`,
+      "invalid-path"
+    );
   }
-  if (states.some((status) => status === "uploaded")) {
-    return "partial";
+  if (state.checkoutRoot !== sourceDir) {
+    throw new SandboxPushError(
+      `Checkout root is ${state.checkoutRoot}, not ${sourceDir}`,
+      "invalid-path"
+    );
   }
-  return "uploading";
-}
-function isUploadState(value, runId) {
-  if (!isObject2(value)) {
-    return false;
+  const currentRepos = new Map(repos.map((repo) => [repo.repoId, repo.name]));
+  for (const [repoId, repo] of Object.entries(state.repos)) {
+    if (currentRepos.get(repoId) !== repo.name) {
+      throw new SandboxPushError(`Checkout state contains unknown repo: ${repoId}`, "invalid-path");
+    }
   }
-  const { schema_version: schemaVersion, run_id: valueRunId, files } = value;
-  return schemaVersion === "runlog.upload.v1" && valueRunId === runId && isObject2(files);
-}
-async function responseJson(response) {
-  try {
-    return await response.json();
-  } catch {
-    return null;
+  for (const scope of state.checkedOutScopes) {
+    const hasRepo = Object.values(state.repos).some(
+      (repo) => scope === repo.name || scope.startsWith(`${repo.name}/`)
+    );
+    if (!hasRepo) throw new SandboxPushError(`Checkout state contains invalid scope: ${scope}`, "invalid-path");
   }
+  return state;
 }
-function apiBaseUrl(env) {
-  return `https://${env.MOXT_HOST ?? DEFAULT_HOST2}/openapi/v1`;
-}
-function userAgent() {
-  return `moxt-cli/${"0.3.3-moxt-run.1"} (${platform2()}/${arch2()}) node/${process.versions.node}`;
-}
-function errorMessage2(error) {
-  if (error instanceof Error && error.message !== "") {
-    return error.message;
+async function assertWorkspaceRoot(sourceDir) {
+  const stats = await lstat2(sourceDir).catch((error) => {
+    if (isNodeError3(error) && error.code === "ENOENT") {
+      throw new SandboxPushError(`Local workspace directory does not exist: ${sourceDir}`, "invalid-path");
+    }
+    throw error;
+  });
+  if (!stats.isDirectory()) {
+    throw new SandboxPushError(`Local workspace path is not a directory: ${sourceDir}`, "invalid-path");
   }
-  return String(error);
-}
-function isObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-
-// src/run/process-session.ts
-import { execFileSync } from "child_process";
-import { isAbsolute, relative as relative2 } from "path";
-function findOpenSessionFile(options) {
-  if ((options.platform ?? process.platform) !== "darwin") {
-    return { match: "none" };
-  }
-  try {
-    const psOutput = execFileSync("ps", ["-axo", "pid=,ppid="], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const pids = processTreePids(options.rootPid, psOutput);
-    const lsofOutput = execFileSync("lsof", ["-F", "pn", "-p", pids.join(",")], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    return openSessionFileFromLsof(lsofOutput, {
-      sessionRoot: options.sessionRoot,
-      ...options.isCandidate === void 0 ? {} : { isCandidate: options.isCandidate }
+async function fetchWorkspaceTree2(context, repos) {
+  const client = new SandboxMoxtClient(context);
+  const response = await client.request(
+    "POST",
+    "/agent/api/pipeline-sandbox/mfs-workspace/batch-trees",
+    {
+      repos: repos.map((repo) => ({ repoId: repo.repoId, prefix: repo.name }))
+    }
+  );
+  return response.data;
+}
+function indexRemoteEntries(tree, repos) {
+  const knownRepoIds = new Set(repos.map((repo) => repo.repoId));
+  const entries = /* @__PURE__ */ new Map();
+  for (const entry of tree.entries) {
+    if (!knownRepoIds.has(entry.repoId)) {
+      throw new SandboxPushError(`Remote tree returned unknown repo: ${entry.repoId}`, "remote");
+    }
+    const key = remoteEntryKey(entry.repoId, entry.path);
+    if (entries.has(key)) {
+      throw new SandboxPushError(`Remote tree returned duplicate path: ${entry.prefixedPath}`, "remote");
+    }
+    entries.set(key, entry);
+  }
+  return entries;
+}
+async function collectLocalFiles(sourceDir, repos, remoteEntries, state) {
+  const files = [];
+  for (const repo of repos) {
+    const repoRoot = resolveSafeRepoRoot(sourceDir, repo.name);
+    const stats = await lstat2(repoRoot).catch((error) => {
+      if (isNodeError3(error) && error.code === "ENOENT") return void 0;
+      throw error;
     });
-  } catch {
-    return { match: "none" };
+    if (!stats) continue;
+    if (!stats.isDirectory()) {
+      throw new SandboxPushError(`Local repo path is not a directory: ${repo.name}`, "invalid-path");
+    }
+    await collectRepoFiles(repoRoot, repo, "", remoteEntries, state, files);
   }
+  return files;
 }
-function processTreePids(rootPid, psOutput) {
-  const childrenByParent = /* @__PURE__ */ new Map();
-  for (const line of psOutput.split("\n")) {
-    const [pidText, ppidText] = line.trim().split(/\s+/, 2);
-    const pid = Number(pidText);
-    const ppid = Number(ppidText);
-    if (!Number.isInteger(pid) || !Number.isInteger(ppid) || pid <= 0) {
-      continue;
+async function collectRepoFiles(repoRoot, repo, relativeDir, remoteEntries, state, files) {
+  const localDir = relativeDir ? join2(repoRoot, ...relativeDir.split("/")) : repoRoot;
+  const entries = await readdir(localDir, { withFileTypes: true });
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.name === ".git") continue;
+    const repoPath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
+    const workspacePath = `${repo.name}/${repoPath}`;
+    assertSafePathPart(entry.name, workspacePath);
+    if (!doesCheckoutPathIntersect(state, workspacePath)) continue;
+    if (entry.isSymbolicLink()) {
+      throw new SandboxPushError(`Refusing to push symbolic link: ${workspacePath}`, "invalid-file");
     }
-    const children = childrenByParent.get(ppid) ?? [];
-    children.push(pid);
-    childrenByParent.set(ppid, children);
-  }
-  const pids = [];
-  const seen = /* @__PURE__ */ new Set();
-  const queue = [rootPid];
-  while (queue.length > 0) {
-    const pid = queue.shift();
-    if (seen.has(pid)) {
+    if (entry.isDirectory()) {
+      const remote = remoteEntries.get(remoteEntryKey(repo.repoId, repoPath));
+      if (remote?.type === "blob") {
+        throw new SandboxPushError(`Local directory conflicts with remote file: ${workspacePath}`, "invalid-file");
+      }
+      await collectRepoFiles(repoRoot, repo, repoPath, remoteEntries, state, files);
       continue;
     }
-    seen.add(pid);
-    pids.push(pid);
-    queue.push(...childrenByParent.get(pid) ?? []);
+    if (!entry.isFile()) {
+      throw new SandboxPushError(`Refusing to push unsupported file: ${workspacePath}`, "invalid-file");
+    }
+    const localPath = join2(repoRoot, ...repoPath.split("/"));
+    const stats = await lstat2(localPath);
+    if (!stats.isFile()) {
+      const kind = stats.isSymbolicLink() ? "symbolic link" : "unsupported file";
+      throw new SandboxPushError(`Refusing to push ${kind}: ${workspacePath}`, "invalid-file");
+    }
+    if (stats.size > MFS_FILE_SIZE_LIMIT_BYTES) {
+      throw new SandboxPushError(
+        `File too large (max ${MFS_FILE_SIZE_LIMIT_LABEL}): ${workspacePath}`,
+        "too-large"
+      );
+    }
+    const content = await readFile3(localPath);
+    if (content.length > MFS_FILE_SIZE_LIMIT_BYTES) {
+      throw new SandboxPushError(
+        `File too large (max ${MFS_FILE_SIZE_LIMIT_LABEL}): ${workspacePath}`,
+        "too-large"
+      );
+    }
+    if (!isCheckoutPathIncluded(state, workspacePath)) continue;
+    files.push({
+      repo,
+      repoPath,
+      workspacePath,
+      localPath,
+      contentHash: createHash3("sha256").update(content).digest("hex"),
+      size: content.length
+    });
   }
-  return pids;
 }
-function openSessionFileFromLsof(lsofOutput, options) {
-  const files = /* @__PURE__ */ new Set();
-  for (const line of lsofOutput.split("\n")) {
-    if (!line.startsWith("n")) {
+function planChanges(localFiles, remoteEntries, state, repos) {
+  const changes = [];
+  const reconciledFiles = [];
+  const removedWorkspacePaths = [];
+  const localWorkspacePaths = new Set(localFiles.map((file) => file.workspacePath));
+  const reposById = new Map(repos.map((repo) => [repo.repoId, repo]));
+  for (const file of localFiles) {
+    const baseline = state.files[file.workspacePath];
+    if (baseline?.sha === file.contentHash) continue;
+    const existing = remoteEntries.get(remoteEntryKey(file.repo.repoId, file.repoPath));
+    if (existing?.type === "tree") {
+      throw new SandboxPushError(`Local file conflicts with remote directory: ${file.workspacePath}`, "invalid-file");
+    }
+    if (existing?.sha === file.contentHash) {
+      reconciledFiles.push({ ...file, remote: existing });
       continue;
     }
-    const path2 = line.slice(1);
-    if (!path2.endsWith(".jsonl") || !isInside(options.sessionRoot, path2)) {
-      continue;
+    if (existing && !existing.sha) {
+      throw new SandboxPushError(`${file.workspacePath} does not have a base content hash`, "remote");
     }
-    if (options.isCandidate !== void 0 && !options.isCandidate(path2)) {
-      continue;
+    if (baseline && existing?.sha !== baseline.sha) {
+      throw new SandboxPushError(`Remote file changed since checkout: ${file.workspacePath}`, "conflict");
     }
-    files.add(alignPathToRoot(options.sessionRoot, path2));
-  }
-  if (files.size === 0) {
-    return { match: "none" };
-  }
-  if (files.size === 1) {
-    return { match: "unique", sessionFile: [...files].join("") };
+    if (!baseline && existing) {
+      throw new SandboxPushError(`Remote file changed since checkout: ${file.workspacePath}`, "conflict");
+    }
+    changes.push({
+      ...file,
+      action: existing ? "update" : "create",
+      ...existing ? { existing } : {}
+    });
   }
-  return { match: "ambiguous" };
-}
-function isInside(root, path2) {
-  if (isPathInside(root, path2)) {
-    return true;
+  for (const [workspacePath, baseline] of Object.entries(state.files)) {
+    if (localWorkspacePaths.has(workspacePath) || !isCheckoutPathIncluded(state, workspacePath)) continue;
+    const repo = reposById.get(baseline.repoId);
+    if (!repo) continue;
+    const existing = remoteEntries.get(remoteEntryKey(baseline.repoId, baseline.repoPath));
+    if (!existing) {
+      removedWorkspacePaths.push(workspacePath);
+      continue;
+    }
+    if (existing.type !== "blob" || existing.sha !== baseline.sha) {
+      throw new SandboxPushError(`Remote file changed since checkout: ${workspacePath}`, "conflict");
+    }
+    changes.push({
+      action: "delete",
+      repo,
+      repoPath: baseline.repoPath,
+      workspacePath,
+      fileId: validFileId(existing.fileId) ?? baseline.fileId
+    });
   }
-  return isPathInside(normalizeDarwinVarPath(root), normalizeDarwinVarPath(path2));
-}
-function isPathInside(root, path2) {
-  const fromRoot = relative2(root, path2);
-  return fromRoot === "" || !fromRoot.startsWith("..") && !isAbsolute(fromRoot);
-}
-function normalizeDarwinVarPath(path2) {
-  return path2.startsWith("/private/var/") ? path2.slice("/private".length) : path2;
+  return { changes, reconciledFiles, removedWorkspacePaths };
+}
+async function uploadChangedFiles(context, changes) {
+  const writeChanges = changes.filter(isWriteChange);
+  if (writeChanges.length === 0) return;
+  const client = new SandboxMoxtClient(context);
+  const changesByRepo = groupChangesByRepo(writeChanges);
+  const uploadUrlsByRepo = await Promise.all(
+    [...changesByRepo].map(async ([repoId, repoChanges]) => {
+      const hashes = [...new Set(repoChanges.map((change) => change.contentHash))];
+      const response = await client.request(
+        "POST",
+        `/agent/api/pipeline-sandbox/mfs/${encodeURIComponent(repoId)}/presign-upload`,
+        { hashes }
+      );
+      return [repoId, response.data.urls];
+    })
+  );
+  const uploadUrls = new Map(uploadUrlsByRepo);
+  await runWithConcurrency(writeChanges, MAX_CONCURRENT_UPLOADS, async (change) => {
+    const uploadUrl = uploadUrls.get(change.repo.repoId)?.[change.contentHash];
+    if (!uploadUrl) {
+      throw new SandboxPushError(`No upload URL returned for ${change.workspacePath}`, "remote");
+    }
+    const content = await readFile3(change.localPath);
+    const currentHash = createHash3("sha256").update(content).digest("hex");
+    if (content.length !== change.size || currentHash !== change.contentHash) {
+      throw new SandboxPushError(`Local file changed while pushing: ${change.workspacePath}`, "invalid-file");
+    }
+    const upload = await fetch(uploadUrl, {
+      method: "PUT",
+      headers: { "Content-Type": "application/octet-stream" },
+      body: new Uint8Array(content)
+    });
+    if (!upload.ok) {
+      throw new SandboxPushError(`Upload failed [${upload.status}]: ${change.workspacePath}`, "remote");
+    }
+  });
 }
-function alignPathToRoot(root, path2) {
-  if (root.startsWith("/var/") && path2.startsWith("/private/var/")) {
-    return path2.slice("/private".length);
+async function pushChanges(context, repos, changes, message) {
+  const client = new SandboxMoxtClient(context);
+  const changesByRepo = groupChangesByRepo(changes);
+  const response = await client.request(
+    "POST",
+    "/agent/api/pipeline-sandbox/mfs-workspace/unified-push",
+    {
+      message,
+      repoPushes: repos.flatMap((repo) => {
+        const repoChanges = changesByRepo.get(repo.repoId);
+        if (!repoChanges) return [];
+        return [{
+          repoId: repo.repoId,
+          changes: repoChanges.map((change) => {
+            if (change.action === "delete") {
+              return {
+                action: change.action,
+                ...change.fileId ? { fileId: change.fileId } : {},
+                path: change.repoPath
+              };
+            }
+            return {
+              action: change.action,
+              ...change.existing?.fileId ? { fileId: change.existing.fileId } : {},
+              path: change.repoPath,
+              contentHash: change.contentHash,
+              ...change.existing?.sha ? { baseContentHash: change.existing.sha } : {},
+              size: change.size,
+              fileType: MFS_FILE_TYPE_REGULAR2
+            };
+          })
+        }];
+      }),
+      crossRepoMoves: []
+    }
+  );
+  return response.data;
+}
+async function updateCheckoutState(state, changes, reconciledFiles, removedWorkspacePaths, response) {
+  const files = { ...state.files };
+  for (const workspacePath of removedWorkspacePaths) delete files[workspacePath];
+  for (const file of reconciledFiles) {
+    files[file.workspacePath] = checkoutStateFile(
+      file,
+      validFileId(file.remote.fileId),
+      validFileType(file.remote.fileType)
+    );
   }
-  if (root.startsWith("/private/var/") && path2.startsWith("/var/")) {
-    return `/private${path2}`;
+  for (const change of changes) {
+    if (change.action === "delete") {
+      delete files[change.workspacePath];
+      continue;
+    }
+    const returnedFileId = validFileId(response?.fileMap?.[change.repo.repoId]?.[change.repoPath]);
+    const fileId = returnedFileId ?? change.existing?.fileId ?? state.files[change.workspacePath]?.fileId ?? null;
+    files[change.workspacePath] = checkoutStateFile(change, validFileId(fileId), validFileType(change.existing?.fileType));
   }
-  return path2;
+  await saveCheckoutState({ ...state, files });
 }
-
-// src/run/repo.ts
-import { execFileSync as execFileSync2 } from "child_process";
-function collectRepoFingerprint(cwd) {
-  const root = git(["rev-parse", "--show-toplevel"], cwd);
-  if (root === null) {
-    return null;
-  }
+function isWriteChange(change) {
+  return change.action !== "delete";
+}
+function checkoutStateFile(file, fileId, fileType) {
   return {
-    root,
-    remote: git(["config", "--get", "remote.origin.url"], cwd) ?? "",
-    branch: git(["branch", "--show-current"], cwd) ?? "",
-    head: git(["rev-parse", "HEAD"], cwd) ?? ""
+    repoId: file.repo.repoId,
+    repoPath: file.repoPath,
+    fileId,
+    sha: file.contentHash,
+    size: file.size,
+    fileType: fileType ?? MFS_FILE_TYPE_REGULAR2
   };
 }
-function git(args, cwd) {
-  try {
-    return execFileSync2("git", args, {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-  } catch {
-    return null;
-  }
+function validFileId(fileId) {
+  return typeof fileId === "string" && fileId.length > 0 ? fileId : null;
 }
-
-// src/run/session-dir.ts
-import { closeSync, openSync, readSync, realpathSync } from "fs";
-import { join as join5, resolve } from "path";
-var CODEX_METADATA_READ_BYTES = 256 * 1024;
-function claudeProjectDir(cwd, home) {
-  return join5(home, ".claude", "projects", encodeClaudeProjectPath(cwd));
-}
-function encodeClaudeProjectPath(cwd) {
-  return cwd.replaceAll(/[^A-Za-z0-9]/g, "-");
-}
-function agentSessionDir(options) {
-  switch (options.agent) {
-    case "claude":
-      return claudeProjectDir(options.cwd, options.home);
-    case "codex":
-      return codexSessionsDir(options.home, options.env);
-  }
-}
-function agentSessionCandidateFilter(options) {
-  switch (options.agent) {
-    case "claude":
-      return void 0;
-    case "codex": {
-      const expectedCwd = expectedCodexCwd(options.cwd, options.agentArgs);
-      return (path2) => {
-        try {
-          const sessionCwd = codexSessionCwd(path2);
-          return sessionCwd !== null && sameCodexCwd(sessionCwd, expectedCwd);
-        } catch {
-          return false;
-        }
-      };
-    }
-  }
+function validFileType(fileType) {
+  return typeof fileType === "number" && Number.isInteger(fileType) && fileType >= 0 ? fileType : null;
 }
-function agentKnownSessionFile(options) {
-  switch (options.agent) {
-    case "claude": {
-      const sessionId = claudeSessionIdArg(options.agentArgs) ?? (claudeForkSessionArg(options.agentArgs) ? void 0 : claudeResumeSessionIdArg(options.agentArgs));
-      return sessionId === void 0 ? void 0 : join5(claudeProjectDir(options.cwd, options.home), `${sessionId}.jsonl`);
-    }
-    case "codex":
-      return void 0;
+function groupChangesByRepo(changes) {
+  const result = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    const repoChanges = result.get(change.repo.repoId) ?? [];
+    repoChanges.push(change);
+    result.set(change.repo.repoId, repoChanges);
   }
+  return result;
 }
-function codexSessionsDir(home, env = {}) {
-  return join5(codexHome(home, env), "sessions");
+function remoteEntryKey(repoId, repoPath) {
+  return `${repoId}\0${repoPath}`;
 }
-function codexHome(home, env = {}) {
-  const { CODEX_HOME: configured } = env;
-  return hasValue2(configured) ? configured : join5(home, ".codex");
+function assertSafePathPart(part, workspacePath) {
+  if (part === "." || part === ".." || part.includes("/") || part.includes("\\") || part.includes("\0")) {
+    throw new SandboxPushError(`Local path is unsafe: ${workspacePath}`, "invalid-path");
+  }
 }
-function expectedCodexCwd(cwd, agentArgs) {
-  const cd = codexCdArg(agentArgs);
-  return cd === void 0 ? resolve(cwd) : resolve(cwd, cd);
+function assertSafeRepoName(sourceDir, repoName) {
+  resolveSafeRepoRoot(sourceDir, repoName);
 }
-function claudeSessionIdArg(agentArgs) {
-  const optionArgs = claudeOptionArgs(agentArgs);
-  for (let index = 0; index < optionArgs.length; index += 1) {
-    const arg = optionArgs[index];
-    if (arg === "--session-id") {
-      return optionArgs[index + 1];
-    }
-    if (arg.startsWith("--session-id=")) {
-      return arg.slice("--session-id=".length);
-    }
+function resolveSafeRepoRoot(sourceDir, repoName) {
+  assertSafePathPart(repoName, repoName);
+  const repoRoot = resolve2(sourceDir, repoName);
+  const relativePath = relative2(sourceDir, repoRoot);
+  if (relativePath.startsWith("..") || isAbsolute4(relativePath)) {
+    throw new SandboxPushError(`Repo path escapes local workspace: ${repoName}`, "invalid-path");
   }
-  return void 0;
+  return repoRoot;
 }
-function claudeResumeSessionIdArg(agentArgs) {
-  const optionArgs = claudeOptionArgs(agentArgs);
-  for (let index = 0; index < optionArgs.length; index += 1) {
-    const arg = optionArgs[index];
-    if (arg === "--resume" || arg === "-r") {
-      const value = optionArgs[index + 1];
-      return isUuid(value) ? value : void 0;
-    }
-    if (arg.startsWith("--resume=")) {
-      const value = arg.slice("--resume=".length);
-      return isUuid(value) ? value : void 0;
-    }
-  }
-  return void 0;
+function isNodeError3(error) {
+  return error instanceof Error && "code" in error;
 }
-function codexSessionCwd(path2) {
-  const text = readFilePrefix(path2, CODEX_METADATA_READ_BYTES);
-  for (const line of text.split("\n")) {
-    const cwd = codexLineCwd(line);
-    if (cwd !== null) {
-      return cwd;
+
+// src/commands/push.ts
+function registerPushCommand(program2) {
+  program2.command("push").description("Push local workspace files to the sandbox workspace").argument("[dir]", "Local workspace directory", ".").option("-m, --message <message>", "Push message", "moxt push").action(async (sourceDir, options) => {
+    const context = resolveSandboxRuntimeContextOrExit3();
+    try {
+      const result = await pushSandboxWorkspace(context, sourceDir, { message: options.message });
+      for (const change of result.changes) {
+        print(`${change.action} ${change.workspacePath}`);
+      }
+      if (result.changes.length === 0) {
+        print("No changes to push");
+        return;
+      }
+      const fileLabel = result.changes.length === 1 ? "file" : "files";
+      print(`Pushed ${result.changes.length} ${fileLabel} from ${result.sourceDir}`);
+    } catch (error) {
+      handlePushError(error);
     }
-  }
-  return null;
+  });
 }
-function codexCdArg(agentArgs) {
-  const optionArgs = codexOptionArgs(agentArgs);
-  for (let index = 0; index < optionArgs.length; index += 1) {
-    const arg = optionArgs[index];
-    if (arg === "--cd" || arg === "-C") {
-      return optionArgs[index + 1];
-    }
-    if (arg.startsWith("--cd=")) {
-      return arg.slice("--cd=".length);
+function resolveSandboxRuntimeContextOrExit3() {
+  let context;
+  try {
+    context = resolveRuntimeContext();
+  } catch (error) {
+    if (error instanceof RuntimeContextError) {
+      printError(error.message);
+      process.exit(1);
     }
+    throw error;
   }
-  return void 0;
-}
-function codexOptionArgs(agentArgs) {
-  const separatorIndex = agentArgs.indexOf("--");
-  return separatorIndex === -1 ? agentArgs : agentArgs.slice(0, separatorIndex);
-}
-function sameCodexCwd(left, right) {
-  return normalizeCodexCwd(left) === normalizeCodexCwd(right);
-}
-function normalizeCodexCwd(path2) {
-  try {
-    return realpathSync(path2);
-  } catch {
-    return resolve(path2);
+  if (context.mode !== "sandbox") {
+    printError("moxt push is only available in sandbox mode");
+    process.exit(1);
   }
+  return context;
 }
-function claudeForkSessionArg(agentArgs) {
-  return claudeOptionArgs(agentArgs).includes("--fork-session");
-}
-function claudeOptionArgs(agentArgs) {
-  const separatorIndex = agentArgs.indexOf("--");
-  return separatorIndex === -1 ? agentArgs : agentArgs.slice(0, separatorIndex);
-}
-function isUuid(value) {
-  return value !== void 0 && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{12}$/i.test(value);
+function handlePushError(error) {
+  if (error instanceof Error) {
+    printError(error.message);
+    process.exit(1);
+  }
+  throw error;
 }
-function codexLineCwd(line) {
-  if (line.trim() === "") {
-    return null;
+
+// src/utils/checkout-status.ts
+import { createHash as createHash4 } from "crypto";
+import { createReadStream } from "fs";
+import { lstat as lstat3, readdir as readdir2 } from "fs/promises";
+import { join as join3 } from "path";
+var CheckoutStatusError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CheckoutStatusError";
   }
-  let value;
-  try {
-    value = JSON.parse(line);
-  } catch {
-    return null;
+};
+async function inspectCheckoutStatus(state) {
+  await requireCheckoutDirectory(state.checkoutRoot);
+  const localFiles = /* @__PURE__ */ new Map();
+  for (const repo of Object.values(state.repos)) {
+    await scanDirectory(state, repo.name, join3(state.checkoutRoot, repo.name), localFiles);
   }
-  const entry = rawCodexSessionLine(value);
-  if (entry === null) {
-    return null;
+  const changes = [];
+  for (const [path2, sha] of localFiles) {
+    const baseline = state.files[path2];
+    if (!baseline) changes.push({ action: "added", path: path2 });
+    else if (baseline.sha !== sha) changes.push({ action: "modified", path: path2 });
   }
-  const type = entry.type;
-  if (type !== "session_meta" && type !== "turn_context") {
-    return null;
+  for (const path2 of Object.keys(state.files)) {
+    if (isCheckoutPathIncluded(state, path2) && !localFiles.has(path2)) changes.push({ action: "deleted", path: path2 });
   }
-  const payload = rawCodexSessionPayload(entry.payload);
-  const cwd = payload?.cwd;
-  return typeof cwd === "string" ? cwd : null;
+  return changes.sort((left, right) => left.path.localeCompare(right.path));
 }
-function readFilePrefix(path2, bytes) {
-  const fd = openSync(path2, "r");
+async function requireCheckoutDirectory(checkoutRoot) {
+  let stats;
   try {
-    const buffer2 = Buffer.alloc(bytes);
-    const read = readSync(fd, buffer2, 0, bytes, 0);
-    return buffer2.subarray(0, read).toString("utf8");
-  } finally {
-    closeSync(fd);
+    stats = await lstat3(checkoutRoot);
+  } catch (error) {
+    throw new CheckoutStatusError(`Checkout root is not available: ${errorMessage2(error)}`);
   }
+  if (stats.isSymbolicLink()) throw new CheckoutStatusError(`Refusing to inspect symbolic link: ${checkoutRoot}`);
+  if (!stats.isDirectory()) throw new CheckoutStatusError(`Checkout root is not a directory: ${checkoutRoot}`);
 }
-function objectValue2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-}
-function rawCodexSessionLine(value) {
-  return objectValue2(value);
-}
-function rawCodexSessionPayload(value) {
-  return objectValue2(value);
-}
-function hasValue2(value) {
-  return value !== void 0 && value !== "";
-}
-
-// src/run/run-agent.ts
-var MAX_TRANSCRIPT_CAPTURE_BYTES = 1024 * 1024;
-var SESSION_SETTLE_TIMEOUT_MS = 1500;
-var SESSION_SETTLE_INTERVAL_MS = 100;
-var PROCESS_SESSION_POLL_INTERVAL_MS = 100;
-var CODEX_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
-  "-a",
-  "--add-dir",
-  "--ask-for-approval",
-  "-c",
-  "-C",
-  "--cd",
-  "--color",
-  "--config",
-  "-i",
-  "--image",
-  "--local-provider",
-  "-m",
-  "--model",
-  "-o",
-  "--output-last-message",
-  "--output-schema",
-  "-p",
-  "--profile",
-  "--remote",
-  "--remote-auth-token-env",
-  "-s",
-  "--sandbox"
-]);
-async function runLocalAgent(options) {
-  const cwd = options.cwd ?? process.cwd();
-  const env = options.env ?? process.env;
-  const home = options.home ?? env.HOME ?? homedir2();
-  const startedAtMs = Date.now();
-  const startedAt = new Date(startedAtMs).toISOString();
-  const runId = createCaptureRunId(startedAt, options.agent);
-  const captureEnv = withDefaultCaptureOutput(env, home);
+async function scanDirectory(state, workspacePath, localPath, files) {
+  let entries;
   try {
-    await prepareCaptureOutputs(captureEnv, runId);
+    entries = await readdir2(localPath, { withFileTypes: true });
   } catch (error) {
-    printPrepareError(options.agent, error);
-    return 1;
-  }
-  const repo = collectRepoFingerprint(cwd);
-  let baselineOk = false;
-  let before = /* @__PURE__ */ new Map();
-  let sessions = "";
-  let isSessionCandidate;
-  let knownSessionFile;
-  let childRootPid;
-  let openSessionFileMatch = { match: "none" };
-  let processSessionTimer;
-  const newSessionFilesOnly = shouldUseNewSessionFilesOnly(options.agent, options.agentArgs);
-  try {
-    const sessionOptions = {
-      agent: options.agent,
-      cwd,
-      home,
-      env: captureEnv,
-      agentArgs: options.agentArgs
-    };
-    sessions = agentSessionDir(sessionOptions);
-    isSessionCandidate = agentSessionCandidateFilter(sessionOptions);
-    knownSessionFile = agentKnownSessionFile(sessionOptions);
-    before = snapshotJsonl(sessions);
-    baselineOk = true;
-  } catch {
-    baselineOk = false;
+    if (isNodeError4(error) && error.code === "ENOENT") return;
+    throw new CheckoutStatusError(`Failed to inspect ${workspacePath}: ${errorMessage2(error)}`);
   }
-  const rememberOpenSessionFile = () => {
-    if (!baselineOk || sessions === "" || childRootPid === void 0 || openSessionFileMatch.match !== "none") {
-      return openSessionFileMatch;
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    if (entry.name === ".git") continue;
+    const childWorkspacePath = `${workspacePath}/${entry.name}`;
+    if (!doesCheckoutPathIntersect(state, childWorkspacePath)) continue;
+    const childLocalPath = join3(localPath, entry.name);
+    const stats = await lstat3(childLocalPath);
+    if (stats.isSymbolicLink()) {
+      throw new CheckoutStatusError(`Refusing to inspect symbolic link: ${childWorkspacePath}`);
     }
-    const matched = findOpenSessionFile({
-      rootPid: childRootPid,
-      sessionRoot: sessions,
-      ...isSessionCandidate === void 0 ? {} : { isCandidate: isSessionCandidate }
-    });
-    if (matched.match !== "none") {
-      openSessionFileMatch = matched;
+    if (stats.isDirectory()) {
+      await scanDirectory(state, childWorkspacePath, childLocalPath, files);
+    } else if (stats.isFile() && isCheckoutPathIncluded(state, childWorkspacePath)) {
+      files.set(childWorkspacePath, await hashFile(childLocalPath));
     }
-    return openSessionFileMatch;
-  };
-  const stopProcessSessionWatcher = () => {
-    if (processSessionTimer !== void 0) {
-      clearInterval(processSessionTimer);
-      processSessionTimer = void 0;
+  }
+}
+async function hashFile(path2) {
+  const hash = createHash4("sha256");
+  const stream = createReadStream(path2);
+  for await (const chunk of stream) hash.update(chunk);
+  return hash.digest("hex");
+}
+function isNodeError4(error) {
+  return error instanceof Error && "code" in error;
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/status.ts
+function registerStatusCommand(program2) {
+  program2.command("status").description("Show Moxt workspace checkout status").option("--json", "Print machine-readable status").action(async (options) => {
+    const context = resolveRuntimeContextOrExit2();
+    if (context.mode !== "sandbox") {
+      printError("moxt status is only available in sandbox mode");
+      process.exit(1);
     }
-  };
-  const liveCapture = createLiveCapture({
-    env: captureEnv,
-    runId,
-    agent: options.agent,
-    startedAt,
-    sessions,
-    before,
-    baselineOk,
-    startedAtMs,
-    ...knownSessionFile === void 0 ? {} : { knownSessionFile },
-    ...isSessionCandidate === void 0 ? {} : { isSessionCandidate },
-    ...newSessionFilesOnly ? { newSessionFilesOnly: true } : {},
-    openSessionFile: rememberOpenSessionFile
-  });
-  try {
-    await liveCapture.start();
-  } catch (error) {
-    printError(
-      [
-        "moxt: cannot prepare run output",
-        `reason: ${errorMessage3(error)}`,
-        "",
-        `${options.agent} was not started because this run cannot be recorded.`
-      ].join("\n")
-    );
-    return 1;
-  }
-  const observedSignals = /* @__PURE__ */ new Set();
-  let child = null;
-  let pendingForward = null;
-  const observe = (signal) => {
-    const number = signalNumber(signal);
-    if (number !== 0) observedSignals.add(number);
-  };
-  const terminalSignalsReachChild = process.stdin.isTTY === true || process.stdout.isTTY === true || process.stderr.isTTY === true;
-  const forwardInteractiveSignal = (signal) => {
-    observe(signal);
-    if (terminalSignalsReachChild) {
+    const status = await buildSandboxStatusOrExit(context);
+    if (options.json) {
+      print(JSON.stringify(status, null, 2));
       return;
     }
-    if (child === null) {
-      pendingForward = signal;
+    print(`${colors.bold}Workspace${colors.reset}: ${status.workspaceId}`);
+    print(`${colors.bold}Mode${colors.reset}: sandbox`);
+    print(`${colors.bold}Checkout${colors.reset}: ${formatCheckoutMode(status.checkout.mode)}`);
+    if (status.checkout.mode !== "not_initialized") {
+      print(`${colors.bold}Root${colors.reset}: ${status.checkout.root}`);
+    }
+    print("");
+    print(`${colors.bold}Repos${colors.reset}:`);
+    const repoNameWidth = status.repos.reduce((width, repo) => Math.max(width, repo.name.length), 0);
+    for (const repo of status.repos) {
+      print(`  ${repo.name.padEnd(repoNameWidth)}  ${repo.repoId}`);
+    }
+    print("");
+    if (status.checkout.mode === "not_initialized") {
+      print(`${colors.bold}Checked out scopes${colors.reset}: none`);
+      print(`${colors.bold}Local changes${colors.reset}: not tracked`);
       return;
     }
-    safeKill(child, signal);
-  };
-  const onInt = () => forwardInteractiveSignal("SIGINT");
-  const onQuit = () => forwardInteractiveSignal("SIGQUIT");
-  const onTerm = () => {
-    observe("SIGTERM");
-    if (child === null) pendingForward = "SIGTERM";
-    else safeKill(child, "SIGTERM");
-  };
-  const onHup = () => {
-    observe("SIGHUP");
-    if (child === null) pendingForward = "SIGHUP";
-    else safeKill(child, "SIGHUP");
-  };
-  process.on("SIGINT", onInt);
-  process.on("SIGQUIT", onQuit);
-  process.on("SIGTERM", onTerm);
-  process.on("SIGHUP", onHup);
-  const spawned = spawn(options.agent, [...options.agentArgs], {
-    cwd,
-    env: captureEnv,
-    stdio: "inherit"
-  });
-  child = spawned;
-  childRootPid = spawned.pid;
-  if (childRootPid !== void 0 && baselineOk) {
-    rememberOpenSessionFile();
-    processSessionTimer = setInterval(() => {
-      rememberOpenSessionFile();
-    }, PROCESS_SESSION_POLL_INTERVAL_MS);
-  }
-  if (pendingForward !== null) {
-    safeKill(spawned, pendingForward);
-  }
-  const exit = await waitForExit(spawned, options.agent);
-  stopProcessSessionWatcher();
-  const onCaptureSignal = () => {
-  };
-  process.on("SIGINT", onCaptureSignal);
-  process.on("SIGQUIT", onCaptureSignal);
-  process.on("SIGTERM", onCaptureSignal);
-  process.on("SIGHUP", onCaptureSignal);
-  process.off("SIGINT", onInt);
-  process.off("SIGQUIT", onQuit);
-  process.off("SIGTERM", onTerm);
-  process.off("SIGHUP", onHup);
-  const classified = classifyExit(exit, observedSignals);
-  const endedAtMs = exit.waitAt;
-  const endedAt = new Date(endedAtMs).toISOString();
-  const durationMs = endedAtMs - startedAtMs;
-  let after;
-  if (baselineOk) {
-    try {
-      after = await waitForSessionSettle(
-        sessions,
-        before,
-        startedAtMs,
-        isSessionCandidate,
-        newSessionFilesOnly
-      );
-    } catch {
+    print(`${colors.bold}Checked out scopes${colors.reset}:`);
+    for (const scope of status.checkout.checkedOutScopes) print(`  ${scope}`);
+    print(`${colors.bold}Local changes${colors.reset}:${status.checkout.changes.length === 0 ? " none" : ""}`);
+    for (const change of status.checkout.changes) {
+      print(`  ${change.action.padEnd(8)}  ${change.path}`);
     }
-  }
-  try {
-    await liveCapture.stop();
-  } catch {
-  }
-  const payload = buildPayload({
-    agent: options.agent,
-    cwd,
-    startedAt,
-    endedAt,
-    durationMs,
-    exitCode: classified.code,
-    status: classified.status,
-    repo: sanitizeRepo(repo),
-    baselineOk,
-    sessions,
-    before,
-    after,
-    startedAtMs,
-    knownSessionFile,
-    isSessionCandidate,
-    newSessionFilesOnly,
-    openSessionFileMatch
   });
-  let finalized = false;
-  try {
-    if (liveCapture.enabled) {
-      await liveCapture.finalize(payload, (/* @__PURE__ */ new Date()).toISOString());
-    } else {
-      await writeCaptureDirectoryPayload(payload, captureEnv, runId, (/* @__PURE__ */ new Date()).toISOString());
-    }
-    finalized = true;
-  } catch (error) {
-    printError(`moxt: cannot finalize run artifact: ${errorMessage3(error)}`);
-  } finally {
-    process.off("SIGINT", onCaptureSignal);
-    process.off("SIGQUIT", onCaptureSignal);
-    process.off("SIGTERM", onCaptureSignal);
-    process.off("SIGHUP", onCaptureSignal);
-  }
-  if (finalized && options.upload !== void 0) {
-    try {
-      await uploadRunArtifacts({
-        env: captureEnv,
-        runId,
-        upload: options.upload
-      });
-    } catch (error) {
-      printError(`moxt: cannot upload run artifact: ${errorMessage3(error)}`);
-    }
-  }
-  return classified.code;
 }
-async function waitForSessionSettle(sessions, before, startedAtMs, isSessionCandidate, newSessionFilesOnly) {
-  const deadline = Date.now() + SESSION_SETTLE_TIMEOUT_MS;
-  let after = snapshotJsonl(sessions);
-  while (!hasSessionChange(before, after, startedAtMs, isSessionCandidate, newSessionFilesOnly) && Date.now() < deadline) {
-    await sleep(SESSION_SETTLE_INTERVAL_MS);
-    after = snapshotJsonl(sessions);
-  }
-  return after;
-}
-function hasSessionChange(before, after, startedAtMs, isSessionCandidate, newSessionFilesOnly) {
-  const matched = matchSession(before, after, startedAtMs, matchOptions(isSessionCandidate, newSessionFilesOnly));
-  if (matched.match !== "unique") {
-    return matched.match !== "none";
-  }
-  if (matched.sessionFile === null) {
-    return false;
-  }
-  const snapshot = after.get(matched.sessionFile);
-  return snapshot !== void 0 && snapshot.size > matched.startOffset;
-}
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-function safeKill(child, signal) {
+async function buildSandboxStatusOrExit(context) {
+  const repos = listRepoEntries(context.repoPayload).map((repo) => ({
+    name: repo.name,
+    repoId: repo.repoId
+  }));
   try {
-    child.kill(signal);
-  } catch {
+    const state = await loadCheckoutState();
+    if (!state) return buildUninitializedStatus(context.workspaceId, repos);
+    validateStateContext(state, context);
+    return {
+      mode: "sandbox",
+      workspaceId: context.workspaceId,
+      checkout: {
+        mode: state.mode,
+        root: state.checkoutRoot,
+        checkedOutScopes: state.checkedOutScopes,
+        localChangesTracked: true,
+        changes: await inspectCheckoutStatus(state)
+      },
+      repos
+    };
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.exit(1);
   }
 }
-function waitForExit(child, agent) {
-  return new Promise((resolve2) => {
-    child.once("error", (error) => {
-      const errorCode = error.code ?? "UNKNOWN";
-      const reason = errorCode === "ENOENT" ? "command not found" : error.message;
-      printError(`moxt: cannot start ${agent}: ${reason}`);
-      resolve2({
-        code: null,
-        signal: null,
-        waitAt: Date.now(),
-        errorCode
-      });
-    });
-    child.once("exit", (code, signal) => {
-      resolve2({ code, signal, waitAt: Date.now() });
-    });
-  });
-}
-function buildPayload(input) {
-  let sessionMatch = input.baselineOk ? "none" : "prep_failed";
-  let transcript;
-  let redactionFailed = false;
-  if (input.baselineOk) {
-    try {
-      const after = input.after ?? snapshotJsonl(input.sessions);
-      const knownMatched = input.knownSessionFile === void 0 ? null : matchKnownSessionFile(input.before, after, input.knownSessionFile);
-      const matched = knownMatched?.match === "unique" ? knownMatched : input.openSessionFileMatch.match === "unique" ? matchKnownSessionFile(input.before, after, input.openSessionFileMatch.sessionFile) : input.openSessionFileMatch.match === "ambiguous" ? {
-        match: "ambiguous",
-        sessionFile: null,
-        startOffset: 0
-      } : matchSession(
-        input.before,
-        after,
-        input.startedAtMs,
-        matchOptions(input.isSessionCandidate, input.newSessionFilesOnly)
-      );
-      sessionMatch = matched.match;
-      if (matched.match === "unique" && matched.sessionFile !== null) {
-        try {
-          transcript = redactText(readFileFromOffset2(matched.sessionFile, matched.startOffset)).text;
-        } catch {
-          redactionFailed = true;
-        }
-      }
-    } catch {
-      sessionMatch = "prep_failed";
-    }
-  }
+function buildUninitializedStatus(workspaceId, repos) {
   return {
-    ...transcript === void 0 ? {} : { transcript_redacted: transcript },
-    ...redactionFailed ? { redaction_failed: true } : {},
-    run: {
-      agent: input.agent,
-      cwd: input.cwd,
-      git_root: input.repo?.root ?? null,
-      started_at: input.startedAt,
-      ended_at: input.endedAt,
-      duration_ms: input.durationMs,
-      status: input.status,
-      exit_code: input.exitCode
+    mode: "sandbox",
+    workspaceId,
+    checkout: {
+      mode: "not_initialized",
+      checkedOutScopes: [],
+      localChangesTracked: false
     },
-    recording: recordingFromSessionMatch(sessionMatch),
-    repo: input.repo
+    repos
   };
 }
-function matchOptions(isSessionCandidate, newSessionFilesOnly) {
-  return {
-    ...isSessionCandidate === void 0 ? {} : { isCandidate: isSessionCandidate },
-    ...newSessionFilesOnly ? { newFilesOnly: true } : {}
-  };
-}
-function shouldUseNewSessionFilesOnly(agent, agentArgs) {
-  return agent === "codex" && !isCodexResumeInvocation(agentArgs);
-}
-function isCodexResumeInvocation(agentArgs) {
-  const command = nextCodexCommandArg(agentArgs, 0);
-  if (command === null) {
-    return false;
-  }
-  if (command.value === "resume") {
-    return true;
+function validateStateContext(state, context) {
+  if (state.workspaceId !== context.workspaceId) {
+    throw new Error(`Checkout state belongs to workspace ${state.workspaceId}, not ${context.workspaceId}`);
   }
-  if (command.value !== "exec" && command.value !== "e") {
-    return false;
-  }
-  return nextCodexCommandArg(agentArgs, command.index + 1)?.value === "resume";
-}
-function nextCodexCommandArg(agentArgs, startIndex) {
-  for (let index = startIndex; index < agentArgs.length; index += 1) {
-    const arg = agentArgs[index];
-    if (arg === void 0) {
-      continue;
+  const currentRepos = new Map(listRepoEntries(context.repoPayload).map((repo) => [repo.repoId, repo.name]));
+  for (const [repoId, repo] of Object.entries(state.repos)) {
+    const currentName = currentRepos.get(repoId);
+    if (!currentName) throw new Error(`Checkout state contains unknown repo: ${repoId}`);
+    if (currentName !== repo.name) {
+      throw new Error(`Checkout state repo name does not match current workspace: ${repo.name}`);
     }
-    if (arg === "--") {
-      return null;
-    }
-    if (arg.startsWith("-")) {
-      if (!arg.includes("=") && CODEX_OPTIONS_WITH_VALUE.has(arg)) {
-        index += 1;
-      }
-      continue;
-    }
-    return { value: arg, index };
   }
-  return null;
 }
-function readFileFromOffset2(path2, offset) {
-  const fd = openSync2(path2, "r");
+function resolveRuntimeContextOrExit2() {
   try {
-    const stat2 = fstatSync(fd);
-    const length = Math.max(0, stat2.size - offset);
-    if (length > MAX_TRANSCRIPT_CAPTURE_BYTES) {
-      throw new Error("transcript capture exceeds maximum size");
-    }
-    const buffer2 = Buffer.alloc(length);
-    if (length === 0) {
-      return "";
-    }
-    readSync2(fd, buffer2, 0, length, offset);
-    return buffer2.toString("utf8");
-  } finally {
-    closeSync2(fd);
-  }
-}
-function printPrepareError(agent, error) {
-  if (error instanceof CaptureOutputPrepareError) {
-    printError(
-      [
-        "moxt: cannot create run output directory",
-        `path: ${error.path}`,
-        `reason: ${error.message}`,
-        "",
-        `${agent} was not started because this run cannot be recorded.`
-      ].join("\n")
-    );
-    return;
-  }
-  printError(
-    [
-      "moxt: cannot prepare run output",
-      `reason: ${errorMessage3(error)}`,
-      "",
-      `${agent} was not started because this run cannot be recorded.`
-    ].join("\n")
-  );
-}
-function errorMessage3(error) {
-  if (error instanceof Error && error.message !== "") {
-    return error.message;
-  }
-  return String(error);
-}
-
-// src/commands/run.ts
-function registerRunCommand(program2) {
-  program2.command("run").description("Run a local agent and capture its work as Moxt context").option("-w, --workspace <workspaceId>", "Workspace ID for upload mode").argument("<agent>", "Local agent to run: claude or codex").argument("[agentArgs...]", "Arguments passed to the local agent after --").allowUnknownOption(true).allowExcessArguments(true).action(async (agentArg, agentArgs, options) => {
-    const agent = parseAgent(agentArg);
-    const upload = resolveUploadOptions(options);
-    const exitCode = await runLocalAgentOrExit(agent, agentArgs ?? [], upload);
-    process.exit(exitCode);
-  });
-}
-function parseAgent(agent) {
-  if (agent === "claude" || agent === "codex") {
-    return agent;
-  }
-  printError(`Error: moxt run supports only "claude" or "codex", got "${agent}".`);
-  process.exit(1);
-}
-function resolveUploadOptions(options) {
-  const workspaceId = resolveWorkspaceId(options);
-  if (workspaceId === void 0) {
-    return void 0;
-  }
-  if (!process.env.MOXT_API_KEY) {
-    printError("Error: MOXT_API_KEY is required when using moxt run upload mode with -w/--workspace or MOXT_WORKSPACE_ID.");
-    process.exit(1);
+    return resolveRuntimeContext();
+  } catch (error) {
+    if (error instanceof RuntimeContextError) {
+      printError(error.message);
+      process.exit(1);
+    }
+    throw error;
   }
-  return {
-    workspaceId
-  };
 }
-function resolveWorkspaceId(options) {
-  return normalizeWorkspaceId(options.workspace) ?? normalizeWorkspaceId(process.env.MOXT_WORKSPACE_ID);
-}
-function normalizeWorkspaceId(value) {
-  const trimmed = value?.trim();
-  return trimmed === void 0 || trimmed === "" ? void 0 : trimmed;
-}
-async function runLocalAgentOrExit(agent, agentArgs, upload) {
-  return await runLocalAgent({
-    agent,
-    agentArgs,
-    ...upload === void 0 ? {} : { upload }
-  });
+function formatCheckoutMode(mode) {
+  return mode === "not_initialized" ? "not initialized" : `${mode} checkout`;
 }
 
 // src/telemetry/config.ts
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 import * as os from "os";
 import * as path from "path";
 function getConfigPath() {
@@ -2887,7 +2617,7 @@ function getConfigPath() {
 }
 function readTelemetryConfig() {
   try {
-    const raw = fs2.readFileSync(getConfigPath(), "utf8");
+    const raw = fs3.readFileSync(getConfigPath(), "utf8");
     const parsed = JSON.parse(raw);
     return parsed.telemetry ?? {};
   } catch {
@@ -2898,14 +2628,14 @@ function writeTelemetryConfig(update) {
   const configPath = getConfigPath();
   let existing = {};
   try {
-    existing = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+    existing = JSON.parse(fs3.readFileSync(configPath, "utf8"));
   } catch {
     existing = {};
   }
   const currentTelemetry = existing.telemetry ?? {};
   const next = { ...existing, telemetry: { ...currentTelemetry, ...update } };
-  fs2.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs2.writeFileSync(configPath, JSON.stringify(next, null, 2));
+  fs3.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs3.writeFileSync(configPath, JSON.stringify(next, null, 2));
 }
 
 // src/telemetry/opt-out.ts
@@ -3077,31 +2807,34 @@ function registerWorkspaceCommand(program2) {
 
 // src/program.ts
 function createProgram(version) {
-  const program2 = new Command();
+  const program2 = new Command2();
   program2.name("moxt").description("Moxt CLI - AI Workspace").version(version).action(() => {
     program2.help();
   });
+  registerAuthCommand(program2);
   registerWhoamiCommand(program2);
   registerWorkspaceCommand(program2);
   registerFileCommand(program2);
   registerMemoryCommand(program2);
-  registerRunCommand(program2);
   registerMiniappCommand(program2);
+  registerPullCommand(program2);
+  registerPushCommand(program2);
+  registerStatusCommand(program2);
   registerTelemetryCommand(program2);
   return program2;
 }
 
 // src/telemetry/client.ts
-import { arch as arch3, platform as platform3 } from "os";
+import { arch as arch2, platform as platform2 } from "os";
 var buffer = [];
 var FLUSH_TIMEOUT_MS = 3e3;
 var MAX_BATCH_SIZE = 100;
 function commonLabels() {
   return {
-    cli_version: "0.3.3-moxt-run.1",
+    cli_version: "0.4.0-beta.0",
     node_version: process.versions.node,
-    os: platform3(),
-    arch: arch3(),
+    os: platform2(),
+    arch: arch2(),
     is_ci: isCiEnvironment() ? "true" : "false"
   };
 }
@@ -3144,7 +2877,7 @@ async function flush() {
   }
   const batch = buffer.splice(0, MAX_BATCH_SIZE);
   const payload = {
-    release_id: "0.3.3-moxt-run.1",
+    release_id: "0.4.0-beta.0",
     client_type: "cli",
     metric_data_list: batch.map((m) => ({
       profile: "cli",
@@ -3285,9 +3018,9 @@ function installExitHandler() {
 
 // src/index.ts
 updateNotifier({
-  pkg: { name: "@moxt-ai/cli", version: "0.3.3-moxt-run.1" }
+  pkg: { name: "@moxt-ai/cli", version: "0.4.0-beta.0" }
 }).notify();
-var program = createProgram("0.3.3-moxt-run.1");
+var program = createProgram("0.4.0-beta.0");
 instrumentProgram(program);
 installExitHandler();
 program.parseAsync(process.argv).then(async () => {