@codeyam-editor/codeyam-editor 0.1.0-staging.g388918e → 0.1.0-staging.g83619a4

package/npm/cloud.js

@@ -11,6 +11,7 @@
 
 const { spawn, spawnSync } = require("child_process");
 const fs = require("fs");
+const https = require("https");
 const os = require("os");
 const path = require("path");
 const readline = require("readline");
@@ -75,12 +76,16 @@ const {
   regionFromZone,
   vmIngressInvocation,
   vmIngressStatusInvocation,
+  vmIngressGrantAccessInvocation,
   parseIngressStatusVerdict,
   parseIngressTeardownVerdict,
   selectIngressReconcileTargets,
+  selectIngressGrantOnlyTargets,
   selectOrphanIngressTargets,
   classifyOrphanDownResult,
   backendServicesListInvocation,
+  negListInvocation,
+  instancesListInvocation,
   ingressConvergeDecision,
   detachedAddTailInvocation,
   ingressInflightMarkerPath,
@@ -88,6 +93,11 @@ const {
   iapAccessInvocation,
   sharedIngressInvocation,
   backendServiceTimeoutInvocation,
+  FLEET_FIREWALL_RULE_NAMES,
+  fleetFirewallDescribeInvocation,
+  fleetFirewallConvergeInvocation,
+  firewallNeedsConverge,
+  firewallAdmitsPort,
 } = require("./ingress-invoke");
 // Shared fleet-roster writer/reader. `cloud:up` rosters the VM it just
 // provisioned so the dashboard, the cloudflared-monitor tunnel publisher, and
@@ -157,14 +167,34 @@ const KNOWN_FLAGS = [
   // default is loud — a tokenless VM cannot sync plan claims and must never
   // report healthy silently. Use only when push genuinely isn't wanted.
   "allow-no-git-credentials",
+  // Provision the VM in admin mode: forward CODEYAM_ADMIN=1 into the container
+  // so the Home-tab Setup door renders. Equivalent to `CODEYAM_ADMIN=1 npm run
+  // cloud:up …`; absent = strict non-admin (the safe default). Survives
+  // re-provision because it rides the compose-render substitution, unlike a
+  // manual VM compose edit.
+  "admin",
+  // GCE machine type for the VM (e.g. n2-standard-4, e2-standard-4). Persisted
+  // in cloud.json so a later bare `cloud:up` keeps it. Defaults to
+  // DEFAULT_FLEET_MACHINE_TYPE. The whole point of exposing this is fleet
+  // scale-out: the region's E2_CPUS quota (72 in us-central1) caps the fleet at
+  // ~14 e2-standard-4 VMs, while N2_CPUS/N2D_CPUS (200, unused) leave room for
+  // 30 — so the fleet defaults to N2 and this flag lets a caller override.
+  "machine-type",
 ];
 
 // Flags that take no value (presence = true). parseFlags must not demand a
 // value for these or `--no-tunnel` would error "requires a value".
-const BOOLEAN_FLAGS = ["no-tunnel", "skip-setup", "list", "allow-no-git-credentials"];
+const BOOLEAN_FLAGS = ["no-tunnel", "skip-setup", "list", "allow-no-git-credentials", "admin"];
 
 const FIREWALL_RULE_NAME = "codeyam-editor-iap-ssh";
 const INSTANCE_TAG = "codeyam-editor";
+// Default GCE machine type for fleet VMs. N2 (not E2) because the fleet must
+// reach 30 VMs: us-central1 E2_CPUS quota is 72, so 30 × e2-standard-4 (120
+// vCPU) + the operator host exceed it and cap the fleet at ~14 regardless of
+// code — while N2_CPUS/N2D_CPUS are 200 and unused, leaving headroom for 30 ×
+// n2-standard-4. Override per-VM with `--machine-type`. See the vm--scale-
+// fleet-to-30-vms plan for the measured quota rationale.
+const DEFAULT_FLEET_MACHINE_TYPE = "n2-standard-4";
 const EDITOR_PORT = 14199;
 const VITE_PORT = 5173;
 
@@ -548,6 +578,32 @@ function isWrongModePreviewOrigin(localJson, sameOriginSafe) {
   return LOOPBACK_ORIGIN_RE.test(origin);
 }
 
+/** Decide whether a VM is presenting as HEALTHY while its Live Preview is
+ *  silently dead — the VM-9 failure mode. The heal
+ *  (`reconcilePreviewOriginToSlugHost`) fixes the mechanism; this predicate is
+ *  the smoke detector that catches a FUTURE mechanism gap (a new stack shape, a
+ *  new provisioning path) by observation instead of by a user noticing a blank
+ *  iframe days later.
+ *
+ *  Input is the editor's own `/api/config` payload — the effective truth table
+ *  (`previewSameOriginSafe` + the resolved `previewOrigin`), not a
+ *  re-derivation from stack.json over ssh. True iff the stack is NOT
+ *  same-origin-safe AND its effective previewOrigin is one a remote browser can
+ *  never load (the `/__codeyam_preview` sentinel, any relative path, or a
+ *  loopback origin) — i.e. exactly `isWrongModePreviewOrigin`'s wrong-mode
+ *  condition, evaluated against the live config rather than editor.local.json.
+ *  Composing the two keeps ONE definition of "wrong-mode origin" in this file.
+ *
+ *  Deliberately conservative: a missing/unparseable payload, an absent
+ *  `previewSameOriginSafe`, or a legitimate same-origin-safe stack on the
+ *  subpath all return false. Absence of evidence is never a false alarm — the
+ *  caller renders "unknown" instead. Pure. */
+function isSilentlyBrokenPreview(apiConfig) {
+  if (!apiConfig || typeof apiConfig !== "object") return false;
+  if (apiConfig.previewSameOriginSafe !== false) return false;
+  return isWrongModePreviewOrigin(apiConfig, false);
+}
+
 /** Read the operator-laptop cloudflared-urls.json sidecar. Missing/unparseable
  *  → {} (the monitor may not have run yet; the seed falls back to localhost). */
 function readCloudflaredUrls() {
@@ -745,6 +801,28 @@ function buildEditorLocalEnvPatch(localEnv, agent) {
   return { provider: agent, env: { [varName]: value } };
 }
 
+/** Build the editor.local.json patch that seeds a GREENFIELD project's
+ *  `projectTitle` so its live identity resolves to the real project name from
+ *  first boot. A greenfield project (`--new-project <name>`, no clientRepo) has
+ *  no origin remote and is bind-mounted at /workspace on the VM, so the editor's
+ *  identity resolver would otherwise fall back to the bare mount basename
+ *  "workspace" — which the fleet dashboard then reads as a permanent false
+ *  project-dir-drift. Seeding `projectTitle` (deep-merged over editor.json on the
+ *  VM) makes `project_identity::read` prefer the real name.
+ *
+ *  Returns `null` for a clone (a repo Add already labels from its origin
+ *  basename, and re-seeding a clone's title would be wrong) or when no
+ *  greenfield name is available, so the caller can no-op without an SSH round
+ *  trip. Pure — mirrors buildEditorLocalEnvPatch so the decision is unit-tested
+ *  without a live VM. */
+function buildGreenfieldTitlePatch(cfg = {}) {
+  const p = resolveProject(cfg);
+  if (!p.greenfield) return null;
+  const name = typeof p.name === 'string' ? p.name.trim() : '';
+  if (!name) return null;
+  return { projectTitle: name };
+}
+
 /** Parse `docker compose ps --format json` (compose v2 — one JSON object per
  *  line) and return the editor service's `State` string, or null when the
  *  service is absent / output is unparseable. Two callers shared an identical
@@ -787,7 +865,7 @@ function buildGcloudArgs(verb, cfg = {}, extras = {}) {
       return [
         "compute", "instances", "create", instanceName,
         "--project", project, "--zone", zone,
-        "--machine-type=e2-standard-4",
+        `--machine-type=${cfg.machineType || DEFAULT_FLEET_MACHINE_TYPE}`,
         "--image-family=debian-12",
         "--image-project=debian-cloud",
         "--boot-disk-size=100GB",
@@ -1494,6 +1572,43 @@ function bootstrapLogTail(cfg, lines = 40) {
   return String(r.stdout || "").trim() || "(log unavailable)";
 }
 
+/** Assemble the extra provision-time env forwarded into the bootstrap shell,
+ *  where it feeds the compose-render substitution. Currently just the admin
+ *  toggle: CODEYAM_ADMIN gates the Home-tab Setup door and is read from the
+ *  editor-server process env (handlers.rs::admin_enabled, strict literal "1").
+ *  The operator opts in with `CODEYAM_ADMIN=1 npm run cloud:up …` or `--admin`
+ *  (which lands as cfg.admin); anything else forwards "" so a normal launch —
+ *  and a re-provision without the flag — is strict non-admin. Pure over its
+ *  inputs so cloud.test.js can pin it without touching gcloud. */
+function buildProvisionEnv(env = process.env, flags = {}) {
+  const admin = flags.admin === true || env.CODEYAM_ADMIN === "1";
+  return { CODEYAM_ADMIN: admin ? "1" : "" };
+}
+
+/** Build the one-shot SSH shell command that reconciles a running VM's admin
+ *  mode without a full re-provision: rewrite the rendered compose's
+ *  CODEYAM_ADMIN line to `value` — or insert it under `environment:` on a legacy
+ *  VM whose compose predates the placeholder — then recreate the editor service
+ *  so admin_enabled() re-reads it. `value` is always "1" or "" (the caller
+ *  normalizes), so inlining it into sed is safe. Pure/string-only so
+ *  cloud.test.js can assert its shape without SSHing. */
+function buildReconcileAdminCommand(repoName, value) {
+  const f = "docker-compose.cloud.yml";
+  const entry = `      - CODEYAM_ADMIN=${value}`;
+  // Capture only the leading indentation (\1) and re-emit the literal key, so a
+  // value that starts with a digit (e.g. "1") never lands right after the
+  // backreference — `\11` would be read by sed as group 11, not `\1` + "1".
+  return (
+    `cd ~/projects/${repoName} && ` +
+    `if grep -qE '^[[:space:]]*- CODEYAM_ADMIN=' ${f}; then ` +
+    `sed -i -E 's#^([[:space:]]*)- CODEYAM_ADMIN=.*#\\1- CODEYAM_ADMIN=${value}#' ${f}; ` +
+    `else ` +
+    `sed -i -E 's#^([[:space:]]*environment:[[:space:]]*)$#\\1\\n${entry}#' ${f}; ` +
+    `fi && ` +
+    `docker compose -f ${f} up -d editor`
+  );
+}
+
 async function ensureProjectBootstrapped(cfg) {
   const repoName = resolveProject(cfg).name;
   console.error(`Checking project bootstrap state for ${repoName}...`);
@@ -1547,12 +1662,18 @@ async function ensureProjectBootstrapped(cfg) {
   const ingressEnv = {};
   const ingressPlan = ingressWiringPlan(cfg);
   if (ingressPlan.wire) ingressEnv.FLEET_DOMAIN = ingressPlan.domain;
+  // Forward the admin-mode toggle (Home-tab Setup door) into the compose
+  // render. cfg.admin carries the `--admin` flag; process.env.CODEYAM_ADMIN
+  // carries the `CODEYAM_ADMIN=1 npm run cloud:up` form. Default "" =
+  // non-admin, so this leaves the normal launch and re-provision unchanged.
+  const provisionEnv = buildProvisionEnv(process.env, cfg);
   const command = sshScriptCommand(scriptBody, scriptArgs, {
     GITHUB_TOKEN: resolveGithubToken(),
     CY_GIT_USER_NAME: laptopGit.name,
     CY_GIT_USER_EMAIL: laptopGit.email,
     ...ingressEnv,
     ...forwardEnv,
+    ...provisionEnv,
   });
   const result = runGcloud(
     buildGcloudArgs("ssh-script", cfg, { command }),
@@ -1761,49 +1882,113 @@ function resolveGhcrPushToken() {
   return process.env.CODEYAM_GHCR_PUSH_TOKEN || "";
 }
 
+// Registry manifest media types we accept when probing image presence over the
+// GHCR HTTP API — Docker v2 + manifest lists and their OCI equivalents, so a
+// multi-arch index answers 200 the same as a single-arch manifest.
+const MANIFEST_ACCEPT = [
+  "application/vnd.docker.distribution.manifest.v2+json",
+  "application/vnd.docker.distribution.manifest.list.v2+json",
+  "application/vnd.oci.image.manifest.v1+json",
+  "application/vnd.oci.image.index.v1+json",
+].join(", ");
+const GHCR_PROBE_TIMEOUT_MS = 15000;
+
+/** Default HTTPS client for the registry probe: a GET that resolves to
+ *  `{ statusCode }` and NEVER rejects — any socket / DNS / timeout error resolves
+ *  to `statusCode: 0` (the probe reads that as "undetermined"). Injected as the
+ *  `httpImpl` option so probeUsableEditorImage is unit-testable with no network
+ *  (and no Docker daemon). `requestImpl` (defaulting to `https.request`) is
+ *  injectable so the response / error / timeout mapping is itself unit-testable
+ *  without a real socket. */
+function httpsManifestGet({ hostname, path: reqPath, headers }, requestImpl = https.request) {
+  return new Promise((resolve) => {
+    const req = requestImpl(
+      { hostname, path: reqPath, method: "GET", headers },
+      (res) => {
+        res.resume(); // drain the body so the socket is freed
+        res.on("end", () => resolve({ statusCode: res.statusCode }));
+      },
+    );
+    req.on("error", () => resolve({ statusCode: 0 }));
+    req.setTimeout(GHCR_PROBE_TIMEOUT_MS, () => req.destroy());
+    req.end();
+  });
+}
+
+/** Probe ONE fully-qualified image ref (`host/repo:tag`) over the registry HTTP
+ *  API — no docker daemon, so a docker-less operator host can still determine
+ *  presence. Returns true (200 present), false (404 absent), or null (auth /
+ *  network / malformed-ref → can't tell absent from forbidden). */
+async function probeManifestRef(fullRef, bearer, httpGet) {
+  const colon = fullRef.lastIndexOf(":");
+  if (colon < 0) return null;
+  const ref = fullRef.slice(0, colon); // host/repo
+  const tag = fullRef.slice(colon + 1); // slug-latest
+  const slash = ref.indexOf("/");
+  if (slash < 0) return null;
+  const hostname = ref.slice(0, slash); // ghcr.io
+  const repo = ref.slice(slash + 1); // codeyam-ai/codeyam-editor-cloud-smoke
+  let res;
+  try {
+    res = await httpGet({
+      hostname,
+      path: `/v2/${repo}/manifests/${encodeURIComponent(tag)}`,
+      headers: { Authorization: `Bearer ${bearer}`, Accept: MANIFEST_ACCEPT },
+    });
+  } catch (_e) {
+    return null;
+  }
+  const code = res && res.statusCode;
+  if (code === 200) return true;
+  if (code === 404) return false;
+  return null; // 401 / 403 / 5xx / 0 (network) → undetermined
+}
+
 /** Read-only probe: does a usable prebuilt editor image already exist on the
  *  registry for `branch`? Used by the fleet dashboard BEFORE a concurrent batch
  *  add to decide whether to pace one VM ahead of the rest (see
- *  npm/fleet-prewarm.js::decideBatchPrewarm). A `docker manifest inspect` is a
- *  HEAD-equivalent — it reads the manifest without pulling the (multi-GB) image.
+ *  npm/fleet-prewarm.js::decideBatchPrewarm).
+ *
+ *  Queries the registry over its HTTP API (`GET /v2/<repo>/manifests/<tag>`, a
+ *  HEAD-equivalent that reads the manifest without pulling the multi-GB image)
+ *  instead of `docker login` / `docker manifest inspect`. This is the root fix
+ *  for the docker-less GCE operator host: the old docker path errored on the
+ *  first `docker login` spawn (the control plane has no docker daemon) and so
+ *  returned `null` forever, which decideBatchPrewarm read as "fan out" — the
+ *  image was therefore never published and every cold add source-built. Over
+ *  HTTP the probe returns a DEFINITIVE verdict with no daemon.
  *
  *  Returns:
  *    true  — at least one of the usable tags exists (a cold add can pull; no pacer)
  *    false — every tag was checked and none exists (known-absent; pacing pays)
- *    null  — undetermined: no read token, docker missing, or a probe error that
- *            can't be distinguished from "absent". The caller treats null as
- *            "fan out" (today's behavior, never worse) rather than risk a
- *            10-min serialization that might buy nothing.
+ *    null  — undetermined: no read token, or an auth/network error that can't be
+ *            distinguished from "absent".
  *
- *  The private packages require auth, so we `docker login` with the read token
- *  first; without a token we can't tell absent from forbidden, so → null.
- *  `spawnImpl` is injectable for unit tests. */
-function probeUsableEditorImage({ branch, registry, token, spawnImpl } = {}) {
+ *  GHCR's private packages require auth; without a read token we can't tell
+ *  absent from forbidden, so → null. The read token is sent as the registry
+ *  bearer (GHCR accepts a base64-encoded PAT directly — no separate token-
+ *  exchange round-trip). `httpImpl` is injectable for unit tests; a legacy
+ *  `spawnImpl` option is still accepted (and ignored) for backward-compat — the
+ *  HTTP happy path needs no spawn. */
+async function probeUsableEditorImage({ branch, registry, token, httpImpl } = {}) {
   const fp = require("./fleet-prewarm");
-  const spawn = spawnImpl || spawnSync;
   const reg = registry || process.env.CODEYAM_REGISTRY || "ghcr.io/codeyam-ai";
   const readToken = token || resolveGhcrToken();
   if (!readToken) return null; // can't auth → can't distinguish absent from forbidden
-  const host = String(reg).split("/")[0];
-  const login = spawn(
-    "docker",
-    ["login", host, "-u", process.env.CODEYAM_GHCR_USER || "codeyam", "--password-stdin"],
-    { input: readToken, encoding: "utf8" },
-  );
-  // spawn error (docker missing) or a non-zero login → undetermined.
-  if (!login || login.error || login.status !== 0) return null;
+  const httpGet = httpImpl || httpsManifestGet;
+  // GHCR accepts a base64-encoded PAT as the registry bearer — no token-exchange
+  // round-trip needed.
+  const bearer = Buffer.from(readToken).toString("base64");
   const tags = fp.usableImageTags({ registry: reg, branch });
   let allClean = true;
-  for (const tag of tags) {
-    const res = spawn("docker", ["manifest", "inspect", tag], { encoding: "utf8" });
-    if (!res || res.error) {
-      allClean = false; // probe itself failed to run — can't claim "absent"
-      continue;
-    }
-    if (res.status === 0) return true; // a usable image exists
-  }
-  // Every tag inspected cleanly and none existed → definitively absent. If any
-  // probe failed to run, we can't be sure → undetermined.
+  for (const fullRef of tags) {
+    const verdict = await probeManifestRef(fullRef, bearer, httpGet);
+    if (verdict === true) return true; // a usable image exists
+    if (verdict === null) allClean = false; // this tag's probe was inconclusive
+    // verdict === false → this tag is absent; keep checking the rest
+  }
+  // Every tag probed cleanly and none existed → definitively absent. If any probe
+  // was inconclusive we can't claim absence → undetermined.
   return allClean ? false : null;
 }
 
@@ -1840,6 +2025,15 @@ function classifyGitRemoteError(stderr) {
   ) {
     return "network";
   }
+  // A greenfield project (`--new-project` scaffold) has no origin remote and an
+  // unborn `main`, so `git ls-remote origin` fails with "does not appear to be a
+  // git repository". No token would fix this — there is simply nothing to push
+  // yet — so it is neither `credential` nor `network` nor `git-spawn`. Keep the
+  // match narrow: `repository not found` is a genuine access failure against a
+  // real remote and must NOT be swallowed here.
+  if (lower.includes("does not appear to be a git repository")) {
+    return "no-remote";
+  }
   return "other";
 }
 
@@ -1877,6 +2071,14 @@ function decideCredentialHeal({ stagingEmpty, lsRemoteOk, lsRemoteStderr }) {
         reason: "git binary failed to launch — not a credential gap, not re-seeding",
       };
     }
+    if (category === "no-remote") {
+      return {
+        heal: false,
+        category,
+        reason:
+          "no git remote configured — greenfield project, nothing to push yet (not a credential gap)",
+      };
+    }
     return {
       heal: true,
       category,
@@ -1894,6 +2096,16 @@ function decideCredentialHeal({ stagingEmpty, lsRemoteOk, lsRemoteStderr }) {
   };
 }
 
+/** The single GitHub credential line format shared by every seed path: the
+ *  host staging file, the durable on-disk `store` fallback, and the live
+ *  cache-daemon approve all expect `https://x-access-token:<token>@github.com`
+ *  (git's credential-URL form, matched by both the entrypoint parser and
+ *  git-credential-store). Centralized so the `x-access-token` shape has one
+ *  source of truth instead of being re-typed at each call site. */
+function githubCredentialLine(token) {
+  return `https://x-access-token:${token}@github.com`;
+}
+
 /** Write the laptop's GitHub token into ~/.codeyam-cloud-git-credentials on
  *  the VM so the cloud compose can mount it into /root/.git-credentials —
  *  without this, claude / codex / gemini inside the container can clone the
@@ -1919,21 +2131,28 @@ async function seedGithubCredentials(cfg, opts = {}) {
   console.error(
     `Writing GitHub token (from ${source}) into ~/.codeyam-cloud-git-credentials on the VM...`,
   );
-  const credLine = `https://x-access-token:${token}@github.com`;
+  const credLine = githubCredentialLine(token);
   // Quote the token through one shell layer (gcloud ssh --command); the
   // value is base64'd to keep it out of the shell history.
   const b64 = Buffer.from(`${credLine}\n`).toString("base64");
-  // Verify-before-move: decode into a chmod-600 temp, assert it is non-empty
-  // (`[ -s ]`), and only THEN move it over the live staging file. An empty or
+  // Verify-before-write: decode into a chmod-600 temp, assert it is non-empty
+  // (`[ -s ]`), and only THEN copy it over the live staging file. An empty or
   // unreadable decode must never clobber an existing good file — the entrypoint
   // reads this file on every boot, and a silent empty write is exactly how a
   // reprovision lands a VM that "could not read Username for github.com". The
-  // trailing `echo OK` runs only on the move, so an empty write can't mask
+  // trailing `echo OK` runs only on success, so an empty write can't mask
   // success with a `&& echo` (the failure shape seen on the Claude creds sinks).
+  //
+  // Use `cat "$t" > "$f"` (in-place truncate), NOT `mv`: the staging file is
+  // bind-mounted read-only into the running container, and `mv` mints a NEW
+  // inode that the live `:ro` mount does not follow — so a `mv`-based re-seed
+  // never reached the running container until a full recreate. Truncating the
+  // existing file in place keeps its inode, so the durable write is visible to
+  // the container immediately. Then remove the temp.
   const remoteCmd =
     `f=$HOME/.codeyam-cloud-git-credentials && t="$f.tmp.$$" && ` +
     `echo ${b64} | base64 -d > "$t" && chmod 600 "$t" && ` +
-    `if [ -s "$t" ]; then mv "$t" "$f" && echo OK; ` +
+    `if [ -s "$t" ]; then cat "$t" > "$f" && chmod 600 "$f" && rm -f "$t" && echo OK; ` +
     `else rm -f "$t"; echo EMPTY-WRITE-REFUSED >&2; exit 1; fi`;
   const result = runGcloud(
     buildGcloudArgs("ssh-probe", cfg, { command: remoteCmd }),
@@ -1944,26 +2163,76 @@ async function seedGithubCredentials(cfg, opts = {}) {
   }
 }
 
+/** Sentinel the remote read prints when it cannot find an `editor.json` under
+ *  any `~/projects/*` directory. Distinguishes "this VM has no scaffolded
+ *  project" (a real miss worth warning about) from "the project is scaffolded
+ *  but declares no port" (legitimately a `VITE_PORT` default). Without the
+ *  distinction both collapse to `{}` and the miss is silent. */
+const VM_APP_PORT_NO_CONFIG = "<<<NOCONFIG>>>";
+
+/** Build the remote shell command that locates the project's `.codeyam` dir and
+ *  cats its two config files in one round-trip.
+ *
+ *  Resolution is glob-based rather than `~/projects/<repoName>` alone: the host
+ *  directory is not guaranteed to be named after the repo (a renamed repo, a
+ *  manually-cloned dir, a fleet slug), and when the guess missed, the old code
+ *  silently returned `VITE_PORT` and forwarded the wrong port. The repo-named
+ *  path is still tried FIRST so a multi-project VM resolves deterministically;
+ *  the glob is the fallback. When nothing matches, print the sentinel so the
+ *  caller can warn instead of guessing. Pure string builder; no I/O. */
+function buildVmAppPortReadCommand(repoName) {
+  return (
+    `d=""; ` +
+    `for c in ~/projects/${repoName}/.codeyam ~/projects/*/.codeyam; do ` +
+    `if [ -f "$c/editor.json" ]; then d="$c"; break; fi; done; ` +
+    `if [ -z "$d" ]; then echo '${VM_APP_PORT_NO_CONFIG}'; else ` +
+    `cat "$d/editor.json" 2>/dev/null || echo '{}'; ` +
+    `echo '<<<LOCAL>>>'; ` +
+    `cat "$d/editor.local.json" 2>/dev/null || echo '{}'; fi`
+  );
+}
+
 /** Best-effort read of the VM's resolved app dev-server port so cloud:up's
  *  laptop `-L` forward, readiness probe, and previewOrigin seed all target the
  *  port the app actually serves on instead of a hardcoded 5173. Cats the VM's
  *  editor.json and editor.local.json in one SSH round-trip and resolves via
- *  `resolveConfiguredAppPort`. Any failure (SSH error, missing/corrupt JSON)
- *  falls back to `VITE_PORT` — the same default `resolved_port()` lands on for
- *  a portless config, so a 5173/greenfield project sees no behavior change. */
+ *  `resolveConfiguredAppPort`.
+ *
+ *  Falls back to `VITE_PORT` on any failure — but fails LOUD, not silent. A
+ *  wrong port here is not a cosmetic default: it forwards the wrong `-L` port,
+ *  and if the preview ends up on a dedicated origin the viewer gets
+ *  "localhost refused to connect" with nothing pointing at the cause. So an SSH
+ *  failure or a VM with no scaffolded project warns on stderr naming that
+ *  symptom. A scaffolded project that simply declares no port is NOT a miss —
+ *  `VITE_PORT` is genuinely correct there (it is what `resolved_port()` lands
+ *  on) and stays quiet. */
 async function readVmAppPort(cfg) {
   const repoName = resolveProject(cfg).name;
-  const base = `~/projects/${repoName}/.codeyam`;
   const read = runGcloud(
     buildGcloudArgs("ssh-probe", cfg, {
-      command:
-        `cat ${base}/editor.json 2>/dev/null || echo '{}'; ` +
-        `echo '<<<LOCAL>>>'; ` +
-        `cat ${base}/editor.local.json 2>/dev/null || echo '{}'`,
+      command: buildVmAppPortReadCommand(repoName),
     }),
     { stdio: ["ignore", "pipe", "ignore"] },
   );
-  if (read.status !== 0 || typeof read.stdout !== "string") return VITE_PORT;
+  if (read.status !== 0 || typeof read.stdout !== "string") {
+    console.error(
+      `[cloud] WARNING: could not read the VM's app port over SSH — ` +
+        `falling back to ${VITE_PORT}. If the app does not serve on ` +
+        `${VITE_PORT}, the laptop port-forward targets the wrong port and the ` +
+        `Live Preview will show "localhost refused to connect".`,
+    );
+    return VITE_PORT;
+  }
+  if (read.stdout.includes(VM_APP_PORT_NO_CONFIG)) {
+    console.error(
+      `[cloud] WARNING: no .codeyam/editor.json found under ~/projects on the ` +
+        `VM (looked for '${repoName}', then any project dir) — falling back to ` +
+        `${VITE_PORT}. If the project is scaffolded under a different name and ` +
+        `serves on another port, the port-forward targets the wrong port and ` +
+        `the Live Preview will show "localhost refused to connect".`,
+    );
+    return VITE_PORT;
+  }
   const parse = (s) => {
     try {
       const v = JSON.parse(s);
@@ -2287,6 +2556,66 @@ async function seedAgentApiKey(cfg) {
   // vm--no-cli-install-before-container-started removed; do not re-add it.
 }
 
+/** Pure: deep-merge `patch` over the VM's current editor.local.json content and
+ *  return the base64 of the pretty-printed result, ready for
+ *  buildEditorLocalSeedWriteCommand. `currentRaw` is the raw `cat` output of the
+ *  remote file (may be undefined, empty, or corrupt) — anything that doesn't
+ *  parse to a plain object is treated as `{}`, because overwriting a corrupt
+ *  override file with a known-good one is safer than refusing to seed. Extracted
+ *  so seedGreenfieldProjectTitle stays a thin I/O passthrough and the
+ *  parse+merge+encode is unit-tested without a live VM. */
+function mergeEditorLocalPatchB64(currentRaw, patch) {
+  let current = {};
+  try {
+    const parsed = JSON.parse(currentRaw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      current = parsed;
+    }
+  } catch {
+    // Unparseable / missing remote content → start from {}.
+  }
+  const merged = deepMergeJson(current, patch);
+  return Buffer.from(JSON.stringify(merged, null, 2), "utf8").toString("base64");
+}
+
+/** Seed a GREENFIELD project's `projectTitle` into the VM's editor.local.json
+ *  BEFORE compose up, so the editor caches the real project name at startup and
+ *  the fleet dashboard renders the correct card label with no false
+ *  project-dir-drift. Like seedAgentApiKey, this MUST run before
+ *  ensureEditorContainerUp — the editor reads its config once at startup.
+ *
+ *  No-op for a clone (buildGreenfieldTitlePatch returns null): a repo Add labels
+ *  from its origin basename, so there is nothing to seed and no SSH round-trip
+ *  is spent. Runs on every cloud:up, so a reconfigure re-seeds the title,
+ *  converging a VM provisioned before this fix onto the correct identity without
+ *  a destroy. Thin I/O passthrough: the parse+merge+encode lives in the pure
+ *  mergeEditorLocalPatchB64 helper. */
+async function seedGreenfieldProjectTitle(cfg) {
+  const patch = buildGreenfieldTitlePatch(cfg);
+  if (!patch) return; // clone (or no greenfield name) — nothing to seed
+
+  const repoName = resolveProject(cfg).name;
+  const remotePath = `~/projects/${repoName}/.codeyam/editor.local.json`;
+  console.error(`Seeding projectTitle='${patch.projectTitle}' into ${remotePath}...`);
+
+  const read = runGcloud(
+    buildGcloudArgs("ssh-probe", cfg, {
+      command: `cat ${remotePath} 2>/dev/null || echo '{}'`,
+    }),
+    { stdio: ["ignore", "pipe", "ignore"] },
+  );
+  const b64 = mergeEditorLocalPatchB64(read.stdout, patch);
+  const write = runGcloud(
+    buildGcloudArgs("ssh-probe", cfg, {
+      command: buildEditorLocalSeedWriteCommand({ repoName, remotePath, b64 }),
+    }),
+    { stdio: ["ignore", "inherit", "inherit"] },
+  );
+  if (write.status !== 0) {
+    throw new Error(`Failed to write ${remotePath} on VM`);
+  }
+}
+
 /** Tri-state probe of the editor container's running state on the VM host.
  *  One ssh round-trip; returns `"running"`, `"not-running"`, or `"unknown"`.
  *
@@ -2549,6 +2878,42 @@ function streamedScriptMergeBase(editorBranch) {
   return mbResult.status === 0 ? mbResult.stdout.trim() : null;
 }
 
+/** Fetch `editorBranch` from origin into a REAL remote-tracking ref
+ *  (`refs/remotes/origin/<branch>`) rather than only into `FETCH_HEAD`.
+ *
+ *  Operator hosts are commonly shallow, single-branch clones that track only
+ *  `+refs/heads/main`, so `origin/<some-feature-branch>` is not a local ref and
+ *  every `git show origin/<branch>:<path>` against it fails. Fetching through an
+ *  explicit refspec creates the ref, which keeps the drift verdict and the bytes
+ *  actually streamed derived from the same object. Falls back to a plain fetch
+ *  (FETCH_HEAD only) when the refspec form is rejected — `readRemoteScriptBlob`
+ *  can still read through FETCH_HEAD in that case. */
+function fetchStreamedScriptRef(editorBranch) {
+  const refspec = `${editorBranch}:refs/remotes/origin/${editorBranch}`;
+  const withRef = spawnSync("git", ["fetch", "--force", "origin", refspec], { encoding: "utf8" });
+  if (withRef.status === 0) return { ok: true, stderr: "" };
+
+  const plain = spawnSync("git", ["fetch", "origin", editorBranch], { encoding: "utf8" });
+  if (plain.status === 0) return { ok: true, stderr: "" };
+  return { ok: false, stderr: (plain.stderr || withRef.stderr || "").trim() };
+}
+
+/** Resolve one revision of a streamed script from the fetched remote, trying the
+ *  remote-tracking ref first and `FETCH_HEAD` second. `gitArg` is the git verb
+ *  (`rev-parse` for the blob hash, `show` for the bytes) so the drift facts and the
+ *  streamed bytes resolve through the SAME ref-preference order — a verdict of
+ *  "stream remote" can therefore never disagree with what actually got streamed.
+ *  Returns `{ ok: false }` only when the blob is unreadable through both refs. */
+function resolveRemoteScriptRev(gitArg, relPath, editorBranch) {
+  for (const ref of [`origin/${editorBranch}`, "FETCH_HEAD"]) {
+    const result = spawnSync("git", [gitArg, `${ref}:${relPath}`], { encoding: "utf8" });
+    if (result.status === 0 && typeof result.stdout === "string") {
+      return { ok: true, stdout: result.stdout, ref };
+    }
+  }
+  return { ok: false, stdout: "", ref: null };
+}
+
 /** Gather the drift facts for one streamed script relative to `origin/<editorBranch>`:
  *  its local (working-tree) blob hash, the remote-tip blob hash, the merge-base blob
  *  hash, and whether the working tree is dirty. Any git failure yields a null hash,
@@ -2560,11 +2925,8 @@ function gatherScriptDriftFacts(relPath, editorBranch, mergeBase) {
   const localHashResult = spawnSync("git", ["hash-object", relPath], { encoding: "utf8" });
   const localHash = localHashResult.status === 0 ? localHashResult.stdout.trim() : null;
 
-  let remoteHash = null;
-  const remoteHashResult = spawnSync("git", ["rev-parse", `origin/${editorBranch}:${relPath}`], { encoding: "utf8" });
-  if (remoteHashResult.status === 0) {
-    remoteHash = remoteHashResult.stdout.trim();
-  }
+  const remoteRev = resolveRemoteScriptRev("rev-parse", relPath, editorBranch);
+  const remoteHash = remoteRev.ok ? remoteRev.stdout.trim() : null;
 
   let baseHash = null;
   if (mergeBase) {
@@ -2587,7 +2949,15 @@ function gatherScriptDriftFacts(relPath, editorBranch, mergeBase) {
  *  un-pulled dashboard can't add VMs" failure. Streams the on-disk copy instead
  *  when the operator authored local content the remote tip lacks (dirty edit or a
  *  committed local-ahead change — developer mode) or when the remote is unreachable
- *  (offline fallback). `absScriptPath` is an absolute path under the repo root. */
+ *  (offline fallback — `remoteHash === null`, the only sanctioned on-disk path).
+ *
+ *  A "remote" verdict NEVER falls back to the on-disk copy. On a clean-but-behind
+ *  checkout the on-disk bytes are precisely the stale bytes the drift guard exists
+ *  to keep off the VM, so substituting them silently defeats the guard: the verdict
+ *  said "stream the reviewed remote tip" and the VM would instead receive the old
+ *  script, with only a `[Warning]` to show for it. When the remote blob cannot be
+ *  read through either ref this throws, aborting the add.
+ *  `absScriptPath` is an absolute path under the repo root. */
 function readStreamedScript(absScriptPath, cfg = {}) {
   const relPath = path.relative(rootDir, absScriptPath) || absScriptPath;
   const editorBranch = streamedScriptEditorBranch(cfg);
@@ -2596,15 +2966,18 @@ function readStreamedScript(absScriptPath, cfg = {}) {
 
   const { streamedScriptSource } = require("./script-drift");
   if (streamedScriptSource(facts) === "remote") {
-    const remote = spawnSync("git", ["show", `origin/${editorBranch}:${relPath}`], { encoding: "utf8" });
-    if (remote.status === 0 && typeof remote.stdout === "string") {
-      console.error(`  streaming canonical ${relPath} from origin/${editorBranch} (checkout behind remote is fine)`);
+    const remote = resolveRemoteScriptRev("show", relPath, editorBranch);
+    if (remote.ok) {
+      console.error(`  streaming canonical ${relPath} from ${remote.ref} (checkout behind remote is fine)`);
       return remote.stdout;
     }
-    // Remote read failed unexpectedly (raced fetch, ref pruned): fall through to disk.
-    console.error(
-      `  [Warning] Could not read ${relPath} from origin/${editorBranch} ` +
-        `(${(remote.stderr || "").trim() || "unavailable"}). Falling back to the on-disk copy.`,
+    // The facts said "the remote tip is the canonical source" but its bytes are
+    // unreadable. Streaming the on-disk copy here would provision unreviewed stale
+    // bytes under the banner of a successful add — fail loud instead.
+    throw new Error(
+      `could not read ${relPath} from origin/${editorBranch} (or FETCH_HEAD); ` +
+        `refusing to stream a possibly-stale on-disk copy. ` +
+        `Fetch the branch first: git fetch origin ${editorBranch}:refs/remotes/origin/${editorBranch}`,
     );
   }
   return fs.readFileSync(absScriptPath, "utf8");
@@ -2626,10 +2999,11 @@ function checkScriptDrift(cfg) {
 
   console.error(`Checking streamed-script drift against origin/${editorBranch}...`);
 
-  // 1. git fetch origin <editorBranch>
-  const fetchResult = spawnSync("git", ["fetch", "origin", editorBranch], { encoding: "utf8" });
-  if (fetchResult.status !== 0) {
-    console.error(`  [Warning] Failed to fetch origin ${editorBranch} (${(fetchResult.stderr || "").trim() || "unknown error"}). Skipping drift check.`);
+  // 1. Fetch into refs/remotes/origin/<editorBranch> so the ref resolves even on a
+  //    single-branch clone that tracks only +refs/heads/main.
+  const fetchResult = fetchStreamedScriptRef(editorBranch);
+  if (!fetchResult.ok) {
+    console.error(`  [Warning] Failed to fetch origin ${editorBranch} (${fetchResult.stderr || "unknown error"}). Skipping drift check.`);
     return;
   }
 
@@ -2742,6 +3116,29 @@ function runVmIngress(cfg, action, vmNumber, domain, appPort, slug) {
   });
 }
 
+/** Grant-only pass: (re-)apply one VM's default IAP access grant by spawning
+ *  `scripts/gcp/vm-ingress.sh <N> grant-access` — the churn-free action that runs
+ *  `apply_default_iap_access` without touching any NEG/BES/host-rule resource.
+ *  Reconcile uses this for already-`wired` VMs its re-wire loop skips, so a healed
+ *  VM whose backends already exist still (re-)grants the automation SA the IAP
+ *  accessor. Returns the spawnSync result so the caller logs granted vs failed;
+ *  best-effort + loud, never fatal. */
+function runVmIngressGrantAccess(cfg, vmNumber, domain, slug) {
+  const scriptPath = path.join(rootDir, "scripts", "gcp", "vm-ingress.sh");
+  const inv = vmIngressGrantAccessInvocation({
+    scriptPath,
+    vmNumber,
+    domain,
+    project: cfg.project,
+    zone: cfg.zone,
+    slug,
+  });
+  return spawnSync(inv.command, inv.args, {
+    stdio: "inherit",
+    env: { ...process.env, ...inv.env },
+  });
+}
+
 /** Add-time hook: wire VM-N onto the shared LB when a fleet domain is set.
  *  Best-effort + loud — a wiring hiccup must never abort an otherwise-green Add
  *  (the VM is reachable operator-side over SSH regardless), so on failure it
@@ -3285,6 +3682,10 @@ async function cmdUp(args, projectDir = rootDir) {
       }
     }
     await seedAgentApiKey(cfg);
+    // Greenfield only (no-op for a clone): seed projectTitle so the editor
+    // resolves its identity to the real project name instead of the bare
+    // /workspace mount basename — the source of the false project-dir-drift.
+    await seedGreenfieldProjectTitle(cfg);
     await ensureEditorContainerUp(cfg);
     // Provision contract: a just-provisioned VM must actually reach GitHub.
     // Verify in-container git auth now that the container (and its credential
@@ -3647,9 +4048,26 @@ async function cmdReconcileIngress(args, projectDir = rootDir) {
   });
   const targets = selectIngressReconcileTargets(statuses);
   const targetNums = new Set(targets.map((t) => t.vmNumber));
+  // The complement of the re-wire loop: `wired` VMs whose backends already exist
+  // so the re-wire loop skips them, yet still need the SA-accessor (re-)granted —
+  // `up` is the only path that grants it, and it never runs for a wired VM. This
+  // closes the VM-8 heal-path gap (a wired VM whose backends predate the SA-grant
+  // fix would otherwise stay 403 forever). Disjoint from `targets` by construction.
+  const grantOnlyNums = new Set(
+    selectIngressGrantOnlyTargets(statuses).map((g) => g.vmNumber),
+  );
   for (const s of statuses) {
-    if (!targetNums.has(s.vmNumber)) {
-      const label = s.slug || `vm-${s.vmNumber}`;
+    if (targetNums.has(s.vmNumber)) continue;
+    const label = s.slug || `vm-${s.vmNumber}`;
+    if (grantOnlyNums.has(s.vmNumber)) {
+      // Churn-free grant-only pass: (re-)grant the accessor without re-wiring any
+      // NEG/BES/host-rule resource. Idempotent (a no-op when the SA is already
+      // bound) and best-effort-but-loud — a grant hiccup logs, never aborts.
+      const gres = runVmIngressGrantAccess(cfg, s.vmNumber, domain, s.slug);
+      console.error(
+        `  VM-${s.vmNumber} ${label}: wired → ok (accessor ${gres.status === 0 ? "granted" : "grant FAILED"})`,
+      );
+    } else {
       console.error(`  VM-${s.vmNumber} ${label}: ${s.verdict || "unknown"} → ok`);
     }
   }
@@ -3689,6 +4107,12 @@ async function cmdReconcileIngress(args, projectDir = rootDir) {
     }
   }
 
+  // Converge the shared fleet firewall, then surface any app port it still fails to
+  // admit. Both ride this same boot + periodic cadence so the running fleet
+  // self-heals without a hand-run bootstrap.
+  const firewallState = convergeFleetFirewall({ cfg });
+  await reportFirewallPortGaps({ cfg, roster, firewallState });
+
   // Auto-clean orphaned LB ingress (vm--auto-clean-orphaned-lb-ingress): any
   // backend service whose VM number is gone from the roster is a destroyed VM's
   // leftover — cleaned here automatically with the verified `down`, so the
@@ -3697,22 +4121,131 @@ async function cmdReconcileIngress(args, projectDir = rootDir) {
   sweepOrphanIngress({ cfg, domain, roster, projectDir });
 }
 
-/** Auto-clean orphaned LB ingress (vm--auto-clean-orphaned-lb-ingress): backend
- *  services whose owning VM number is gone from the roster (a destroyed VM) and
- *  has no in-flight add. Enumerates the live backends, maps each name back to its
- *  VM number, subtracts the roster + in-flight adds (the false-orphan guards),
- *  and runs the VERIFIED `vm-ingress.sh <N> down` (asserts neg=no bes=no host=no,
- *  with retries) for each orphan — so an orphan is genuinely cleared or surfaced
- *  as a real failure, never a silent leak and never a manual command. Emits a
- *  machine-readable `CY_ORPHAN_SWEEP <json>` summary line the dashboard parses to
- *  reconcile its orphan-attention banner. Best-effort per VM: one `down` failing
- *  never aborts the rest of the sweep. Returns the `{ cleaned, failed, skipped }`
- *  summary (null when the enumeration itself failed) — the same shape it prints —
- *  so the flow is directly assertable. `deps` is injectable so the enumerate →
- *  select → down flow is testable without gcloud. */
+/** Auto-clean orphaned LB ingress (vm--auto-clean-orphaned-lb-ingress): LB
+ *  resources whose owning VM number is gone from the roster (a destroyed VM) and
+ *  has no in-flight add. Enumerates the live backend services AND zonal NEGs,
+ *  UNIONs their owning VM numbers (so a partial teardown whose NEG outlived its
+ *  backend service — the VM-5/6 case — still surfaces its VM as a candidate),
+ *  maps each name back to its VM number, subtracts the roster + in-flight adds +
+ *  live instances (the false-orphan guards), and runs the VERIFIED
+ *  `vm-ingress.sh <N> down` (asserts neg=no bes=no host=no, with retries) for
+ *  each orphan — so an orphan is genuinely cleared or surfaced as a real failure,
+ *  never a silent leak and never a manual command. Emits a machine-readable
+ *  `CY_ORPHAN_SWEEP <json>` summary line the dashboard parses to reconcile its
+ *  orphan-attention banner; the summary carries `stillPresent` (VM numbers that
+ *  still own ≥1 LB resource after the sweep) so the dashboard can clear a stale
+ *  banner for a VM that is now back in the roster or has no residual resources.
+ *  Best-effort per VM: one `down` failing never aborts the rest of the sweep.
+ *  Fail-safe: if the live-instance list can't be fetched, teardown is skipped for
+ *  this pass (a live-but-unrostered VM must never be torn down) while the banner
+ *  reconcile still runs. Returns the `{ cleaned, failed, skipped, stillPresent }`
+ *  summary (null when the backend-service enumeration itself failed) — the same
+ *  shape it prints — so the flow is directly assertable. `deps` is injectable so
+ *  the enumerate → select → down flow is testable without gcloud. */
+/** Converge the shared fleet firewall rule to all-tcp so the LB reaches whatever
+ *  port a project's app actually serves.
+ *
+ *  A rule pinned to a hardcoded port list (`tcp:14199,tcp:5173,tcp:3000`) drops
+ *  LB→VM traffic for any VM serving outside it — the VM-6-on-8080 Live Preview
+ *  outage — while the preview backend service still reads HEALTHY, because its
+ *  health check runs on the always-admitted editor port. The failure is therefore
+ *  invisible until someone opens the preview. Converging here (not only in the
+ *  hand-run google-ingress.sh bootstrap) is what makes a drifted rule self-heal on
+ *  the running fleet.
+ *
+ *  All-tcp is the right exposure, not a per-stack port list: the rule stays scoped
+ *  to Google's LB + health-check source ranges and the fleet instance tag either
+ *  way, so it admits any app port (Vite 5173, Next 3000, Astro 4321, Go 8080, …)
+ *  without enumeration. EVERY candidate name in FLEET_FIREWALL_RULE_NAMES is
+ *  converged: describing only one silently no-ops on a fleet wired under the other.
+ *
+ *  Scope-safe by construction — `update --rules=tcp` rewrites only the allowed
+ *  protocols/ports, never a rule's source ranges or target tags, so this can never
+ *  change who the rule applies to. Best-effort throughout: a describe/update
+ *  failure logs and continues, never aborting the rest of the reconcile.
+ *
+ *  Returns `[{ ruleName, rules, converged }]` for every rule that exists — `rules`
+ *  is the post-converge allowed value — so the flow is assertable without gcloud.
+ *  `deps.spawnSync` is injectable for the same reason.
+ *  See plan vm--self-healing-app-port-agnostic-fleet-lb-firewall. */
+function convergeFleetFirewall({ cfg } = {}, deps = {}) {
+  const run = deps.spawnSync || spawnSync;
+  const project = cfg && cfg.project;
+  const state = [];
+  for (const ruleName of FLEET_FIREWALL_RULE_NAMES) {
+    const dinv = fleetFirewallDescribeInvocation({ ruleName, project });
+    const dres = run(dinv.command, dinv.args, { encoding: "utf8" });
+    // A non-zero describe means no rule under this name — expected, not an error:
+    // only one of the candidate names is deployed on any given fleet.
+    if (!dres || dres.status !== 0) continue;
+    const current = ((dres.stdout || "") + "").trim();
+    if (!firewallNeedsConverge(current)) {
+      console.error(`  firewall ${ruleName}: already all-tcp → ok`);
+      state.push({ ruleName, rules: "tcp", converged: false });
+      continue;
+    }
+    const cinv = fleetFirewallConvergeInvocation({ ruleName, project });
+    const cres = run(cinv.command, cinv.args, { encoding: "utf8" });
+    if (cres && cres.status === 0) {
+      console.error(`  firewall ${ruleName}: rules '${current}' → tcp (all-tcp)`);
+      state.push({ ruleName, rules: "tcp", converged: true });
+    } else {
+      const tail = (
+        (cres && (cres.stderr || (cres.error && cres.error.message))) || ""
+      ).toString().trim().split("\n").pop() || "error";
+      console.error(`  firewall ${ruleName}: converge skipped (${tail})`);
+      state.push({ ruleName, rules: current, converged: false });
+    }
+  }
+  if (!state.length) {
+    console.error(
+      `  firewall: no rule found under ${FLEET_FIREWALL_RULE_NAMES.join(" / ")} —` +
+        " LB→VM traffic may be blocked; run scripts/gcp/google-ingress.sh",
+    );
+  }
+  return state;
+}
+
+/** Surface any rostered VM whose app port the fleet firewall does not admit — the
+ *  tripwire for a masked "HEALTHY but unreachable" preview.
+ *
+ *  The preview backend service health-checks the fixed editor port, so a rule that
+ *  admits that port but not the app's real one reads HEALTHY while every real
+ *  request is dropped. That masking is what made the VM-6 outage invisible. Emits a
+ *  machine-readable `CY_FIREWALL_PORT_GAP <json>` line per gap, mirroring the
+ *  `CY_ORPHAN_SWEEP` marker convention the dashboard already parses.
+ *
+ *  Only runs when a rule is still port-pinned: a converged all-tcp rule admits every
+ *  port, so the healthy path cannot produce a gap and skipping it avoids an SSH
+ *  round-trip per rostered VM for a check that cannot fail. In practice this fires
+ *  only if the converge itself failed (e.g. a permissions regression).
+ *
+ *  Returns the emitted `[{ vmNumber, appPort, rule, allowed }]` gaps — the same
+ *  shape it prints — so the marker contract is directly assertable.
+ *  `deps.readVmAppPort` is injectable so tests never reach for SSH. */
+async function reportFirewallPortGaps({ cfg, roster, firewallState } = {}, deps = {}) {
+  const readPort = deps.readVmAppPort || readVmAppPort;
+  const pinned = (firewallState || []).filter((f) => firewallNeedsConverge(f.rules));
+  const gaps = [];
+  if (!pinned.length) return gaps;
+  for (const n of roster || []) {
+    const perVmCfg = { ...cfg, instanceName: `${fleetInstancePrefix()}${n}` };
+    const appPort = await readPort(perVmCfg);
+    for (const f of pinned) {
+      if (firewallAdmitsPort(f.rules, appPort)) continue;
+      const gap = { vmNumber: n, appPort, rule: f.ruleName, allowed: f.rules };
+      console.error(`  VM-${n}: app port ${appPort} NOT admitted by ${f.ruleName}`);
+      console.log(`CY_FIREWALL_PORT_GAP ${JSON.stringify(gap)}`);
+      gaps.push(gap);
+    }
+  }
+  return gaps;
+}
+
 function sweepOrphanIngress({ cfg, domain, roster, projectDir = rootDir } = {}, deps = {}) {
   const gi = deps.googleIngress || require("./google-ingress.js");
   const fcl = deps.fleetCleanup || require("./fleet-cleanup.js");
+  const frecon = deps.fleetReconcile || require("./fleet-reconcile.js");
   const run = deps.spawnSync || spawnSync;
 
   const listInv = backendServicesListInvocation({ project: cfg && cfg.project });
@@ -3724,11 +4257,31 @@ function sweepOrphanIngress({ cfg, domain, roster, projectDir = rootDir } = {},
     console.error(`  orphan sweep skipped — could not list backend services (${tail}).`);
     return null;
   }
-  const ingressVmNumbers = String(listRes.stdout || "")
+  const besVmNumbers = String(listRes.stdout || "")
     .split("\n")
     .map((line) => gi.vmNumberFromResourceName(line.trim()))
     .filter((n) => n != null);
 
+  // Also enumerate zonal NEGs and union their owners in: a partial teardown can
+  // leave a `vm-<N>-<surface>-neg` behind after its backend service is already
+  // gone, so a backend-service-only candidate set misses that residue. Best-effort
+  // — a NEG-list failure never aborts the backend-service-driven sweep.
+  let negVmNumbers = [];
+  const negInv = negListInvocation({ project: cfg && cfg.project });
+  const negRes = run(negInv.command, negInv.args, { encoding: "utf8" });
+  if (negRes && negRes.status === 0) {
+    negVmNumbers = String(negRes.stdout || "")
+      .split("\n")
+      .map((line) => gi.vmNumberFromResourceName(line.trim()))
+      .filter((n) => n != null);
+  } else {
+    const tail = (
+      (negRes && (negRes.stderr || (negRes.error && negRes.error.message))) || ""
+    ).toString().trim().split("\n").pop() || "error";
+    console.error(`  orphan sweep: could not list NEGs (${tail}) — sweeping backend services only.`);
+  }
+  const ingressVmNumbers = [...new Set([...besVmNumbers, ...negVmNumbers])].sort((a, b) => a - b);
+
   // A VM in the roster, or with an in-flight `add-<n>.json` sidecar (provisioning,
   // not yet rostered), is live — never an orphan.
   const pendingDir = process.env.PENDING_JOBS_DIR || path.join(projectDir, ".codeyam/logs/pending-jobs");
@@ -3736,9 +4289,34 @@ function sweepOrphanIngress({ cfg, domain, roster, projectDir = rootDir } = {},
     .listPendingJobs(pendingDir)
     .filter((j) => j.action === "add")
     .map((j) => j.n);
-  const orphans = selectOrphanIngressTargets({ ingressVmNumbers, roster, inFlightAdds });
 
-  const summary = { cleaned: [], failed: [], skipped: inFlightAdds.slice() };
+  // Defensive live-instance guard: never tear down a VM whose GCP instance is
+  // actually running (a roster drift could leave a live VM unrostered; a teardown
+  // that SUCCEEDED against it would knock it offline). `liveVmNumbers === null`
+  // means the list couldn't be fetched — fail safe by skipping teardown this pass
+  // (below) rather than risk a false teardown. The banner reconcile still runs.
+  let liveVmNumbers = null;
+  const instInv = instancesListInvocation({ project: cfg && cfg.project });
+  const instRes = run(instInv.command, instInv.args, { encoding: "utf8" });
+  if (instRes && instRes.status === 0) {
+    liveVmNumbers = frecon.parseRunningFleetVms(instRes.stdout, fleetInstancePrefix());
+  } else {
+    const tail = (
+      (instRes && (instRes.stderr || (instRes.error && instRes.error.message))) || ""
+    ).toString().trim().split("\n").pop() || "error";
+    console.error(`  orphan sweep: could not list instances (${tail}) — skipping teardown this pass (banners still reconciled).`);
+  }
+
+  const orphans = liveVmNumbers === null
+    ? []
+    : selectOrphanIngressTargets({ ingressVmNumbers, roster, inFlightAdds, liveVmNumbers });
+
+  // stillPresent = every VM that owned an LB resource going in, minus the ones we
+  // verifiably clean below. The dashboard clears a banner for any orphan VM not in
+  // this set (or now back in the roster). Computed up front so the no-orphans and
+  // fail-safe-skip paths report it too — that is what unfreezes a VM-3-style banner
+  // (re-rostered, so never a sweep target) with no teardown at all.
+  const summary = { cleaned: [], failed: [], skipped: inFlightAdds.slice(), stillPresent: ingressVmNumbers.slice() };
   if (!orphans.length) {
     console.error("  orphan sweep: no orphaned LB ingress found.");
     console.log(`CY_ORPHAN_SWEEP ${JSON.stringify(summary)}`);
@@ -3775,6 +4353,11 @@ function sweepOrphanIngress({ cfg, domain, roster, projectDir = rootDir } = {},
       console.error(`  VM-${n}: orphaned ingress → auto-clean FAILED (${tail.slice(-200)})`);
     }
   }
+  // A verifiably-cleaned VM no longer owns any LB resource — drop it from
+  // stillPresent so the dashboard clears its banner (failed VMs stay, keeping
+  // their real attention item).
+  const cleanedSet = new Set(summary.cleaned);
+  summary.stillPresent = ingressVmNumbers.filter((n) => !cleanedSet.has(n));
   console.log(`CY_ORPHAN_SWEEP ${JSON.stringify(summary)}`);
   return summary;
 }
@@ -3828,20 +4411,33 @@ async function probeGitCredentials(cfg) {
 /** Seed the LIVE in-memory git credential-cache daemon over its socket — the
  *  same `git credential approve` shape the entrypoint uses
  *  (scripts/cloud-editor-entrypoint.sh) — so push works immediately with no
- *  container restart. base64 keeps the token out of the shell history across
- *  the gcloud-ssh → docker layers. Throws if the approve fails. Shared by
- *  {@link cmdReconcileCredentials} and {@link assertGitPushCredentials}. */
+ *  container restart. ALSO writes the container-local on-disk `store` fallback
+ *  file (the fill-only second helper baked into the image) directly, so a
+ *  reconcile leaves the VM durable against the cache daemon dying mid-life, not
+ *  just healthy for the moment. base64 keeps the token out of the shell history
+ *  across the gcloud-ssh → docker layers, and the store write is an in-place
+ *  `cat > file` truncate (chmod 600), never touched by git's approve path.
+ *  Throws if either write fails. Shared by {@link cmdReconcileCredentials} and
+ *  {@link assertGitPushCredentials}. */
 async function seedLiveCredentialCache(cfg, token) {
   const repoName = resolveProject(cfg).name;
   const projectCd = `cd ~/projects/${repoName}`;
   const composeExec = `docker compose -f docker-compose.cloud.yml exec -T editor`;
   const socket = "/run/codeyam/git-credential-cache.socket";
+  const store = "/run/codeyam/git-credentials-store";
   const approveStdin = `protocol=https\nhost=github.com\nusername=x-access-token\npassword=${token}\n\n`;
   const b64 = Buffer.from(approveStdin).toString("base64");
+  // The store-file line is the same one-URL-per-line format as the host staging
+  // file; the image's fill-only `store` helper reads it on a cache miss.
+  const storeB64 = Buffer.from(`${githubCredentialLine(token)}\n`).toString("base64");
   const seedCmd =
-    `${projectCd} && echo ${b64} | base64 -d | ${composeExec} ` +
+    `${projectCd} && ` +
+    `echo ${b64} | base64 -d | ${composeExec} ` +
     `git -c 'credential.helper=cache --timeout=31536000 --socket=${socket}' ` +
-    `credential approve && echo APPROVED`;
+    `credential approve && ` +
+    `echo ${storeB64} | base64 -d | ${composeExec} ` +
+    `bash -c 'cat > ${store} && chmod 600 ${store}' && ` +
+    `echo APPROVED`;
   const seed = runGcloud(
     buildGcloudArgs("ssh-probe", cfg, { command: seedCmd }),
     { stdio: ["ignore", "pipe", "inherit"] },
@@ -3880,6 +4476,39 @@ async function cmdReconcileCredentials(args, projectDir = rootDir) {
   );
 }
 
+/** `cloud:reconcile-admin` — flip admin mode on/off for an already-running VM
+ *  WITHOUT a full re-provision. Resolves the desired value from this invocation
+ *  (`--admin` / `CODEYAM_ADMIN`, else off), rewrites the rendered compose's
+ *  CODEYAM_ADMIN line, and recreates the editor service — matching what a manual
+ *  compose edit + `docker compose up -d editor` does today, so the durable admin
+ *  setting no longer requires a full re-provision to change. */
+async function cmdReconcileAdmin(args, projectDir = rootDir) {
+  ensureGcloud();
+  const flags = parseFlags(args);
+  const cfg = loadCloudConfig(projectDir);
+  if (!cfg) {
+    throw new Error("No .codeyam/cloud.json found. Run `npm run cloud:up` first.");
+  }
+  const desired =
+    buildProvisionEnv(process.env, flags).CODEYAM_ADMIN === "1" ? "1" : "";
+  const repoName = resolveProject(cfg).name;
+  console.error(
+    `Reconciling admin mode to ${desired === "1" ? "ON" : "off"} on ${cfg.instanceName}...`,
+  );
+  const result = runGcloud(
+    buildGcloudArgs("ssh-probe", cfg, {
+      command: buildReconcileAdminCommand(repoName, desired),
+    }),
+    { stdio: "inherit" },
+  );
+  if (result.status !== 0) {
+    throw new Error(`Failed to reconcile admin mode on ${cfg.instanceName}.`);
+  }
+  console.error(
+    `  ✓ editor service recreated; /api/config now reports admin=${desired === "1" ? "true" : "false"}.`,
+  );
+}
+
 /** Provision-time guarantee that a just-provisioned VM can actually reach
  *  GitHub. Probes the staging file + in-container `git ls-remote origin` and
  *  routes the outcome through the SAME {@link decideCredentialHeal} classifier
@@ -4011,6 +4640,7 @@ const HANDLERS = {
   "reconcile-ingress": cmdReconcileIngress,
   "wire-add-tail": cmdWireAddTail,
   "reconcile-credentials": cmdReconcileCredentials,
+  "reconcile-admin": cmdReconcileAdmin,
   access: cmdAccess,
 };
 
@@ -4048,6 +4678,7 @@ module.exports = {
   KNOWN_FLAGS,
   FIREWALL_RULE_NAME,
   INSTANCE_TAG,
+  DEFAULT_FLEET_MACHINE_TYPE,
   EDITOR_PORT,
   VITE_PORT,
   parseFlags,
@@ -4066,6 +4697,7 @@ module.exports = {
   previewSameOriginSafeFromStack,
   isRottedManagedPreviewOrigin,
   isWrongModePreviewOrigin,
+  isSilentlyBrokenPreview,
   resolveEditorConfig,
   validateEditorVariant,
   assertVariantProvisionable,
@@ -4074,13 +4706,19 @@ module.exports = {
   resolveGhcrToken,
   resolveGhcrPushToken,
   probeUsableEditorImage,
+  httpsManifestGet,
   resolveProject,
   clientProjectBootstrapArgs,
   cloudConfigPath,
   loadCloudConfig,
   saveCloudConfig,
   loadOrInitCloudConfig,
+  buildProvisionEnv,
+  buildReconcileAdminCommand,
+  cmdReconcileAdmin,
   buildEditorLocalEnvPatch,
+  buildGreenfieldTitlePatch,
+  mergeEditorLocalPatchB64,
   buildEditorLocalSeedWriteCommand,
   seedPreviewOrigin,
   healPreviewOriginAtReady,
@@ -4108,6 +4746,8 @@ module.exports = {
   checkScriptDrift,
   streamedScriptEditorBranch,
   streamedScriptMergeBase,
+  fetchStreamedScriptRef,
+  resolveRemoteScriptRev,
   gatherScriptDriftFacts,
   readStreamedScript,
   STREAMED_SCRIPTS,
@@ -4134,6 +4774,8 @@ module.exports = {
   cmdIngressUp,
   cmdReconcileIngress,
   sweepOrphanIngress,
+  convergeFleetFirewall,
+  reportFirewallPortGaps,
   cmdReconcileCredentials,
   cmdAccess,
   cloudMain,
@@ -4141,12 +4783,14 @@ module.exports = {
   seedLiveCredentialCache,
   assertGitPushCredentials,
   seedGithubCredentials,
+  githubCredentialLine,
   resolveGithubToken,
   resolveGithubTokenWithSource,
   MissingGitPushCredentialsError,
   classifyGitRemoteError,
   decideCredentialHeal,
   readVmAppPort,
+  buildVmAppPortReadCommand,
   resolveLaptopGitIdentity,
 };