@tablation/crew 0.111.1 → 0.113.0

package/dist/cli.js

@@ -6131,6 +6131,61 @@ var State = class _State {
 
 // src/environment.ts
 import { basename as basename6 } from "path";
+
+// src/sandbox-brief.ts
+var SANDBOX_SKILL_SWAPS = [
+  ["Worktree Setup", "Sandbox Setup"]
+];
+var SANDBOX_STUB_DIR = "/sandbox/.crew-bin";
+var CONTAINER_ENGINES = ["docker", "podman", "nerdctl", "docker-compose"];
+var CONTAINER_ENGINE_MESSAGE = 'crew: this run is inside a sandbox, which has no container engine. Run the service as a process in hooks.setup instead (ports from hooks.ports, overrides from hooks.isolate) \u2014 see "Services inside the sandbox" in REPO_SPEC.md.';
+function swapSandboxSkills(text2) {
+  let out = text2;
+  for (const [host, sandbox] of SANDBOX_SKILL_SWAPS) out = out.split(`\`${host}\``).join(`\`${sandbox}\``);
+  return out;
+}
+function containerEngineStubScript(dir = SANDBOX_STUB_DIR) {
+  const body = `#!/bin/sh
+printf '%s\\n' ${shSingle(CONTAINER_ENGINE_MESSAGE)} >&2
+exit 125
+`;
+  return [
+    `mkdir -p ${shSingle(dir)}`,
+    ...CONTAINER_ENGINES.map((e) => `printf '%b' ${shSingle(body)} > ${shSingle(`${dir}/${e}`)} && chmod 755 ${shSingle(`${dir}/${e}`)}`)
+  ].join(" && ");
+}
+function shSingle(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function containerEngineUse(hook2) {
+  const names = CONTAINER_ENGINES.map((e) => e.replace(/-/g, "\\-")).join("|");
+  const re = new RegExp(`(?:^|[;&|(\`]|&&|\\|\\||\\$\\()\\s*(?:(?:then|do|else|elif|if|while|until|time|exec)\\s+)*(?:sudo\\s+)?(?:\\S*/)?(${names})(?=\\s|$)`, "m");
+  const m = re.exec(hook2.split("\n").filter((l) => !/^\s*#/.test(l)).join("\n"));
+  return m ? m[1] : null;
+}
+function sandboxCheckoutSection(workDir, heading) {
+  return [
+    "",
+    heading,
+    "",
+    `You are already inside a sandbox created for this run. \`${workDir}\` is a fresh`,
+    "clone of the repository on a fresh branch, and it is your working directory. There is",
+    "no primary checkout and no other worktree: do not cut a worktree, do not run `crew",
+    "worktree`, and do not look for files to copy from a main checkout. The digest's",
+    "`worktree` column does not apply; its `branch` column is the name your work is pushed",
+    "under, so create it with `git checkout -b <branch>` in the clone.",
+    "",
+    "The sandbox has no container engine, and nothing installs at run time: a service the",
+    "tests need is a process the repository's `setup` hook starts. Fetch the `Sandbox Setup`",
+    "skill for setup, ports and the hand-off push."
+  ];
+}
+function sandboxEnv(ship) {
+  return ship.runner === "sandbox" ? { sandbox: { workDir: ship.sandbox?.workDir ?? DEFAULT_SANDBOX_WORKDIR } } : {};
+}
+var DEFAULT_SANDBOX_WORKDIR = "/sandbox/work";
+
+// src/environment.ts
 var API_KEY_VAR = "CREW_API_KEY";
 function authorshipBullets(a, contract) {
   if (!a) return [];
@@ -6414,7 +6469,9 @@ function renderEnvironment(i) {
       ] : []
     );
   }
-  if (only) {
+  if (only && i.sandbox) {
+    lines2.push(...sandboxCheckoutSection(i.sandbox.workDir, "## Your checkout"));
+  } else if (only) {
     lines2.push(...repoSection(only, key, "## Your worktree"));
   } else {
     lines2.push(
@@ -6427,8 +6484,9 @@ function renderEnvironment(i) {
       "ignore the others. A ticket whose repo is not listed here has no checkout on",
       "this machine and is not yours to work."
     );
+    if (i.sandbox) lines2.push(...sandboxCheckoutSection(i.sandbox.workDir, "### Your checkout"));
     for (const r of repos) {
-      lines2.push(...repoSection(r, key, `### ${r.name} \u2014 \`${r.dir}\``));
+      lines2.push(...i.sandbox ? ["", `### ${r.name}`] : repoSection(r, key, `### ${r.name} \u2014 \`${r.dir}\``));
       lines2.push("", `Hooks for ${r.name} \u2014 the only commands you should run here:`, "", hookTable(r.config));
     }
   }
@@ -9714,7 +9772,7 @@ var execFileP = promisify(execFile);
 var DEFAULT_SANDBOX_CONFIG = {
   bin: "openshell",
   mirrorDir: "/cache",
-  workDir: "/sandbox/work"
+  workDir: DEFAULT_SANDBOX_WORKDIR
 };
 var SANDBOX_STDIN_LIMIT = 4 * 1024 * 1024 - 64 * 1024;
 var SANDBOX_PROMPT_PATH = "/sandbox/prompt.txt";
@@ -9818,14 +9876,14 @@ var SandboxRunner = class {
     }
     try {
       const branch = `crew-run-${name.slice(-8)}`;
-      const clone = cloneScript({
+      const clone = `${cloneScript({
         mirrorDir: cfg.mirrorDir,
         repo,
         workDir: cfg.workDir,
         origin,
         branch,
         lockfile: cfg.depsLockfile ?? DEFAULT_CACHE_SETTINGS.depsLockfile
-      });
+      })} && ${containerEngineStubScript()}`;
       await this.os(["sandbox", "exec", "-n", name, "--no-login-shell", "--", "sh", "-c", clone]);
       const harness = cfg.agentBin ?? basename8(plan.bin);
       const viaUpload = Buffer.byteLength(plan.prompt) > SANDBOX_STDIN_LIMIT;
@@ -9839,7 +9897,8 @@ var SandboxRunner = class {
           rmSync12(tmp, { recursive: true, force: true });
         }
       }
-      const command2 = viaUpload ? ["sh", "-c", `exec ${[harness, ...plan.args].map(shQuote2).join(" ")} < ${SANDBOX_PROMPT_PATH}`] : [harness, ...plan.args];
+      const withStubs = `PATH=${shQuote2(SANDBOX_STUB_DIR)}:"$PATH"; export PATH; `;
+      const command2 = viaUpload ? ["sh", "-c", `${withStubs}exec ${[harness, ...plan.args].map(shQuote2).join(" ")} < ${SANDBOX_PROMPT_PATH}`] : ["sh", "-c", `${withStubs}exec "$@"`, "sh", harness, ...plan.args];
       const child = spawn2(cfg.bin, ["sandbox", "exec", "-n", name, "--no-login-shell", "--workdir", cfg.workDir, "--", ...command2], {
         env: process.env,
         stdio: ["pipe", o.streamFd, "inherit"],
@@ -10032,6 +10091,7 @@ function planAgentRun(o) {
     if (e instanceof SkillIncludeError) throw new AgentError(`${e.message} \u2014 refusing to run an unscoped session`);
     throw e;
   }
+  if (o.ship.runner === "sandbox") expanded = { ...expanded, text: swapSandboxSkills(expanded.text) };
   const prompt = assemblePrompt({
     roster: o.roster,
     environment: o.environment,
@@ -11724,7 +11784,13 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/sandbox-image.ts
 var SANDBOX_BASE_IMAGE = "nvcr.io/nvidia/base/ubuntu:24.04";
-var SANDBOX_HARNESS_VERSION = "0.1.6";
+var SANDBOX_OPENSHELL_VERSION = "0.1.6";
+var SANDBOX_CLAUDE_VERSION = "2.1.309";
+var SANDBOX_CLAUDE_DIST = "https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases";
+var SANDBOX_CLAUDE_SHA256 = {
+  x86_64: { platform: "linux-x64", sha256: "4d704a8aecbe038affa3000f498ae17c1b4f753add8facb8764120affc99b658" },
+  aarch64: { platform: "linux-arm64", sha256: "9796dd26899337f687739a0b39a7353b639f062a3436a7b941fcf19a1b757a9b" }
+};
 var SANDBOX_UID = 1e3;
 var CREW_PREFIX = "/opt/crew";
 var SANDBOX_RETRY_AFTER_MS = 60 * 60 * 1e3;
@@ -11748,15 +11814,28 @@ var CREW_ENV = {
   XDG_CACHE_HOME: `${CREW_PREFIX}/cache`,
   npm_config_cache: `${CREW_PREFIX}/cache/npm`,
   npm_config_store_dir: `${CREW_PREFIX}/pnpm-store`,
-  PNPM_HOME: `${CREW_PREFIX}/pnpm`
+  PNPM_HOME: `${CREW_PREFIX}/pnpm`,
+  // A run cannot reach the download host, so an in-run update attempt is only noise.
+  DISABLE_AUTOUPDATER: "1"
 };
+function claudeInstallCommand() {
+  const cases = Object.entries(SANDBOX_CLAUDE_SHA256).map(([arch, { platform: platform2, sha256: sha2562 }]) => `${arch}) p=${platform2}; sum=${sha2562};;`).join(" ");
+  return [
+    `case "$(uname -m)" in ${cases} *) echo "no pinned Claude Code binary for $(uname -m)" >&2; exit 1;; esac`,
+    `mkdir -p ${CREW_PREFIX}/bin`,
+    `curl -fsSL --retry 3 -o ${CREW_PREFIX}/bin/claude "${SANDBOX_CLAUDE_DIST}/${SANDBOX_CLAUDE_VERSION}/$p/claude"`,
+    `echo "$sum  ${CREW_PREFIX}/bin/claude" | sha256sum -c -`,
+    `chmod 0755 ${CREW_PREFIX}/bin/claude`,
+    `${CREW_PREFIX}/bin/claude --version | grep -F "${SANDBOX_CLAUDE_VERSION}"`
+  ].join("; ");
+}
 function baseLayer() {
   const dockerfile = [
     `FROM ${SANDBOX_BASE_IMAGE}`,
-    `LABEL io.crew.sandbox.layer="base" io.crew.sandbox.harness="${SANDBOX_HARNESS_VERSION}"`,
+    `LABEL io.crew.sandbox.layer="base" io.crew.sandbox.openshell="${SANDBOX_OPENSHELL_VERSION}"`,
     ""
   ].join("\n");
-  return { name: "base", tag: `crew-sandbox-base:${hash({ SANDBOX_BASE_IMAGE, SANDBOX_HARNESS_VERSION })}`, dockerfile, files: {} };
+  return { name: "base", tag: `crew-sandbox-base:${hash({ SANDBOX_BASE_IMAGE, SANDBOX_OPENSHELL_VERSION })}`, dockerfile, files: {} };
 }
 function crewLayer(base) {
   const files = { "credential-helper": CREDENTIAL_HELPER, "mcp.json": MCP_CONFIG };
@@ -11767,10 +11846,11 @@ function crewLayer(base) {
     run2("apt-get update && apt-get install -y --no-install-recommends ca-certificates curl git && rm -rf /var/lib/apt/lists/*"),
     `COPY credential-helper ${CREW_PREFIX}/bin/credential-helper`,
     `COPY mcp.json ${CREW_PREFIX}/mcp/mcp.json`,
+    run2(claudeInstallCommand()),
     run2(`chmod 0755 ${CREW_PREFIX}/bin/credential-helper && git config --system credential.helper ${CREW_PREFIX}/bin/credential-helper`),
     run2(`mkdir -p ${CREW_PREFIX}/cache ${CREW_PREFIX}/pnpm-store ${CREW_PREFIX}/pnpm /sandbox && chown -R ${SANDBOX_UID}:${SANDBOX_UID} ${CREW_PREFIX} /sandbox`),
     `ENV ${env} PATH=${CREW_PREFIX}/pnpm:${CREW_PREFIX}/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin`,
-    `LABEL io.crew.sandbox.layer="crew"`,
+    `LABEL io.crew.sandbox.layer="crew" io.crew.sandbox.claude="${SANDBOX_CLAUDE_VERSION}"`,
     ""
   ].join("\n");
   return { name: "crew", tag: `crew-sandbox-crew:${hash({ base: base.tag, dockerfile, files })}`, dockerfile, files };
@@ -11831,7 +11911,7 @@ function planSandbox(repo, decl, warm = {}) {
   const base = baseLayer();
   const crew = crewLayer(base);
   const layer = repoLayer(repo, decl, crew, warm);
-  return { repo, tag: layer.tag, layers: [base, crew, layer] };
+  return { repo, tag: layer.tag, claude: SANDBOX_CLAUDE_VERSION, layers: [base, crew, layer] };
 }
 var sandboxStatePath = (stateDir) => join26(stateDir, "sandbox-images.json");
 function readSandboxState(stateDir) {
@@ -11856,8 +11936,8 @@ function sandboxImageStatus(state, plan) {
     return { status: "failed", detail: `last build of ${plan.tag} failed at ${s.failure.at}; log ${s.failure.logPath}${current ? `; running ${current.tag}` : ""}` };
   }
   if (!current) return { status: "missing", detail: `no image built yet (wants ${plan.tag}); run \`crew sandbox build\`` };
-  if (current.tag !== plan.tag) return { status: "stale", detail: `running ${current.tag}, declaration now builds ${plan.tag}` };
-  return { status: "ok", detail: `${current.tag} built ${current.builtAt}` };
+  if (current.tag !== plan.tag) return { status: "stale", detail: `running ${current.tag} (claude ${current.claude ?? "unknown"}), declaration now builds ${plan.tag} (claude ${plan.claude})` };
+  return { status: "ok", detail: `${current.tag} built ${current.builtAt}, claude ${current.claude ?? "unknown"}` };
 }
 var spawnBuildRunner = (engine = "docker") => (args, logPath) => new Promise((resolve7) => {
   const child = spawn4(engine, args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -11920,7 +12000,7 @@ async function buildSandboxImage(plan, deps) {
       rmSync13(ctx, { recursive: true, force: true });
     }
   }
-  const tags = [{ tag: plan.tag, builtAt: now().toISOString() }, ...entry.tags.filter((t) => t.tag !== plan.tag)];
+  const tags = [{ tag: plan.tag, builtAt: now().toISOString(), claude: plan.claude }, ...entry.tags.filter((t) => t.tag !== plan.tag)];
   const dropped = tags.slice(KEEP_TAGS);
   state[plan.repo] = { tags: tags.slice(0, KEEP_TAGS) };
   writeSandboxState(deps.stateDir, state);
@@ -13009,6 +13089,22 @@ async function runPoolMember(deps) {
         relayReported = null;
         continue;
       }
+      if (body.action === "tokens") {
+        if (body.leaseId !== current) {
+          deps.log(`ignoring a tokens message for ${body.leaseId}; this member holds ${current ?? "no lease"}`);
+          continue;
+        }
+        const applied = await deps.applyTokens(body.forges ?? []);
+        if (!applied.ok) {
+          deps.log(`tokens: ${applied.reason ?? "could not apply the delivered forge tokens"}`);
+          continue;
+        }
+        deps.log(`tokens: replaced the forge tokens (${(body.forges ?? []).length} host${(body.forges ?? []).length === 1 ? "" : "s"})`);
+        const r2 = await report("running", { leaseId: current });
+        if (r2 === "credential") return POOL_EXIT.credential;
+        if (r2 === "stopped") return POOL_EXIT.ok;
+        continue;
+      }
       if (current) {
         deps.log("ignoring a provision payload: a lease is already held");
         continue;
@@ -14023,6 +14119,27 @@ function realPoolMemberDeps(o) {
       if (outcome.code === PROVISION_EXIT.ok) return { ok: true };
       return { ok: false, reason: `crew provision exited ${outcome.code}: ${lines2.at(-1) ?? "no detail"}` };
     },
+    async applyTokens(forges) {
+      const want = new Map(forges.map((f) => [f.host.toLowerCase(), f.token]));
+      for (const [host, token] of want) {
+        const stored = provisionDeps.storedToken(host);
+        if (stored === token) continue;
+        const res = provisionDeps.crew(["forge", stored === null ? "set" : "rotate", host, "--token-stdin"], { input: `${token}
+` });
+        if (res.status !== 0) return { ok: false, reason: `forge ${host}: ${res.stderr.trim() || `crew forge exited ${res.status}`}` };
+      }
+      const cfg = loadShip(o.crewHome);
+      if (!cfg) return { ok: false, reason: "no ship config to apply forge tokens to" };
+      for (const host of Object.keys(cfg.ship.forges ?? {})) {
+        if (want.has(host.toLowerCase())) continue;
+        try {
+          eraseForgeToken(cfg.ship.forges, host, cfg.ship.stateDir, env);
+        } catch (e) {
+          return { ok: false, reason: `forge ${host}: ${e.message}` };
+        }
+      }
+      return { ok: true };
+    },
     async reconcile() {
       const before = provisionDeps.installState();
       if (before.unitsStale || !before.running || !before.lingering) {
@@ -19204,6 +19321,10 @@ function checkRepoSpec(dir, opts = {}) {
   }
   const effective = resolveRepoConfig(parsed, opts.ship, dir);
   const readiness = validateEffective(effective);
+  if (effective.sandbox) {
+    const engine = effective.hooks.setup ? containerEngineUse(effective.hooks.setup) : null;
+    if (engine) readiness.push(`hooks.setup runs \`${engine}\`, and a sandbox has no container engine \u2014 start the service as a process instead (REPO_SPEC.md, "Services inside the sandbox")`);
+  }
   const hooks = Object.keys(effective.hooks).map((name) => ({
     name,
     label: hookLabel(effective, name),
@@ -21699,7 +21820,7 @@ async function buildEnvironment(route2, ship, ticket) {
   });
   const authorship = await tracker.authorshipProbe().catch(() => null);
   const attachments = await tracker.attachmentsProbe().catch(() => null);
-  return renderEnvironment({ route: route2, userAgent: ship.userAgent, repos, contract, sourceTicket: ticket, authorship, attachments, shipName: ship.name });
+  return renderEnvironment({ route: route2, userAgent: ship.userAgent, repos, contract, sourceTicket: ticket, authorship, attachments, shipName: ship.name, ...sandboxEnv(ship) });
 }
 
 // src/control-api.ts
@@ -23861,7 +23982,8 @@ ${changed2.map((c) => `  - ${c}
       sourceTicket: ticket,
       authorship: await tracker.authorshipProbe().catch(() => null),
       attachments: await tracker.attachmentsProbe().catch(() => null),
-      shipName: cfg.ship.name
+      shipName: cfg.ship.name,
+      ...sandboxEnv(cfg.ship)
     });
   }
   async function releaserLine(tracker, routeName, repo, release) {
@@ -26581,7 +26703,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
 `);
               for (const t of r.tags) {
                 const ageH = Math.max(0, Math.round((Date.now() - Date.parse(t.builtAt)) / 36e5));
-                process.stdout.write(`  ${t.tag}  built ${t.builtAt} (${ageH}h ago)
+                process.stdout.write(`  ${t.tag}  built ${t.builtAt} (${ageH}h ago), claude ${t.claude ?? "unknown"}
 `);
               }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.111.1",
+  "version": "0.113.0",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",

package/prompts/default/skills/sandbox-setup.md

@@ -0,0 +1,53 @@
+---
+name: Sandbox Setup
+description: How a lane agent prepares and hands off from a sandboxed run — the checkout is already cut, then the setup, ports and handoff hooks and the push. Fetch where the brief names the Worktree Setup skill and your environment section says you are in a sandbox.
+---
+# Setting up inside a sandbox
+
+A sandboxed run starts in a fresh clone on a fresh branch. Your working
+directory is that clone. There is no primary checkout, no other worktree and no
+`crew` command to cut one: skip every step of the lane policy that cuts a
+worktree, copies files across from a main checkout, or runs `crew sync` or
+`crew worktree`. The Environment section names the checkout's path.
+
+## Branch
+
+The clone starts on a throwaway branch. Create the ticket's branch from it —
+the digest's `branch` column, verbatim — with `git checkout -b <branch>`, and
+commit there. Never commit on the throwaway branch.
+
+## Making it runnable
+
+Run the **`setup`** hook from the checkout, verbatim. Nothing installs from a
+network at run time: the toolchains and packages are already in the image, and
+a download that is not is blocked. If setup needs something the image lacks,
+that is the repository's `sandbox:` declaration to fix, not yours: say so on
+the ticket and stop.
+
+- **Services.** A service the tests need (a database, a queue) is a process the
+  `setup` hook starts inside this sandbox. The sandbox has no container engine:
+  `docker` and `podman` exit at once naming this pattern. Use the ports the
+  **`ports`** hook prints and export what the **`isolate`** hook prints; both
+  are the same hooks a host run uses.
+- **`isolate`** — run it, and export what it prints, whenever the ticket touches
+  stored state. The sandbox's own services are already private to this run,
+  but the hook is where the repository says which settings point at them.
+- **`handoff`** — a preview server cannot be reached from outside a sandbox, so
+  there is nothing to leave running. Skip it unless the repository's own
+  instructions say otherwise, and say in your progress comment that you did.
+
+## Running the suite
+
+Run the **`test`** and **`build`** hooks in the foreground, as the lane policy
+says. Stop every process `setup` started before you finish; the sandbox is
+deleted when the run ends, so nothing outlives it, but a service still writing
+when the push happens makes the result harder to judge.
+
+## Handing off
+
+Commit on the ticket's branch and push it as a plain fast-forward to `origin`,
+exactly as the lane policy says: `git push --set-upstream origin <branch>`.
+Push credentials are already in place. The sandbox is deleted at the end of the
+run, so **anything not pushed is gone**; there is no worktree for QA to pick up
+and QA cuts its own from the remote branch you pushed. Put which hooks you ran,
+and their results, in your progress comment.

package/prompts/dev-qa/skills/sandbox-setup.md

@@ -0,0 +1,53 @@
+---
+name: Sandbox Setup
+description: How a lane agent prepares and hands off from a sandboxed run — the checkout is already cut, then the setup, ports and handoff hooks and the push. Fetch where the brief names the Worktree Setup skill and your environment section says you are in a sandbox.
+---
+# Setting up inside a sandbox
+
+A sandboxed run starts in a fresh clone on a fresh branch. Your working
+directory is that clone. There is no primary checkout, no other worktree and no
+`crew` command to cut one: skip every step of the lane policy that cuts a
+worktree, copies files across from a main checkout, or runs `crew sync` or
+`crew worktree`. The Environment section names the checkout's path.
+
+## Branch
+
+The clone starts on a throwaway branch. Create the ticket's branch from it —
+the digest's `branch` column, verbatim — with `git checkout -b <branch>`, and
+commit there. Never commit on the throwaway branch.
+
+## Making it runnable
+
+Run the **`setup`** hook from the checkout, verbatim. Nothing installs from a
+network at run time: the toolchains and packages are already in the image, and
+a download that is not is blocked. If setup needs something the image lacks,
+that is the repository's `sandbox:` declaration to fix, not yours: say so on
+the ticket and stop.
+
+- **Services.** A service the tests need (a database, a queue) is a process the
+  `setup` hook starts inside this sandbox. The sandbox has no container engine:
+  `docker` and `podman` exit at once naming this pattern. Use the ports the
+  **`ports`** hook prints and export what the **`isolate`** hook prints; both
+  are the same hooks a host run uses.
+- **`isolate`** — run it, and export what it prints, whenever the ticket touches
+  stored state. The sandbox's own services are already private to this run,
+  but the hook is where the repository says which settings point at them.
+- **`handoff`** — a preview server cannot be reached from outside a sandbox, so
+  there is nothing to leave running. Skip it unless the repository's own
+  instructions say otherwise, and say in your progress comment that you did.
+
+## Running the suite
+
+Run the **`test`** and **`build`** hooks in the foreground, as the lane policy
+says. Stop every process `setup` started before you finish; the sandbox is
+deleted when the run ends, so nothing outlives it, but a service still writing
+when the push happens makes the result harder to judge.
+
+## Handing off
+
+Commit on the ticket's branch and push it as a plain fast-forward to `origin`,
+exactly as the lane policy says: `git push --set-upstream origin <branch>`.
+Push credentials are already in place. The sandbox is deleted at the end of the
+run, so **anything not pushed is gone**; there is no worktree for QA to pick up
+and QA cuts its own from the remote branch you pushed. Put which hooks you ran,
+and their results, in your progress comment.