@moxt-ai/cli 0.3.1 → 0.3.3-moxt-run.0

package/dist/index.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command } from "commander";
 import updateNotifier from "update-notifier";
 
+// src/program.ts
+import { Command } from "commander";
+
 // src/commands/file.ts
 import * as fs from "fs";
 
@@ -147,7 +149,7 @@ function getApiKeyOrUndefined() {
 
 // src/utils/http.ts
 function getUserAgent() {
-  return `moxt-cli/${"0.3.1"} (${platform()}/${arch()}) node/${process.versions.node}`;
+  return `moxt-cli/${"0.3.3-moxt-run.0"} (${platform()}/${arch()}) node/${process.versions.node}`;
 }
 async function fetchApi(method, path2, body) {
   const apiKey = getApiKey();
@@ -217,6 +219,59 @@ function printError(message) {
   console.error(`${colors.red}${message}${colors.reset}`);
 }
 
+// src/utils/search-options.ts
+var SearchOptionsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SearchOptionsError";
+  }
+};
+function parseSearchLimit(raw, defaultValue, max) {
+  if (raw == null || raw === "") {
+    return defaultValue;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0 || String(parsed) !== raw) {
+    throw new SearchOptionsError(`Error: --limit must be a positive integer, got "${raw}".`);
+  }
+  if (parsed > max) {
+    throw new SearchOptionsError(`Error: --limit must be less than or equal to ${max}.`);
+  }
+  return parsed;
+}
+function parseSearchMode(raw) {
+  if (raw == null || raw === "") {
+    return "any";
+  }
+  if (raw === "all" || raw === "any") {
+    return raw;
+  }
+  throw new SearchOptionsError(`Error: --mode must be "any" or "all", got "${raw}".`);
+}
+function parseTeammateId(raw) {
+  if (raw == null || raw === "") {
+    return void 0;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0 || String(parsed) !== raw) {
+    throw new SearchOptionsError(`Error: --teammate-id must be a positive integer, got "${raw}".`);
+  }
+  return parsed;
+}
+
+// src/utils/run-or-exit.ts
+function runOrExit(fn) {
+  try {
+    return fn();
+  } catch (err) {
+    if (err instanceof SpaceOptionsError || err instanceof SearchOptionsError) {
+      printError(err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+
 // src/utils/spinner.ts
 var frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var intervalId = null;
@@ -240,22 +295,48 @@ function stopSpinner(success, message) {
 }
 
 // src/commands/file.ts
-function runOrExit(fn) {
-  try {
-    return fn();
-  } catch (err) {
-    if (err instanceof SpaceOptionsError) {
-      printError(err.message);
-      process.exit(1);
-    }
-    throw err;
-  }
-}
 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)");
 }
 function registerFileCommand(program2) {
   const file = program2.command("file").description("File operations");
+  addSpaceOptions(
+    file.command("search").description("Search files in accessible spaces").argument("<query>", "Search query").option("-l, --limit <limit>", "Maximum number of files to return", "30").option("--mode <mode>", "Keyword matching mode: any or all", "any")
+  ).action(async (query, options) => {
+    const spaceParams = runOrExit(() => resolveSpaceSelector(options));
+    const limit = runOrExit(() => parseSearchLimit(options.limit, 30, 80));
+    const mode = runOrExit(() => parseSearchMode(options.mode));
+    startSpinner("Searching files...");
+    const response = await httpPost(
+      `/workspaces/${options.workspace}/files/search`,
+      {
+        query,
+        limit,
+        mode,
+        ...spaceParams
+      }
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
+      process.exit(1);
+    }
+    const { items } = response.data;
+    if (items.length === 0) {
+      stopSpinner(true, "No files found.");
+      return;
+    }
+    stopSpinner(true, `Found ${items.length} file(s)`);
+    for (const item of items) {
+      print(`${colors.bold}${item.rank}. ${item.filePath}${colors.reset}`);
+      print(`${colors.dim}repo=${item.repoId} file=${item.fileId}${colors.reset}`);
+      const snippet = item.contentHighlight?.text ?? item.semanticSnippets[0]?.content;
+      if (snippet) {
+        print(snippet);
+      }
+      print("");
+    }
+  });
   addSpaceOptions(
     file.command("get-url").description("Resolve the shareable browser URL for a file").requiredOption("-p, --path <path>", "File path")
   ).action(async (options) => {
@@ -469,6 +550,43 @@ function registerFileCommand(program2) {
   );
 }
 
+// src/commands/memory.ts
+function registerMemoryCommand(program2) {
+  const memory = program2.command("memory").description("Memory operations");
+  memory.command("search").description("Search archived agent memory").requiredOption("-w, --workspace <workspaceId>", "Workspace ID").option("--teammate-id <teammateId>", "Search a managed AI teammate memory").option("-l, --limit <limit>", "Maximum number of memory chunks to return", "5").argument("<query>", "Search query").action(
+    async (query, options) => {
+      const limit = runOrExit(() => parseSearchLimit(options.limit, 5, 10));
+      const teammateId = runOrExit(() => parseTeammateId(options.teammateId));
+      startSpinner("Searching memory...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/memory/search`,
+        {
+          query,
+          limit,
+          ...teammateId !== void 0 ? { agentId: teammateId } : {}
+        }
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
+        process.exit(1);
+      }
+      const { items } = response.data;
+      if (items.length === 0) {
+        stopSpinner(true, "No memory found.");
+        return;
+      }
+      stopSpinner(true, `Found ${items.length} memory chunk(s)`);
+      for (const item of items) {
+        print(`${colors.bold}${item.rank}. pipeline=${item.pipelineId} chunk=${item.chunkIndex}${colors.reset}`);
+        print(`${colors.dim}chunkId=${item.chunkId}${item.contentTruncated ? " truncated=true" : ""}${colors.reset}`);
+        print(item.content);
+        print("");
+      }
+    }
+  );
+}
+
 // src/utils/miniapp-db.ts
 var MiniappDbOptionsError = class extends Error {
   constructor(message) {
@@ -626,120 +744,2246 @@ function registerMiniappCommand(program2) {
   });
 }
 
-// src/telemetry/config.ts
-import * as fs2 from "fs";
-import * as os from "os";
-import * as path from "path";
-function getConfigPath() {
-  return path.join(os.homedir(), ".moxt", "config.json");
+// 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/run/capture.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;
+  }
+};
+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 readTelemetryConfig() {
+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)
+  };
+}
+async function prepareCaptureOutputs(env, runId) {
+  const { outputDir, outputRoot } = captureEnvPaths(env);
+  if (hasValue(outputDir)) {
+    await prepareOutputPath(outputDir, () => prepareCaptureDirectory(outputDir));
+  }
+  if (hasValue(outputRoot)) {
+    const runDir = join(outputRoot, runId);
+    await prepareOutputPath(runDir, () => prepareCaptureDirectory(runDir));
+  }
+}
+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));
+  }
+  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);
+    })
+  );
+}
+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 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 serializeEventsFromTranscript(transcript, startSeq, agent = "claude") {
+  const events = normalizeEvents(transcript, startSeq, agent);
+  return {
+    text: serializeEvents(events),
+    nextSeq: startSeq + events.length
+  };
+}
+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;
+  }
+  if (!entries.includes(RUNLOG_DIRECTORY_MARKER)) {
+    throw new Error("refusing to use run output directory without ownership marker");
+  }
+  await assertRunlogDirectoryMarker(outputDir);
+  const metadataEntries = RUNLOG_METADATA_FILE_NAMES.filter((entry) => entries.includes(entry));
+  if (metadataEntries.length === 0) {
+    return;
+  }
+  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");
+  }
+}
+async function readRunlogMetadataRunId(outputDir, fileName) {
+  let parsed;
   try {
-    const raw = fs2.readFileSync(getConfigPath(), "utf8");
-    const parsed = JSON.parse(raw);
-    return parsed.telemetry ?? {};
-  } catch {
-    return {};
+    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;
 }
-function writeTelemetryConfig(update) {
-  const configPath = getConfigPath();
-  let existing = {};
+async function assertRunlogDirectoryMarker(outputDir) {
+  let parsed;
   try {
-    existing = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+    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`);
+  }
+}
+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"
+  );
+}
+async function writeCaptureUploadFile(outputDir, runId) {
+  const path2 = join(outputDir, "upload.json");
+  try {
+    await access(path2);
+    return;
   } 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));
+  const uploadFile2 = {
+    schema_version: "runlog.upload.v1",
+    run_id: runId,
+    status: "pending",
+    files: {}
+  };
+  await writeFile(path2, `${JSON.stringify(uploadFile2, null, 2)}
+`, "utf8");
 }
-
-// src/telemetry/opt-out.ts
-function isCiEnvironment() {
-  return process.env.CI === "true" || process.env.CI === "1";
+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");
 }
-function isTelemetryDisabled() {
-  if (process.env.MOXT_TELEMETRY_DISABLED === "1" || process.env.MOXT_TELEMETRY_DISABLED === "true") {
-    return true;
+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 [];
   }
-  if (process.env.DO_NOT_TRACK === "1" || process.env.DO_NOT_TRACK === "true") {
-    return true;
+  const chunks = [];
+  let content = "";
+  let bytes = 0;
+  let lines = 0;
+  let oversizedLine = false;
+  const flush2 = () => {
+    if (content === "") {
+      return;
+    }
+    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;
+    }
+    if (bytes > 0 && bytes + lineBytes > DATA_FILE_TARGET_BYTES) {
+      flush2();
+    }
+    content += line;
+    bytes += lineBytes;
+    lines += 1;
   }
-  return readTelemetryConfig().disabled === true;
+  flush2();
+  return chunks;
 }
-
-// src/commands/telemetry.ts
-function registerTelemetryCommand(program2) {
-  const telemetry = program2.command("telemetry").description("Manage Moxt CLI telemetry");
-  telemetry.command("status").description("Show telemetry status").action(() => {
-    const cfg = readTelemetryConfig();
-    const envOverride = process.env.MOXT_TELEMETRY_DISABLED === "1" || process.env.MOXT_TELEMETRY_DISABLED === "true" || process.env.DO_NOT_TRACK === "1" || process.env.DO_NOT_TRACK === "true";
-    const state = isTelemetryDisabled() ? "disabled" : "enabled";
-    print(`telemetry: ${state}`);
-    if (envOverride) {
-      print("(disabled via environment variable)");
-    } else if (cfg.disabled) {
-      print("(disabled via config file)");
-    }
-  });
-  telemetry.command("enable").description("Enable telemetry").action(() => {
-    writeTelemetryConfig({ disabled: false });
-    print("telemetry: enabled");
-  });
-  telemetry.command("disable").description("Disable telemetry").action(() => {
-    writeTelemetryConfig({ disabled: true });
-    print("telemetry: disabled");
-  });
+function jsonlLines(text) {
+  const normalized = normalizeJsonl(text);
+  if (normalized === "") {
+    return [];
+  }
+  return normalized.slice(0, -1).split("\n").map((line) => `${line}
+`);
 }
-
-// src/commands/whoami.ts
-function registerWhoamiCommand(program2) {
-  program2.command("whoami").description("Show current user information").action(async () => {
-    startSpinner("Fetching user info...");
-    const response = await httpGet("/users/whoami");
-    if (response.ok) {
-      stopSpinner(true, "Done");
-      print(`${colors.bold}Nickname${colors.reset}: ${response.data.nickname}`);
-      print(`${colors.bold}Email${colors.reset}: ${response.data.email}`);
-    } else {
-      stopSpinner(false, "Failed");
-      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
-      process.exit(1);
+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() === "") {
+      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);
+    }
+  }
+  return events;
 }
-
-// src/commands/workspace.ts
-var emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
-function isValidEmail(email) {
-  return emailRegex.test(email);
+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;
+    }
+    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;
+    }
+    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 registerWorkspaceCommand(program2) {
-  const workspace = program2.command("workspace").description("Workspace management");
-  workspace.command("list").description("List all workspaces you belong to").action(async () => {
-    startSpinner("Fetching workspaces...");
-    const response = await httpGet("/workspaces");
-    if (response.ok) {
-      const { workspaces } = response.data;
-      if (workspaces.length === 0) {
-        stopSpinner(true, "No workspaces found.");
-        return;
-      }
-      stopSpinner(true, `Found ${workspaces.length} workspace(s)`);
-      for (const ws of workspaces) {
-        print(`${colors.bold}${ws.workspaceId}${colors.reset}	${ws.name}`);
-      }
-    } else {
-      stopSpinner(false, "Failed");
-      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
-      process.exit(1);
+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;
     }
-  });
-  const members = program2.command("members").description("Manage workspace members");
-  members.command("list").description("List all members in a workspace").requiredOption("-w, --workspace <workspaceId>", "Workspace ID").action(async (options) => {
-    const { workspace: workspaceId } = options;
+    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;
+    }
+    return {
+      schema_version: "runlog.events.v1",
+      seq,
+      type: "assistant_message",
+      ...timestamp === void 0 ? {} : { timestamp },
+      text
+    };
+  }
+  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 }
+    };
+  }
+  return null;
+}
+function parseTranscriptLine(line) {
+  try {
+    const value = JSON.parse(line);
+    return isObject(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function textFromContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  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;
+  }
+  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)}>`
+  }
+];
+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);
+    });
+  }
+  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>`;
+  });
+  return {
+    text: redacted,
+    hits: [...hitCounts.entries()].map(([rule, count]) => ({ rule, count }))
+  };
+}
+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);
+}
+
+// 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 sanitizeRepo(repo) {
+  if (repo === null) return null;
+  return {
+    ...repo,
+    remote: stripRemoteCredentials(repo.remote)
+  };
+}
+
+// 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 };
+  }
+  return {
+    match: "unique",
+    sessionFile,
+    startOffset: previous?.size ?? 0
+  };
+}
+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;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+      continue;
+    }
+    const stat2 = statSync2(path2);
+    snapshot.set(path2, {
+      mtimeMs: stat2.mtimeMs,
+      size: stat2.size
+    });
+  }
+}
+function wasChangedAfterStart(current2, startedAtMs) {
+  return current2.mtimeMs >= startedAtMs - SESSION_START_TOLERANCE_MS;
+}
+
+// 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" };
+}
+
+// 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);
+    }
+  }
+  async stop() {
+    if (!this.enabled) {
+      return;
+    }
+    if (this.timer !== void 0) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    if (this.pollInFlight !== null) {
+      await this.pollInFlight;
+    }
+    await this.poll();
+    await this.flushPendingText();
+  }
+  async finalize(payload, capturedAt) {
+    if (!this.enabled) {
+      return;
+    }
+    if (!isCompleteRecording(payload)) {
+      await Promise.all(this.outputs.map((output) => output.invalidate()));
+    }
+    await finalizeCaptureDirectories(this.directoryPayload(payload), this.env, this.runId, capturedAt, this.files());
+  }
+  queuePoll() {
+    if (this.pollInFlight !== null) {
+      return;
+    }
+    this.pollInFlight = this.poll().finally(() => {
+      this.pollInFlight = null;
+    });
+  }
+  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;
+      }
+      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;
+    }
+    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();
+  }
+  matchOptions() {
+    return {
+      ...this.isSessionCandidate === void 0 ? {} : { isCandidate: this.isSessionCandidate },
+      ...this.newSessionFilesOnly ? { newFilesOnly: true } : {}
+    };
+  }
+};
+var CaptureDirectoryOutput = class {
+  transcript;
+  events;
+  constructor(outputDir) {
+    this.transcript = new JsonlStreamWriter(outputDir, "transcript", "transcript");
+    this.events = new JsonlStreamWriter(outputDir, "events", "events");
+  }
+  async appendTranscript(text) {
+    await this.transcript.appendText(text);
+  }
+  async appendEvents(text) {
+    await this.events.appendText(text);
+  }
+  async invalidate() {
+    await Promise.all([this.transcript.invalidate(), this.events.invalidate()]);
+  }
+  files() {
+    return {
+      events: this.events.files(),
+      transcript: this.transcript.files()
+    };
+  }
+};
+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");
+      })
+    );
+    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;
+    }
+    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;
+  }
+};
+function isCompleteRecording(payload) {
+  return payload.recording.found_chat && payload.recording.quality === "complete";
+}
+function jsonlLines2(text) {
+  if (text === "") {
+    return [];
+  }
+  const normalized = text.endsWith("\n") ? text : `${text}
+`;
+  return normalized.slice(0, -1).split("\n").map((line) => `${line}
+`);
+}
+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();
+  }
+}
+
+// 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;
+  }
+  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;
+  }
+  return headers;
+}
+function firstValue(...values) {
+  return values.find((value) => value !== void 0 && value !== "");
+}
+
+// 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) {
+    try {
+      await uploadDirectory(outputDir, options.runId, options.upload, options.env);
+    } catch (error) {
+      failures.push(`${outputDir}: ${errorMessage2(error)}`);
+    }
+  }
+  if (failures.length > 0) {
+    throw new Error(failures.join("; "));
+  }
+}
+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);
+  }
+  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 {
+    }
+  }
+  for (const dir of ["events", "transcript"]) {
+    await collectFiles(outputDir, join4(outputDir, dir), paths);
+  }
+  return paths.sort();
+}
+async function collectFiles(outputDir, dir, paths) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const absolute = join4(dir, entry.name);
+    if (entry.isDirectory()) {
+      await collectFiles(outputDir, absolute, paths);
+      continue;
+    }
+    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);
+  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 };
+  } catch (error) {
+    if (controller.signal.aborted) {
+      throw new Error(`upload timed out after ${timeoutMs}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function readUploadState(outputDir, runId) {
+  try {
+    const value = JSON.parse(await readFile2(join4(outputDir, "upload.json"), "utf8"));
+    if (isUploadState(value, runId)) {
+      return value;
+    }
+  } catch {
+  }
+  return {
+    schema_version: "runlog.upload.v1",
+    run_id: runId,
+    status: "pending",
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    files: {}
+  };
+}
+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";
+  }
+  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 (states.some((status) => status === "uploaded")) {
+    return "partial";
+  }
+  return "uploading";
+}
+function isUploadState(value, runId) {
+  if (!isObject2(value)) {
+    return false;
+  }
+  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;
+  }
+}
+function apiBaseUrl(env) {
+  return `https://${env.MOXT_HOST ?? DEFAULT_HOST2}/openapi/v1`;
+}
+function userAgent() {
+  return `moxt-cli/${"0.3.3-moxt-run.0"} (${platform2()}/${arch2()}) node/${process.versions.node}`;
+}
+function errorMessage2(error) {
+  if (error instanceof Error && error.message !== "") {
+    return error.message;
+  }
+  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 }
+    });
+  } catch {
+    return { match: "none" };
+  }
+}
+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;
+    }
+    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)) {
+      continue;
+    }
+    seen.add(pid);
+    pids.push(pid);
+    queue.push(...childrenByParent.get(pid) ?? []);
+  }
+  return pids;
+}
+function openSessionFileFromLsof(lsofOutput, options) {
+  const files = /* @__PURE__ */ new Set();
+  for (const line of lsofOutput.split("\n")) {
+    if (!line.startsWith("n")) {
+      continue;
+    }
+    const path2 = line.slice(1);
+    if (!path2.endsWith(".jsonl") || !isInside(options.sessionRoot, path2)) {
+      continue;
+    }
+    if (options.isCandidate !== void 0 && !options.isCandidate(path2)) {
+      continue;
+    }
+    files.add(alignPathToRoot(options.sessionRoot, path2));
+  }
+  if (files.size === 0) {
+    return { match: "none" };
+  }
+  if (files.size === 1) {
+    return { match: "unique", sessionFile: [...files].join("") };
+  }
+  return { match: "ambiguous" };
+}
+function isInside(root, path2) {
+  if (isPathInside(root, path2)) {
+    return true;
+  }
+  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;
+}
+function alignPathToRoot(root, path2) {
+  if (root.startsWith("/var/") && path2.startsWith("/private/var/")) {
+    return path2.slice("/private".length);
+  }
+  if (root.startsWith("/private/var/") && path2.startsWith("/var/")) {
+    return `/private${path2}`;
+  }
+  return path2;
+}
+
+// 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;
+  }
+  return {
+    root,
+    remote: git(["config", "--get", "remote.origin.url"], cwd) ?? "",
+    branch: git(["branch", "--show-current"], cwd) ?? "",
+    head: git(["rev-parse", "HEAD"], cwd) ?? ""
+  };
+}
+function git(args, cwd) {
+  try {
+    return execFileSync2("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return 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 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 codexSessionsDir(home, env = {}) {
+  return join5(codexHome(home, env), "sessions");
+}
+function codexHome(home, env = {}) {
+  const { CODEX_HOME: configured } = env;
+  return hasValue2(configured) ? configured : join5(home, ".codex");
+}
+function expectedCodexCwd(cwd, agentArgs) {
+  const cd = codexCdArg(agentArgs);
+  return cd === void 0 ? resolve(cwd) : resolve(cwd, cd);
+}
+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);
+    }
+  }
+  return void 0;
+}
+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 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;
+    }
+  }
+  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);
+    }
+  }
+  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);
+  }
+}
+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 codexLineCwd(line) {
+  if (line.trim() === "") {
+    return null;
+  }
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const entry = rawCodexSessionLine(value);
+  if (entry === null) {
+    return null;
+  }
+  const type = entry.type;
+  if (type !== "session_meta" && type !== "turn_context") {
+    return null;
+  }
+  const payload = rawCodexSessionPayload(entry.payload);
+  const cwd = payload?.cwd;
+  return typeof cwd === "string" ? cwd : null;
+}
+function readFilePrefix(path2, bytes) {
+  const fd = openSync(path2, "r");
+  try {
+    const buffer2 = Buffer.alloc(bytes);
+    const read = readSync(fd, buffer2, 0, bytes, 0);
+    return buffer2.subarray(0, read).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+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);
+  try {
+    await prepareCaptureOutputs(captureEnv, runId);
+  } 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;
+  }
+  const rememberOpenSessionFile = () => {
+    if (!baselineOk || sessions === "" || childRootPid === void 0 || openSessionFileMatch.match !== "none") {
+      return openSessionFileMatch;
+    }
+    const matched = findOpenSessionFile({
+      rootPid: childRootPid,
+      sessionRoot: sessions,
+      ...isSessionCandidate === void 0 ? {} : { isCandidate: isSessionCandidate }
+    });
+    if (matched.match !== "none") {
+      openSessionFileMatch = matched;
+    }
+    return openSessionFileMatch;
+  };
+  const stopProcessSessionWatcher = () => {
+    if (processSessionTimer !== void 0) {
+      clearInterval(processSessionTimer);
+      processSessionTimer = void 0;
+    }
+  };
+  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) {
+      return;
+    }
+    if (child === null) {
+      pendingForward = signal;
+      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 {
+    }
+  }
+  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) {
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+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";
+    }
+  }
+  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
+    },
+    recording: recordingFromSessionMatch(sessionMatch),
+    repo: input.repo
+  };
+}
+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;
+  }
+  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;
+    }
+    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");
+  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) {
+  if (!options.workspace) {
+    return void 0;
+  }
+  if (!process.env.MOXT_API_KEY) {
+    printError("Error: MOXT_API_KEY is required when using moxt run upload mode.");
+    process.exit(1);
+  }
+  return {
+    workspaceId: options.workspace
+  };
+}
+async function runLocalAgentOrExit(agent, agentArgs, upload) {
+  return await runLocalAgent({
+    agent,
+    agentArgs,
+    ...upload === void 0 ? {} : { upload }
+  });
+}
+
+// src/telemetry/config.ts
+import * as fs2 from "fs";
+import * as os from "os";
+import * as path from "path";
+function getConfigPath() {
+  return path.join(os.homedir(), ".moxt", "config.json");
+}
+function readTelemetryConfig() {
+  try {
+    const raw = fs2.readFileSync(getConfigPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.telemetry ?? {};
+  } catch {
+    return {};
+  }
+}
+function writeTelemetryConfig(update) {
+  const configPath = getConfigPath();
+  let existing = {};
+  try {
+    existing = JSON.parse(fs2.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));
+}
+
+// src/telemetry/opt-out.ts
+function isCiEnvironment() {
+  return process.env.CI === "true" || process.env.CI === "1";
+}
+function isTelemetryDisabled() {
+  if (process.env.MOXT_TELEMETRY_DISABLED === "1" || process.env.MOXT_TELEMETRY_DISABLED === "true") {
+    return true;
+  }
+  if (process.env.DO_NOT_TRACK === "1" || process.env.DO_NOT_TRACK === "true") {
+    return true;
+  }
+  return readTelemetryConfig().disabled === true;
+}
+
+// src/commands/telemetry.ts
+function registerTelemetryCommand(program2) {
+  const telemetry = program2.command("telemetry").description("Manage Moxt CLI telemetry");
+  telemetry.command("status").description("Show telemetry status").action(() => {
+    const cfg = readTelemetryConfig();
+    const envOverride = process.env.MOXT_TELEMETRY_DISABLED === "1" || process.env.MOXT_TELEMETRY_DISABLED === "true" || process.env.DO_NOT_TRACK === "1" || process.env.DO_NOT_TRACK === "true";
+    const state = isTelemetryDisabled() ? "disabled" : "enabled";
+    print(`telemetry: ${state}`);
+    if (envOverride) {
+      print("(disabled via environment variable)");
+    } else if (cfg.disabled) {
+      print("(disabled via config file)");
+    }
+  });
+  telemetry.command("enable").description("Enable telemetry").action(() => {
+    writeTelemetryConfig({ disabled: false });
+    print("telemetry: enabled");
+  });
+  telemetry.command("disable").description("Disable telemetry").action(() => {
+    writeTelemetryConfig({ disabled: true });
+    print("telemetry: disabled");
+  });
+}
+
+// src/commands/whoami.ts
+function registerWhoamiCommand(program2) {
+  program2.command("whoami").description("Show current user information").action(async () => {
+    startSpinner("Fetching user info...");
+    const response = await httpGet("/users/whoami");
+    if (response.ok) {
+      stopSpinner(true, "Done");
+      print(`${colors.bold}Nickname${colors.reset}: ${response.data.nickname}`);
+      print(`${colors.bold}Email${colors.reset}: ${response.data.email}`);
+    } else {
+      stopSpinner(false, "Failed");
+      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/workspace.ts
+var emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+function isValidEmail(email) {
+  return emailRegex.test(email);
+}
+function registerWorkspaceCommand(program2) {
+  const workspace = program2.command("workspace").description("Workspace management");
+  workspace.command("list").description("List all workspaces you belong to").action(async () => {
+    startSpinner("Fetching workspaces...");
+    const response = await httpGet("/workspaces");
+    if (response.ok) {
+      const { workspaces } = response.data;
+      if (workspaces.length === 0) {
+        stopSpinner(true, "No workspaces found.");
+        return;
+      }
+      stopSpinner(true, `Found ${workspaces.length} workspace(s)`);
+      for (const ws of workspaces) {
+        print(`${colors.bold}${ws.workspaceId}${colors.reset}	${ws.name}`);
+      }
+    } else {
+      stopSpinner(false, "Failed");
+      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
+      process.exit(1);
+    }
+  });
+  const members = program2.command("members").description("Manage workspace members");
+  members.command("list").description("List all members in a workspace").requiredOption("-w, --workspace <workspaceId>", "Workspace ID").action(async (options) => {
+    const { workspace: workspaceId } = options;
     startSpinner("Fetching workspace members...");
     const response = await httpGet(`/workspaces/${workspaceId}/members`);
     if (!response.ok) {
@@ -823,17 +3067,33 @@ function registerWorkspaceCommand(program2) {
   });
 }
 
+// src/program.ts
+function createProgram(version) {
+  const program2 = new Command();
+  program2.name("moxt").description("Moxt CLI - AI Workspace").version(version).action(() => {
+    program2.help();
+  });
+  registerWhoamiCommand(program2);
+  registerWorkspaceCommand(program2);
+  registerFileCommand(program2);
+  registerMemoryCommand(program2);
+  registerRunCommand(program2);
+  registerMiniappCommand(program2);
+  registerTelemetryCommand(program2);
+  return program2;
+}
+
 // src/telemetry/client.ts
-import { arch as arch2, platform as platform2 } from "os";
+import { arch as arch3, platform as platform3 } from "os";
 var buffer = [];
 var FLUSH_TIMEOUT_MS = 3e3;
 var MAX_BATCH_SIZE = 100;
 function commonLabels() {
   return {
-    cli_version: "0.3.1",
+    cli_version: "0.3.3-moxt-run.0",
     node_version: process.versions.node,
-    os: platform2(),
-    arch: arch2(),
+    os: platform3(),
+    arch: arch3(),
     is_ci: isCiEnvironment() ? "true" : "false"
   };
 }
@@ -876,7 +3136,7 @@ async function flush() {
   }
   const batch = buffer.splice(0, MAX_BATCH_SIZE);
   const payload = {
-    release_id: "0.3.1",
+    release_id: "0.3.3-moxt-run.0",
     client_type: "cli",
     metric_data_list: batch.map((m) => ({
       profile: "cli",
@@ -1017,19 +3277,11 @@ function installExitHandler() {
 
 // src/index.ts
 updateNotifier({
-  pkg: { name: "@moxt-ai/cli", version: "0.3.1" }
+  pkg: { name: "@moxt-ai/cli", version: "0.3.3-moxt-run.0" }
 }).notify();
-var program = new Command();
-program.name("moxt").description("Moxt CLI - AI Workspace").version("0.3.1").action(() => {
-  program.help();
-});
+var program = createProgram("0.3.3-moxt-run.0");
 instrumentProgram(program);
 installExitHandler();
-registerWhoamiCommand(program);
-registerWorkspaceCommand(program);
-registerFileCommand(program);
-registerMiniappCommand(program);
-registerTelemetryCommand(program);
 program.parseAsync(process.argv).then(async () => {
   await flush();
 }).catch(async (err) => {