@moxt-ai/cli 0.3.3-moxt-run.1 → 0.3.3

package/dist/index.js

@@ -149,7 +149,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.3.3"} (${platform()}/${arch()}) node/${process.versions.node}`;
 }
 async function fetchApi(method, path2, body) {
   const apiKey = getApiKey();
@@ -189,6 +189,9 @@ async function httpPut(path2, body) {
 async function httpPost(path2, body) {
   return request("POST", path2, body);
 }
+async function httpPatch(path2, body) {
+  return request("PATCH", path2, body);
+}
 async function httpDelete(path2, body) {
   return request("DELETE", path2, body);
 }
@@ -744,2334 +747,1147 @@ 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/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");
+// 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 {};
   }
-  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;
+function writeTelemetryConfig(update) {
+  const configPath = getConfigPath();
+  let existing = {};
+  try {
+    existing = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+  } catch {
+    existing = {};
   }
-  return {
-    ...env,
-    MOXT_RUN_OUTPUT_ROOT: defaultCaptureOutputRoot(home, env)
-  };
+  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";
 }
-async function prepareCaptureOutputs(env, runId) {
-  const { outputDir, outputRoot } = captureEnvPaths(env);
-  if (hasValue(outputDir)) {
-    await prepareOutputPath(outputDir, () => prepareCaptureDirectory(outputDir));
+function isTelemetryDisabled() {
+  if (process.env.MOXT_TELEMETRY_DISABLED === "1" || process.env.MOXT_TELEMETRY_DISABLED === "true") {
+    return true;
   }
-  if (hasValue(outputRoot)) {
-    const runDir = join(outputRoot, runId);
-    await prepareOutputPath(runDir, () => prepareCaptureDirectory(runDir));
+  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) {
+      stopSpinner(false, "Failed to fetch members");
+      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
+      process.exit(1);
+    }
+    const { members: members2 } = response.data;
+    if (members2.length === 0) {
+      stopSpinner(true, "No members found.");
+      return;
+    }
+    stopSpinner(true, `Found ${members2.length} member(s)`);
+    for (const member of members2) {
+      const name = member.displayName || "-";
+      print(`${colors.bold}${member.email}${colors.reset}	${name}	${member.role}`);
+    }
+  });
+  members.command("remove").description("Remove members from a workspace").requiredOption("-w, --workspace <workspaceId>", "Workspace ID").argument("<emails>", "Emails to remove (comma-separated)").action(async (emailsArg, options) => {
+    const { workspace: workspaceId } = options;
+    const emails = emailsArg.split(",").map((e) => e.trim()).filter(Boolean);
+    if (emails.length === 0) {
+      printError("No valid emails provided");
+      process.exit(1);
+    }
+    const invalidEmails = emails.filter((e) => !isValidEmail(e));
+    if (invalidEmails.length > 0) {
+      for (const email of invalidEmails) {
+        printError(`Invalid email format: ${email}`);
+      }
+      process.exit(1);
+    }
+    startSpinner("Fetching workspace members...");
+    const membersResponse = await httpGet(`/workspaces/${workspaceId}/members`);
+    if (!membersResponse.ok) {
+      stopSpinner(false, "Failed to fetch members");
+      printError(`Error [${membersResponse.status}]: ${JSON.stringify(membersResponse.data)}`);
+      process.exit(1);
+    }
+    stopSpinner(true, "Members fetched");
+    const { members: members2 } = membersResponse.data;
+    const emailToMember = new Map(members2.map((m) => [m.email.toLowerCase(), m]));
+    for (const email of emails) {
+      const member = emailToMember.get(email.toLowerCase());
+      if (!member) {
+        print(`${colors.red}\u2717${colors.reset} ${email} - not found in workspace`);
+        continue;
+      }
+      const deleteResponse = await httpDelete(`/workspaces/${workspaceId}/members/${member.userId}`);
+      if (deleteResponse.ok) {
+        print(`${colors.green}\u2713${colors.reset} ${email} - removed`);
+      } else {
+        print(`${colors.red}\u2717${colors.reset} ${email} - failed: ${JSON.stringify(deleteResponse.data)}`);
+      }
+    }
+  });
+  const space = program2.command("space").description("Manage spaces");
+  space.command("list").description("List accessible spaces in a workspace").requiredOption("-w, --workspace <workspaceId>", "Workspace ID").action(async (options) => {
+    const { workspace: workspaceId } = options;
+    startSpinner("Fetching spaces...");
+    const response = await httpGet(`/workspaces/${workspaceId}/spaces`);
+    if (!response.ok) {
+      stopSpinner(false, "Failed to fetch spaces");
+      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
+      process.exit(1);
+    }
+    const { spaces } = response.data;
+    if (spaces.length === 0) {
+      stopSpinner(true, "No spaces found.");
+      return;
+    }
+    stopSpinner(true, `Found ${spaces.length} space(s)`);
+    print(
+      `${colors.bold}TYPE${colors.reset}	${colors.bold}TEAM_SPACE_ID${colors.reset}	${colors.bold}TEAMMATE_ID${colors.reset}	${colors.bold}NAME${colors.reset}`
+    );
+    for (const s of spaces) {
+      const teamSpaceId = s.teamSpaceId ?? "";
+      const teammateId = s.agentId != null ? String(s.agentId) : "";
+      print(`${s.type}	${teamSpaceId}	${teammateId}	${s.name}`);
+    }
+  });
 }
-function captureOutputDirectories(env, runId) {
-  const { outputDir, outputRoot } = captureEnvPaths(env);
-  const dirs = /* @__PURE__ */ new Set();
-  if (hasValue(outputDir)) {
-    dirs.add(outputDir);
+
+// src/commands/workflow.ts
+import * as fs3 from "fs";
+import { TextDecoder } from "util";
+var MAX_DESC_LENGTH = 5e3;
+var MAX_COMMENT_CONTENT_LENGTH = 5e3;
+var MAX_COMMENT_CONTENT_BYTES = MAX_COMMENT_CONTENT_LENGTH * 4;
+var WorkflowOptionsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorkflowOptionsError";
   }
-  if (hasValue(outputRoot)) {
-    dirs.add(join(outputRoot, runId));
+};
+function runOrExit3(fn) {
+  try {
+    return fn();
+  } catch (err) {
+    if (err instanceof WorkflowOptionsError || err instanceof SpaceOptionsError || err instanceof SearchOptionsError) {
+      printError(err.message);
+      process.exit(1);
+    }
+    throw err;
   }
-  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 addWorkspaceOption(command) {
+  return command.requiredOption("-w, --workspace <workspaceId>", "Workspace ID");
 }
-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 addSpaceOptions2(command) {
+  return addWorkspaceOption(command).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 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 addAssigneeOptions(command) {
+  return command.option("--human-id <humanId>", "Human assignee ID").option("--assistant-id <assistantId>", "AI assistant assignee ID").option("--teammate-id <teammateId>", "AI teammate assignee ID");
 }
-function serializeEventsFromTranscript(transcript, startSeq, agent = "claude") {
-  const events = normalizeEvents(transcript, startSeq, agent);
-  return {
-    text: serializeEvents(events),
-    nextSeq: startSeq + events.length
-  };
+function addPreferredAssigneeOptions(command) {
+  return command.option("--preferred-human-id <humanId>", "Preferred human assignee ID").option("--preferred-assistant-id <assistantId>", "Preferred AI assistant assignee ID").option("--preferred-teammate-id <teammateId>", "Preferred AI teammate assignee ID");
 }
-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");
+function parsePositiveInteger(raw, label) {
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0 || String(parsed) !== raw) {
+    throw new WorkflowOptionsError(`Error: ${label} must be a positive integer, got "${raw}".`);
   }
-  await assertRunlogDirectoryMarker(outputDir);
-  const metadataEntries = RUNLOG_METADATA_FILE_NAMES.filter((entry) => entries.includes(entry));
-  if (metadataEntries.length === 0) {
-    return;
+  return parsed;
+}
+function parseOptionalPositiveInteger(raw, label) {
+  if (raw == null || raw === "") return void 0;
+  return parsePositiveInteger(raw, label);
+}
+function parseStatusType(raw) {
+  if (raw == null || raw === "") return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  if ((parsed === 1 || parsed === 2 || parsed === 3) && String(parsed) === raw) return parsed;
+  throw new WorkflowOptionsError("Error: --type must be one of 1 (todo), 2 (in-progress), or 3 (done).");
+}
+function parseRequiredStatusType(raw) {
+  const value = parseStatusType(raw);
+  if (value === void 0) {
+    throw new WorkflowOptionsError("Error: --type is required.");
+  }
+  return value;
+}
+function parsePriority(raw) {
+  if (raw == null || raw === "") return void 0;
+  if (raw === "urgent") return 0;
+  if (raw === "high") return 1;
+  if (raw === "medium") return 2;
+  if (raw === "low") return 3;
+  throw new WorkflowOptionsError('Error: --priority must be "urgent", "high", "medium", or "low".');
+}
+function parseRequiredPriority(raw) {
+  return parsePriority(raw ?? "medium") ?? 2;
+}
+function parseWorkflowScope(raw) {
+  if (raw == null || raw === "") return "all";
+  if (raw === "all" || raw === "owner_is_me") return raw;
+  throw new WorkflowOptionsError('Error: --scope must be "all" or "owner_is_me".');
+}
+function parseTaskScope(raw) {
+  if (raw == null || raw === "") return "all";
+  if (raw === "all" || raw === "assigned_to_me" || raw === "subscribed_by_me" || raw === "owner_is_me") {
+    return raw;
   }
-  const runIds = await Promise.all(
-    metadataEntries.map((entry) => readRunlogMetadataRunId(outputDir, entry))
+  throw new WorkflowOptionsError(
+    'Error: --scope must be "all", "assigned_to_me", "subscribed_by_me", or "owner_is_me".'
   );
-  const uniqueRunIds = new Set(runIds);
-  if (uniqueRunIds.size > 1) {
-    throw new Error("refusing to use run output directory with mismatched run metadata");
+}
+function parseFileIds(raw, label = "--file-ids") {
+  if (raw == null || raw === "") return void 0;
+  const ids = raw.split(",").map((item) => item.trim()).filter(Boolean);
+  if (ids.length === 0) {
+    throw new WorkflowOptionsError(`Error: ${label} must include at least one file ID.`);
   }
+  return ids;
 }
-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)}`);
+function readDescFile(path2) {
+  if (path2 == null || path2 === "") return void 0;
+  if (!fs3.existsSync(path2)) {
+    throw new WorkflowOptionsError(`Error: desc file not found: ${path2}`);
   }
-  const value = objectValue(parsed);
-  if (value === null) {
-    throw new Error(`invalid ${fileName}: expected object`);
+  const stat = fs3.statSync(path2);
+  if (!stat.isFile()) {
+    throw new WorkflowOptionsError(`Error: desc file is not a file: ${path2}`);
   }
-  if (value.schema_version !== RUNLOG_METADATA_SCHEMAS[fileName]) {
-    throw new Error(`invalid ${fileName}: unexpected schema_version`);
+  const buffer2 = fs3.readFileSync(path2);
+  if (isBinaryContent(buffer2)) {
+    throw new WorkflowOptionsError("Error: desc file must be UTF-8 text, not binary content.");
   }
-  if (typeof value.run_id !== "string" || value.run_id.trim() === "") {
-    throw new Error(`invalid ${fileName}: missing run_id`);
+  const content = buffer2.toString("utf8");
+  if (content.length > MAX_DESC_LENGTH) {
+    throw new WorkflowOptionsError(`Error: desc file must be at most ${MAX_DESC_LENGTH} characters.`);
   }
-  return value.run_id;
+  return content;
 }
-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)}`);
+function readCommentContentFile(path2) {
+  if (!fs3.existsSync(path2)) {
+    throw new WorkflowOptionsError(`Error: comment content file not found: ${path2}`);
   }
-  const value = objectValue(parsed);
-  if (value?.schema_version !== RUNLOG_DIRECTORY_MARKER_SCHEMA) {
-    throw new Error(`invalid ${RUNLOG_DIRECTORY_MARKER}: unexpected schema_version`);
+  const stat = fs3.statSync(path2);
+  if (!stat.isFile()) {
+    throw new WorkflowOptionsError(`Error: comment content path is not a file: ${path2}`);
   }
-}
-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");
+  if (stat.size > MAX_COMMENT_CONTENT_BYTES) {
+    throw new WorkflowOptionsError(
+      `Error: comment content file must be at most ${MAX_COMMENT_CONTENT_LENGTH} characters.`
+    );
+  }
+  const buffer2 = fs3.readFileSync(path2);
+  if (buffer2.includes(0)) {
+    throw new WorkflowOptionsError("Error: comment content file must not contain NUL bytes.");
+  }
+  if (isBinaryContent(buffer2)) {
+    throw new WorkflowOptionsError("Error: comment content file must be UTF-8 text, not binary content.");
+  }
+  let content;
   try {
-    await access(path2);
-    return;
+    content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(buffer2);
   } catch {
+    throw new WorkflowOptionsError("Error: comment content file must contain valid UTF-8 text.");
   }
-  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");
+  if (content.length === 0) {
+    throw new WorkflowOptionsError("Error: comment content file must not be empty.");
+  }
+  if (content.length > MAX_COMMENT_CONTENT_LENGTH) {
+    throw new WorkflowOptionsError(
+      `Error: comment content file must be at most ${MAX_COMMENT_CONTENT_LENGTH} characters.`
+    );
+  }
+  return content;
 }
-async function writeChunks(outputDir, chunks) {
-  await Promise.all(chunks.map((chunk) => writeFile(join(outputDir, chunk.path), chunk.content, "utf8")));
+function parseAssigneeBody(options, allowClear) {
+  const hasClear = options.clear === true;
+  const humanId = parseOptionalPositiveInteger(options.humanId, "--human-id");
+  const assistantId = parseOptionalPositiveInteger(options.assistantId, "--assistant-id");
+  const teammateId = parseOptionalPositiveInteger(options.teammateId, "--teammate-id");
+  const count = (humanId !== void 0 ? 1 : 0) + (assistantId !== void 0 ? 1 : 0) + (teammateId !== void 0 ? 1 : 0);
+  if (hasClear && !allowClear) {
+    throw new WorkflowOptionsError("Error: --clear is not supported here.");
+  }
+  if (hasClear && count > 0) {
+    throw new WorkflowOptionsError("Error: --clear cannot be used with assignee ID options.");
+  }
+  if (count > 1) {
+    throw new WorkflowOptionsError("Error: assignee ID options are mutually exclusive.");
+  }
+  if (hasClear) return {};
+  if (humanId !== void 0) return { assigneeHumanId: humanId };
+  if (assistantId !== void 0) return { assigneeAiAssistantId: assistantId };
+  if (teammateId !== void 0) return { assigneeAiTeammateId: teammateId };
+  return {};
 }
-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;
-    }
-    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;
-  }
-  flush2();
-  return chunks;
-}
-function jsonlLines(text) {
-  const normalized = normalizeJsonl(text);
-  if (normalized === "") {
-    return [];
-  }
-  return normalized.slice(0, -1).split("\n").map((line) => `${line}
-`);
+function parsePreferredAssigneeBody(options) {
+  const hasClear = options.clearPreferredAssignee === true;
+  const humanId = parseOptionalPositiveInteger(options.preferredHumanId, "--preferred-human-id");
+  const assistantId = parseOptionalPositiveInteger(options.preferredAssistantId, "--preferred-assistant-id");
+  const teammateId = parseOptionalPositiveInteger(options.preferredTeammateId, "--preferred-teammate-id");
+  const count = (humanId !== void 0 ? 1 : 0) + (assistantId !== void 0 ? 1 : 0) + (teammateId !== void 0 ? 1 : 0);
+  if (hasClear && count > 0) {
+    throw new WorkflowOptionsError("Error: --clear-preferred-assignee cannot be used with preferred assignee ID options.");
+  }
+  if (count > 1) {
+    throw new WorkflowOptionsError("Error: preferred assignee ID options are mutually exclusive.");
+  }
+  if (hasClear) return { preferredAssigneeHumanId: null };
+  if (humanId !== void 0) return { preferredAssigneeHumanId: humanId };
+  if (assistantId !== void 0) return { preferredAssigneeAiAssistantId: assistantId };
+  if (teammateId !== void 0) return { preferredAssigneeAiTeammateId: teammateId };
+  return {};
 }
-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;
-}
-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 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;
-    }
-    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 assertNonEmptyBody(body) {
+  if (Object.keys(body).length === 0) {
+    throw new WorkflowOptionsError("Error: at least one update option must be provided.");
   }
 }
-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 "";
+function buildQuery(params) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      query.set(key, String(value));
     }
-    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;
+  const text = query.toString();
+  return text ? `?${text}` : "";
 }
-
-// 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 failResponse(response) {
+  printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
+  process.exit(1);
 }
-function addHit(hitCounts, rule) {
-  hitCounts.set(rule, (hitCounts.get(rule) ?? 0) + 1);
+function priorityLabel(value) {
+  switch (value) {
+    case 0:
+      return "urgent";
+    case 1:
+      return "high";
+    case 2:
+      return "medium";
+    case 3:
+      return "low";
+    default: {
+      const unsupportedValue = value;
+      throw new Error(`Unsupported workflow task priority: ${String(unsupportedValue)}`);
+    }
+  }
+}
+function statusTypeLabel(value) {
+  switch (value) {
+    case 1:
+      return "todo";
+    case 2:
+      return "in-progress";
+    case 3:
+      return "done";
+    default: {
+      const unsupportedValue = value;
+      throw new Error(`Unsupported workflow status type: ${String(unsupportedValue)}`);
+    }
+  }
+}
+function formatAssignee(assignee) {
+  if (!assignee) return "-";
+  if (assignee.type === "human") return assignee.displayName ?? `human:${assignee.humanId}`;
+  if (assignee.type === "assistant") return assignee.displayName ?? `assistant:${assignee.aiAssistantId}`;
+  if (assignee.type === "teammate") return assignee.displayName ?? `teammate:${assignee.aiTeammateId}`;
+  return "unknown";
+}
+function printWorkflow(item) {
+  print(`${colors.bold}${item.fileId}${colors.reset}	owner=${item.ownerHumanId ?? "-"}	desc=${item.desc ?? "-"}`);
+}
+function indentation(size) {
+  return " ".repeat(size);
+}
+function escapeTerminalControlCharacters(value) {
+  return value.replace(/\r\n/g, "\n").replace(
+    /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g,
+    (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "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 formatDetailScalar(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") {
+    const escaped = escapeTerminalControlCharacters(value);
+    if (escaped === "") return '""';
+    if (/\n/.test(escaped)) return JSON.stringify(escaped);
+    return escaped;
   }
+  return String(value);
 }
-function sanitizeRepo(repo) {
-  if (repo === null) return null;
-  return {
-    ...repo,
-    remote: stripRemoteCredentials(repo.remote)
-  };
+function printDetailField(name, value, indent = 0) {
+  print(`${indentation(indent)}${name}: ${formatDetailScalar(value)}`);
 }
-
-// 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 printDetailTextField(name, value, indent = 0) {
+  if (value === null || value === "") {
+    printDetailField(name, value, indent);
+    return;
   }
-  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
-    });
+  const escaped = escapeTerminalControlCharacters(value);
+  print(`${indentation(indent)}${name}:`);
+  for (const line of escaped.split("\n")) {
+    print(`${indentation(indent + 2)}${line}`);
   }
 }
-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;
-    }
+function printAssigneeDetail(name, assignee, indent = 0) {
+  if (assignee === null) {
+    printDetailField(name, null, indent);
+    return;
   }
-  async captureNewText() {
-    if (this.sessionFile === null) {
-      return;
-    }
-    const next = await readFileFromOffset(this.sessionFile, this.readOffset);
-    if (next.bytes === 0) {
+  print(`${indentation(indent)}${name}:`);
+  printDetailField("type", assignee.type, indent + 2);
+  switch (assignee.type) {
+    case "human":
+      printDetailField("humanId", assignee.humanId, indent + 2);
+      printDetailField("displayName", assignee.displayName, indent + 2);
+      printDetailField("avatarUrl", assignee.avatarUrl, indent + 2);
       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;
+    case "assistant":
+      printDetailField("aiAssistantId", assignee.aiAssistantId, indent + 2);
+      printDetailField("displayName", assignee.displayName, indent + 2);
+      printDetailField("avatarUrl", assignee.avatarUrl, indent + 2);
       return;
-    }
-    const complete = combined.slice(0, lastNewline + 1);
-    this.pendingText = combined.slice(lastNewline + 1);
-    await this.captureTranscriptText(complete);
-  }
-  async flushPendingText() {
-    if (this.pendingText === "") {
+    case "teammate":
+      printDetailField("aiTeammateId", assignee.aiTeammateId, indent + 2);
+      printDetailField("displayName", assignee.displayName, indent + 2);
+      printDetailField("avatarUrl", assignee.avatarUrl, indent + 2);
       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)
+    case "unknown":
+      printDetailField("humanId", assignee.humanId, indent + 2);
+      printDetailField("aiAssistantId", assignee.aiAssistantId, indent + 2);
+      printDetailField("aiTeammateId", assignee.aiTeammateId, indent + 2);
+  }
+}
+function printStatusRemainingFields(item, indent) {
+  printDetailField("name", item.name, indent);
+  printDetailTextField("desc", item.desc, indent);
+  printDetailField("type", `${item.type} (${statusTypeLabel(item.type)})`, indent);
+  printAssigneeDetail("preferredAssignee", item.preferredAssignee, indent);
+  printDetailField("order", item.order, indent);
+}
+function printStatusDetail(item) {
+  print(`${colors.bold}Status${colors.reset}`);
+  printDetailField("scopedId", item.scopedId);
+  printStatusRemainingFields(item, 0);
+}
+function printWorkflowDetail(item) {
+  print(`${colors.bold}Workflow${colors.reset}`);
+  printDetailField("fileId", item.fileId);
+  printDetailField("ownerHumanId", item.ownerHumanId);
+  printDetailTextField("desc", item.desc);
+  if (item.statusList.length === 0) {
+    print("statusList: []");
+  } else {
+    print("statusList:");
+    for (const status of item.statusList) {
+      print(`  - scopedId: ${status.scopedId}`);
+      printStatusRemainingFields(status, 4);
+    }
+  }
+  if (item.transitions.length === 0) {
+    print("transitions: []");
+  } else {
+    print("transitions:");
+    for (const transition of item.transitions) {
+      print(`  - statusFromScopedId: ${transition.statusFromScopedId}`);
+      printDetailField("statusToScopedId", transition.statusToScopedId, 4);
+    }
+  }
+}
+function printTaskSummary(item) {
+  const runIds = item.agentRuns.map((run) => run.pipelineTriggerId).join(",") || "-";
+  print(
+    `${colors.bold}#${item.scopedId}${colors.reset}	${item.title}	status=${item.statusScopedId}	priority=${priorityLabel(item.priority)}	assignee=${formatAssignee(item.assignee)}	runs=${runIds}`
   );
-  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
-        })
-      }
+function printTaskDetail(item) {
+  print(`${colors.bold}Task${colors.reset}`);
+  printDetailField("scopedId", item.scopedId);
+  printDetailField("workflowFileId", item.workflowFileId);
+  printDetailField("ownerHumanId", item.ownerHumanId);
+  printDetailField("title", item.title);
+  printDetailTextField("desc", item.desc);
+  printDetailField("statusScopedId", item.statusScopedId);
+  printDetailField("priority", `${item.priority} (${priorityLabel(item.priority)})`);
+  printAssigneeDetail("assignee", item.assignee);
+  if (item.linkedFileIds.length === 0) {
+    print("linkedFileIds: []");
+  } else {
+    print("linkedFileIds:");
+    for (const fileId of item.linkedFileIds) print(`  - ${fileId}`);
+  }
+  printDetailField("subscribed", item.subscribed);
+  if (item.agentRuns.length === 0) {
+    print("agentRuns: []");
+  } else {
+    print("agentRuns:");
+    for (const run of item.agentRuns) {
+      print(`  - pipelineTriggerId: ${run.pipelineTriggerId}`);
+      printAssigneeDetail("executor", run.executor, 4);
+    }
+  }
+  printDetailField("createdAt", item.createdAt);
+  printDetailField("latestActAt", item.latestActAt);
+}
+function printCommentDetail(item) {
+  print(`${colors.bold}Comment${colors.reset}`);
+  printDetailField("id", item.id);
+  printDetailField("workflowFileId", item.workflowFileId);
+  printDetailField("workflowTaskScopedId", item.workflowTaskScopedId);
+  printDetailTextField("content", item.content);
+  printAssigneeDetail("createdBy", item.createdBy);
+  printDetailField("createdAt", item.createdAt);
+  printDetailField("updatedAt", item.updatedAt);
+}
+function registerWorkflowCommand(program2) {
+  const workflow = program2.command("workflow").description("Workflow operations");
+  addWorkspaceOption(
+    workflow.command("list").description("List accessible workflows").option("--scope <scope>", "Workflow scope: all or owner_is_me", "all")
+  ).action(async (options) => {
+    const scope = runOrExit3(() => parseWorkflowScope(options.scope));
+    startSpinner("Fetching workflows...");
+    const response = await httpGet(
+      `/workspaces/${options.workspace}/workflows${buildQuery({ scope })}`
     );
     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.1"} (${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;
+      stopSpinner(false, "Failed");
+      failResponse(response);
     }
-    if (child === null) {
-      pendingForward = signal;
+    if (response.data.workflows.length === 0) {
+      stopSpinner(true, "No workflows found.");
       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);
+    stopSpinner(true, `Found ${response.data.workflows.length} workflow(s)`);
+    for (const item of response.data.workflows) printWorkflow(item);
   });
-}
-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 {
-    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 }
-  });
-}
-
-// 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)");
+  addSpaceOptions2(
+    workflow.command("create").description("Create a blank workflow").requiredOption("-p, --path <path>", "Target .workflow path").option("--desc-file <localPath>", "Local UTF-8 text file for workflow description").option("--owner-human-id <humanId>", "Workflow owner human ID")
+  ).action(async (options) => {
+    const body = runOrExit3(() => {
+      const next = {
+        path: options.path,
+        ...resolveSpaceSelector(options)
+      };
+      const desc = readDescFile(options.descFile);
+      if (desc !== void 0) next.desc = desc;
+      const ownerHumanId = parseOptionalPositiveInteger(options.ownerHumanId, "--owner-human-id");
+      if (ownerHumanId !== void 0) next.ownerHumanId = ownerHumanId;
+      return next;
+    });
+    startSpinner("Creating workflow...");
+    const response = await httpPost(`/workspaces/${options.workspace}/workflows`, body);
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
     }
+    stopSpinner(true, "Workflow created");
+    printWorkflow(response.data);
   });
-  telemetry.command("enable").description("Enable telemetry").action(() => {
-    writeTelemetryConfig({ disabled: false });
-    print("telemetry: enabled");
+  addWorkspaceOption(workflow.command("get").description("Get a workflow").argument("<workflowFileId>")).action(
+    async (workflowFileId, options) => {
+      startSpinner("Fetching workflow...");
+      const response = await httpGet(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}`
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Workflow fetched");
+      printWorkflowDetail(response.data);
+    }
+  );
+  addWorkspaceOption(
+    workflow.command("update").description("Update workflow metadata").argument("<workflowFileId>").option("--desc-file <localPath>", "Local UTF-8 text file for workflow description").option("--owner-human-id <humanId>", "Workflow owner human ID")
+  ).action(async (workflowFileId, options) => {
+    const body = runOrExit3(() => {
+      const next = {};
+      const desc = readDescFile(options.descFile);
+      if (desc !== void 0) next.desc = desc;
+      const ownerHumanId = parseOptionalPositiveInteger(options.ownerHumanId, "--owner-human-id");
+      if (ownerHumanId !== void 0) next.ownerHumanId = ownerHumanId;
+      assertNonEmptyBody(next);
+      return next;
+    });
+    startSpinner("Updating workflow...");
+    const response = await httpPatch(`/workspaces/${options.workspace}/workflows/${workflowFileId}`, body);
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, "Workflow updated");
+    printWorkflow(response.data);
   });
-  telemetry.command("disable").description("Disable telemetry").action(() => {
-    writeTelemetryConfig({ disabled: true });
-    print("telemetry: disabled");
+  addWorkspaceOption(
+    workflow.command("delete").description("Delete a workflow").argument("<workflowFileId>").option("--message <message>", "Commit message")
+  ).action(async (workflowFileId, options) => {
+    startSpinner("Deleting workflow...");
+    const response = await httpDelete(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}`,
+      options.message ? { message: options.message } : {}
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, `Deleted: ${response.data.fileId}`);
   });
-}
-
-// 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 {
+  addWorkspaceOption(workflow.command("duplicate").description("Duplicate a workflow").argument("<workflowFileId>")).action(
+    async (workflowFileId, options) => {
+      startSpinner("Duplicating workflow...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/duplicate`,
+        {}
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Workflow duplicated");
+      printWorkflow(response.data);
+    }
+  );
+  registerStatusCommands(workflow);
+  registerTransitionCommands(workflow);
+  registerTaskCommands(workflow);
+  registerCommentCommands(workflow);
+  registerRunCommands(workflow);
+}
+function registerStatusCommands(workflow) {
+  const status = workflow.command("status").description("Workflow status operations");
+  addPreferredAssigneeOptions(
+    addWorkspaceOption(
+      status.command("create").description("Create a workflow status").argument("<workflowFileId>").requiredOption("--name <name>", "Status name").requiredOption("--type <type>", "Status type value: 1=todo, 2=in-progress, 3=done").option("--desc-file <localPath>", "Local UTF-8 text file for status description")
+    )
+  ).action(
+    async (workflowFileId, options) => {
+      const body = runOrExit3(() => {
+        const next = {
+          name: options.name,
+          type: parseRequiredStatusType(options.type)
+        };
+        const desc = readDescFile(options.descFile);
+        if (desc !== void 0) next.desc = desc;
+        Object.assign(next, parsePreferredAssigneeBody(options));
+        return next;
+      });
+      startSpinner("Creating status...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/statuses`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Status created");
+      printStatusDetail(response.data);
+    }
+  );
+  addPreferredAssigneeOptions(
+    addWorkspaceOption(
+      status.command("update").description("Update a workflow status").argument("<workflowFileId>").argument("<statusScopedId>").option("--name <name>", "Status name").option("--type <type>", "Status type value: 1=todo, 2=in-progress, 3=done").option("--desc-file <localPath>", "Local UTF-8 text file for status description").option("--clear-desc", "Clear status description").option("--clear-preferred-assignee", "Clear preferred assignee")
+    )
+  ).action(
+    async (workflowFileId, statusScopedId, options) => {
+      const body = runOrExit3(() => {
+        if (options.descFile && options.clearDesc) {
+          throw new WorkflowOptionsError("Error: --desc-file cannot be used with --clear-desc.");
+        }
+        const next = {};
+        if (options.name) next.name = options.name;
+        const type = parseStatusType(options.type);
+        if (type !== void 0) next.type = type;
+        const desc = readDescFile(options.descFile);
+        if (desc !== void 0) next.desc = desc;
+        if (options.clearDesc) next.desc = null;
+        Object.assign(next, parsePreferredAssigneeBody(options));
+        assertNonEmptyBody(next);
+        return next;
+      });
+      const id = runOrExit3(() => parsePositiveInteger(statusScopedId, "statusScopedId"));
+      startSpinner("Updating status...");
+      const response = await httpPatch(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/statuses/${id}`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Status updated");
+      printStatusDetail(response.data);
+    }
+  );
+  addWorkspaceOption(
+    status.command("move-after").description("Move a workflow status after another status").argument("<workflowFileId>").argument("<statusScopedId>").option("--after <statusScopedId>", "Anchor status scoped ID").option("--first", "Move to first position")
+  ).action(
+    async (workflowFileId, statusScopedId, options) => {
+      const { id, anchoredStatusScopedId } = runOrExit3(() => {
+        if (options.after && options.first) {
+          throw new WorkflowOptionsError("Error: --after cannot be used with --first.");
+        }
+        if (!options.after && !options.first) {
+          throw new WorkflowOptionsError("Error: either --after or --first is required.");
+        }
+        return {
+          id: parsePositiveInteger(statusScopedId, "statusScopedId"),
+          anchoredStatusScopedId: options.first ? null : parsePositiveInteger(options.after, "--after")
+        };
+      });
+      startSpinner("Moving status...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/statuses/${id}/move-after`,
+        { anchoredStatusScopedId }
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Status moved");
+    }
+  );
+  addWorkspaceOption(
+    status.command("delete").description("Delete a workflow status").argument("<workflowFileId>").argument("<statusScopedId>")
+  ).action(async (workflowFileId, statusScopedId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(statusScopedId, "statusScopedId"));
+    startSpinner("Deleting status...");
+    const response = await httpDelete(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/statuses/${id}`
+    );
+    if (!response.ok) {
       stopSpinner(false, "Failed");
-      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
-      process.exit(1);
+      failResponse(response);
     }
+    stopSpinner(true, `Deleted: ${response.data.scopedId}`);
   });
 }
-
-// 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 registerTransitionCommands(workflow) {
+  const transition = workflow.command("transition").description("Workflow transition operations");
+  for (const action of ["create", "delete"]) {
+    addWorkspaceOption(
+      transition.command(action).description(`${action === "create" ? "Create" : "Delete"} a workflow transition`).argument("<workflowFileId>").requiredOption("--from <statusScopedId>", "Source status scoped ID").requiredOption("--to <statusScopedId>", "Target status scoped ID")
+    ).action(async (workflowFileId, options) => {
+      const body = runOrExit3(() => ({
+        statusFromScopedId: parsePositiveInteger(options.from, "--from"),
+        statusToScopedId: parsePositiveInteger(options.to, "--to")
+      }));
+      startSpinner(`${action === "create" ? "Creating" : "Deleting"} transition...`);
+      const response = action === "create" ? await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/transitions`,
+        body
+      ) : await httpDelete(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/transitions`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, action === "create" ? "Transition created" : "Transition deleted");
+      print(`${response.data.statusFromScopedId} -> ${response.data.statusToScopedId}`);
+    });
+  }
 }
-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.");
+function registerTaskCommands(workflow) {
+  const task = workflow.command("task").description("Workflow task operations");
+  addWorkspaceOption(
+    task.command("list").description("List workflow tasks").option("--workflow-file-id <workflowFileId>", "Filter by workflow file ID").option("--scope <scope>", "Task scope", "all").option("-l, --limit <limit>", "Maximum number of tasks to return", "20").option("--cursor <cursor>", "Pagination cursor")
+  ).action(
+    async (options) => {
+      const query = runOrExit3(() => buildQuery({
+        scope: parseTaskScope(options.scope),
+        limit: parseSearchLimit(options.limit, 20, 100),
+        cursor: options.cursor,
+        workflowFileId: options.workflowFileId
+      }));
+      startSpinner("Fetching workflow tasks...");
+      const response = await httpGet(`/workspaces/${options.workspace}/workflow-tasks${query}`);
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      if (response.data.tasks.length === 0) {
+        stopSpinner(true, "No workflow tasks found.");
         return;
       }
-      stopSpinner(true, `Found ${workspaces.length} workspace(s)`);
-      for (const ws of workspaces) {
-        print(`${colors.bold}${ws.workspaceId}${colors.reset}	${ws.name}`);
+      stopSpinner(true, `Found ${response.data.tasks.length} task(s)`);
+      for (const item of response.data.tasks) printTaskSummary(item);
+      if (response.data.nextCursor) print(`${colors.dim}nextCursor=${response.data.nextCursor}${colors.reset}`);
+    }
+  );
+  addWorkspaceOption(
+    task.command("get").description("Get a workflow task").argument("<workflowFileId>").argument("<taskScopedId>")
+  ).action(async (workflowFileId, taskScopedId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(taskScopedId, "taskScopedId"));
+    startSpinner("Fetching task...");
+    const response = await httpGet(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}`
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
+    }
+    stopSpinner(true, "Task fetched");
+    printTaskDetail(response.data);
+  });
+  addAssigneeOptions(
+    addWorkspaceOption(
+      task.command("create").description("Create a workflow task").argument("<workflowFileId>").requiredOption("--title <title>", "Task title").requiredOption("--status <statusScopedId>", "Status scoped ID").option("--priority <priority>", "Priority: urgent, high, medium, or low", "medium").option("--desc-file <localPath>", "Local UTF-8 text file for task description").option("--owner-human-id <humanId>", "Task owner human ID")
+    )
+  ).action(
+    async (workflowFileId, options) => {
+      const body = runOrExit3(() => {
+        const next = {
+          title: options.title,
+          statusScopedId: parsePositiveInteger(options.status, "--status"),
+          priority: parseRequiredPriority(options.priority)
+        };
+        const desc = readDescFile(options.descFile);
+        if (desc !== void 0) next.desc = desc;
+        const ownerHumanId = parseOptionalPositiveInteger(options.ownerHumanId, "--owner-human-id");
+        if (ownerHumanId !== void 0) next.ownerHumanId = ownerHumanId;
+        Object.assign(next, parseAssigneeBody(options, false));
+        return next;
+      });
+      startSpinner("Creating task...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
       }
-    } else {
+      stopSpinner(true, "Task created");
+      printTaskDetail(response.data);
+    }
+  );
+  addWorkspaceOption(
+    task.command("update").description("Update workflow task metadata").argument("<workflowFileId>").argument("<taskScopedId>").option("--title <title>", "Task title").option("--priority <priority>", "Priority: urgent, high, medium, or low").option("--desc-file <localPath>", "Local UTF-8 text file for task description").option("--clear-desc", "Clear task description").option("--owner-human-id <humanId>", "Task owner human ID")
+  ).action(
+    async (workflowFileId, taskScopedId, options) => {
+      const body = runOrExit3(() => {
+        if (options.descFile && options.clearDesc) {
+          throw new WorkflowOptionsError("Error: --desc-file cannot be used with --clear-desc.");
+        }
+        const next = {};
+        if (options.title) next.title = options.title;
+        const priority = parsePriority(options.priority);
+        if (priority !== void 0) next.priority = priority;
+        const desc = readDescFile(options.descFile);
+        if (desc !== void 0) next.desc = desc;
+        if (options.clearDesc) next.desc = null;
+        const ownerHumanId = parseOptionalPositiveInteger(options.ownerHumanId, "--owner-human-id");
+        if (ownerHumanId !== void 0) next.ownerHumanId = ownerHumanId;
+        assertNonEmptyBody(next);
+        return next;
+      });
+      const id = runOrExit3(() => parsePositiveInteger(taskScopedId, "taskScopedId"));
+      startSpinner("Updating task...");
+      const response = await httpPatch(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/metadata`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Task updated");
+      printTaskDetail(response.data);
+    }
+  );
+  for (const action of ["add-linked-files", "remove-linked-files"]) {
+    addWorkspaceOption(
+      task.command(action).description(`${action === "add-linked-files" ? "Add" : "Remove"} linked files on a workflow task`).argument("<workflowFileId>").argument("<taskScopedId>").requiredOption("--file-ids <ids>", "Comma-separated file IDs")
+    ).action(
+      async (workflowFileId, taskScopedId, options) => {
+        const { id, fileIds } = runOrExit3(() => ({
+          id: parsePositiveInteger(taskScopedId, "taskScopedId"),
+          fileIds: parseFileIds(options.fileIds, "--file-ids")
+        }));
+        startSpinner(action === "add-linked-files" ? "Adding linked files..." : "Removing linked files...");
+        const path2 = `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/linked-files`;
+        const response = action === "add-linked-files" ? await httpPost(path2, { fileIds }) : await httpDelete(path2, { fileIds });
+        if (!response.ok) {
+          stopSpinner(false, "Failed");
+          failResponse(response);
+        }
+        stopSpinner(true, action === "add-linked-files" ? "Linked files added" : "Linked files removed");
+        printTaskDetail(response.data);
+      }
+    );
+  }
+  addWorkspaceOption(
+    task.command("move").description("Move a workflow task to another status").argument("<workflowFileId>").argument("<taskScopedId>").requiredOption("--status <statusScopedId>", "Target status scoped ID")
+  ).action(
+    async (workflowFileId, taskScopedId, options) => {
+      const { id, statusScopedId } = runOrExit3(() => ({
+        id: parsePositiveInteger(taskScopedId, "taskScopedId"),
+        statusScopedId: parsePositiveInteger(options.status, "--status")
+      }));
+      startSpinner("Moving task...");
+      const response = await httpPatch(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/status`,
+        { statusScopedId }
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Task moved");
+      printTaskDetail(response.data);
+    }
+  );
+  addAssigneeOptions(
+    addWorkspaceOption(
+      task.command("assign").description("Update workflow task assignee").argument("<workflowFileId>").argument("<taskScopedId>").option("--clear", "Clear assignee")
+    )
+  ).action(
+    async (workflowFileId, taskScopedId, options) => {
+      const body = runOrExit3(() => {
+        const next = parseAssigneeBody(options, true);
+        if (Object.keys(next).length === 0 && options.clear !== true) assertNonEmptyBody(next);
+        return next;
+      });
+      const id = runOrExit3(() => parsePositiveInteger(taskScopedId, "taskScopedId"));
+      startSpinner("Updating task assignee...");
+      const response = await httpPatch(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/assignee`,
+        body
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Task assignee updated");
+      printTaskDetail(response.data);
+    }
+  );
+  addWorkspaceOption(
+    task.command("delete").description("Delete a workflow task").argument("<workflowFileId>").argument("<taskScopedId>")
+  ).action(async (workflowFileId, taskScopedId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(taskScopedId, "taskScopedId"));
+    startSpinner("Deleting task...");
+    const response = await httpDelete(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}`
+    );
+    if (!response.ok) {
       stopSpinner(false, "Failed");
-      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
-      process.exit(1);
+      failResponse(response);
     }
+    stopSpinner(true, `Deleted: ${response.data.scopedId}`);
   });
-  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`);
+}
+function registerCommentCommands(workflow) {
+  const comment = workflow.command("comment").description("Workflow task comment operations");
+  addWorkspaceOption(
+    comment.command("create").description("Create a workflow task comment").argument("<workflowFileId>").argument("<taskScopedId>").requiredOption("--content-path <localPath>", "Local UTF-8 text file for comment content")
+  ).action(
+    async (workflowFileId, taskScopedId, options) => {
+      const { id, content } = runOrExit3(() => ({
+        id: parsePositiveInteger(taskScopedId, "taskScopedId"),
+        content: readCommentContentFile(options.contentPath)
+      }));
+      startSpinner("Creating comment...");
+      const response = await httpPost(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/comments`,
+        { content }
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
+      }
+      stopSpinner(true, "Comment created");
+      printCommentDetail(response.data);
+    }
+  );
+  addWorkspaceOption(
+    comment.command("list").description("List workflow task comments").argument("<workflowFileId>").argument("<taskScopedId>")
+  ).action(async (workflowFileId, taskScopedId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(taskScopedId, "taskScopedId"));
+    startSpinner("Fetching comments...");
+    const response = await httpGet(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${id}/comments`
+    );
     if (!response.ok) {
-      stopSpinner(false, "Failed to fetch members");
-      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
-      process.exit(1);
+      stopSpinner(false, "Failed");
+      failResponse(response);
     }
-    const { members: members2 } = response.data;
-    if (members2.length === 0) {
-      stopSpinner(true, "No members found.");
+    if (response.data.items.length === 0) {
+      stopSpinner(true, "No comments found.");
       return;
     }
-    stopSpinner(true, `Found ${members2.length} member(s)`);
-    for (const member of members2) {
-      const name = member.displayName || "-";
-      print(`${colors.bold}${member.email}${colors.reset}	${name}	${member.role}`);
-    }
+    stopSpinner(true, `Found ${response.data.items.length} comment(s)`);
+    response.data.items.forEach((item, index) => {
+      if (index > 0) print("");
+      printCommentDetail(item);
+    });
   });
-  members.command("remove").description("Remove members from a workspace").requiredOption("-w, --workspace <workspaceId>", "Workspace ID").argument("<emails>", "Emails to remove (comma-separated)").action(async (emailsArg, options) => {
-    const { workspace: workspaceId } = options;
-    const emails = emailsArg.split(",").map((e) => e.trim()).filter(Boolean);
-    if (emails.length === 0) {
-      printError("No valid emails provided");
-      process.exit(1);
-    }
-    const invalidEmails = emails.filter((e) => !isValidEmail(e));
-    if (invalidEmails.length > 0) {
-      for (const email of invalidEmails) {
-        printError(`Invalid email format: ${email}`);
+  addWorkspaceOption(
+    comment.command("delete").description("Delete a workflow task comment").argument("<workflowFileId>").argument("<taskScopedId>").argument("<commentId>")
+  ).action(
+    async (workflowFileId, taskScopedId, commentId, options) => {
+      const ids = runOrExit3(() => ({
+        task: parsePositiveInteger(taskScopedId, "taskScopedId"),
+        comment: parsePositiveInteger(commentId, "commentId")
+      }));
+      startSpinner("Deleting comment...");
+      const response = await httpDelete(
+        `/workspaces/${options.workspace}/workflows/${workflowFileId}/tasks/${ids.task}/comments/${ids.comment}`
+      );
+      if (!response.ok) {
+        stopSpinner(false, "Failed");
+        failResponse(response);
       }
-      process.exit(1);
+      stopSpinner(true, `Deleted: ${response.data.id}`);
     }
-    startSpinner("Fetching workspace members...");
-    const membersResponse = await httpGet(`/workspaces/${workspaceId}/members`);
-    if (!membersResponse.ok) {
-      stopSpinner(false, "Failed to fetch members");
-      printError(`Error [${membersResponse.status}]: ${JSON.stringify(membersResponse.data)}`);
-      process.exit(1);
+  );
+}
+function registerRunCommands(workflow) {
+  const run = workflow.command("run").description("Workflow agent run operations");
+  addWorkspaceOption(
+    run.command("status").description("Get workflow agent run statuses").argument("<workflowFileId>").argument("<triggerIds...>")
+  ).action(async (workflowFileId, triggerIds, options) => {
+    const workflowPipelineTriggerIds = runOrExit3(
+      () => triggerIds.map((triggerId) => parsePositiveInteger(triggerId, "workflowPipelineTriggerId"))
+    );
+    startSpinner("Fetching run statuses...");
+    const response = await httpPost(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/pipeline/triggers/statuses`,
+      { workflowPipelineTriggerIds }
+    );
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
     }
-    stopSpinner(true, "Members fetched");
-    const { members: members2 } = membersResponse.data;
-    const emailToMember = new Map(members2.map((m) => [m.email.toLowerCase(), m]));
-    for (const email of emails) {
-      const member = emailToMember.get(email.toLowerCase());
-      if (!member) {
-        print(`${colors.red}\u2717${colors.reset} ${email} - not found in workspace`);
-        continue;
-      }
-      const deleteResponse = await httpDelete(`/workspaces/${workspaceId}/members/${member.userId}`);
-      if (deleteResponse.ok) {
-        print(`${colors.green}\u2713${colors.reset} ${email} - removed`);
-      } else {
-        print(`${colors.red}\u2717${colors.reset} ${email} - failed: ${JSON.stringify(deleteResponse.data)}`);
-      }
+    stopSpinner(true, `Found ${response.data.length} run status item(s)`);
+    for (const item of response.data) {
+      print(`${colors.bold}${item.workflowPipelineTriggerId}${colors.reset}	${item.pipelineStatus}`);
     }
   });
-  const space = program2.command("space").description("Manage spaces");
-  space.command("list").description("List accessible spaces in a workspace").requiredOption("-w, --workspace <workspaceId>", "Workspace ID").action(async (options) => {
-    const { workspace: workspaceId } = options;
-    startSpinner("Fetching spaces...");
-    const response = await httpGet(`/workspaces/${workspaceId}/spaces`);
+  addWorkspaceOption(
+    run.command("output").description("Get workflow agent run output events").argument("<workflowFileId>").argument("<triggerId>")
+  ).action(async (workflowFileId, triggerId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(triggerId, "workflowPipelineTriggerId"));
+    startSpinner("Fetching run output...");
+    const response = await httpGet(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/pipeline/trigger/${id}/output`
+    );
     if (!response.ok) {
-      stopSpinner(false, "Failed to fetch spaces");
-      printError(`Error [${response.status}]: ${JSON.stringify(response.data)}`);
-      process.exit(1);
-    }
-    const { spaces } = response.data;
-    if (spaces.length === 0) {
-      stopSpinner(true, "No spaces found.");
-      return;
+      stopSpinner(false, "Failed");
+      failResponse(response);
     }
-    stopSpinner(true, `Found ${spaces.length} space(s)`);
-    print(
-      `${colors.bold}TYPE${colors.reset}	${colors.bold}TEAM_SPACE_ID${colors.reset}	${colors.bold}TEAMMATE_ID${colors.reset}	${colors.bold}NAME${colors.reset}`
+    stopSpinner(true, `Run ${response.data.workflowPipelineTriggerId}`);
+    for (const event of response.data.pipelineEvents) print(event);
+  });
+  addWorkspaceOption(
+    run.command("abort").description("Abort a workflow agent run").argument("<workflowFileId>").argument("<triggerId>")
+  ).action(async (workflowFileId, triggerId, options) => {
+    const id = runOrExit3(() => parsePositiveInteger(triggerId, "workflowPipelineTriggerId"));
+    startSpinner("Aborting run...");
+    const response = await httpPost(
+      `/workspaces/${options.workspace}/workflows/${workflowFileId}/pipeline/trigger/${id}/abort`,
+      {}
     );
-    for (const s of spaces) {
-      const teamSpaceId = s.teamSpaceId ?? "";
-      const teammateId = s.agentId != null ? String(s.agentId) : "";
-      print(`${s.type}	${teamSpaceId}	${teammateId}	${s.name}`);
+    if (!response.ok) {
+      stopSpinner(false, "Failed");
+      failResponse(response);
     }
+    stopSpinner(true, `Abort accepted: ${id}`);
   });
 }
 
@@ -3085,23 +1901,23 @@ function createProgram(version) {
   registerWorkspaceCommand(program2);
   registerFileCommand(program2);
   registerMemoryCommand(program2);
-  registerRunCommand(program2);
+  registerWorkflowCommand(program2);
   registerMiniappCommand(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.3.3",
     node_version: process.versions.node,
-    os: platform3(),
-    arch: arch3(),
+    os: platform2(),
+    arch: arch2(),
     is_ci: isCiEnvironment() ? "true" : "false"
   };
 }
@@ -3144,7 +1960,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.3.3",
     client_type: "cli",
     metric_data_list: batch.map((m) => ({
       profile: "cli",
@@ -3285,9 +2101,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.3.3" }
 }).notify();
-var program = createProgram("0.3.3-moxt-run.1");
+var program = createProgram("0.3.3");
 instrumentProgram(program);
 installExitHandler();
 program.parseAsync(process.argv).then(async () => {