@mutagent/cli 0.2.184 → 0.2.186

package/dist/bin/cli.js

@@ -19809,7 +19809,8 @@ function platformError(status, body, ctx) {
   if (ctx.credential === "sandbox-token" && status === 401) {
     return sandboxTokenRefused();
   }
-  const reason = typeof parsed.reason === "string" ? parsed.reason : typeof parsed.message === "string" ? parsed.message : undefined;
+  const routeMiss = status === 404 && parsed.code === undefined && parsed.message === undefined && parsed.error === "Route not found";
+  const reason = typeof parsed.reason === "string" ? parsed.reason : typeof parsed.message === "string" ? parsed.message : routeMiss ? "Route not found" : undefined;
   if (typeof parsed.code === "string" && /^[A-Z][A-Z0-9_]{1,63}$/.test(parsed.code) && reason !== undefined) {
     const fix = typeof parsed.fix === "string" && parsed.fix.trim() !== "" ? asSuggestion(parsed.fix) : `Run: ${ctx.help}`;
     return new PlatformRefusal(parsed.code, reason, fix, status, Array.isArray(parsed.errors) ? parsed.errors : undefined);
@@ -22692,6 +22693,12 @@ fill in for you, and which credential it signs in with.
 
 \`mutagent helix access --json\` says whether this account may use cloud sandboxes.
 
+An Architech cloud session runs through \`mutagent architech\`, the cloud form of the
+local \`architech\`, never through \`mutagent helix --preset architech\` (refused with
+\`HARNESS_USE_PRODUCT_COMMAND\`; run the \`mutagent architech …\` line it names). Its
+\`agent\`, \`session\`, \`models\` and \`access\` verbs work like Helix's and take the same
+\`hs1_\` references; it has no \`--preset\`.
+
 ## What defaults from the session
 
 In a cloud sandbox launched for a Factory entry, the platform sets these:
@@ -26416,7 +26423,40 @@ AI Agent Directive:
   return install;
 }
 
-// src/commands/helix/index.ts
+// src/lib/cloud-product.ts
+var HELIX_PRODUCT = Object.freeze({ command: "helix", cli: "mutagent helix", title: "Helix", harness: "helix", sessions: "/api/helix/sessions" });
+var ARCHITECH_PRODUCT = Object.freeze({
+  command: "architech",
+  cli: "mutagent architech",
+  title: "Architech",
+  harness: "architech",
+  sessions: "/api/architech/sessions",
+  preset: "architech"
+});
+var CLOUD_PRODUCTS = [HELIX_PRODUCT, ARCHITECH_PRODUCT];
+function productOwningPreset(preset) {
+  if (preset === undefined)
+    return;
+  return CLOUD_PRODUCTS.find((product) => product.preset !== undefined && product.preset === preset.trim());
+}
+var active = HELIX_PRODUCT;
+function productCopy(text, product = active) {
+  return product === HELIX_PRODUCT ? text : text.replace(/mutagent helix(?! (?:version|doctor|smoke|update)\b)/g, product.cli);
+}
+function productText(text, product) {
+  if (product === HELIX_PRODUCT)
+    return text;
+  const article = /^[AEIOU]/.test(product.title) ? "an" : "a";
+  return productCopy(text, product).replace(/\b([Aa]) Helix\b(?! binary)/g, (_match, a) => `${a === "A" ? article.charAt(0).toUpperCase() + article.slice(1) : article} ${product.title}`).replace(/\bHelix\b(?! binary)/g, product.title);
+}
+function activeProduct() {
+  return active;
+}
+function selectProduct(product) {
+  active = product;
+}
+
+// src/commands/cloud-session/product-command.ts
 import { Command as Command14 } from "commander";
 
 // src/lib/launch-failure.ts
@@ -26466,10 +26506,10 @@ function handleLaunchFailure(raw, mode) {
   handleError(error, mode.isJson);
 }
 
-// src/commands/helix/index.ts
+// src/commands/cloud-session/product-command.ts
 init_output();
 
-// src/commands/helix/agent.ts
+// src/commands/cloud-session/agent.ts
 init_output();
 init_errors();
 import { Option } from "commander";
@@ -26619,12 +26659,12 @@ function agentRepositoryRefusal(argv, options, runnable) {
   if (options.rpc === true)
     bound.push("--rpc");
   const words = [...kept, ...bound].map(shellWord);
-  const line = words.every((word) => word !== undefined) ? ["mutagent helix agent", ...words].join(" ") : undefined;
+  const line = words.every((word) => word !== undefined) ? [`${activeProduct().cli} agent`, ...words].join(" ") : undefined;
   return new LaunchRepositoryError("MANAGED_AGENT_REQUEST_INVALID", "A managed agent runs its package; drop --repository or run a native brief.", {
     fix: line !== undefined && runnable(line) ? [line] : [],
     notes: [
       "A managed agent (@slug) runs its deployed package, so the server refuses a repository checkout with it. Run the same command without --repository and --branch.",
-      'To run in a repository checkout, use a native brief: mutagent helix agent --name <agent> --repository <owner/name> -p "<task>", or the launcher: mutagent helix --repository <owner/name> -p "<task>".'
+      `To run in a repository checkout, use a native brief: ${activeProduct().cli} agent --name <agent> --repository <owner/name> -p "<task>", or the launcher: ${activeProduct().cli} --repository <owner/name> -p "<task>".`
     ]
   });
 }
@@ -26950,13 +26990,13 @@ function renderWorkspaceConfigFix(fix, resource) {
   return escalate === undefined ? rendered : { ...rendered, escalate };
 }
 
-// src/commands/helix/agent-argv.ts
+// src/commands/cloud-session/agent-argv.ts
 init_errors();
 import { homedir as homedir5 } from "os";
 import { basename as basename6, join as join20, isAbsolute as isAbsolute6, resolve as resolve8 } from "path";
 import { accessSync as accessSync3, constants as constants3, existsSync as existsSync11, readFileSync as readFileSync13, statSync as statSync4 } from "fs";
 
-// src/commands/helix/argv-transport.ts
+// src/commands/cloud-session/argv-transport.ts
 var HOST_PATH = "it names a path on THIS machine, and the sandbox is a different machine";
 var TRANSPORT_TABLE = [
   {
@@ -26978,7 +27018,9 @@ var TRANSPORT_TABLE = [
     takesValue: false,
     class: "reject",
     reason: "the sandbox image already contains Helix",
-    alternative: "The image pins its own Helix build; see `mutagent sandbox presets`."
+    alternative: "The image pins its own Helix build; see `mutagent sandbox presets`.",
+    fixedHarnessReason: "the sandbox image already contains the Architech harness",
+    fixedHarnessAlternative: "The image pins its own Architech harness build; see `mutagent sandbox presets`."
   },
   {
     token: "--prompt",
@@ -27152,14 +27194,16 @@ var TRANSPORT_TABLE = [
     takesValue: false,
     class: "reject",
     reason: "there is no previous session in a new sandbox to continue",
-    alternative: "Run against a sandbox you kept: `mutagent helix agent --sandbox <id> …`, or restore a checkpoint."
+    alternative: "Run against a sandbox you kept: `mutagent helix agent --sandbox <id> …`, or restore a checkpoint.",
+    fixedHarnessAlternative: "Continue the session from its checkpoint in a rebuilt sandbox: `mutagent helix session restore <reference>`."
   },
   {
     token: "-c",
     takesValue: false,
     class: "reject",
     reason: "there is no previous session in a new sandbox to continue",
-    alternative: "Run against a sandbox you kept: `mutagent helix agent --sandbox <id> …`, or restore a checkpoint."
+    alternative: "Run against a sandbox you kept: `mutagent helix agent --sandbox <id> …`, or restore a checkpoint.",
+    fixedHarnessAlternative: "Continue the session from its checkpoint in a rebuilt sandbox: `mutagent helix session restore <reference>`."
   },
   {
     token: "--resume",
@@ -27229,17 +27273,27 @@ var TRANSPORT_TABLE = [
     takesValue: false,
     class: "reject",
     reason: "it would spawn a whole sandbox to print a version string",
-    alternative: "Run `mutagent helix version`, which reports both this CLI and the image’s pinned Helix."
+    alternative: "Run `mutagent helix version`, which reports both this CLI and the image’s pinned Helix.",
+    fixedHarnessAlternative: "Drop it: `mutagent helix --help --json` reports the cloud surface (the pinned harness flag surface) without a sandbox."
   },
   {
     token: "-v",
     takesValue: false,
     class: "reject",
     reason: "it would spawn a whole sandbox to print a version string",
-    alternative: "Run `mutagent helix version`, which reports both this CLI and the image’s pinned Helix."
+    alternative: "Run `mutagent helix version`, which reports both this CLI and the image’s pinned Helix.",
+    fixedHarnessAlternative: "Drop it: `mutagent helix --help --json` reports the cloud surface (the pinned harness flag surface) without a sandbox."
   }
 ];
 var BY_TOKEN = new Map(TRANSPORT_TABLE.map((entry) => [entry.token, entry]));
+function alternativeFor(entry, product = activeProduct()) {
+  const text = product.preset !== undefined && entry.fixedHarnessAlternative !== undefined ? entry.fixedHarnessAlternative : entry.alternative ?? "";
+  return productCopy(text, product);
+}
+function reasonFor(entry, product = activeProduct()) {
+  const reason = product.preset !== undefined && entry.fixedHarnessReason !== undefined ? entry.fixedHarnessReason : entry.reason;
+  return reason ?? "it cannot mean the same thing there";
+}
 function transportFor(token) {
   return BY_TOKEN.get(token);
 }
@@ -27268,7 +27322,7 @@ function redactCommanderError(text) {
   return text.replace(/(unknown (?:option|command) ')([^']*)(')/g, (_match, before, token, after) => `${before}${redactToken(token)}${after}`);
 }
 
-// src/commands/helix/planned-flags.ts
+// src/commands/cloud-session/planned-flags.ts
 init_errors();
 import { basename as basename5, isAbsolute as isAbsolute5, resolve as resolve7 } from "path";
 var OWN_FLAGS = {
@@ -27360,7 +27414,7 @@ function checkSandboxId(value) {
   }
 }
 
-// src/commands/helix/agent-argv.ts
+// src/commands/cloud-session/agent-argv.ts
 function defaultPlanDeps() {
   return {
     cwd: process.cwd(),
@@ -27456,7 +27510,7 @@ function planAgentArgv(argv, deps, flags = {}) {
       continue;
     }
     if (entry.class === "reject") {
-      throw rejection(token, entry.reason ?? "it cannot mean the same thing there", entry.alternative ?? "");
+      throw rejection(token, reasonFor(entry), alternativeFor(entry));
     }
     let value = "";
     if (entry.takesValue) {
@@ -27516,7 +27570,7 @@ function planAgentArgv(argv, deps, flags = {}) {
   };
 }
 function rejection(token, reason, alternative) {
-  return new MutagentError("INVALID_ARGUMENTS", `${token} is not supported in a cloud run: ${reason}.`, alternative);
+  return new MutagentError("INVALID_ARGUMENTS", `${token} is not supported in a cloud run: ${reason}.`, productCopy(alternative));
 }
 function resolveDefinition(source, deps) {
   if (source === undefined) {
@@ -27585,7 +27639,7 @@ function stripFrontmatter(raw) {
   return text.slice(3 + close.index + fence.length).trim();
 }
 
-// src/commands/helix/native-mode.ts
+// src/commands/cloud-session/native-mode.ts
 init_errors();
 function hasNativeMode(args) {
   return modeSelection(args).explicit;
@@ -27636,7 +27690,7 @@ function nativeMode(args, print, rpc = false) {
     return "json";
   if (print)
     return "text";
-  throw new MutagentError("NOT_SUPPORTED", "mutagent helix has no terminal chat UI.", 'Use -p "<task>" for a complete run, --mode json "<task>" for events, or --mode rpc with a JSONL client.');
+  throw new MutagentError("NOT_SUPPORTED", `${activeProduct().cli} has no terminal chat UI.`, 'Use -p "<task>" for a complete run, --mode json "<task>" for events, or --mode rpc with a JSONL client.');
 }
 function nativeTaskNotices(mode, messages) {
   if (mode === "rpc") {
@@ -27648,7 +27702,7 @@ function nativeTaskNotices(mode, messages) {
   return [];
 }
 
-// src/commands/helix/run-cloud.ts
+// src/commands/cloud-session/run-cloud.ts
 init_errors();
 
 // src/lib/sandbox-api.ts
@@ -28183,81 +28237,141 @@ function hostArch() {
   return null;
 }
 
-// src/lib/helix-session-api.ts
+// src/lib/sandbox-session-api.ts
 init_errors();
-var SESSIONS = "/api/sandbox/helix/sessions";
-async function listWorkspaceHelixSessions(options = {}) {
-  const params = new URLSearchParams;
-  if (options.limit !== undefined)
-    params.set("limit", String(options.limit));
-  if (options.cursor !== undefined)
-    params.set("cursor", options.cursor);
-  const query = params.toString();
-  return requestJson(SESSIONS + (query === "" ? "" : `?${query}`));
-}
-async function checkpointHelixSession(reference) {
-  return requestJson(liveSessionPath(reference) + "/checkpoint", {
-    method: "POST",
-    body: "{}"
-  });
-}
-async function listHelixSessionCheckpoints(reference) {
-  return requestJson(liveSessionPath(reference) + "/checkpoints");
-}
-async function restoreHelixSession(reference, body) {
-  return requestJson(liveSessionPath(reference) + "/restore", {
-    method: "POST",
-    body: JSON.stringify(body),
-    retryWhenStopping: true
-  });
+var LEGACY_SESSIONS = "/api/sandbox/helix/sessions";
+var chosen = new Map;
+var ROUTE_NOT_FOUND = "Route not found";
+function routeMissing(error) {
+  return error instanceof ApiError && error.statusCode === 404 && error.code === "API_404" && error.message === ROUTE_NOT_FOUND;
+}
+async function onRoute(routes, call) {
+  const choice = chosen.get(routes.sessions);
+  if (choice === "legacy")
+    return call(LEGACY_SESSIONS, true);
+  try {
+    const result = await call(routes.sessions, false);
+    chosen.set(routes.sessions, "product");
+    return result;
+  } catch (error) {
+    if (choice === undefined && routeMissing(error)) {
+      chosen.set(routes.sessions, "legacy");
+      return call(LEGACY_SESSIONS, true);
+    }
+    if (choice === undefined && error instanceof ApiError)
+      chosen.set(routes.sessions, "product");
+    throw error;
+  }
 }
-function liveSessionPath(reference) {
+function referencePath(base, reference) {
   if (reference.trim() === "") {
     throw new MutagentError("INVALID_ARGUMENTS", "A live session reference is required.", "Use the reference returned when the session starts.");
   }
-  return SESSIONS + "/" + encodeURIComponent(reference);
+  return base + "/" + encodeURIComponent(reference);
 }
-async function endHelixSession(reference) {
-  return requestJson(liveSessionPath(reference) + "/end", { method: "POST", body: "{}" });
+function sessionPath(routes, reference) {
+  return referencePath(chosen.get(routes.sessions) === "legacy" ? LEGACY_SESSIONS : routes.sessions, reference);
 }
-async function getHelixAccess() {
-  return requestJson("/api/sandbox/helix/access");
+function ownsRow(routes, row) {
+  const harness = row.harness ?? "helix";
+  return harness === routes.harness;
+}
+async function listSessionsPage(routes, cursor) {
+  const page = await onRoute(routes, (base, legacy) => {
+    const params = new URLSearchParams;
+    if (cursor !== undefined)
+      params.set("cursor", cursor);
+    if (legacy)
+      params.set("harness", routes.harness);
+    const query = params.toString();
+    return requestJson(base + (query === "" ? "" : `?${query}`));
+  });
+  return { ...page, sessions: page.sessions.filter((row) => ownsRow(routes, row)) };
+}
+var SESSION_LIST_PAGE = 100;
+var SESSION_LIST_MAX_REQUESTS = 20;
+async function listHarnessSessions(routes) {
+  const sessions = [];
+  let cursor;
+  let workspaceId = "";
+  for (let request = 0;request < SESSION_LIST_MAX_REQUESTS; request++) {
+    const page = await listSessionsPage(routes, cursor).catch((error) => {
+      if (error instanceof MutagentError && error.code === "UNKNOWN_SESSION_HARNESS") {
+        throw new MutagentError(error.code, error.message, `The platform does not list ${routes.harness} sessions yet.`);
+      }
+      throw error;
+    });
+    workspaceId = page.workspaceId;
+    sessions.push(...page.sessions);
+    const next = page.nextCursor;
+    if (next === undefined || next === "" || next === cursor || sessions.length >= SESSION_LIST_PAGE) {
+      return { workspaceId, sessions, ...next === undefined || next === "" || next === cursor ? {} : { nextCursor: next } };
+    }
+    cursor = next;
+  }
+  return { workspaceId, sessions, ...cursor === undefined ? {} : { nextCursor: cursor } };
 }
-async function launchHelixSession(body) {
-  return requestJson(SESSIONS, { method: "POST", body: JSON.stringify(body) });
+async function launchSession(routes, body) {
+  const sent = JSON.stringify(body);
+  return onRoute(routes, (base) => requestJson(base, { method: "POST", body: sent }));
 }
-async function sendHelixInput(reference, line, signal) {
-  return requestJson(liveSessionPath(reference) + "/input", {
+async function sendSessionInput(routes, reference, line, signal) {
+  return onRoute(routes, (base) => requestJson(referencePath(base, reference) + "/input", {
     method: "POST",
     body: JSON.stringify({ line }),
     signal
-  });
+  }));
 }
-async function closeHelixInput(reference, signal) {
-  return requestJson(liveSessionPath(reference) + "/close-input", {
+async function closeSessionInput(routes, reference, signal) {
+  return onRoute(routes, (base) => requestJson(referencePath(base, reference) + "/close-input", {
     method: "POST",
     body: "{}",
     signal
-  });
+  }));
 }
-async function signalHelixSession(reference, signal, abort) {
-  return requestJson(liveSessionPath(reference) + "/signal", {
+async function signalSession(routes, reference, signal, abort) {
+  return onRoute(routes, (base) => requestJson(referencePath(base, reference) + "/signal", {
     method: "POST",
     body: JSON.stringify({ signal }),
     signal: abort
-  });
+  }));
 }
-async function openHelixStream(reference, options = {}) {
+async function openSessionStream(routes, reference, options = {}) {
   const query = options.since === undefined ? "" : "?since=" + String(options.since);
-  return openStream(liveSessionPath(reference) + "/stream" + query, {
-    retryHint: "Reattach with: mutagent helix session attach " + reference
-  }, options);
+  return onRoute(routes, (base) => openStream(referencePath(base, reference) + "/stream" + query, {
+    retryHint: "Reattach with: " + routes.cli + " session attach " + reference
+  }, options));
+}
+async function checkpointSession(routes, reference) {
+  return onRoute(routes, (base) => requestJson(referencePath(base, reference) + "/checkpoint", {
+    method: "POST",
+    body: "{}"
+  }));
+}
+async function listSessionCheckpoints(routes, reference) {
+  return onRoute(routes, (base) => requestJson(referencePath(base, reference) + "/checkpoints"));
+}
+async function restoreSession(routes, reference, body) {
+  return onRoute(routes, (base) => requestJson(referencePath(base, reference) + "/restore", {
+    method: "POST",
+    body: JSON.stringify(body),
+    retryWhenStopping: true
+  }));
+}
+async function endSession(routes, reference) {
+  return onRoute(routes, (base) => requestJson(referencePath(base, reference) + "/end", { method: "POST", body: "{}" }));
+}
+async function onSessionRoute(routes, call) {
+  return onRoute(routes, (base) => call(base));
+}
+async function getCloudAccess() {
+  return requestJson("/api/sandbox/helix/access");
 }
 
-// src/lib/helix-native-session.ts
+// src/lib/sandbox-native-session.ts
 init_errors();
-init_known_secrets();
 import { createInterface as createInterface2 } from "node:readline";
+init_known_secrets();
 
 // src/lib/sse.ts
 var DEFAULT_EVENT_NAME = "message";
@@ -28613,7 +28727,7 @@ function delay(ms, signal) {
   });
 }
 
-// src/lib/helix-native-session.ts
+// src/lib/sandbox-native-session.ts
 var TEARDOWN_SIGNALS = ["SIGTERM", "SIGHUP"];
 var EOF_SETTLE_MS = 100;
 async function runNativeSession(options) {
@@ -28742,7 +28856,7 @@ async function runNativeSession(options) {
     }
     const closed = await closeInput(inputController.signal);
     if (!closed.closed) {
-      throw new MutagentError("RPC_INPUT_REJECTED", "The session did not confirm stdin closure.", "Check the session: mutagent helix session list. No signal was sent in place of EOF.");
+      throw new MutagentError("RPC_INPUT_REJECTED", "The session did not confirm stdin closure.", `Check the session: ${activeProduct().cli} session list. No signal was sent in place of EOF.`);
     }
   };
   try {
@@ -28807,9 +28921,9 @@ async function runNativeSession(options) {
     if (interruption.requested && result.end !== "exited")
       process.exitCode = 1;
     if (result.end === "asleep") {
-      notice("Session " + options.reference + " is asleep: it stopped for idling. Everything it recorded is above. " + "Wake it with: mutagent helix session send " + options.reference + ' "<message>"');
+      notice("Session " + options.reference + " is asleep: it stopped for idling. Everything it recorded is above. " + "Wake it with: " + activeProduct().cli + " session send " + options.reference + ' "<message>"');
     } else if (result.end !== "exited") {
-      notice("Reattach with: mutagent helix session attach " + options.reference + " --since " + String(result.lastSeq));
+      notice("Reattach with: " + activeProduct().cli + " session attach " + options.reference + " --since " + String(result.lastSeq));
     }
     return result;
   } finally {
@@ -28828,7 +28942,7 @@ async function runNativeSession(options) {
   }
 }
 
-// src/commands/helix/run-cloud.ts
+// src/commands/cloud-session/run-cloud.ts
 function repositoryFields(flags) {
   return {
     ...flags.repository === undefined ? {} : { repository: flags.repository },
@@ -28869,7 +28983,7 @@ async function runCloudLaunch(plan, mode) {
   };
   process.on("SIGINT", queueInterrupt);
   try {
-    const session = sandbox ? await startSession(sandbox, body) : await launchHelixSession({
+    const session = sandbox ? await startSession(sandbox, body) : await launchSession(activeProduct(), {
       ...body,
       ...plan.preset === undefined ? {} : { preset: plan.preset },
       ...plan.sandboxProvider === undefined ? {} : { sandboxProvider: plan.sandboxProvider },
@@ -28880,10 +28994,10 @@ async function runCloudLaunch(plan, mode) {
       throw entryRefusal(launchRepositoryRefusal(error));
     });
     if (!session.reference) {
-      throw new MutagentError("INVALID_RESPONSE", "The server did not return a session reference.", "Run: mutagent helix doctor");
+      throw new MutagentError("INVALID_RESPONSE", "The server did not return a session reference.", activeProduct() === HELIX_PRODUCT ? "Run: mutagent helix doctor" : `Run: ${activeProduct().cli} access`);
     }
     if (session.arm !== plan.arm || session.mode !== body.mode) {
-      throw new MutagentError("INVALID_RESPONSE", "The server started the session with a different arm or mode than requested.", "Session " + session.reference + " may still be running. Check: mutagent helix session list");
+      throw new MutagentError("INVALID_RESPONSE", "The server started the session with a different arm or mode than requested.", "Session " + session.reference + " may still be running. Check: " + activeProduct().cli + " session list");
     }
     process.removeListener("SIGINT", queueInterrupt);
     await attachLaunched({ reference: session.reference, sessionId: session.sessionId }, mode === "rpc", interruptRequested);
@@ -28907,7 +29021,7 @@ async function runManagedAgentLaunch(launch, write = (line) => {
   };
   process.on("SIGINT", queueInterrupt);
   try {
-    const session = await launchHelixSession({
+    const session = await launchSession(activeProduct(), {
       agent: plan.address,
       ...plan.mode === undefined ? {} : { mode: plan.mode },
       ...plan.task === undefined ? {} : { args: ["-p", plan.task] },
@@ -28919,7 +29033,7 @@ async function runManagedAgentLaunch(launch, write = (line) => {
       throw new MutagentError("INVALID_RESPONSE", "The server did not return a session reference for the managed agent run.", "Check that the server supports managed agents (mutagent agent --help) before running again.");
     }
     if (session.arm !== "agent" || plan.mode !== undefined && session.mode !== plan.mode) {
-      throw new MutagentError("INVALID_RESPONSE", "The server started the session with a different arm or mode than requested.", "Session " + session.reference + " may still be running. Check: mutagent helix session list");
+      throw new MutagentError("INVALID_RESPONSE", "The server started the session with a different arm or mode than requested.", "Session " + session.reference + " may still be running. Check: " + activeProduct().cli + " session list");
     }
     write("[mutagent] " + JSON.stringify({ reference: session.reference, sessionId: session.reference, agent: session.agent, mode: session.mode }) + `
 `);
@@ -28932,21 +29046,22 @@ async function runManagedAgentLaunch(launch, write = (line) => {
 }
 async function attachLaunched(session, rpc, interruptRequested) {
   const reference = session.reference;
+  const routes = activeProduct();
   await runNativeSession({
     reference,
     sessionId: session.sessionId,
     rpc,
-    open: (options) => openHelixStream(reference, options),
-    send: (line, signal) => sendHelixInput(reference, line, signal),
-    closeInput: (signal) => closeHelixInput(reference, signal),
-    interrupt: (signal) => signalHelixSession(reference, "SIGINT", signal),
+    open: (options) => openSessionStream(routes, reference, options),
+    send: (line, signal) => sendSessionInput(routes, reference, line, signal),
+    closeInput: (signal) => closeSessionInput(routes, reference, signal),
+    interrupt: (signal) => signalSession(routes, reference, "SIGINT", signal),
     interruptRequested
   }).catch((error) => {
     throw markStreamStarted(error);
   });
 }
 
-// src/commands/helix/managed-agent.ts
+// src/commands/cloud-session/managed-agent.ts
 init_errors();
 var ADDRESS = /^@([a-z][a-z0-9-]{1,49})(?::(?:v([1-9]\d{0,8})|(latest)))?$/;
 var MANAGED_AGENT_ARGS_MESSAGE = 'a managed agent takes its prompt, tools, skills and model from its package, so @slug accepts only -p "<task>" or --rpc';
@@ -28970,7 +29085,7 @@ function usage(message, recovery) {
 function planManagedAgentRun(argv, flags) {
   const [token, ...rest] = argv;
   const address = parseManagedAgentAddress(token ?? "");
-  const example = `mutagent helix agent @${address.slug} -p "<task>"`;
+  const example = `${activeProduct().cli} agent @${address.slug} -p "<task>"`;
   if (flags.sandbox !== undefined) {
     throw usage("a managed agent runs in a fresh sandbox the platform stages its package into, so --sandbox is refused", `Run: ${example}`);
   }
@@ -28998,7 +29113,7 @@ function planManagedAgentRun(argv, flags) {
     throw usage("-p needs the task text", `Run: ${example}`);
   }
   if (printSeen && flags.rpc === true) {
-    throw usage("-p runs headless and --rpc runs interactive, so pass one of them", `Run: ${example}  or  mutagent helix agent @${address.slug} --rpc`);
+    throw usage("-p runs headless and --rpc runs interactive, so pass one of them", `Run: ${example}  or  ${activeProduct().cli} agent @${address.slug} --rpc`);
   }
   if (task !== undefined)
     return { address, mode: "headless", task };
@@ -29212,11 +29327,93 @@ async function resolveFactoryDefault(name, explicit, usage, conn, env = process.
   throw new MutagentError("MISSING_ARGUMENTS", why + unreadable + several, `Run: ${usage.command} --help`);
 }
 
-// src/commands/helix/agent.ts
+// src/commands/cloud-session/product-guard.ts
+init_errors();
+var HARNESS_USE_PRODUCT_COMMAND = "HARNESS_USE_PRODUCT_COMMAND";
+var FIXED_HARNESS_REFUSED = {
+  "--preset": (product) => `${product.cli} always runs the ${product.title} harness, so it takes no preset.`,
+  "--sandbox": (product) => `${product.cli} always starts a new sandbox with the ${product.title} harness; an existing sandbox runs the harness it was built with.`
+};
+function flagOf(token) {
+  const eq = token.indexOf("=");
+  return eq === -1 ? token : token.slice(0, eq);
+}
+function fixedHarnessFlagRefusal(product, verb, argv) {
+  if (product.preset === undefined)
+    return;
+  const token = argv.find((arg) => FIXED_HARNESS_REFUSED[flagOf(arg)] !== undefined);
+  if (token === undefined)
+    return;
+  const flag = flagOf(token);
+  const why = FIXED_HARNESS_REFUSED[flag]?.(product) ?? "";
+  const command = verb === "" ? product.cli : `${product.cli} ${verb}`;
+  return new MutagentError("UNKNOWN_OPTION", `unknown option '${flag}' for '${command}': ${why}`, `Drop ${flag}. See: ${command} --help`);
+}
+function splitPresets(argv) {
+  const presets = [];
+  const rest = [];
+  for (let i = 0;i < argv.length; i++) {
+    const token = argv[i] ?? "";
+    if (token === "--preset") {
+      const value = argv[i + 1];
+      if (value !== undefined)
+        presets.push(value);
+      i++;
+      continue;
+    }
+    if (token.startsWith("--preset=")) {
+      presets.push(token.slice("--preset=".length));
+      continue;
+    }
+    rest.push(token);
+  }
+  while (rest.length > 0 && rest[rest.length - 1] === "--")
+    rest.pop();
+  return { presets, rest };
+}
+function productPresetRefusal(product, verb, argv, bound = {}) {
+  if (product.preset !== undefined)
+    return;
+  const { presets, rest } = splitPresets(argv);
+  const owner = [bound.preset, ...presets].map(productOwningPreset).find((found) => found !== undefined && found !== product);
+  if (owner === undefined)
+    return;
+  const carried = [];
+  const valued = [
+    [bound.sandboxProvider, "--sandbox-provider"],
+    [bound.env, "--env"],
+    [bound.cwd, "--cwd"],
+    [bound.repository, "--repository"],
+    [bound.branch, "--branch"],
+    [bound.subject, "--subject"],
+    [bound.stage, "--stage"]
+  ];
+  for (const [value, flag] of valued)
+    if (value !== undefined)
+      carried.push(flag, value);
+  if (bound.rpc === true)
+    carried.push("--rpc");
+  const words = [...rest, ...carried].map(shellWord);
+  const head = verb === "" ? owner.cli : `${owner.cli} ${verb}`;
+  const line = words.every((word) => word !== undefined) ? [head, ...words].join(" ") : undefined;
+  const sandboxNamed = bound.sandbox !== undefined || rest.some((token) => flagOf(token) === "--sandbox");
+  const runnable = line !== undefined && !sandboxNamed && isRunnableFixCommand(line);
+  const launched = verb === "" ? product.cli : `${product.cli} ${verb}`;
+  return new MutagentError(HARNESS_USE_PRODUCT_COMMAND, `${launched} does not launch the ${owner.title} harness: --preset ${owner.preset ?? ""} belongs to ${head}, which always runs it.`, runnable ? `Run: ${line}` : `Run the same launch with ${head}, without --preset${sandboxNamed ? " and without --sandbox (it always starts a new sandbox)" : ""}.`);
+}
+
+// src/commands/cloud-session/agent.ts
 var MISSING_TASK_MESSAGE = 'a cloud run needs a task: pass -p "<task>", or --rpc for an interactive session';
 function registerAgentCommand(parent, registration, deps = defaultPlanDeps()) {
   const jsonSource = registration?.jsonSource ?? parent;
-  parent.command("agent").description("Run a Helix agent in the cloud, or a managed agent by @slug").argument("[argv...]", "Agent definition, then the task and Helix flags; or @slug[:vN|:latest] for a managed agent").allowUnknownOption(true).allowExcessArguments(true).addOption(new Option("--sandbox <id>", "Run in an existing sandbox, by sandbox id").hideHelp()).option("--preset <name>", "Sandbox preset (not with --sandbox)").option("--sandbox-provider <name>", "Run on this configured sandbox provider").option("--env <name>", "Workspace Environment to load for this run (see mutagent env list)").option("--rpc", "Read JSON commands on stdin; write events on stdout").option("--cwd <path>", "Working directory in the sandbox").option("--repository <owner/name>", "Native brief only: run in a checkout of this GitHub repository (not with --sandbox or --cwd)").option("--branch <name>", "Branch of --repository to check out (default: its default branch)").option("--subject <id>", "Native brief only: bind the session to this Factory entry (with or without --stage)").option("--stage <stage>", `The platform opens a stage run first (${FACTORY_STAGES.join("|")}); the entry is --subject, else inferred`).addHelpText("after", [
+  const p = registration?.product ?? HELIX_PRODUCT;
+  const fixed = p.preset !== undefined;
+  const t = (text) => productText(text, p);
+  const agent = parent.command("agent").description(t("Run a Helix agent in the cloud, or a managed agent by @slug")).argument("[argv...]", t("Agent definition, then the task and Helix flags; or @slug[:vN|:latest] for a managed agent")).allowUnknownOption(true).allowExcessArguments(true);
+  if (!fixed) {
+    agent.addOption(new Option("--sandbox <id>", "Run in an existing sandbox, by sandbox id").hideHelp()).option("--preset <name>", "Sandbox preset (not with --sandbox)");
+  }
+  agent.option("--sandbox-provider <name>", "Run on this configured sandbox provider").option("--env <name>", "Workspace Environment to load for this run (see mutagent env list)").option("--rpc", "Read JSON commands on stdin; write events on stdout").option("--cwd <path>", "Working directory in the sandbox").option("--repository <owner/name>", `Native brief only: run in a checkout of this GitHub repository (not with ${fixed ? "--cwd" : "--sandbox or --cwd"})`).option("--branch <name>", "Branch of --repository to check out (default: its default branch)").option("--subject <id>", "Native brief only: bind the session to this Factory entry (with or without --stage)").option("--stage <stage>", `The platform opens a stage run first (${FACTORY_STAGES.join("|")}); the entry is --subject, else inferred`).addHelpText("after", t([
     "",
     "Examples:",
     '  mutagent helix agent @invoice-pricing --env prod -p "Price three widget units."',
@@ -29271,8 +29468,15 @@ function registerAgentCommand(parent, registration, deps = defaultPlanDeps()) {
     "  --repository <owner/name> [--branch <name>]; the checkout is the working directory. @slug refuses it.",
     "  On a refusal, show the returned fix: the Run: lines, the notes, and who has to act; do not invent other commands."
   ].join(`
-`)).action(async (argv, options) => {
+`))).action(async (argv, options) => {
     const isJson = getJsonFlag(jsonSource);
+    const productRefusal = fixedHarnessFlagRefusal(p, "agent", argv) ?? productPresetRefusal(p, "agent", argv, options);
+    if (productRefusal !== undefined) {
+      handleLaunchFailure(productRefusal, {
+        isJson: isJson && !hasNativeMode(argv) && options.rpc !== true,
+        machine: options.rpc === true || isMachineMode(argv)
+      });
+    }
     const factoryRefusal = factoryLaunchRefusal(argv, options);
     if (factoryRefusal !== undefined) {
       handleLaunchFailure(factoryRefusal, {
@@ -29293,7 +29497,7 @@ function registerAgentCommand(parent, registration, deps = defaultPlanDeps()) {
         await runManagedAgentLaunch({
           plan,
           ...options.env === undefined ? {} : { environment: options.env },
-          ...options.preset === undefined ? {} : { preset: options.preset },
+          ...presetOf(p, options.preset),
           ...options.sandboxProvider === undefined ? {} : { sandboxProvider: options.sandboxProvider }
         });
       } catch (error) {
@@ -29302,7 +29506,7 @@ function registerAgentCommand(parent, registration, deps = defaultPlanDeps()) {
       return;
     }
     try {
-      const plan = planAgentArgv(argv, deps, { own: TRANSPORT_ONLY_FLAGS, verb: "`mutagent helix agent`" });
+      const plan = planAgentArgv(argv, deps, { own: agentOwnFlags(p), verb: `\`${p.cli} agent\`` });
       const opts = withPlannedFlags(options, plan.own);
       if (!plan.print && !hasNativeMode(plan.nativeArgs) && !opts.rpc) {
         throw new MutagentError("MISSING_ARGUMENTS", MISSING_TASK_MESSAGE, taskRecovery(plan));
@@ -29310,14 +29514,14 @@ function registerAgentCommand(parent, registration, deps = defaultPlanDeps()) {
       const mode = nativeMode(plan.nativeArgs, plan.print, opts.rpc);
       const taskNotices = nativeTaskNotices(mode, plan.messages);
       checkArgsForRoute(plan.nativeArgs, plan.inlined);
-      const factory = await factoryTarget(opts);
+      const factory = await factoryTarget(opts, p);
       for (const notice of [...plan.notices, ...taskNotices])
         process.stderr.write("[mutagent] " + notice + `
 `);
       await runCloudLaunch({
         arm: "agent",
         ...opts.sandbox === undefined ? {} : { sandbox: opts.sandbox },
-        ...opts.preset === undefined ? {} : { preset: opts.preset },
+        ...presetOf(p, opts.preset),
         ...opts.sandboxProvider === undefined ? {} : { sandboxProvider: opts.sandboxProvider },
         ...opts.env === undefined ? {} : { environment: opts.env },
         ...opts.cwd === undefined ? {} : { cwd: opts.cwd },
@@ -29338,6 +29542,13 @@ function registerAgentCommand(parent, registration, deps = defaultPlanDeps()) {
     }
   });
 }
+function presetOf(p, requested) {
+  const preset = p.preset ?? requested;
+  return preset === undefined ? {} : { preset };
+}
+function agentOwnFlags(p) {
+  return p.preset === undefined ? TRANSPORT_ONLY_FLAGS : TRANSPORT_ONLY_FLAGS.filter((flag) => flag !== "--preset" && flag !== "--sandbox");
+}
 function factoryLaunchRefusal(argv, options) {
   const { subject, stage } = options;
   if (subject === undefined && stage === undefined)
@@ -29350,15 +29561,15 @@ function factoryLaunchRefusal(argv, options) {
   }
   return;
 }
-async function factoryTarget(opts) {
+async function factoryTarget(opts, p) {
   if (opts.stage === undefined)
     return opts.subject === undefined ? undefined : { subject: opts.subject };
-  const subject = await resolveFactoryDefault("subject", opts.subject, { what: "--subject <id>", command: "mutagent helix agent" }, connectPlatform);
+  const subject = await resolveFactoryDefault("subject", opts.subject, { what: "--subject <id>", command: `${p.cli} agent` }, connectPlatform);
   return { subject, stage: opts.stage };
 }
 function taskRecovery(plan) {
   if (plan.source === undefined) {
-    return 'Run: mutagent helix agent --prompt "<who the agent is>" -p "<what to do>"\nThe positional is the DEFINITION, not the task — same as the local `helix agent`.';
+    return productCopy('Run: mutagent helix agent --prompt "<who the agent is>" -p "<what to do>"\nThe positional is the DEFINITION, not the task — same as the local `helix agent`.');
   }
   return `The definition is set (${plan.origin}); the task is not. Add: -p "<what to do>"`;
 }
@@ -29391,13 +29602,16 @@ function withPlannedFlags(options, own) {
   };
 }
 
-// src/commands/helix/launcher-argv.ts
+// src/commands/cloud-session/launcher-argv.ts
 init_errors();
 var LAUNCHER_OWN_FLAGS = ["--sandbox", "--preset", "--sandbox-provider", "--cwd", "--env", "--rpc", "--repository", "--branch"];
+function launcherOwnFlags(product) {
+  return product.preset === undefined ? LAUNCHER_OWN_FLAGS : LAUNCHER_OWN_FLAGS.filter((flag) => flag !== "--preset" && flag !== "--sandbox");
+}
 function rejection2(token, reason, alternative) {
-  return new MutagentError("NOT_SUPPORTED", `${token} is not supported in a cloud run: ${reason}`, alternative);
+  return new MutagentError("NOT_SUPPORTED", `${token} is not supported in a cloud run: ${reason}`, productCopy(alternative));
 }
-function planLauncherArgv(argv, deps = defaultPlanDeps()) {
+function planLauncherArgv(argv, deps = defaultPlanDeps(), ownFlags = LAUNCHER_OWN_FLAGS) {
   let arm = "classic";
   let task;
   let sandbox;
@@ -29424,7 +29638,7 @@ function planLauncherArgv(argv, deps = defaultPlanDeps()) {
       continue;
     if (token === "--")
       continue;
-    const mine = readOwnFlag(argv, i, LAUNCHER_OWN_FLAGS, "the classic and prime arms");
+    const mine = readOwnFlag(argv, i, ownFlags, "the classic and prime arms");
     if (mine !== undefined) {
       if (mine.flag === "--rpc")
         rpc = true;
@@ -29487,7 +29701,7 @@ function planLauncherArgv(argv, deps = defaultPlanDeps()) {
     }
     const cls = entry.launcherClass ?? entry.class;
     if (cls === "reject") {
-      throw rejection2(token, entry.reason ?? "it cannot mean the same thing there", entry.alternative ?? "");
+      throw rejection2(token, reasonFor(entry), alternativeFor(entry));
     }
     let value = "";
     if (entry.takesValue) {
@@ -29513,14 +29727,14 @@ function planLauncherArgv(argv, deps = defaultPlanDeps()) {
           forwardFlag(token, read.text);
           continue;
         }
-        throw rejection2(token, "it names an agent definition, and the classic arm has no agent to define", `Use the agent arm instead: mutagent helix agent ${token} ${redactToken(value)} -p "<task>"`);
+        throw rejection2(token, "it names an agent definition, and the classic arm has no agent to define", `Use the agent arm instead: ${activeProduct().cli} agent ${token} ${redactToken(value)} -p "<task>"`);
       case "cross":
         if (token === "--prime") {
           arm = "prime";
           continue;
         }
         if (token === "--prompt") {
-          throw rejection2(token, "it supplies an agent definition, and the classic arm has no agent to define", 'Use the agent arm instead: mutagent helix agent --prompt "<who>" -p "<task>"');
+          throw rejection2(token, "it supplies an agent definition, and the classic arm has no agent to define", `Use the agent arm instead: ${activeProduct().cli} agent --prompt "<who>" -p "<task>"`);
         }
         forwardFlag(token);
         if (entry.takesValue)
@@ -29548,7 +29762,7 @@ function planLauncherArgv(argv, deps = defaultPlanDeps()) {
   };
 }
 
-// src/commands/helix/session-commands.ts
+// src/commands/cloud-session/session-commands.ts
 init_output();
 init_errors();
 import { Command as Command13, Option as Option4 } from "commander";
@@ -29971,7 +30185,7 @@ function parseSince(raw) {
   return value;
 }
 
-// src/lib/helix-session-gone.ts
+// src/lib/sandbox-session-gone.ts
 init_errors();
 var GONE_STATUSES = new Set([404, 410]);
 var CONSEQUENCE = {
@@ -29980,19 +30194,21 @@ var CONSEQUENCE = {
   stream: "it can't be attached to",
   input: "it can't take input"
 };
-var NEW_SESSION_COMMANDS = ['mutagent helix -p "<task>"', "mutagent helix --mode rpc"];
+function newSessionCommands(cli = activeProduct().cli) {
+  return [`${cli} -p "<task>"`, `${cli} --mode rpc`];
+}
 
 class SessionSandboxGoneError extends MutagentError {
   serverMessage;
   constructor(code, reference, route, serverMessage) {
-    super(code, `The sandbox of ${sessionLabel(reference) === reference ? `session ${reference}` : "this session"} was deleted, so ${CONSEQUENCE[route]}.`, `Start a new session: ${NEW_SESSION_COMMANDS[0]} or ${NEW_SESSION_COMMANDS[1]}`);
+    super(code, `The sandbox of ${sessionLabel(reference) === reference ? `session ${reference}` : "this session"} was deleted, so ${CONSEQUENCE[route]}.`, `Start a new session: ${newSessionCommands()[0]} or ${newSessionCommands()[1]}`);
     this.serverMessage = serverMessage;
     this.name = "SessionSandboxGoneError";
   }
   toJSON() {
     return {
       ...super.toJSON(),
-      _agentGuidance: { fix: [...NEW_SESSION_COMMANDS], notes: [`The server answered: ${redactSandboxIds(this.serverMessage)}`] }
+      _agentGuidance: { fix: [...newSessionCommands()], notes: [`The server answered: ${redactSandboxIds(this.serverMessage)}`] }
     };
   }
 }
@@ -30002,13 +30218,14 @@ function sessionGoneGuidance(error, route, reference) {
   return new SessionSandboxGoneError(error.code, reference, route, error.message);
 }
 
-// src/commands/helix/restore-command.ts
+// src/commands/cloud-session/restore-command.ts
 init_output();
 init_errors();
 import chalk25 from "chalk";
 var DRIFT_MODES = ["warn", "refuse", "skip"];
-function registerRestore(session, root) {
-  session.command("restore").description("Continue a session from a checkpoint in a rebuilt sandbox").argument("<reference>", "Session reference (hs1_...) from 'mutagent helix' or 'session list'; the session may be stopped").option("--snapshot <id>", "Checkpoint to use, from 'session checkpoints' (default: the newest complete one from this session's sandbox)").option("--on-drift <mode>", `If files the conversation names are missing: ${DRIFT_MODES.join(" | ")} (default: warn)`).option("--partial", "Also restore turns saved after the checkpoint (may end mid tool call)").addHelpText("after", `
+function registerRestore(session, root, p = HELIX_PRODUCT) {
+  const t = (text) => productText(text, p);
+  session.command("restore").description("Continue a session from a checkpoint in a rebuilt sandbox").argument("<reference>", t("Session reference (hs1_...) from 'mutagent helix' or 'session list'; the session may be stopped")).option("--snapshot <id>", "Checkpoint to use, from 'session checkpoints' (default: the newest complete one from this session's sandbox)").option("--on-drift <mode>", `If files the conversation names are missing: ${DRIFT_MODES.join(" | ")} (default: warn)`).option("--partial", "Also restore turns saved after the checkpoint (may end mid tool call)").addHelpText("after", t(`
 Examples:
   ${chalk25.dim("$")} mutagent helix session restore <reference>
   ${chalk25.dim("$")} mutagent helix session restore <reference> --snapshot snap_1
@@ -30037,7 +30254,7 @@ AI Agent Directive:
   partial, partialBytes, skippedSnapshots }. 'reference' is the NEW session:
   use it for attach, send, signal and checkpoint. Read notRestored before
   relying on the restored state.
-      `).action(async (reference, options) => {
+      `)).action(async (reference, options) => {
     const isJson = getJsonFlag(root);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
@@ -30047,17 +30264,17 @@ AI Agent Directive:
         ...options.onDrift === undefined ? {} : { onWorkspaceDrift: parseDriftMode(options.onDrift) },
         ...options.partial === true ? { partial: true } : {}
       };
-      const result = await restoreHelixSession(reference, body);
+      const result = await restoreSession(p, reference, body);
       if (isJson) {
         output.output({
           success: true,
           ...result,
-          _links: { api: liveSessionPath(result.reference) },
+          _links: { api: sessionPath(p, result.reference) },
           _directive: {
             instruction: "The sandbox has been rebuilt and the agent is continuing the checkpoint’s conversation. Use the NEW reference.",
             next: [
-              `mutagent helix session attach ${result.reference} --since ${String(result.seq)}`,
-              `mutagent helix session send ${result.reference} "<message>" --json`
+              productCopy(`mutagent helix session attach ${result.reference} --since ${String(result.seq)}`),
+              productCopy(`mutagent helix session send ${result.reference} "<message>" --json`)
             ]
           }
         });
@@ -30093,12 +30310,13 @@ function parseDriftMode(raw) {
   throw new MutagentError("INVALID_ARGUMENTS", `--on-drift must be one of ${DRIFT_MODES.join(", ")}, got "${raw}".`, "warn restores and reports; refuse fails before switching; skip does not probe.");
 }
 
-// src/commands/helix/reference-commands.ts
+// src/commands/cloud-session/reference-commands.ts
 init_output();
 init_errors();
 import chalk26 from "chalk";
-function registerCheckpoints(session, root) {
-  session.command("checkpoints").description("List the checkpoints of the sandbox a session runs in").argument("<reference>", "Session reference (hs1_...) from 'mutagent helix' or 'session list'").addHelpText("after", `
+function registerCheckpoints(session, root, p = HELIX_PRODUCT) {
+  const t = (text) => productText(text, p);
+  session.command("checkpoints").description("List the checkpoints of the sandbox a session runs in").argument("<reference>", t("Session reference (hs1_...) from 'mutagent helix' or 'session list'")).addHelpText("after", t(`
 Examples:
   ${chalk26.dim("$")} mutagent helix session checkpoints <reference>
   ${chalk26.dim("$")} mutagent helix session checkpoints <reference> --json
@@ -30111,19 +30329,19 @@ Pass an id to 'mutagent helix session restore <reference> --snapshot <id>'.
 AI Agent Directive:
   --json returns { snapshots: [...], count: N, reference }. Read it to find a
   'snapshotId' (the row's id) for 'restore'.
-      `).action(async (reference) => {
+      `)).action(async (reference) => {
     const isJson = getJsonFlag(root);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
-      const { snapshots } = await listHelixSessionCheckpoints(reference);
+      const { snapshots } = await listSessionCheckpoints(p, reference);
       if (isJson) {
-        output.output({ snapshots, count: snapshots.length, reference, _links: { api: liveSessionPath(reference) + "/checkpoints" } });
+        output.output({ snapshots, count: snapshots.length, reference, _links: { api: sessionPath(p, reference) + "/checkpoints" } });
         return;
       }
       if (snapshots.length === 0) {
         console.log(chalk26.gray("No checkpoints captured from this session's sandbox."));
         console.log("");
-        console.log(`  Capture one: mutagent helix session checkpoint ${reference}`);
+        console.log(productCopy(`  Capture one: mutagent helix session checkpoint ${reference}`));
         return;
       }
       output.output(snapshots.map((snapshot) => ({
@@ -30138,8 +30356,9 @@ AI Agent Directive:
     }
   });
 }
-function registerCloseInput(session, root) {
-  session.command("close-input").description("Close a session's input (end of stdin)").argument("<reference>", "Session reference (hs1_...) from 'mutagent helix' or 'session list'").addHelpText("after", `
+function registerCloseInput(session, root, p = HELIX_PRODUCT) {
+  const t = (text) => productText(text, p);
+  session.command("close-input").description("Close a session's input (end of stdin)").argument("<reference>", t("Session reference (hs1_...) from 'mutagent helix' or 'session list'")).addHelpText("after", t(`
 Examples:
   ${chalk26.dim("$")} mutagent helix session close-input <reference>
   ${chalk26.dim("$")} mutagent helix session close-input <reference> --json
@@ -30152,11 +30371,11 @@ close-input support answers 422.
 AI Agent Directive:
   --json returns { success, reference, closed }. This is not a signal: use
   'mutagent helix session signal <reference> --force' to interrupt a turn.
-      `).action(async (reference) => {
+      `)).action(async (reference) => {
     const isJson = getJsonFlag(root);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
-      const result = await closeHelixInput(reference);
+      const result = await closeSessionInput(p, reference);
       if (isJson)
         output.output({ success: true, reference, closed: result.closed });
       else
@@ -30167,9 +30386,8 @@ AI Agent Directive:
   });
 }
 
-// src/commands/helix/end-access.ts
+// src/commands/cloud-session/end-access.ts
 import chalk27 from "chalk";
-import { helixSessionsEndHelixSession } from "@mutagent/sdk/funcs/helix-sessions-end-helix-session.js";
 init_errors();
 init_output();
 var NOT_ENDED_CODES = new Set(["AUTH_EXPIRED", "AUTH_REQUIRED", "WORKSPACE_REQUIRED", "SANDBOX_TOKEN_REFUSED", "TENANCY_DENIED", "WORKSPACE_KEY_MISMATCH", "CONFIRMATION_REQUIRED", "MISSING_ARGUMENTS"]);
@@ -30183,17 +30401,20 @@ function notEnded(reference, error) {
     return error;
   const label = sessionLabel(reference);
   if (label === reference) {
-    return new MutagentError("SESSION_END_FAILED", `${reference} was not ended: ${error.message}`, `Run: mutagent helix session end ${reference} --force`);
+    return new MutagentError("SESSION_END_FAILED", `${reference} was not ended: ${error.message}`, productCopy(`Run: mutagent helix session end ${reference} --force`));
   }
-  return new MutagentError("SESSION_END_FAILED", `${label} was not ended: ${error.message}. A session is ended by its hs1_ session id: find it in session list, then run mutagent helix session end <hs1_ref> --force.`, "Run: mutagent helix session list --json");
+  return new MutagentError("SESSION_END_FAILED", productCopy(`${label} was not ended: ${error.message}. A session is ended by its hs1_ session id: find it in session list, then run mutagent helix session end <hs1_ref> --force.`), productCopy("Run: mutagent helix session list --json"));
 }
-async function end(reference) {
+async function end(p, reference) {
   if (resolveCredential().kind !== "sandbox-token")
-    return endHelixSession(reference);
-  return sdkJson(await connectPlatform(), (sdk) => helixSessionsEndHelixSession(sdk, { reference }), "mutagent helix session end --help");
-}
-function registerEnd(session, root) {
-  session.command("end").description("End a Helix session and remove its sandbox, addressed by its hs1_ session id").argument("[reference]", "The Helix session id (hs1_…); in a sandbox, its own session").option("-f, --force", "Confirm the end (required in every mode, --json included): ending removes the sandbox").addHelpText("after", `
+    return endSession(p, reference);
+  const conn = await connectPlatform();
+  const help = productCopy("mutagent helix session end --help", p);
+  return onSessionRoute(p, (base) => rawJson(conn, "POST", `${base}/${encodeURIComponent(reference)}/end`, { body: {}, help }));
+}
+function registerEnd(session, root, p = HELIX_PRODUCT) {
+  const t = (text) => productText(text, p);
+  session.command("end").description(t("End a Helix session and remove its sandbox, addressed by its hs1_ session id")).argument("[reference]", t("The Helix session id (hs1_…); in a sandbox, its own session")).option("-f, --force", "Confirm the end (required in every mode, --json included): ending removes the sandbox").addHelpText("after", t(`
 Examples:
   ${chalk27.dim("$")} mutagent helix session end hs1_8f2c41d07a --force
   ${chalk27.dim("$")} mutagent helix session end hs1_8f2c41d07a --force --json
@@ -30211,16 +30432,16 @@ Errors (code: recovery):
 AI Agent Directive:
   Destructive: the sandbox and its files are removed. Confirm with the user, then pass --force.
   --json returns { success, session, ended, sandboxRemoved, checkpointSkipped }.
-`).action(async (reference, options) => {
+`)).action(async (reference, options) => {
     const isJson = getJsonFlag(root);
     const output = new OutputFormatter(isJson ? "json" : "table");
     let ref = reference ?? "<hs1_ref>";
     try {
-      requireForce(options, { what: `Ending session ${ref}`, verb: "mutagent helix session end", command: `mutagent helix session end ${ref}` });
-      ref = await resolveFactoryDefault("session", reference, { what: "the hs1_ session id", command: "mutagent helix session end" }, connectPlatform);
+      requireForce(options, { what: `Ending session ${ref}`, verb: productCopy("mutagent helix session end"), command: productCopy(`mutagent helix session end ${ref}`) });
+      ref = await resolveFactoryDefault("session", reference, { what: "the hs1_ session id", command: productCopy("mutagent helix session end") }, connectPlatform);
       let result;
       try {
-        result = await end(ref);
+        result = await end(p, ref);
       } catch (error) {
         if (!alreadyGone(error))
           throw notEnded(ref, error);
@@ -30235,8 +30456,9 @@ AI Agent Directive:
     }
   });
 }
-function registerAccess(helix) {
-  helix.command("access").description("Whether this account may use cloud sandboxes, and why not").addHelpText("after", `
+function registerAccess(helix, p = HELIX_PRODUCT) {
+  const t = (text) => productText(text, p);
+  helix.command("access").description("Whether this account may use cloud sandboxes, and why not").addHelpText("after", t(`
 Examples:
   ${chalk27.dim("$")} mutagent helix access
   ${chalk27.dim("$")} mutagent helix access --json
@@ -30249,12 +30471,12 @@ Errors (code: recovery):
 AI Agent Directive:
   A read: run it before a cloud launch. --json returns { success, allowed, reason?, fix? };
   allowed false is a successful answer: show the reason and who can fix it.
-`).action(async () => {
+`)).action(async () => {
     const isJson = getJsonFlag(helix);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
       const inSandbox = runLocation() !== "local" && resolveCredential().kind === "sandbox-token";
-      const allowed = inSandbox ? true : await getHelixAccess().then((a) => a.cloudSandboxes, (error) => {
+      const allowed = inSandbox ? true : await getCloudAccess().then((a) => a.cloudSandboxes, (error) => {
         if (error instanceof ApiError && error.statusCode === 404)
           return true;
         throw error;
@@ -30273,7 +30495,7 @@ AI Agent Directive:
   });
 }
 
-// src/commands/helix/session-start-argv.ts
+// src/commands/cloud-session/session-start-argv.ts
 var SESSION_START_OWN_FLAGS = ["--rpc", "--cwd", "--env"];
 function planSessionStartArgs(argv, deps) {
   const plan = planAgentArgv(argv, deps, { own: SESSION_START_OWN_FLAGS, verb: "`mutagent helix session start`" });
@@ -30287,7 +30509,7 @@ function planSessionStartArgs(argv, deps) {
   return { args, notices: plan.notices, own: plan.own };
 }
 
-// src/commands/helix/send.ts
+// src/commands/cloud-session/send.ts
 init_output();
 init_errors();
 import { Option as Option2 } from "commander";
@@ -30297,7 +30519,9 @@ var COMMAND_TYPES = ["prompt", "steer", "follow_up", "abort"];
 var NEEDS_MESSAGE = new Set(["prompt", "steer", "follow_up"]);
 function registerSendCommand(parent, registration) {
   const jsonSource = registration?.jsonSource ?? parent;
-  parent.command("send").description("Send a prompt or command to a session").argument("<reference>", "Session reference (hs1_...)").argument("[message...]", "What to say to the agent").addOption(new Option2("--session <id>", "The session id, when the first argument is a sandbox id").hideHelp()).option("--type <type>", `${COMMAND_TYPES.join(" | ")} (default: prompt)`).option("--line <json>", "Send this exact JSON command instead of building one").option("--message-id <id>", "Use this command id instead of a generated one").addHelpText("after", `
+  const p = registration?.product ?? HELIX_PRODUCT;
+  const t = (text) => productText(text, p);
+  parent.command("send").description("Send a prompt or command to a session").argument("<reference>", "Session reference (hs1_...)").argument("[message...]", "What to say to the agent").addOption(new Option2("--session <id>", "The session id, when the first argument is a sandbox id").hideHelp()).option("--type <type>", `${COMMAND_TYPES.join(" | ")} (default: prompt)`).option("--line <json>", "Send this exact JSON command instead of building one").option("--message-id <id>", "Use this command id instead of a generated one").addHelpText("after", t(`
 Examples:
   ${chalk28.dim("$")} mutagent helix session send <reference> "also check the refresh path"
   ${chalk28.dim("$")} mutagent helix session send <reference> --type steer "stop and re-read the spec"
@@ -30332,22 +30556,22 @@ AI Agent Directive:
   being restored and the message is not delivered yet; the stream reports the
   delivery, or the failed restore and the message it lost. Use --type and a message; use --line only for a
   command the four types cannot express.
-      `).action(async (id, messageParts, options) => {
+      `)).action(async (id, messageParts, options) => {
     const isJson = getJsonFlag(jsonSource);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
       if (options.session === undefined) {
         const built = buildLine(messageParts.join(" ").trim(), options);
-        const result = await sendHelixInput(id, built.line);
+        const result = await sendSessionInput(p, id, built.line);
         if (queuedForWake(result)) {
-          const watch = `mutagent helix session attach ${id}`;
+          const watch = productCopy(`mutagent helix session attach ${id}`);
           if (isJson) {
             output.output({
               success: true,
               reference: id,
               ...built,
               ...result,
-              _links: { api: liveSessionPath(id) },
+              _links: { api: sessionPath(p, id) },
               _directive: {
                 instruction: "Queued, not delivered yet: the session is being restored from its checkpoint. The stream reports the delivery, or a failed restore.",
                 next: [watch]
@@ -30360,17 +30584,17 @@ AI Agent Directive:
           return;
         }
         if (!result.accepted) {
-          throw new MutagentError("RPC_INPUT_REJECTED", "The session did not accept the command.", "Check the session: mutagent helix session list");
+          throw new MutagentError("RPC_INPUT_REJECTED", "The session did not accept the command.", productCopy("Check the session: mutagent helix session list"));
         }
         if (isJson)
-          output.output({ success: result.accepted, reference: id, ...built, ...result, _links: { api: liveSessionPath(id) } });
+          output.output({ success: result.accepted, reference: id, ...built, ...result, _links: { api: sessionPath(p, id) } });
         else
           output.success("Sent " + built.type + " to " + id + "; the reply arrives on the session stream.");
         return;
       }
       const sessionId = options.session.trim();
       if (sessionId === "") {
-        throw new MutagentError("MISSING_ARGUMENTS", "--session is required — a sandbox can hold more than one session.", `Run: mutagent helix session send ${id} --session <session-id> "<message>"`);
+        throw new MutagentError("MISSING_ARGUMENTS", "--session is required — a sandbox can hold more than one session.", productCopy(`Run: mutagent helix session send ${id} --session <session-id> "<message>"`));
       }
       const built = buildLine(messageParts.join(" ").trim(), options);
       const result = await postInput(id, { sessionId, line: built.line });
@@ -30413,7 +30637,7 @@ function buildLine(message, options) {
     throw new MutagentError("INVALID_ARGUMENTS", `Unknown command type "${options.type ?? ""}".`, `Use one of: ${COMMAND_TYPES.join(", ")}. For anything else, pass the raw JSON with --line.`);
   }
   if (message === "" && NEEDS_MESSAGE.has(type)) {
-    throw new MutagentError("MISSING_ARGUMENTS", `A "${type}" carries a message — there is nothing to send without one.`, `Run: mutagent helix session send <id> --session <session-id> --type ${type} "<message>"`);
+    throw new MutagentError("MISSING_ARGUMENTS", `A "${type}" carries a message — there is nothing to send without one.`, productCopy(`Run: mutagent helix session send <id> --session <session-id> --type ${type} "<message>"`));
   }
   if (message !== "" && !NEEDS_MESSAGE.has(type)) {
     throw new MutagentError("INVALID_ARGUMENTS", `A "${type}" takes no message, so the text would be silently discarded.`, `Drop the message, or send it separately as a prompt.`);
@@ -30454,7 +30678,7 @@ function readType(raw) {
   return "raw";
 }
 
-// src/commands/helix/signal.ts
+// src/commands/cloud-session/signal.ts
 init_output();
 init_errors();
 import { Option as Option3 } from "commander";
@@ -30463,7 +30687,9 @@ var SIGNAL_TYPES = ["SIGINT", "SIGTERM"];
 var DEFAULT_SIGNAL = "SIGINT";
 function registerSignalCommand(parent, registration) {
   const jsonSource = registration?.jsonSource ?? parent;
-  parent.command("signal").description("Stop a session with SIGINT or SIGTERM; its sandbox stays up").argument("<reference>", "Session reference (hs1_...)").addOption(new Option3("--session <id>", "The session id, when the argument is a sandbox id").hideHelp()).option("--type <signal>", `${SIGNAL_TYPES.join(" | ")} (default: ${DEFAULT_SIGNAL})`).option("-f, --force", "Confirm the stop (required in every mode, --json included)").addHelpText("after", `
+  const p = registration?.product ?? HELIX_PRODUCT;
+  const t = (text) => productText(text, p);
+  parent.command("signal").description("Stop a session with SIGINT or SIGTERM; its sandbox stays up").argument("<reference>", "Session reference (hs1_...)").addOption(new Option3("--session <id>", "The session id, when the argument is a sandbox id").hideHelp()).option("--type <signal>", `${SIGNAL_TYPES.join(" | ")} (default: ${DEFAULT_SIGNAL})`).option("-f, --force", "Confirm the stop (required in every mode, --json included)").addHelpText("after", t(`
 Examples:
   ${chalk29.dim("$")} mutagent helix session signal <reference> --force
   ${chalk29.dim("$")} mutagent helix session signal <reference> --type SIGTERM --force
@@ -30487,7 +30713,7 @@ AI Agent Directive:
   'signalled' is true only when a running process was stopped. A session that had
   already ended exits non-zero; the agent is already stopped, so treat it as
   information and do not retry.
-      `).action(async (id, options) => {
+      `)).action(async (id, options) => {
     const isJson = getJsonFlag(jsonSource);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
@@ -30496,26 +30722,26 @@ AI Agent Directive:
         const type = options.type === undefined ? "" : ` --type ${options.type}`;
         requireForce(options, {
           what: `Stopping session ${id}`,
-          verb: "mutagent helix session signal",
-          command: `mutagent helix session signal ${id}${session}${type}`
+          verb: productCopy("mutagent helix session signal"),
+          command: productCopy(`mutagent helix session signal ${id}${session}${type}`)
         });
       };
       if (options.session === undefined) {
         const signal = resolveSignal(options.type);
         confirm();
-        const result = await signalHelixSession(id, signal);
+        const result = await signalSession(p, id, signal);
         if (!result.signalled) {
-          throw new MutagentError("SESSION_SIGNAL_REJECTED", "The session was not signalled.", "Check the session: mutagent helix session list");
+          throw new MutagentError("SESSION_SIGNAL_REJECTED", "The session was not signalled.", productCopy("Check the session: mutagent helix session list"));
         }
         if (isJson)
-          output.output({ success: result.signalled, reference: id, signal, ...result, _links: { api: liveSessionPath(id) } });
+          output.output({ success: result.signalled, reference: id, signal, ...result, _links: { api: sessionPath(p, id) } });
         else
           output.success("Sent " + signal + " to " + id + ".");
         return;
       }
       const sessionId = options.session.trim();
       if (sessionId === "") {
-        throw new MutagentError("MISSING_ARGUMENTS", "--session is required — a sandbox can hold more than one session.", `Run: mutagent helix session signal ${id} --session <session-id>`);
+        throw new MutagentError("MISSING_ARGUMENTS", "--session is required — a sandbox can hold more than one session.", productCopy(`Run: mutagent helix session signal ${id} --session <session-id>`));
       }
       const signal = resolveSignal(options.type);
       confirm();
@@ -30553,9 +30779,10 @@ function resolveSignal(raw) {
   return normalised;
 }
 
-// src/commands/helix/session-commands.ts
-function registerSessionCommand(parent) {
-  const session = new Command13("session").description("List, watch and control Helix sessions").addHelpText("after", `
+// src/commands/cloud-session/session-commands.ts
+function registerSessionCommand(parent, p = HELIX_PRODUCT) {
+  const t = (text) => productText(text, p);
+  const session = new Command13("session").description(t("List, watch and control Helix sessions")).addHelpText("after", t(`
 Examples:
   ${chalk30.dim("$")} mutagent helix session list
   ${chalk30.dim("$")} mutagent helix session attach <reference>
@@ -30576,17 +30803,18 @@ AI Agent Directive:
   checkpoint, checkpoints and restore; never guess one. Only an interactive
   (--mode rpc) session accepts send. restore starts a NEW session and returns its
   reference. A managed agent's session cannot be restored yet (409).
-      `);
-  registerStart(session, parent);
-  registerSessionList(session, parent);
-  registerSessionAttach(session);
-  registerSendCommand(session, { jsonSource: parent });
-  registerSignalCommand(session, { jsonSource: parent });
-  registerCloseInput(session, parent);
-  registerCheckpoint(session, parent);
-  registerCheckpoints(session, parent);
-  registerRestore(session, parent);
-  registerEnd(session, parent);
+      `));
+  if (p.preset === undefined)
+    registerStart(session, parent);
+  registerSessionList(session, parent, p);
+  registerSessionAttach(session, p);
+  registerSendCommand(session, { jsonSource: parent, product: p });
+  registerSignalCommand(session, { jsonSource: parent, product: p });
+  registerCloseInput(session, parent, p);
+  registerCheckpoint(session, parent, p);
+  registerCheckpoints(session, parent, p);
+  registerRestore(session, parent, p);
+  registerEnd(session, parent, p);
   parent.addCommand(session);
 }
 function withSessionFlags(options, own) {
@@ -30672,13 +30900,15 @@ function requireSessionId(result, sandboxId) {
     return result.sessionId;
   throw new MutagentError("INVALID_RESPONSE", "The server started a session but did not return a session id.", `The session may be running — watch it with: mutagent sandbox attach ${sandboxId}`);
 }
-function registerSessionList(session, root) {
-  session.command("list").alias("ls").description("List this workspace's Helix sessions").addHelpText("after", `
+function registerSessionList(session, root, p) {
+  const t = (text) => productText(text, p);
+  session.command("list").alias("ls").description(t("List this workspace's Helix sessions")).addHelpText("after", t(`
 Examples:
   ${chalk30.dim("$")} mutagent helix session list
   ${chalk30.dim("$")} mutagent helix session list --json
 
-Every session in the workspace, live and ended, newest activity first.
+Every Helix session in the workspace, live and ended, newest activity first.
+Sessions of the other cloud product's harness are not listed here: its own session list shows them.
 STATUS is live (running now), ended (finished; exitCode in --json), stopped-for-idling
 (its sandbox was idle for 15 minutes and was stopped) or restored
 (running in a sandbox rebuilt from a checkpoint). AGENT is slug:vN for a session
@@ -30691,11 +30921,11 @@ AI Agent Directive:
   sessions: [{ reference, status, agent, arm, mode (interactive or headless), ... }],
   count }. reference is the hs1_ session id: find one session by it, and hold it
   for attach/send/signal; never guess one. The command takes no argument.
-      `).action(async () => {
+      `)).action(async () => {
     const isJson = getJsonFlag(root);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
-      const { workspaceId, sessions, nextCursor } = await listWorkspaceHelixSessions();
+      const { workspaceId, sessions, nextCursor } = await listHarnessSessions(p);
       if (isJson) {
         output.output({
           workspaceId,
@@ -30705,10 +30935,14 @@ AI Agent Directive:
         });
         return;
       }
-      if (sessions.length === 0) {
-        console.log(chalk30.gray("No Helix sessions in this workspace yet."));
+      if (sessions.length === 0 && nextCursor === undefined) {
+        console.log(chalk30.gray(t("No Helix sessions in this workspace yet.")));
         console.log("");
-        console.log('  Start one: mutagent helix -p "<task>"  or  mutagent helix --rpc');
+        console.log(t('  Start one: mutagent helix -p "<task>"  or  mutagent helix --rpc'));
+        return;
+      }
+      if (sessions.length === 0) {
+        console.log(chalk30.gray(t("No Helix sessions in the pages read so far; the listing has more.")));
         return;
       }
       output.output(sessions.map((s) => ({
@@ -30720,15 +30954,17 @@ AI Agent Directive:
         "LAST ACTIVITY": s.lastActivityAt
       })));
       if (nextCursor !== undefined) {
-        console.log(chalk30.gray("\nMore sessions — re-run with the cursor from --json `nextCursor`."));
+        console.log(chalk30.gray(t(`
+More Helix sessions exist than one list reads; these are the newest.`)));
       }
     } catch (error) {
       handleError(withoutSandboxIds(error), isJson);
     }
   });
 }
-function registerSessionAttach(session) {
-  session.command("attach").description("Watch a session").argument("<reference>", "Session reference (hs1_...) from 'mutagent helix' or 'session list'").option("--since <n>", "Replay from after event number n").addHelpText("after", [
+function registerSessionAttach(session, p) {
+  const t = (text) => productText(text, p);
+  session.command("attach").description("Watch a session").argument("<reference>", t("Session reference (hs1_...) from 'mutagent helix' or 'session list'")).option("--since <n>", "Replay from after event number n").addHelpText("after", t([
     "",
     "Examples:",
     "  mutagent helix session attach <reference>",
@@ -30741,23 +30977,24 @@ function registerSessionAttach(session) {
     '  When a send wakes the session, stderr carries [mutagent] {"event":"woken","reference":"hs1_..."}:',
     "  this stream ends there; attach to that reference with --since 0."
   ].join(`
-`)).action(async (reference, options) => {
+`))).action(async (reference, options) => {
     try {
       const since = parseSince(options.since);
       await runNativeSession({
         reference,
         rpc: false,
         ...since === undefined ? {} : { since },
-        open: (request) => openHelixStream(reference, request),
-        send: (line, signal) => sendHelixInput(reference, line, signal)
+        open: (request) => openSessionStream(p, reference, request),
+        send: (line, signal) => sendSessionInput(p, reference, line, signal)
       });
     } catch (error) {
       handleError(sessionGoneGuidance(error, "stream", reference), false);
     }
   });
 }
-function registerCheckpoint(session, root) {
-  session.command("checkpoint").description("Save a session's conversation as a checkpoint").argument("<reference>", "Session reference (hs1_...)").addOption(new Option4("--session <id>", "The session id, when the argument is a sandbox id").hideHelp()).addHelpText("after", `
+function registerCheckpoint(session, root, p) {
+  const t = (text) => productText(text, p);
+  session.command("checkpoint").description("Save a session's conversation as a checkpoint").argument("<reference>", "Session reference (hs1_...)").addOption(new Option4("--session <id>", "The session id, when the argument is a sandbox id").hideHelp()).addHelpText("after", t(`
 Examples:
   ${chalk30.dim("$")} mutagent helix session checkpoint <reference>
   ${chalk30.dim("$")} mutagent helix session checkpoint <reference> --json
@@ -30771,14 +31008,14 @@ AI Agent Directive:
   --json returns { success, reference, snapshotId, bytes, sha256, harnessSessionId,
   messageCount, sourcePath, manifestKey, workspaceBytes, workspaceFiles, notCaptured }.
   Keep snapshotId and read notCaptured before relying on a restore.
-      `).action(async (id, options) => {
+      `)).action(async (id, options) => {
     const isJson = getJsonFlag(root);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
       if (options.session === undefined) {
-        const result = await checkpointHelixSession(id);
+        const result = await checkpointSession(p, id);
         if (isJson)
-          output.output({ success: true, reference: id, ...result, _links: { api: liveSessionPath(id) } });
+          output.output({ success: true, reference: id, ...result, _links: { api: sessionPath(p, id) } });
         else {
           output.success("Snapshot " + result.snapshotId + " captured from " + id);
           if (Array.isArray(result.notCaptured))
@@ -30787,7 +31024,7 @@ AI Agent Directive:
         }
         return;
       }
-      const sessionId = requireSession(options.session, `mutagent helix session checkpoint ${id}`);
+      const sessionId = requireSession(options.session, t(`mutagent helix session checkpoint ${id}`));
       const result = await captureCheckpoint(id, sessionId);
       if (isJson) {
         output.output({
@@ -30799,7 +31036,7 @@ AI Agent Directive:
           _directive: {
             instruction: "Inspect notCaptured. Restore takes the session's reference: find it with session list, then restore rebuilds the sandbox from this snapshot and returns the new session's reference.",
             next: [
-              "mutagent helix session list --json"
+              t("mutagent helix session list --json")
             ]
           }
         });
@@ -30822,13 +31059,13 @@ function requireSession(raw, example) {
   throw new MutagentError("MISSING_ARGUMENTS", "--session is required — a sandbox can hold more than one session.", `Run: ${example} --session <session-id>`);
 }
 
-// src/commands/helix/models.ts
+// src/commands/cloud-session/models.ts
 init_output();
 init_errors();
 import chalk31 from "chalk";
 function printView(view, output) {
   if (view.models.length === 0) {
-    console.log(chalk31.gray("No Helix Cloud models: this workspace has no active LLM provider that Helix can use."));
+    console.log(chalk31.gray(productText("No Helix Cloud models: this workspace has no active LLM provider that Helix can use.", activeProduct())));
     console.log("");
     console.log("  Add one: mutagent providers add --provider <id> --name <name> --api-key <key>");
   } else {
@@ -30838,14 +31075,15 @@ function printView(view, output) {
       name: m.displayName
     })));
     console.log("");
-    console.log(view.default === null ? chalk31.yellow("No default set — a run without --model answers 428. Set one: mutagent helix models default <provider/model>") : `Default: ${view.default}`);
+    console.log(view.default === null ? chalk31.yellow(productCopy("No default set — a run without --model answers 428. Set one: mutagent helix models default <provider/model>")) : `Default: ${view.default}`);
   }
   if (view.unmapped.length > 0) {
-    console.log(chalk31.yellow(`Not usable by Helix Cloud (Helix cannot load this LLM provider's key): ${view.unmapped.join(", ")}`));
+    console.log(chalk31.yellow(productText(`Not usable by Helix Cloud (Helix cannot load this LLM provider's key): ${view.unmapped.join(", ")}`, activeProduct())));
   }
 }
-function registerModelsCommand(helix) {
-  const models = helix.command("models").description("List the models Helix can use in the cloud, and the workspace default model").addHelpText("after", `
+function registerModelsCommand(helix, p = HELIX_PRODUCT) {
+  const t = (text) => productText(text, p);
+  const models = helix.command("models").description(t("List the models Helix can use in the cloud, and the workspace default model")).addHelpText("after", t(`
 Examples:
   ${chalk31.dim("$")} mutagent helix models
   ${chalk31.dim("$")} mutagent helix models --json
@@ -30863,7 +31101,7 @@ AI Agent Directive:
   --json returns { workspaceId, models: [{ id, provider, harnessProvider, model,
   displayName }], defaults: [...], default: <id|null>, unmapped: [...] }. Pick a
   model from models[].id; never invent one — an id outside the list is a 422.
-      `).action(async () => {
+      `)).action(async () => {
     const isJson = getJsonFlag(helix);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
@@ -30877,7 +31115,7 @@ AI Agent Directive:
       handleError(error, isJson);
     }
   });
-  models.command("default").description("Set the workspace default model for Helix in the cloud, and its fallbacks").argument("[models...]", "Model ids from 'mutagent helix models'; the first is the default").option("--clear", "Remove the default model and every fallback").addHelpText("after", `
+  models.command("default").description(t("Set the workspace default model for Helix in the cloud, and its fallbacks")).argument("[models...]", t("Model ids from 'mutagent helix models'; the first is the default")).option("--clear", "Remove the default model and every fallback").addHelpText("after", t(`
 Examples:
   ${chalk31.dim("$")} mutagent helix models default zai-coding-cn/glm-5.3
   ${chalk31.dim("$")} mutagent helix models default zai-coding-cn/glm-5.3 openai/gpt-5.6-sol
@@ -30892,15 +31130,15 @@ AI Agent Directive:
   change. Run it with your own sign-in; it is refused from inside a sandbox
   (task credentials). It is the fix when a run without --model answers 428
   NO_PROVIDER_CONFIGURED because no default model is set.
-      `).action(async (ids, opts) => {
+      `)).action(async (ids, opts) => {
     const isJson = getJsonFlag(helix);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
       if (opts.clear === true && ids.length > 0) {
-        throw new MutagentError("INVALID_ARGUMENTS", "--clear takes no model ids.", "Either: mutagent helix models default --clear  or: mutagent helix models default <provider/model>...");
+        throw new MutagentError("INVALID_ARGUMENTS", "--clear takes no model ids.", productCopy("Either: mutagent helix models default --clear  or: mutagent helix models default <provider/model>..."));
       }
       if (opts.clear !== true && ids.length === 0) {
-        throw new MutagentError("INVALID_ARGUMENTS", "Name at least one model, or pass --clear.", "List the choices: mutagent helix models");
+        throw new MutagentError("INVALID_ARGUMENTS", "Name at least one model, or pass --clear.", productCopy("List the choices: mutagent helix models"));
       }
       const view = await setHelixDefaults(opts.clear === true ? [] : ids);
       if (isJson) {
@@ -30914,6 +31152,85 @@ AI Agent Directive:
   });
 }
 
+// src/commands/cloud-session/product-command.ts
+function launchHelp(p) {
+  const fixed = p.preset !== undefined;
+  return [
+    "",
+    "Run options:",
+    '  -p "<task>"                Run the task to completion and print the final answer',
+    '  --mode json "<task>"       Stream events as JSON lines',
+    "  --mode rpc, --rpc          Read JSON commands on stdin; write events on stdout",
+    "  --prime                    Run the lean Prime agent instead of the full orchestrator",
+    `  --model <provider/model>   Model to use (default: the workspace default model; see ${p.cli} models)`,
+    "  --env <name>               Workspace Environment to load (see mutagent env list)",
+    ...fixed ? [] : ["  --preset <name>            Sandbox preset (default: the server's Helix preset)"],
+    "  --sandbox-provider <name>  Run on this configured sandbox provider",
+    "  --cwd <path>               Working directory in the sandbox",
+    `  --repository <owner/name>  Run ${p.title} in a checkout of this GitHub repository (the workspace's GitHub connection);`,
+    "                             the checkout is the working directory, so --cwd is refused with it",
+    "  --branch <name>            Branch of --repository to check out (default: its default branch)",
+    "",
+    "Examples:",
+    `  ${p.cli} -p "plan the refactor"`,
+    `  ${p.cli} --mode json "run the tests"`,
+    `  ${p.cli} --prime --mode rpc`,
+    `  ${p.cli} --env staging -p "check the deploy"`,
+    `  ${p.cli} --repository acme/api --branch feat/login --mode rpc`,
+    `  ${p.cli} agent --file reviewer.md --prime --mode rpc`,
+    "",
+    ...fixed ? [`Every run starts a new sandbox with the ${p.title} harness; there is no --preset.`, ""] : [],
+    "Each run prints its session reference (hs1_...) on stderr. Use it with",
+    `${p.cli} session attach, send, signal and checkpoint.`,
+    "Ctrl-C sends SIGINT to the session, which stops it; the exit status is reported.",
+    "There is no terminal chat UI: choose -p, --mode json or --mode rpc.",
+    "With --mode rpc, closing stdin ends the session's input; a dropped connection only detaches.",
+    "A sandbox idle for 15 minutes is stopped; an interactive session in it is checkpointed first.",
+    "A send to that session wakes it in a new sandbox from its last checkpoint;",
+    `${p.cli} session restore is the manual option.`,
+    "",
+    "AI Agent Directive:",
+    "  Choose -p (one-shot), --mode json or --mode rpc (a steerable session) explicitly.",
+    `  Without --prime the full ${p.title} orchestrator runs; --prime runs the lean Prime agent.`,
+    "  Keep the session reference (hs1_...) printed on stderr; attach, send, signal and checkpoint take it.",
+    ...fixed ? [`  This is the cloud form of the local architech command; Helix runs with mutagent helix. Never pass --preset.`] : ["  mutagent install helix installs the Helix binary on this machine; this command runs it in the cloud."],
+    "  Inside a git checkout, pass the git remote's owner/name to start with it checked out: --repository <owner/name> [--branch <name>].",
+    "  On a refusal, show the returned fix: the Run: lines, the notes, and who has to act; do not invent other commands.",
+    "  In --mode rpc/json a launch refusal is one JSON line on stderr: {success:false, code, error, suggestedAction,",
+    `  _agentGuidance:{fix, notes, escalate?}}; stdout stays the session's. With -p it is text on stderr.`
+  ].join(`
+`);
+}
+function createCloudProductCommand(p, own = {}) {
+  const group = new Command14(p.command).description(`Run ${p.title} in the cloud`).allowUnknownOption(true).allowExcessArguments(true).argument("[argv...]", `${p.title} flags and the task, e.g. -p "<task>"`).helpCommand("help [command]", `Print usage for ${p.cli} or one of its subcommands`).addHelpText("after", launchHelp(p)).hook("preAction", () => {
+    selectProduct(p);
+  }).action(async (argv, _options, command) => {
+    try {
+      if (own.reportVersions !== undefined && argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
+        await own.reportVersions(getJsonFlag(command));
+        return;
+      }
+      const refusal = fixedHarnessFlagRefusal(p, "", argv) ?? productPresetRefusal(p, "", argv);
+      if (refusal !== undefined)
+        throw refusal;
+      const plan = planLauncherArgv(argv, undefined, launcherOwnFlags(p));
+      const mode = nativeMode(plan.nativeArgs, plan.print, plan.rpc);
+      for (const notice of [...plan.notices, ...nativeTaskNotices(mode, plan.messages)])
+        process.stderr.write("[mutagent] " + notice + `
+`);
+      await runCloudLaunch({ ...plan, ...p.preset === undefined ? {} : { preset: p.preset }, args: plan.nativeArgs }, mode);
+    } catch (error) {
+      handleLaunchFailure(error, { isJson: getJsonFlag(command) && !hasNativeMode(argv), machine: isMachineMode(argv) });
+    }
+  });
+  registerAgentCommand(group, { product: p });
+  registerSessionCommand(group, p);
+  registerModelsCommand(group, p);
+  registerAccess(group, p);
+  own.register?.(group);
+  return group;
+}
+
 // src/commands/helix/doctor.ts
 init_output();
 init_errors();
@@ -31104,74 +31421,20 @@ function reportSandboxRun(result, output, isJson, context) {
 
 // src/commands/helix/index.ts
 function createHelixCommand() {
-  const helix = new Command14("helix").description("Run Helix in the cloud").allowUnknownOption(true).allowExcessArguments(true).argument("[argv...]", 'Helix flags and the task, e.g. -p "<task>"').helpCommand("help [command]", "Print usage for mutagent helix or one of its subcommands").addHelpText("after", [
-    "",
-    "Run options:",
-    '  -p "<task>"                Run the task to completion and print the final answer',
-    '  --mode json "<task>"       Stream events as JSON lines',
-    "  --mode rpc, --rpc          Read JSON commands on stdin; write events on stdout",
-    "  --prime                    Run the lean Prime agent instead of the full orchestrator",
-    "  --model <provider/model>   Model to use (default: the workspace default model; see mutagent helix models)",
-    "  --env <name>               Workspace Environment to load (see mutagent env list)",
-    "  --preset <name>            Sandbox preset (default: the server's Helix preset)",
-    "  --sandbox-provider <name>  Run on this configured sandbox provider",
-    "  --cwd <path>               Working directory in the sandbox",
-    "  --repository <owner/name>  Run Helix in a checkout of this GitHub repository (the workspace's GitHub connection);",
-    "                             the checkout is the working directory, so --cwd is refused with it",
-    "  --branch <name>            Branch of --repository to check out (default: its default branch)",
-    "",
-    "Examples:",
-    '  mutagent helix -p "plan the refactor"',
-    '  mutagent helix --mode json "run the tests"',
-    "  mutagent helix --prime --mode rpc",
-    '  mutagent helix --env staging -p "check the deploy"',
-    "  mutagent helix --repository acme/api --branch feat/login --mode rpc",
-    "  mutagent helix agent --file reviewer.md --prime --mode rpc",
-    "",
-    "Each run prints its session reference (hs1_...) on stderr. Use it with",
-    "mutagent helix session attach, send, signal and checkpoint.",
-    "Ctrl-C sends SIGINT to the session, which stops it; the exit status is reported.",
-    "There is no terminal chat UI: choose -p, --mode json or --mode rpc.",
-    "With --mode rpc, closing stdin ends the session's input; a dropped connection only detaches.",
-    "A sandbox idle for 15 minutes is stopped; an interactive session in it is checkpointed first.",
-    "A send to that session wakes it in a new sandbox from its last checkpoint;",
-    "mutagent helix session restore is the manual option.",
-    "",
-    "AI Agent Directive:",
-    "  Choose -p (one-shot), --mode json or --mode rpc (a steerable session) explicitly.",
-    "  Without --prime the full Helix orchestrator runs; --prime runs the lean Prime agent.",
-    "  Keep the session reference (hs1_...) printed on stderr; attach, send, signal and checkpoint take it.",
-    "  mutagent install helix installs the Helix binary on this machine; this command runs it in the cloud.",
-    "  Inside a git checkout, pass the git remote's owner/name to start with it checked out: --repository <owner/name> [--branch <name>].",
-    "  On a refusal, show the returned fix: the Run: lines, the notes, and who has to act; do not invent other commands.",
-    "  In --mode rpc/json a launch refusal is one JSON line on stderr: {success:false, code, error, suggestedAction,",
-    "  _agentGuidance:{fix, notes, escalate?}}; stdout stays the session's. With -p it is text on stderr."
-  ].join(`
-`)).action(async (argv, _options, command) => {
-    try {
-      if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
-        await reportVersions(getJsonFlag(command));
-        return;
-      }
-      const plan = planLauncherArgv(argv);
-      const mode = nativeMode(plan.nativeArgs, plan.print, plan.rpc);
-      for (const notice of [...plan.notices, ...nativeTaskNotices(mode, plan.messages)])
-        process.stderr.write("[mutagent] " + notice + `
-`);
-      await runCloudLaunch({ ...plan, args: plan.nativeArgs }, mode);
-    } catch (error) {
-      handleLaunchFailure(error, { isJson: getJsonFlag(command) && !hasNativeMode(argv), machine: isMachineMode(argv) });
+  return createCloudProductCommand(HELIX_PRODUCT, {
+    reportVersions,
+    register: (group) => {
+      registerDoctorCommand(group);
+      registerSmokeCommand(group);
+      registerVersionCommand(group);
+      registerUpdateCommand2(group);
     }
   });
-  registerAgentCommand(helix);
-  registerSessionCommand(helix);
-  registerModelsCommand(helix);
-  registerAccess(helix);
-  registerDoctorCommand(helix);
-  registerSmokeCommand(helix);
-  registerVersionCommand(helix);
-  registerUpdateCommand2(helix);
-  return helix;
+}
+
+// src/commands/architech/index.ts
+function createArchitechCommand() {
+  return createCloudProductCommand(ARCHITECH_PRODUCT);
 }
 
 // src/commands/sandbox/index.ts
@@ -31571,7 +31834,7 @@ import chalk36 from "chalk";
 init_errors();
 init_config();
 init_organization_scope();
-async function getCloudAccess() {
+async function getCloudAccess2() {
   let body;
   try {
     body = await requestJson("/api/sandbox/access");
@@ -31622,7 +31885,7 @@ Requires a workspace: mutagent workspaces use <name> (or --workspace for one com
       `).action(async () => {
     const isJson = getJsonFlag(parent);
     try {
-      const access = await getCloudAccess();
+      const access = await getCloudAccess2();
       if (isJson) {
         console.log(JSON.stringify(access));
         return;
@@ -33960,9 +34223,14 @@ function assertCreatableKind(kind) {
 function registerList3(gateway) {
   const triggers = new Command17("triggers").description("Event → agent run: create, list, show, update, enable, disable, delete, test");
   gateway.addCommand(triggers);
-  triggers.description("List triggers — user-created first, then built-ins").addHelpText("after", `
+  configureList(triggers, gateway, "mutagent gateway triggers");
+  configureList(triggers.command("list").alias("ls"), gateway, "mutagent gateway triggers list");
+  return triggers;
+}
+function configureList(command, gateway, usage) {
+  command.description("List triggers — user-created first, then built-ins").addHelpText("after", `
 Examples:
-  ${chalk49.dim("$")} mutagent gateway triggers --json
+  ${chalk49.dim("$")} ${usage} --json
 
 Built-in triggers (the default @mention behaviour) are listed, marked 'builtin: true',
 and are read-only — 'update'/'enable'/'disable'/'delete' on one refuse (409). A built-in
@@ -33989,7 +34257,6 @@ AI Agent Directive:
       return;
     }, RESOURCE);
   });
-  return triggers;
 }
 function createFilter(options) {
   if (options.on === "trace.threshold") {
@@ -34386,9 +34653,14 @@ function printRoutine(r) {
 function registerList4(gateway) {
   const routines = new Command18("routines").description("Schedule → agent run: create, list, show, update, pause, resume, run-now, delete");
   gateway.addCommand(routines);
-  routines.description("List routines, with their next three fire times").addHelpText("after", `
+  configureList2(routines, gateway, "mutagent gateway routines");
+  configureList2(routines.command("list").alias("ls"), gateway, "mutagent gateway routines list");
+  return routines;
+}
+function configureList2(command, gateway, usage) {
+  command.description("List routines, with their next three fire times").addHelpText("after", `
 Examples:
-  ${chalk50.dim("$")} mutagent gateway routines --json
+  ${chalk50.dim("$")} ${usage} --json
 
 AI Agent Directive:
   --json returns { success, ok, data: { items: Routine[] } }. schedule.next is 3 ISO-8601
@@ -34410,7 +34682,6 @@ AI Agent Directive:
       return;
     }, RESOURCE2);
   });
-  return routines;
 }
 function timezoneRequired() {
   return new GatewayCliError("TIMEZONE_REQUIRED", "A routine schedule needs a timezone.", {
@@ -34914,13 +35185,13 @@ function assertUntil(value) {
     fix: ["mutagent gateway runs --since 24h --until 2h --json"]
   });
 }
-function registerRunsList(runs, gateway) {
-  runs.description("Runs from triggers, routines, the test run and emit — newest first").option("--status <s>", "Comma-separated states to filter to").option("--since <duration>", "ISO-8601 timestamp, or a duration like 30m / 24h / 7d").option("--until <when>", "End of the window: ISO-8601, a duration like 30m / 24h / 7d, or now").option("--session <session-id>", "Only the run of this Helix session (its hs1_ reference)").option("--trigger <id>", "Only runs launched by this trigger").option("--routine <id>", "Only runs launched by this routine").addHelpText("after", `
+function configureRunsList(command, gateway, usage, group) {
+  command.description("Runs from triggers, routines, the test run and emit — newest first").option("--status <s>", "Comma-separated states to filter to").option("--since <duration>", "ISO-8601 timestamp, or a duration like 30m / 24h / 7d").option("--until <when>", "End of the window: ISO-8601, a duration like 30m / 24h / 7d, or now").option("--session <session-id>", "Only the run of this Helix session (its hs1_ reference)").option("--trigger <id>", "Only runs launched by this trigger").option("--routine <id>", "Only runs launched by this routine").addHelpText("after", `
 Examples:
-  ${chalk51.dim("$")} mutagent gateway runs --since 24h --json
-  ${chalk51.dim("$")} mutagent gateway runs --status failed --json
-  ${chalk51.dim("$")} mutagent gateway runs --since 24h --until 2h --json
-  ${chalk51.dim("$")} mutagent gateway runs --session hs1_8f2c41d07a --json
+  ${chalk51.dim("$")} ${usage} --since 24h --json
+  ${chalk51.dim("$")} ${usage} --status failed --json
+  ${chalk51.dim("$")} ${usage} --since 24h --until 2h --json
+  ${chalk51.dim("$")} ${usage} --session hs1_8f2c41d07a --json
 
 --since and --until bound the window by when a run was created. A window value is
 ISO-8601, a duration back from now (30m, 24h, 7d), or, for --until, now. Anything else
@@ -34930,7 +35201,8 @@ AI Agent Directive:
   --json returns { success, ok, data: { items: RunSummary[] } }. state is one of queued |
   allocating | checkout_ready | grant_ready | running | succeeded | failed |
   cancelled | unknown.
-      `).action(async (options) => {
+      `).action(async (own) => {
+    const options = { ...group?.opts() ?? {}, ...own };
     const isJson = gatewayIsJson(gateway);
     await runGatewayAction(isJson, undefined, async () => {
       if (options.until !== undefined)
@@ -35176,7 +35448,8 @@ function registerGatewayRunCommands(gateway) {
   registerTestRun(gateway);
   const runs = new Command19("runs");
   gateway.addCommand(runs);
-  registerRunsList(runs, gateway);
+  configureRunsList(runs, gateway, "mutagent gateway runs");
+  configureRunsList(runs.command("list").alias("ls"), gateway, "mutagent gateway runs list", runs);
   registerRunsShow(runs, gateway);
   registerRunsLogs(runs, gateway);
   registerRunsCancel(runs, gateway);
@@ -41289,13 +41562,15 @@ AI Agent Directive:
 
 // src/commands/factory/index.ts
 function createFactoryCommand() {
-  const factory = new Command30("factory").description("Manage Factory entries: their specs, builds and stage runs");
+  const factory = new Command30("factory").description("Manage Agent Factory entries: their specs, builds and stage runs");
   registerEntryCommands(factory);
   factory.addCommand(createSpecCommand());
   factory.addCommand(createStageCommand());
   factory.addHelpText("after", `
-A Factory entry is one agent, skill, workflow or multi-agent system you manage,
-wherever it runs. Its id is its agentspec's metadata.id.
+This is the Agent Factory. A Factory entry is one agent, skill, workflow or
+multi-agent system you manage, wherever it runs. Its id is its agentspec's
+metadata.id. The Software Factory (factory.yaml, board-driven runs) is a
+different product with its own CLI: architech factory.
 
   Register   add <agentspec-file|->            (targets come from the spec)
   Read       list · show <id> · activity <id> · builds <id>
@@ -43458,6 +43733,7 @@ function registerCommands(program) {
   program.addCommand(createTracesCommand());
   program.addCommand(createArtifactsCommand());
   program.addCommand(createHelixCommand());
+  program.addCommand(createArchitechCommand());
   program.addCommand(createFeedbackCommand());
   program.addCommand(createAgentCommand());
 }
@@ -43488,12 +43764,13 @@ function findRemovedCommand(words) {
 }
 
 // src/lib/removed-arguments.ts
-var REMOVED_ARGUMENTS = {
-  "helix session list": {
-    message: "`mutagent helix session list` takes no sandbox id: filter by hs1_ session id instead. " + "Every row of the listing names its session by `reference` (hs1_…); " + "`mutagent helix session attach <hs1_id>` opens that one session.",
-    recovery: "mutagent helix session list --json"
-  }
-};
+function sessionListTakesNoSandboxId(cli) {
+  return {
+    message: `\`${cli} session list\` takes no sandbox id: filter by hs1_ session id instead. ` + "Every row of the listing names its session by `reference` (hs1_…); " + `\`${cli} session attach <hs1_id>\` opens that one session.`,
+    recovery: `${cli} session list --json`
+  };
+}
+var REMOVED_ARGUMENTS = Object.fromEntries(CLOUD_PRODUCTS.map((product) => [`${product.command} session list`, sessionListTakesNoSandboxId(product.cli)]));
 function findRemovedArgument(path) {
   return REMOVED_ARGUMENTS[path];
 }
@@ -43738,10 +44015,11 @@ function commandPathIndexes(rawArgs, depth) {
 // src/bin/run-cli.ts
 init_errors();
 
-// src/commands/helix/api-key-guard.ts
+// src/commands/cloud-session/api-key-guard.ts
 init_errors();
 var FORWARDING_VERBS = [
   { path: ["helix"], label: "mutagent helix" },
+  { path: ["architech"], label: "mutagent architech" },
   { path: ["sandbox", "exec"], label: "mutagent sandbox exec" }
 ];
 function rootValueOption(arg) {
@@ -43770,10 +44048,10 @@ function forwardedRootOptionRefusal(rawArgs) {
       continue;
     const after = rawArgs.slice((at[at.length - 1] ?? -1) + 1);
     const bindable = commanderBindable(after);
-    const isHelix = verb.path[0] === "helix";
-    const keyScope = isHelix ? after : bindable;
+    const isProduct = verb.path.length === 1;
+    const keyScope = isProduct ? after : bindable;
     if (keyScope.some((arg) => rootValueOption(arg) === "--api-key")) {
-      return isHelix ? helixKeyRefusal() : sandboxExecKeyRefusal();
+      return isProduct ? productKeyRefusal(verb.label) : sandboxExecKeyRefusal();
     }
     const other = bindable.map(rootValueOption).find((option) => option !== undefined);
     if (other !== undefined)
@@ -43785,9 +44063,10 @@ function forwardedRootOptionRefusal(rawArgs) {
 function keyAlternative() {
   return transportFor("--api-key")?.alternative ?? "";
 }
-function helixKeyRefusal() {
-  return new MutagentError("NOT_SUPPORTED", "--api-key after 'mutagent helix' is refused: locally it is the LLM key for the run, but here the mutagent CLI would read it as its own platform key and send it to the Mutagent platform.", `${keyAlternative()}
-To pass the Mutagent platform key instead, put it before the command (mutagent --api-key <mutagent-key> helix …) or export MUTAGENT_API_KEY.`);
+function productKeyRefusal(label) {
+  const command = label.replace(/^mutagent /, "");
+  return new MutagentError("NOT_SUPPORTED", `--api-key after '${label}' is refused: locally it is the LLM key for the run, but here the mutagent CLI would read it as its own platform key and send it to the Mutagent platform.`, `${keyAlternative()}
+To pass the Mutagent platform key instead, put it before the command (mutagent --api-key <mutagent-key> ${command} …) or export MUTAGENT_API_KEY.`);
 }
 function sandboxExecKeyRefusal() {
   return new MutagentError("NOT_SUPPORTED", "--api-key after 'mutagent sandbox exec' and before a -- is refused: it reads as a flag of the command in the sandbox, but the mutagent CLI would take it as its own platform key and send it to the Mutagent platform.", `${keyAlternative()}
@@ -43829,8 +44108,8 @@ function rescopeProviderApiKeyFlag(rawArgs) {
   }
   return [...rawArgs];
 }
-// src/commands/helix/helix-surface.json
-var helix_surface_default = {
+// src/commands/cloud-session/harness-surface.json
+var harness_surface_default = {
   helixVersion: "0.4.20",
   harnessVersion: "1.0.0",
   launcher: {
@@ -44128,36 +44407,37 @@ var helix_surface_default = {
   }
 };
 
-// src/commands/helix/help-json.ts
+// src/commands/cloud-session/help-json.ts
 var HELP_FLAGS = new Set(["--help", "-h"]);
-function isHelixHelpJson(rawArgs) {
+function cloudHelpJsonProduct(rawArgs) {
   const at = findSubcommandIndex(rawArgs);
-  if (at === -1 || rawArgs[at] !== "helix")
-    return false;
-  if (!rawArgs.includes("--json"))
-    return false;
+  const product = at === -1 ? undefined : CLOUD_PRODUCTS.find((candidate) => candidate.command === rawArgs[at]);
+  if (product === undefined || !rawArgs.includes("--json"))
+    return;
   const rest = rawArgs.slice(at + 1).filter((arg) => arg !== "--json");
-  return rest.length === 1 && HELP_FLAGS.has(rest[0] ?? "");
+  return rest.length === 1 && HELP_FLAGS.has(rest[0] ?? "") ? product : undefined;
 }
-function helixCloudSurface(cliVersion) {
+function helixCloudSurface(cliVersion, product = HELIX_PRODUCT) {
+  const fixed = product.preset !== undefined;
   return {
-    surface: "mutagent helix",
+    surface: product.cli,
+    ...fixed ? { preset: product.preset } : {},
     cli: cliVersion,
-    helixVersion: helix_surface_default.helixVersion,
-    harnessVersion: helix_surface_default.harnessVersion,
-    manifest: helix_surface_default,
+    helixVersion: harness_surface_default.helixVersion,
+    harnessVersion: harness_surface_default.harnessVersion,
+    manifest: harness_surface_default,
     transport: TRANSPORT_TABLE.map((entry) => ({
       flag: entry.token,
       class: entry.class,
       takesValue: entry.takesValue,
       ...entry.via === undefined ? {} : { via: entry.via },
       ...entry.launcherClass === undefined ? {} : { launcherClass: entry.launcherClass },
-      ...entry.reason === undefined ? {} : { reason: entry.reason },
-      ...entry.alternative === undefined ? {} : { alternative: entry.alternative },
+      ...entry.reason === undefined ? {} : { reason: fixed ? reasonFor(entry, product) : entry.reason },
+      ...entry.alternative === undefined ? {} : { alternative: fixed ? alternativeFor(entry, product) : entry.alternative },
       ...entry.notice === undefined ? {} : { notice: entry.notice },
       ...entry.note === undefined ? {} : { note: entry.note }
     })),
-    transportOnlyFlags: [...TRANSPORT_ONLY_FLAGS]
+    transportOnlyFlags: fixed ? TRANSPORT_ONLY_FLAGS.filter((flag) => flag !== "--preset" && flag !== "--sandbox") : [...TRANSPORT_ONLY_FLAGS]
   };
 }
 
@@ -44207,6 +44487,7 @@ async function runCli(argv, cliVersion) {
   addGlobalOptions(program).name("mutagent").description(`Mutagent runs AI coding agents in cloud sandboxes. Helix is its coding agent:
 mutagent helix runs Helix on your task in a sandbox in your workspace.
 Prime is Helix's lean agent: mutagent helix --prime runs it instead of the full orchestrator.
+mutagent architech runs the Architech harness the same way (the cloud form of the local architech).
 A managed agent is an agent.md folder deployed with mutagent agent deploy.
 
   Documentation: https://docs.mutagent.io/cli
@@ -44259,7 +44540,7 @@ ${chalk77.yellow("AI Agent Directive:")}
   1. Sign in: with MUTAGENT_API_KEY set, run mutagent login --json. To help a user sign in,
      run mutagent login --browser --json, show the printed URL to the user verbatim, and
      wait: the CLI polls for up to 5 minutes.
-  2. Pass --json to every command except a mutagent helix launch (-p, --mode json or rpc), whose output is Helix's own.
+  2. Pass --json to every command except a mutagent helix or mutagent architech launch (-p, --mode json or rpc), whose output is the harness's own.
   3. Run <command> --help before the first use of a command.
   4. A --json response may carry _directive.renderedCard (a status card: copy it into your chat
      reply verbatim before running another command), _directive.instruction (what to do next),
@@ -44283,9 +44564,10 @@ ${!hasCredentials() ? `
     }
     process.exit(0);
   }
-  const helixHelpJson = isHelixHelpJson(rawArgs);
-  if (helixHelpJson) {
-    process.stdout.write(`${JSON.stringify(helixCloudSurface(cliVersion))}
+  const helpJsonProduct = cloudHelpJsonProduct(rawArgs);
+  const helixHelpJson = helpJsonProduct !== undefined;
+  if (helpJsonProduct !== undefined) {
+    process.stdout.write(`${JSON.stringify(helixCloudSurface(cliVersion, helpJsonProduct))}
 `);
   }
   const rootOptionError = forwardedRootOptionRefusal(rawArgs);
@@ -44345,4 +44627,4 @@ if (process.env.CLI_VERSION) {
 }
 runCli(process.argv.slice(2), cliVersion);
 
-//# debugId=1817737D964116B364756E2164756E21
+//# debugId=BBE3EBCBEECE0C5A64756E2164756E21