@sentropic/h2a-runtime 0.85.0 → 0.85.2

package/dist/index.js

@@ -18,7 +18,7 @@ import { attachLocalSession, attachPodTmux, capturePane, conductorRunning, curre
 import { planRelaunch } from "./relaunch.js";
 import { readLastLayout, restore as restoreLayout, } from "./restore.js";
 import { getLayoutConfig } from "./config.js";
-import { advanceJob, coerceRegistryTool, enroll, enrollFromRun, isLive, listJobs, listLocalForLs, loadRegistry, tryClaimSlot, withRegistryLock, resolveRegistryPath, } from "./registry.js";
+import { advanceJob, coerceRegistryTool, enroll, enrollFromRun, isLive, listJobs, listLocalForLs, loadRegistry, localTmuxSessionForName, tryClaimSlot, withRegistryLock, resolveRegistryPath, } from "./registry.js";
 import { aimdEffectiveCap, assertSafeName, buildDelegateArgs, buildJobRows, buildRemoteDelegate, buildThrottleResumeArgs, canDelegateAtDepth, childDepthEnvValue, clampDepth, clampRemoteDepthBudget, conductorAdvisory, DEFAULT_MAX_CONCURRENT, DEPTH_ENV, inheritedDepthBudget, isDelegateType, isThrottleResumeDue, jitteredBackoffMs, JOB_ID_ENV, jobDir, planNextStarts, planThrottleStep, readJobResult, THROTTLE_MAX_ATTEMPTS, reconcileRemoteJobs, renderJobsTable, resolveJobCwd, runTrackMirror, sweepStaleJobs, trackItemNewArgs, trackItemRealizeArgs, } from "./delegate.js";
 import { detectThrottle, THROTTLE_TAIL_LINES } from "./throttle-signatures.js";
 import { interactiveResumeNudge, planInteractiveResume, } from "./interactive-throttle.js";
@@ -135,12 +135,12 @@ async function startRemoteFanout(remote, profileName, members, spec) {
         ].join("\t");
     });
     process.stdout.write(`NAME\tSESSION\tWORKSPACE\tSTATUS\n${rows.join("\n")}\n`);
-    process.stderr.write(`[remote] ${ok.length}/${members.length} remote ${profileName} sessions created on ${remote} (shared RWX, subPath per session)\n`);
+    process.stderr.write(`[h2a] ${ok.length}/${members.length} remote ${profileName} sessions created on ${remote} (shared RWX, subPath per session)\n`);
     if (ok.length > 0) {
-        process.stderr.write(`[remote] attach one with: remote attach <session>   (list: remote ls)\n`);
+        process.stderr.write(`[h2a] attach one with: h2a attach <session>   (list: h2a ls)\n`);
     }
     if (failed.length > 0) {
-        process.stderr.write(`[remote] ${failed.length} session(s) failed to create — re-run --count for the shortfall, or check the control-plane\n`);
+        process.stderr.write(`[h2a] ${failed.length} session(s) failed to create — re-run --count for the shortfall, or check the control-plane\n`);
         process.exitCode = 1;
     }
 }
@@ -152,7 +152,7 @@ async function runProfile(profileName, opts, commandArgs = []) {
             throw new Error("--count must be a whole number >= 1");
         }
         if (opts.count > 1 && !opts.remote) {
-            throw new Error("--count > 1 is a REMOTE fan-out — it needs a configured remote (use `remote run --count` for LOCAL tmux fan-out)");
+            throw new Error("--count > 1 is a REMOTE fan-out — it needs a configured remote (use `h2a run --count` for LOCAL tmux fan-out)");
         }
     }
     if (opts.remote) {
@@ -162,7 +162,7 @@ async function runProfile(profileName, opts, commandArgs = []) {
             if (opts.authRefresh !== false) {
                 const result = await ensureProfileAuthFresh(profileName);
                 if (result.checked) {
-                    process.stderr.write(`[remote] auth status ok: ${result.command}\n`);
+                    process.stderr.write(`[h2a] auth status ok: ${result.command}\n`);
                 }
             }
             const bundle = await collectProfileAuth(profileName);
@@ -210,9 +210,9 @@ async function runProfile(profileName, opts, commandArgs = []) {
         }
         let archive;
         if (opts.sync) {
-            process.stderr.write(`[remote] packing ${process.cwd()} (respecting .gitignore)\n`);
+            process.stderr.write(`[h2a] packing ${process.cwd()} (respecting .gitignore)\n`);
             archive = await buildWorkspaceArchive(process.cwd());
-            process.stderr.write(`[remote] workspace archive: ${(archive.byteLength / 1024).toFixed(0)} KiB\n`);
+            process.stderr.write(`[h2a] workspace archive: ${(archive.byteLength / 1024).toFixed(0)} KiB\n`);
         }
         const session = await createRemoteSession(opts.remote, {
             profile: profileName,
@@ -226,13 +226,13 @@ async function runProfile(profileName, opts, commandArgs = []) {
         });
         if (archive) {
             await uploadWorkspaceArchive(opts.remote, session.id, archive);
-            process.stderr.write(`[remote] uploaded workspace to ${opts.remote}/sessions/${session.id}/workspace\n`);
+            process.stderr.write(`[h2a] uploaded workspace to ${opts.remote}/sessions/${session.id}/workspace\n`);
         }
         if (credentials) {
-            process.stderr.write(`[remote] sending ${profileName} creds to ${opts.remote}: ${Object.keys(credentials).join(", ")}\n`);
-            process.stderr.write(`[remote] (use --no-auth to start without credentials)\n`);
+            process.stderr.write(`[h2a] sending ${profileName} creds to ${opts.remote}: ${Object.keys(credentials).join(", ")}\n`);
+            process.stderr.write(`[h2a] (use --no-auth to start without credentials)\n`);
         }
-        process.stderr.write(`[remote] attached to ${opts.remote}/sessions/${session.id}\n`);
+        process.stderr.write(`[h2a] attached to ${opts.remote}/sessions/${session.id}\n`);
         const attachSession = await attach({
             baseUrl: opts.remote,
             sessionId: session.id,
@@ -247,7 +247,7 @@ async function runProfile(profileName, opts, commandArgs = []) {
         ...(commandArgs.length > 0 ? { startupArgs: commandArgs } : {}),
     };
     const result = await run(runOptions);
-    process.stderr.write(`[remote] session ${result.sessionId} attach at http://127.0.0.1:${result.port}\n`);
+    process.stderr.write(`[h2a] session ${result.sessionId} attach at http://127.0.0.1:${result.port}\n`);
     const { exitCode } = await result.exit;
     process.exitCode = exitCode;
 }
@@ -257,7 +257,7 @@ async function refreshProfileSession(baseUrl, sessionId, opts) {
     const requestedProfile = opts.profile ?? remoteProfile;
     if (opts.profile &&
         coerceCliProfileName(opts.profile) !== coerceCliProfileName(remoteProfile)) {
-        process.stderr.write(`[remote] warning: --profile ${opts.profile} does not match the session profile ${remoteProfile}; bundling ${opts.profile} credentials anyway\n`);
+        process.stderr.write(`[h2a] warning: --profile ${opts.profile} does not match the session profile ${remoteProfile}; bundling ${opts.profile} credentials anyway\n`);
     }
     const profileName = coerceCliProfileName(requestedProfile);
     if (!profileName) {
@@ -268,7 +268,7 @@ async function refreshProfileSession(baseUrl, sessionId, opts) {
         if (opts.authRefresh !== false) {
             const result = await ensureProfileAuthFresh(profileName);
             if (result.checked) {
-                process.stderr.write(`[remote] auth status ok: ${result.command}\n`);
+                process.stderr.write(`[h2a] auth status ok: ${result.command}\n`);
             }
         }
         const bundle = await collectProfileAuth(profileName);
@@ -277,11 +277,11 @@ async function refreshProfileSession(baseUrl, sessionId, opts) {
             credentials = bundle;
     }
     if (!credentials || Object.keys(credentials).length === 0) {
-        process.stderr.write(`[remote] no credentials to refresh for session ${sessionId} (${profileName})\n`);
+        process.stderr.write(`[h2a] no credentials to refresh for session ${sessionId} (${profileName})\n`);
         return;
     }
     const response = await refreshRemoteSession(baseUrl, sessionId, credentials, fetch, opts.name);
-    process.stderr.write(`[remote] refresh ${response.accepted ? "accepted" : "rejected"} for ${response.sessionId}` +
+    process.stderr.write(`[h2a] refresh ${response.accepted ? "accepted" : "rejected"} for ${response.sessionId}` +
         (opts.name ? ` (renamed → ${opts.name})` : "") +
         "\n");
 }
@@ -305,12 +305,12 @@ async function pushAllProfiles(baseUrl, sessionId, opts) {
         sent.push(profile);
     }
     if (sent.length === 0) {
-        process.stderr.write(`[remote] no local credentials found for any profile; nothing to push\n`);
+        process.stderr.write(`[h2a] no local credentials found for any profile; nothing to push\n`);
         return;
     }
-    process.stderr.write(`[remote] sending creds for ${sent.join(", ")} to ${baseUrl}/sessions/${sessionId}: ${Object.keys(merged).join(", ")}\n`);
+    process.stderr.write(`[h2a] sending creds for ${sent.join(", ")} to ${baseUrl}/sessions/${sessionId}: ${Object.keys(merged).join(", ")}\n`);
     const response = await refreshRemoteSession(baseUrl, sessionId, merged);
-    process.stderr.write(`[remote] push ${response.accepted ? "accepted" : "rejected"} for ${response.sessionId}\n`);
+    process.stderr.write(`[h2a] push ${response.accepted ? "accepted" : "rejected"} for ${response.sessionId}\n`);
 }
 /** Validate `--watch <minutes>`: a whole number of minutes >= 1. */
 export function parseWatchMinutes(raw) {
@@ -415,12 +415,12 @@ async function preflightOrWarn(profile) {
     try {
         const fresh = await ensureProfileAuthFresh(profile);
         if (fresh.checked) {
-            process.stderr.write(`[remote] auth status ok: ${fresh.command}\n`);
+            process.stderr.write(`[h2a] auth status ok: ${fresh.command}\n`);
         }
     }
     catch (error) {
         const detail = error instanceof Error ? error.message : String(error);
-        process.stderr.write(`[remote] auth preflight failed (${detail.slice(0, 120)}) — pushing current creds anyway\n`);
+        process.stderr.write(`[h2a] auth preflight failed (${detail.slice(0, 120)}) — pushing current creds anyway\n`);
     }
 }
 /**
@@ -440,7 +440,7 @@ export async function softRefreshAllSessions(url, opts, hashes) {
         process.stderr.write(`${claudeWarn}\n`);
     const sessions = await listRemoteSessions(url);
     if (sessions.length === 0) {
-        process.stderr.write("[remote] no live remote sessions to refresh\n");
+        process.stderr.write("[h2a] no live remote sessions to refresh\n");
         return { failed: 0 };
     }
     const preflighted = new Set();
@@ -492,12 +492,12 @@ export async function softRefreshAllSessions(url, opts, hashes) {
                 const actions = await probePodCredHealth(s.id);
                 for (const a of actions) {
                     if (!a.health.ok) {
-                        process.stderr.write(`[remote]   ${s.id}: ${a.health.reason}${a.pushed ? " — pushed" : ""}\n`);
+                        process.stderr.write(`[h2a]   ${s.id}: ${a.health.reason}${a.pushed ? " — pushed" : ""}\n`);
                     }
                 }
             }
             catch (probeError) {
-                process.stderr.write(`[remote]   ${s.id}: tool health probe skipped: ${String(probeError).slice(0, 120)}\n`);
+                process.stderr.write(`[h2a]   ${s.id}: tool health probe skipped: ${String(probeError).slice(0, 120)}\n`);
             }
             // Slice 3: ADDITIONAL trigger — compare the local desired-state manifest
             // hash with the Pod's recorded sidecar; on drift, re-run the EXISTING
@@ -506,7 +506,7 @@ export async function softRefreshAllSessions(url, opts, hashes) {
                 reconcileSessionPlugins(s.id, profile);
             }
             catch (driftError) {
-                process.stderr.write(`[remote]   ${s.id}: plugin drift reconcile skipped: ${String(driftError).slice(0, 120)}\n`);
+                process.stderr.write(`[h2a]   ${s.id}: plugin drift reconcile skipped: ${String(driftError).slice(0, 120)}\n`);
             }
             outcomes.push({
                 sessionId: s.id,
@@ -524,7 +524,7 @@ export async function softRefreshAllSessions(url, opts, hashes) {
         }
     }
     const failed = outcomes.filter((o) => o.status === "failed").length;
-    process.stderr.write(`[remote] soft refresh recap — ${outcomes.length} session(s), ${failed} failed:\n`);
+    process.stderr.write(`[h2a] soft refresh recap — ${outcomes.length} session(s), ${failed} failed:\n`);
     for (const o of outcomes) {
         process.stderr.write(`  ${o.sessionId} (${o.profile}) ${o.status}${o.detail ? ` — ${o.detail}` : ""}\n`);
     }
@@ -566,12 +566,12 @@ async function softRefreshOneGated(url, sessionId, opts, hashes) {
             const actions = await probePodCredHealth(sessionId);
             for (const a of actions) {
                 if (!a.health.ok) {
-                    process.stderr.write(`[remote]   ${sessionId}: ${a.health.reason}${a.pushed ? " — pushed" : ""}\n`);
+                    process.stderr.write(`[h2a]   ${sessionId}: ${a.health.reason}${a.pushed ? " — pushed" : ""}\n`);
                 }
             }
         }
         catch (probeError) {
-            process.stderr.write(`[remote]   ${sessionId}: tool health probe skipped: ${String(probeError).slice(0, 120)}\n`);
+            process.stderr.write(`[h2a]   ${sessionId}: tool health probe skipped: ${String(probeError).slice(0, 120)}\n`);
         }
         // Slice 3: ADDITIONAL trigger — plugin/MCP drift reconcile (manifest hash
         // mismatch → re-run the EXISTING buildPodSyncScript). Best-effort.
@@ -579,13 +579,13 @@ async function softRefreshOneGated(url, sessionId, opts, hashes) {
             reconcileSessionPlugins(sessionId, profile);
         }
         catch (driftError) {
-            process.stderr.write(`[remote]   ${sessionId}: plugin drift reconcile skipped: ${String(driftError).slice(0, 120)}\n`);
+            process.stderr.write(`[h2a]   ${sessionId}: plugin drift reconcile skipped: ${String(driftError).slice(0, 120)}\n`);
         }
-        process.stderr.write(`[remote] ${sessionId} (${profile}) ${result.changed ? "refreshed" : "unchanged"}\n`);
+        process.stderr.write(`[h2a] ${sessionId} (${profile}) ${result.changed ? "refreshed" : "unchanged"}\n`);
         return { failed: 0 };
     }
     catch (error) {
-        process.stderr.write(`[remote] ${sessionId} refresh failed: ${(error instanceof Error ? error.message : String(error)).slice(0, 200)}\n`);
+        process.stderr.write(`[h2a] ${sessionId} refresh failed: ${(error instanceof Error ? error.message : String(error)).slice(0, 200)}\n`);
         return { failed: 1 };
     }
 }
@@ -607,16 +607,16 @@ signals = process) {
     signals.on("SIGINT", onSigint);
     try {
         while (!stopped) {
-            process.stderr.write(`[remote] refresh pass — ${new Date().toISOString()}\n`);
+            process.stderr.write(`[h2a] refresh pass — ${new Date().toISOString()}\n`);
             try {
                 await pass();
             }
             catch (error) {
-                process.stderr.write(`[remote] refresh pass failed: ${(error instanceof Error ? error.message : String(error)).slice(0, 200)}\n`);
+                process.stderr.write(`[h2a] refresh pass failed: ${(error instanceof Error ? error.message : String(error)).slice(0, 200)}\n`);
             }
             if (stopped)
                 break;
-            process.stderr.write(`[remote] next pass in ${minutes} min (Ctrl-C to stop)\n`);
+            process.stderr.write(`[h2a] next pass in ${minutes} min (Ctrl-C to stop)\n`);
             await new Promise((resolve) => {
                 const timer = setTimeout(resolve, minutes * 60_000);
                 wake = () => {
@@ -630,7 +630,7 @@ signals = process) {
     finally {
         signals.removeListener("SIGINT", onSigint);
     }
-    process.stderr.write("[remote] watch stopped (SIGINT)\n");
+    process.stderr.write("[h2a] watch stopped (SIGINT)\n");
     return 0;
 }
 /**
@@ -651,17 +651,17 @@ export async function conductLoop(minutes, pass, signals = process) {
     signals.on("SIGINT", onSigint);
     try {
         while (!stopped) {
-            process.stderr.write(`[remote] conduct pass — ${new Date().toISOString()}\n`);
+            process.stderr.write(`[h2a] conduct pass — ${new Date().toISOString()}\n`);
             try {
                 const { started, finished } = await pass();
-                process.stderr.write(`[remote] conduct: ${started} started, ${finished} finished this pass\n`);
+                process.stderr.write(`[h2a] conduct: ${started} started, ${finished} finished this pass\n`);
             }
             catch (error) {
-                process.stderr.write(`[remote] conduct pass failed: ${(error instanceof Error ? error.message : String(error)).slice(0, 200)}\n`);
+                process.stderr.write(`[h2a] conduct pass failed: ${(error instanceof Error ? error.message : String(error)).slice(0, 200)}\n`);
             }
             if (stopped)
                 break;
-            process.stderr.write(`[remote] next conduct pass in ${minutes} min (Ctrl-C to stop)\n`);
+            process.stderr.write(`[h2a] next conduct pass in ${minutes} min (Ctrl-C to stop)\n`);
             await new Promise((resolve) => {
                 const timer = setTimeout(resolve, minutes * 60_000);
                 wake = () => {
@@ -675,7 +675,7 @@ export async function conductLoop(minutes, pass, signals = process) {
     finally {
         signals.removeListener("SIGINT", onSigint);
     }
-    process.stderr.write("[remote] conduct stopped (SIGINT)\n");
+    process.stderr.write("[h2a] conduct stopped (SIGINT)\n");
     return 0;
 }
 /**
@@ -809,7 +809,7 @@ export async function startJob(job) {
             : selectAccountWithFallback(preferredProvider, job.id);
         if (!("allExhausted" in sel) && sel.candidate !== undefined) {
             if (sel.crossProvider) {
-                const msg = `[remote] account-pool: all ${preferredProvider} accounts exhausted — ` +
+                const msg = `[h2a] account-pool: all ${preferredProvider} accounts exhausted — ` +
                     `falling back to ${sel.candidate.provider} (${sel.candidate.label})`;
                 process.stderr.write(msg + "\n");
                 // Notify the current tmux pane (non-blocking, best-effort).
@@ -959,11 +959,11 @@ export function resumeThrottledJob(job) {
     const sel = selectAccountWithFallback(preferredProvider, job.id);
     const accountEnvOverrides = {};
     if ("allExhausted" in sel) {
-        process.stderr.write(`[remote] account-pool: all accounts exhausted for job ${job.id} — resuming without account override (may throttle again)\n`);
+        process.stderr.write(`[h2a] account-pool: all accounts exhausted for job ${job.id} — resuming without account override (may throttle again)\n`);
     }
     else if (sel.candidate !== undefined) {
         if (sel.crossProvider) {
-            const msg = `[remote] account-pool: all ${preferredProvider} accounts exhausted — falling back to ${sel.candidate.provider} (${sel.candidate.label}) for resume`;
+            const msg = `[h2a] account-pool: all ${preferredProvider} accounts exhausted — falling back to ${sel.candidate.provider} (${sel.candidate.label}) for resume`;
             process.stderr.write(msg + "\n");
             if (process.env.TMUX)
                 spawnSync("tmux", ["display-message", msg], { stdio: "ignore" });
@@ -1047,7 +1047,7 @@ export function resumeThrottledJob(job) {
 function getConfiguredRemote(overrideUrl) {
     const remote = overrideUrl ?? getConfiguredRemoteOptional();
     if (!remote) {
-        throw new Error("No remote URL configured. Set one with `remote config set <url>` (or `remote install <url>`) or pass --remote/URL explicitly.");
+        throw new Error("No remote URL configured. Set one with `h2a config set <url>` (or `h2a install <url>`) or pass --remote/URL explicitly.");
     }
     return remote;
 }
@@ -1075,7 +1075,7 @@ function resolveTools(withOpt) {
         : getDefaultTools();
     const { known, unknown } = partitionTools(raw);
     if (unknown.length > 0) {
-        process.stderr.write(`[remote] ignoring unknown tools: ${unknown.join(", ")} (known: ${KNOWN_TOOLS.join(", ")})\n`);
+        process.stderr.write(`[h2a] ignoring unknown tools: ${unknown.join(", ")} (known: ${KNOWN_TOOLS.join(", ")})\n`);
     }
     return known;
 }
@@ -1183,16 +1183,16 @@ async function injectLlmMeshGatewayEnv(mode = "auto") {
                     ANTHROPIC_AUTH_TOKEN: result.gatewayToken,
                     ANTHROPIC_API_KEY: result.gatewayToken,
                 };
-                process.stderr.write(`[remote] llm-mesh: gateway was stopped; started on ${meshEnv.ANTHROPIC_BASE_URL}\n`);
+                process.stderr.write(`[h2a] llm-mesh: gateway was stopped; started on ${meshEnv.ANTHROPIC_BASE_URL}\n`);
             }
             catch (err) {
-                process.stderr.write(`[remote] llm-mesh: gateway env unavailable (${String(err)}); Claude may ask for login.\n`);
+                process.stderr.write(`[h2a] llm-mesh: gateway env unavailable (${String(err)}); Claude may ask for login.\n`);
             }
         }
     }
     if (!meshEnv) {
         if (mode === "gateway") {
-            process.stderr.write("[remote] llm-mesh: --gw requested but no gateway env is available; continuing direct. Run `remote llm-mesh start` or enroll an account first.\n");
+            process.stderr.write("[h2a] llm-mesh: --gw requested but no gateway env is available; continuing direct. Run `h2a llm-mesh start` or enroll an account first.\n");
         }
         return undefined;
     }
@@ -1202,7 +1202,7 @@ async function injectLlmMeshGatewayEnv(mode = "auto") {
     for (const [k, v] of Object.entries(meshEnv))
         process.env[k] = v;
     if (!alreadyCurrent) {
-        process.stderr.write(`[remote] llm-mesh: injecting gateway env (${meshEnv.ANTHROPIC_BASE_URL})\n`);
+        process.stderr.write(`[h2a] llm-mesh: injecting gateway env (${meshEnv.ANTHROPIC_BASE_URL})\n`);
     }
     return meshEnv.ANTHROPIC_BASE_URL;
 }
@@ -1211,20 +1211,20 @@ async function prepareLlmMeshForRestore(opts = {}) {
         return;
     const config = readLlmMeshConfig();
     if (!config?.accounts.length) {
-        process.stderr.write("[remote] llm-mesh: restore config enabled, but no llm-mesh account is enrolled; Claude may ask for login.\n");
+        process.stderr.write("[h2a] llm-mesh: restore config enabled, but no llm-mesh account is enrolled; Claude may ask for login.\n");
         return;
     }
     const port = config.port ?? 3002;
     const pid = readGatewayPid();
     if (opts.dryRun) {
         process.stderr.write(pid
-            ? `[remote] llm-mesh: restore config enabled; gateway running (pid ${pid}, port ${port})\n`
-            : `[remote] llm-mesh: restore config enabled; gateway would be started on port ${port}\n`);
+            ? `[h2a] llm-mesh: restore config enabled; gateway running (pid ${pid}, port ${port})\n`
+            : `[h2a] llm-mesh: restore config enabled; gateway would be started on port ${port}\n`);
         return;
     }
     const gateway = await injectLlmMeshGatewayEnv();
     if (gateway) {
-        process.stderr.write(`[remote] llm-mesh: restore context active (${gateway})\n`);
+        process.stderr.write(`[h2a] llm-mesh: restore context active (${gateway})\n`);
     }
 }
 function registryEntryForResumeTarget(target, local) {
@@ -1275,7 +1275,7 @@ function resolveUrlAndSessionId(first, second) {
 function setAndReportDefaultRemote(url) {
     const configured = setDefaultRemote(url);
     ensureManagedTmuxProfile(getTmuxProfileConfig().profile);
-    process.stderr.write(`[remote] default remote set to ${configured}\n`);
+    process.stderr.write(`[h2a] default remote set to ${configured}\n`);
 }
 export async function main(argv) {
     // ②b — auto-migrate the config home remote-cli/ -> h2a/ on first run (backup +
@@ -1292,7 +1292,7 @@ export async function main(argv) {
     if (shouldShowProfileMenu(argv, process.stdin.isTTY === true && process.stdout.isTTY === true)) {
         const profile = await promptProfileMenu(process.stdin, process.stderr, process.cwd());
         if (!profile) {
-            process.stderr.write("[remote] no profile selected\n");
+            process.stderr.write("[h2a] no profile selected\n");
             return 1;
         }
         return main([
@@ -1306,7 +1306,7 @@ export async function main(argv) {
     const program = new Command();
     program
         .name("remote")
-        .description("Wrap a local agent CLI (codex/claude/agy/gemini/mistral) and expose its session for remote attach.")
+        .description("Wrap a local agent CLI (codex/claude/agy/gemini/mistral) and expose its session for h2a attach.")
         .version("0.0.0");
     for (const [profileName, alias] of [
         ["codex", undefined],
@@ -1341,7 +1341,7 @@ export async function main(argv) {
                     await runProfile(profileName, { ...rest }, commandArgs ?? []);
                 }
                 catch (err) {
-                    process.stderr.write(`[remote] ${err.message}\n`);
+                    process.stderr.write(`[h2a] ${err.message}\n`);
                     process.exitCode = 1;
                 }
                 return;
@@ -1355,7 +1355,7 @@ export async function main(argv) {
                 : readWorkspaceMarker(process.cwd());
             const remote = getConfiguredRemote(remoteOverride ?? marker?.remote);
             if (marker) {
-                process.stderr.write(`[remote] cwd mapped to ${marker.workspaceId} (reusing workspace)\n`);
+                process.stderr.write(`[h2a] cwd mapped to ${marker.workspaceId} (reusing workspace)\n`);
             }
             try {
                 await runProfile(profileName, {
@@ -1365,7 +1365,7 @@ export async function main(argv) {
                 }, commandArgs ?? []);
             }
             catch (err) {
-                process.stderr.write(`[remote] ${err.message}\n`);
+                process.stderr.write(`[h2a] ${err.message}\n`);
                 process.exitCode = 1;
             }
         });
@@ -1390,13 +1390,13 @@ export async function main(argv) {
         const cwd = process.cwd();
         const existing = readWorkspaceMarker(cwd);
         if (existing) {
-            process.stderr.write(`[remote] ${cwd} already mapped to ${existing.workspaceId} (${existing.remote})\n`);
+            process.stderr.write(`[h2a] ${cwd} already mapped to ${existing.workspaceId} (${existing.remote})\n`);
             return;
         }
         const remote = getConfiguredRemote(opts.remote);
         const ws = await createWorkspace(remote, opts.name ? { displayName: opts.name } : {});
         writeWorkspaceMarker(cwd, { remote, workspaceId: ws.id });
-        process.stderr.write(`[remote] linked ${cwd} -> ${ws.id} (wrote .remote/workspace.json)\n`);
+        process.stderr.write(`[h2a] linked ${cwd} -> ${ws.id} (wrote .remote/workspace.json)\n`);
     });
     workspaceCommand
         .command("list [url]")
@@ -1405,7 +1405,7 @@ export async function main(argv) {
         const remote = getConfiguredRemote(url);
         const workspaces = await listWorkspaces(remote);
         if (workspaces.length === 0) {
-            process.stderr.write("[remote] no workspaces\n");
+            process.stderr.write("[h2a] no workspaces\n");
             return;
         }
         const rows = workspaces.map((w) => [w.id, w.createdAt, w.displayName ?? ""].join("\t"));
@@ -1417,7 +1417,7 @@ export async function main(argv) {
         .action(() => {
         const marker = readWorkspaceMarker(process.cwd());
         if (!marker) {
-            process.stdout.write("[remote] no workspace mapped for this directory (run `remote workspace link`)\n");
+            process.stdout.write("[h2a] no workspace mapped for this directory (run `h2a workspace link`)\n");
             return;
         }
         process.stdout.write(`workspace: ${marker.workspaceId}\n`);
@@ -1426,7 +1426,7 @@ export async function main(argv) {
     const requireMarker = (cwd) => {
         const marker = readWorkspaceMarker(cwd);
         if (!marker) {
-            throw new Error("No workspace mapped for this directory. Run `remote workspace link` first.");
+            throw new Error("No workspace mapped for this directory. Run `h2a workspace link` first.");
         }
         return marker;
     };
@@ -1437,7 +1437,7 @@ export async function main(argv) {
                 throw new Error(`Workspace ${workspaceId} is held by ${lock.holder} since ${lock.since}. ` +
                     `Coordinate, or pass --force to override the soft lock.`);
             }
-            process.stderr.write(`[remote] warning: overriding soft lock held by ${lock.holder} (--force)\n`);
+            process.stderr.write(`[h2a] warning: overriding soft lock held by ${lock.holder} (--force)\n`);
         }
     };
     workspaceCommand
@@ -1449,9 +1449,9 @@ export async function main(argv) {
         const marker = requireMarker(cwd);
         await guardLock(marker.remote, marker.workspaceId, opts.force ?? false);
         try {
-            process.stderr.write(`[remote] packing ${cwd} (respecting .gitignore)\n`);
+            process.stderr.write(`[h2a] packing ${cwd} (respecting .gitignore)\n`);
             const archive = await buildWorkspaceArchive(cwd);
-            process.stderr.write(`[remote] archive: ${(archive.byteLength / 1024).toFixed(0)} KiB -> ${marker.workspaceId}\n`);
+            process.stderr.write(`[h2a] archive: ${(archive.byteLength / 1024).toFixed(0)} KiB -> ${marker.workspaceId}\n`);
             // Reuse the --sync path via a throwaway session bound to the workspace:
             // the session-agent extracts the archive into the retained PVC, then the
             // shell exits and the session auto-cleans (the workspace PVC is kept).
@@ -1469,7 +1469,7 @@ export async function main(argv) {
             await attached.finished;
             // The pushed tree is now the shared sync base.
             writeBaseSnapshot(cwd, archive);
-            process.stderr.write(`[remote] pushed ${cwd} to ${marker.workspaceId}\n`);
+            process.stderr.write(`[h2a] pushed ${cwd} to ${marker.workspaceId}\n`);
         }
         finally {
             await releaseWorkspaceLock(marker.remote, marker.workspaceId);
@@ -1510,7 +1510,7 @@ export async function main(argv) {
                 await stopRemoteSession(marker.remote, session.id, "pull-complete");
             }
             if (!remoteArchive) {
-                process.stderr.write(`[remote] nothing to pull (workspace ${marker.workspaceId} produced no export)\n`);
+                process.stderr.write(`[h2a] nothing to pull (workspace ${marker.workspaceId} produced no export)\n`);
                 return;
             }
             const result = mergeWorkspaceArchive({
@@ -1518,9 +1518,9 @@ export async function main(argv) {
                 remoteArchive,
                 baseArchive: readBaseSnapshot(cwd),
             });
-            process.stderr.write(`[remote] pull: ${result.tookRemote.length} from remote, ${result.keptLocal.length} kept local, ${result.merged.length} merged\n`);
+            process.stderr.write(`[h2a] pull: ${result.tookRemote.length} from remote, ${result.keptLocal.length} kept local, ${result.merged.length} merged\n`);
             if (result.conflicts.length > 0) {
-                process.stderr.write(`[remote] ${result.conflicts.length} conflict(s) (left with markers, resolve then re-run):\n`);
+                process.stderr.write(`[h2a] ${result.conflicts.length} conflict(s) (left with markers, resolve then re-run):\n`);
                 for (const f of result.conflicts)
                     process.stderr.write(`  ${f}\n`);
                 process.exitCode = 1;
@@ -1528,7 +1528,7 @@ export async function main(argv) {
             }
             // Clean merge → the remote tree is the new shared base.
             writeBaseSnapshot(cwd, remoteArchive);
-            process.stderr.write(`[remote] pulled ${marker.workspaceId} into ${cwd}\n`);
+            process.stderr.write(`[h2a] pulled ${marker.workspaceId} into ${cwd}\n`);
             if (opts.restoreSessions) {
                 const onConflict = opts.onConflict === "backup"
                     ? "backup"
@@ -1547,7 +1547,7 @@ export async function main(argv) {
                     const touched = r.restored.length + r.backedUp.length + r.conflicts.length;
                     if (touched === 0 && r.keptLocal.length === 0)
                         continue;
-                    process.stderr.write(`[remote] sessions(${profile}): ${r.restored.length} restored, ${r.backedUp.length} backed-up, ${r.keptLocal.length} kept, ${r.conflicts.length} conflict\n`);
+                    process.stderr.write(`[h2a] sessions(${profile}): ${r.restored.length} restored, ${r.backedUp.length} backed-up, ${r.keptLocal.length} kept, ${r.conflicts.length} conflict\n`);
                     for (const b of r.backedUp)
                         process.stderr.write(`    backup ${b}\n`);
                     if (r.conflicts.length > 0) {
@@ -1557,7 +1557,7 @@ export async function main(argv) {
                     }
                 }
                 if (anyConflict) {
-                    process.stderr.write(`[remote] diverged conversations left untouched. Re-run with --on-conflict backup (keep both) or keep-local.\n`);
+                    process.stderr.write(`[h2a] diverged conversations left untouched. Re-run with --on-conflict backup (keep both) or keep-local.\n`);
                     process.exitCode = 1;
                 }
             }
@@ -1579,8 +1579,8 @@ export async function main(argv) {
         }
         const deleted = await deleteWorkspace(remote, id);
         process.stderr.write(deleted
-            ? `[remote] deleted workspace ${id}\n`
-            : `[remote] workspace ${id} not found\n`);
+            ? `[h2a] deleted workspace ${id}\n`
+            : `[h2a] workspace ${id} not found\n`);
     });
     workspaceCommand
         .command("gc")
@@ -1605,16 +1605,16 @@ export async function main(argv) {
         // before the candidate list has been printed (and confirmed).
         const dryRun = await requestWorkspaceGc(remote, { olderThanDays });
         if (dryRun.candidates.length === 0) {
-            process.stderr.write(`[remote] workspace gc: no candidates older than ${olderThanDays} day(s) — nothing to do\n`);
+            process.stderr.write(`[h2a] workspace gc: no candidates older than ${olderThanDays} day(s) — nothing to do\n`);
             return;
         }
-        process.stderr.write(`[remote] workspace gc: ${dryRun.candidates.length} candidate(s) older than ${olderThanDays} day(s) (workspaces of known sessions are always kept):\n`);
+        process.stderr.write(`[h2a] workspace gc: ${dryRun.candidates.length} candidate(s) older than ${olderThanDays} day(s) (workspaces of known sessions are always kept):\n`);
         process.stdout.write([
             "ID\tSIZE\tLAST-MODIFIED",
             ...dryRun.candidates.map((c) => `${c.id}\t${c.sizeH}\t${c.lastModified}`),
         ].join("\n") + "\n");
         if (!opts.apply) {
-            process.stderr.write("[remote] dry-run only — nothing was deleted. Re-run with --apply to archive these to the volume's .trash/ and remove them.\n");
+            process.stderr.write("[h2a] dry-run only — nothing was deleted. Re-run with --apply to archive these to the volume's .trash/ and remove them.\n");
             return;
         }
         if (!opts.yes) {
@@ -1623,12 +1623,12 @@ export async function main(argv) {
                 input: process.stdin,
                 output: process.stderr,
             });
-            const answer = (await rl.question(`[remote] archive ${dryRun.candidates.length} director(y/ies) to on-volume .trash/ and DELETE them? [y/N] `))
+            const answer = (await rl.question(`[h2a] archive ${dryRun.candidates.length} director(y/ies) to on-volume .trash/ and DELETE them? [y/N] `))
                 .trim()
                 .toLowerCase();
             rl.close();
             if (answer !== "y" && answer !== "yes") {
-                process.stderr.write("[remote] aborted — nothing was deleted\n");
+                process.stderr.write("[h2a] aborted — nothing was deleted\n");
                 return;
             }
         }
@@ -1639,18 +1639,18 @@ export async function main(argv) {
         // The janitor re-checks keep-list and age at apply time, so the applied
         // set can legitimately be smaller than the dry-run shown above.
         for (const c of report.candidates) {
-            process.stderr.write(`[remote] archived ${c.id} (${c.sizeH}) -> ${c.archivedTo ?? ".trash/"} then removed\n`);
+            process.stderr.write(`[h2a] archived ${c.id} (${c.sizeH}) -> ${c.archivedTo ?? ".trash/"} then removed\n`);
         }
         for (const f of report.failed ?? []) {
-            process.stderr.write(`[remote] FAILED ${f.id}: ${f.reason} — directory left untouched\n`);
+            process.stderr.write(`[h2a] FAILED ${f.id}: ${f.reason} — directory left untouched\n`);
         }
         if ((report.failed ?? []).length > 0)
             process.exitCode = 1;
         if (report.candidates.length === 0) {
-            process.stderr.write("[remote] nothing collected (candidates became active or protected since the dry-run)\n");
+            process.stderr.write("[h2a] nothing collected (candidates became active or protected since the dry-run)\n");
         }
         else {
-            process.stderr.write(`[remote] workspace gc done: ${report.candidates.length} archived+removed (recoverable from the volume's .trash/)\n`);
+            process.stderr.write(`[h2a] workspace gc done: ${report.candidates.length} archived+removed (recoverable from the volume's .trash/)\n`);
         }
     });
     const authCommand = program
@@ -1683,7 +1683,7 @@ export async function main(argv) {
             return;
         }
         if (!profileName) {
-            throw new Error("Specify a profile (e.g. `remote auth status codex`) or pass --all.");
+            throw new Error("Specify a profile (e.g. `h2a auth status codex`) or pass --all.");
         }
         const profile = coerceCliProfileName(profileName);
         if (!profile) {
@@ -1701,13 +1701,13 @@ export async function main(argv) {
         }
         const loginCommand = getLoginCommand(profile);
         if (!loginCommand) {
-            process.stderr.write(`[remote] ${profile} has no scripted login. Run \`${profile}\` directly and complete its sign-in flow (browser / SSH-mode URL), then \`remote auth status ${profile}\`.\n`);
+            process.stderr.write(`[h2a] ${profile} has no scripted login. Run \`${profile}\` directly and complete its sign-in flow (browser / SSH-mode URL), then \`h2a auth status ${profile}\`.\n`);
             return;
         }
-        process.stderr.write(`[remote] running ${loginCommand.command} ${loginCommand.args.join(" ")}\n`);
+        process.stderr.write(`[h2a] running ${loginCommand.command} ${loginCommand.args.join(" ")}\n`);
         const code = await runInteractiveLogin(loginCommand);
         if (code !== 0) {
-            process.stderr.write(`[remote] login exited with code ${code}; check the output above.\n`);
+            process.stderr.write(`[h2a] login exited with code ${code}; check the output above.\n`);
             process.exitCode = code;
             return;
         }
@@ -1732,7 +1732,7 @@ export async function main(argv) {
             if (opts.authRefresh !== false) {
                 const fresh = await ensureProfileAuthFresh(resolved);
                 if (fresh.checked)
-                    process.stderr.write(`[remote] auth status ok: ${fresh.command}\n`);
+                    process.stderr.write(`[h2a] auth status ok: ${fresh.command}\n`);
             }
             await softRefreshSession(sessionId, resolved);
             return;
@@ -1790,14 +1790,14 @@ export async function main(argv) {
         .description("Store the bearer token sent as Authorization on control-plane requests (overridden by $REMOTE_TOKEN)")
         .action((value) => {
         setToken(value);
-        process.stderr.write("[remote] stored bearer token\n");
+        process.stderr.write("[h2a] stored bearer token\n");
     });
     configCommand
         .command("target <target>")
         .description("Set the default session target label (where the workload runs), e.g. scaleway-kapsule")
         .action((target) => {
         setDefaultTarget(target);
-        process.stderr.write(`[remote] default target set to ${target}\n`);
+        process.stderr.write(`[h2a] default target set to ${target}\n`);
     });
     configCommand
         .command("tools <list>")
@@ -1811,10 +1811,10 @@ export async function main(argv) {
                 .filter(Boolean);
         const { known, unknown } = partitionTools(requested);
         if (unknown.length > 0) {
-            process.stderr.write(`[remote] unknown tools ignored: ${unknown.join(", ")}\n`);
+            process.stderr.write(`[h2a] unknown tools ignored: ${unknown.join(", ")}\n`);
         }
         setDefaultTools(known);
-        process.stderr.write(`[remote] default tools: ${known.length > 0 ? known.join(", ") : "(none)"}\n`);
+        process.stderr.write(`[h2a] default tools: ${known.length > 0 ? known.join(", ") : "(none)"}\n`);
     });
     configCommand
         .command("tmux-profile <name>")
@@ -1823,21 +1823,21 @@ export async function main(argv) {
         setTmuxProfileConfig({ profile: name });
         const profile = getTmuxProfileConfig().profile;
         ensureManagedTmuxProfile(profile);
-        process.stderr.write(`[remote] tmux profile set to ${profile}\n`);
+        process.stderr.write(`[h2a] tmux profile set to ${profile}\n`);
     });
     configCommand
         .command("clear")
         .description("Clear default remote URL")
         .action(() => {
         clearDefaultRemote();
-        process.stderr.write("[remote] cleared default remote\n");
+        process.stderr.write("[h2a] cleared default remote\n");
     });
     configCommand
         .command("show")
         .description("Display configured default remote URL, managed tmux profile, and tunnel")
         .action(() => {
         const remote = getDefaultRemote();
-        process.stdout.write(remote ? `${remote}\n` : "[remote] no default remote configured\n");
+        process.stdout.write(remote ? `${remote}\n` : "[h2a] no default remote configured\n");
         process.stdout.write(`target: ${getDefaultTarget()}\n`);
         const tools = getDefaultTools();
         if (tools.length > 0)
@@ -1867,7 +1867,7 @@ export async function main(argv) {
             ...(opts.kubeconfig ? { kubeconfig: opts.kubeconfig } : {}),
         };
         setTunnel(tunnel);
-        process.stderr.write(`[remote] tunnel configured: kubectl -n ${tunnel.namespace} port-forward svc/${tunnel.service} ${tunnel.localPort}:${tunnel.remotePort}\n`);
+        process.stderr.write(`[h2a] tunnel configured: kubectl -n ${tunnel.namespace} port-forward svc/${tunnel.service} ${tunnel.localPort}:${tunnel.remotePort}\n`);
     });
     // ---------------------------------------------------------------------------
     // connect / disconnect — manage the on-demand tunnel
@@ -1879,7 +1879,7 @@ export async function main(argv) {
         .action(async (opts) => {
         const url = getConfiguredRemote(opts.remote);
         await ensureConnected(url);
-        process.stderr.write(`[remote] connected: ${url}\n`);
+        process.stderr.write(`[h2a] connected: ${url}\n`);
     });
     program
         .command("disconnect")
@@ -1887,8 +1887,8 @@ export async function main(argv) {
         .action(() => {
         const stopped = stopTunnel();
         process.stderr.write(stopped
-            ? "[remote] tunnel closed\n"
-            : "[remote] no managed tunnel was running\n");
+            ? "[h2a] tunnel closed\n"
+            : "[h2a] no managed tunnel was running\n");
     });
     program
         .command("status")
@@ -1960,7 +1960,7 @@ export async function main(argv) {
         if (sessionId) {
             const entries = transmittedSecrets(sessionId);
             if (entries === undefined) {
-                process.stdout.write(`[remote] cannot read secrets for ${sessionId} (no tunnel configured, or no auth Secret)\n`);
+                process.stdout.write(`[h2a] cannot read secrets for ${sessionId} (no tunnel configured, or no auth Secret)\n`);
                 return;
             }
             process.stdout.write(`Secrets transmitted to ${sessionId} (live, names only):\n`);
@@ -1986,7 +1986,7 @@ export async function main(argv) {
         for (const s of sessions) {
             process.stdout.write(`  ${projectName(s).padEnd(22)} ${secretsSummary(s.id)}   (${s.id})\n`);
         }
-        process.stdout.write("\n(⚠ = account-wide cloud cred. Detail: remote secrets status <sessionId>.)\n");
+        process.stdout.write("\n(⚠ = account-wide cloud cred. Detail: h2a secrets status <sessionId>.)\n");
     });
     // ---------------------------------------------------------------------------
     // diff — is the remote session aligned with the local one?
@@ -1999,7 +1999,7 @@ export async function main(argv) {
         .option("--remote <url>", "control-plane URL (defaults to configured remote)")
         .action(async (sessionId, opts) => {
         if (opts.session && opts.files) {
-            process.stderr.write("[remote] --session and --files are mutually exclusive\n");
+            process.stderr.write("[h2a] --session and --files are mutually exclusive\n");
             process.exitCode = 1;
             return;
         }
@@ -2010,7 +2010,7 @@ export async function main(argv) {
             ? all.filter((s) => s.id === sessionId)
             : all;
         if (sessions.length === 0) {
-            process.stdout.write("[remote] no matching session\n");
+            process.stdout.write("[h2a] no matching session\n");
             return;
         }
         const icon = {
@@ -2055,12 +2055,12 @@ export async function main(argv) {
         .option("--interval <seconds>", "seconds between sync passes in --watch mode (default: 30)", (v) => Number(v))
         .action(async (sessionId, opts) => {
         if (opts.files) {
-            process.stderr.write("[remote] files: utilise git (commit/push des deux côtés) — non automatisé\n");
+            process.stderr.write("[h2a] files: utilise git (commit/push des deux côtés) — non automatisé\n");
             process.exitCode = 1;
             return;
         }
         if (opts.session !== "push" && opts.session !== "pull") {
-            process.stderr.write("[remote] usage: remote sync <sessionId> --session <push|pull>\n");
+            process.stderr.write("[h2a] usage: h2a sync <sessionId> --session <push|pull>\n");
             process.exitCode = 1;
             return;
         }
@@ -2069,7 +2069,7 @@ export async function main(argv) {
         await ensureConnected(url);
         const session = (await listRemoteSessions(url)).find((s) => s.id === sessionId);
         if (!session?.workspacePath) {
-            process.stderr.write(`[remote] no session ${sessionId} with a workspace path\n`);
+            process.stderr.write(`[h2a] no session ${sessionId} with a workspace path\n`);
             process.exitCode = 1;
             return;
         }
@@ -2082,23 +2082,23 @@ export async function main(argv) {
                 force: opts.force ?? false,
             });
             if (!result.ok) {
-                process.stderr.write(`[remote] refused: ${result.reason}\n`);
+                process.stderr.write(`[h2a] refused: ${result.reason}\n`);
                 return false;
             }
             if (result.backup) {
-                process.stderr.write(`[remote] backup: ${result.backup}\n`);
+                process.stderr.write(`[h2a] backup: ${result.backup}\n`);
             }
             const lines = direction === "pull" ? result.lines.remote : result.lines.local;
             const mode = result.incremental ? " [incremental]" : "";
-            process.stderr.write(`[remote] ${direction === "pull" ? "pulled" : "pushed"} ${result.convId} (${lines} lines) → ${result.written}${mode}\n`);
+            process.stderr.write(`[h2a] ${direction === "pull" ? "pulled" : "pushed"} ${result.convId} (${lines} lines) → ${result.written}${mode}\n`);
             if (direction === "push") {
-                process.stderr.write(`[remote] not relaunching the Pod CLI — relance la session pour charger : remote refresh ${sessionId} --soft\n`);
+                process.stderr.write(`[h2a] not relaunching the Pod CLI — relance la session pour charger : h2a refresh ${sessionId} --soft\n`);
             }
             return true;
         };
         if (opts.watch) {
             const intervalSec = opts.interval ?? 30;
-            process.stderr.write(`[remote] sync --watch: syncing every ${intervalSec}s (Ctrl-C to stop)\n`);
+            process.stderr.write(`[h2a] sync --watch: syncing every ${intervalSec}s (Ctrl-C to stop)\n`);
             let stopped = false;
             let wake;
             const onSigint = () => {
@@ -2108,12 +2108,12 @@ export async function main(argv) {
             process.on("SIGINT", onSigint);
             try {
                 while (!stopped) {
-                    process.stderr.write(`[remote] sync pass — ${new Date().toISOString()}\n`);
+                    process.stderr.write(`[h2a] sync pass — ${new Date().toISOString()}\n`);
                     try {
                         runOnce();
                     }
                     catch (err) {
-                        process.stderr.write(`[remote] sync pass error: ${err.message}\n`);
+                        process.stderr.write(`[h2a] sync pass error: ${err.message}\n`);
                     }
                     if (stopped)
                         break;
@@ -2130,7 +2130,7 @@ export async function main(argv) {
             finally {
                 process.removeListener("SIGINT", onSigint);
             }
-            process.stderr.write("[remote] sync --watch stopped\n");
+            process.stderr.write("[h2a] sync --watch stopped\n");
             return;
         }
         const ok = runOnce();
@@ -2208,7 +2208,7 @@ export async function main(argv) {
     program
         .command("sync-files")
         .description("Push the current git workspace to the session pod incrementally (git bundle on first push, diff on subsequent). " +
-        "Distinct from `remote sync` which syncs conversations.")
+        "Distinct from `h2a sync` which syncs conversations.")
         .option("--remote <url>", "control-plane URL (defaults to configured remote)")
         .option("--session <id>", "session id to sync into (defaults to .remote/workspace.json marker)")
         .option("--dry-run", "show what would be sent without uploading")
@@ -2216,13 +2216,13 @@ export async function main(argv) {
         const cwd = process.cwd();
         const { isGitRepo: checkGit, getHeadSha, buildGitBundle, buildIncrementalManifest, buildUntrackedTarball, } = await import("./workspace-sync-incremental.js");
         if (!checkGit(cwd)) {
-            process.stderr.write("[remote] sync-files: current directory is not a git repo\n");
+            process.stderr.write("[h2a] sync-files: current directory is not a git repo\n");
             process.exitCode = 1;
             return;
         }
         const headSha = getHeadSha(cwd);
         if (!headSha) {
-            process.stderr.write("[remote] sync-files: cannot resolve HEAD — make at least one commit\n");
+            process.stderr.write("[h2a] sync-files: cannot resolve HEAD — make at least one commit\n");
             process.exitCode = 1;
             return;
         }
@@ -2231,7 +2231,7 @@ export async function main(argv) {
         // Resolve session id: explicit --session, or from marker
         const sessionId = opts.session ?? marker?.workspaceId;
         if (!sessionId) {
-            process.stderr.write("[remote] sync-files: no session id — pass --session or run `remote workspace link` first\n");
+            process.stderr.write("[h2a] sync-files: no session id — pass --session or run `h2a workspace link` first\n");
             process.exitCode = 1;
             return;
         }
@@ -2245,18 +2245,18 @@ export async function main(argv) {
         }
         if (opts.dryRun) {
             if (baseSha) {
-                process.stderr.write(`[remote] sync-files (dry-run): incremental push HEAD=${headSha} base=${baseSha}\n`);
+                process.stderr.write(`[h2a] sync-files (dry-run): incremental push HEAD=${headSha} base=${baseSha}\n`);
             }
             else {
-                process.stderr.write(`[remote] sync-files (dry-run): bootstrap push HEAD=${headSha} (no base on CP)\n`);
+                process.stderr.write(`[h2a] sync-files (dry-run): bootstrap push HEAD=${headSha} (no base on CP)\n`);
             }
             return;
         }
         if (!baseSha) {
             // Bootstrap: upload full git bundle.
-            process.stderr.write(`[remote] sync-files: bootstrap — building git bundle (HEAD=${headSha})\n`);
+            process.stderr.write(`[h2a] sync-files: bootstrap — building git bundle (HEAD=${headSha})\n`);
             const bundle = buildGitBundle(cwd);
-            process.stderr.write(`[remote] sync-files: bundle ${(bundle.byteLength / 1024).toFixed(0)} KiB → ${sessionId}\n`);
+            process.stderr.write(`[h2a] sync-files: bundle ${(bundle.byteLength / 1024).toFixed(0)} KiB → ${sessionId}\n`);
             const uploadRes = await fetch(`${remote.replace(/\/$/, "")}/sessions/${sessionId}/workspace/incremental/bundle`, {
                 method: "POST",
                 headers: {
@@ -2287,7 +2287,7 @@ export async function main(argv) {
             if (!manifestRes.ok) {
                 throw new Error(`manifest record failed: ${manifestRes.status} ${manifestRes.statusText}`);
             }
-            process.stderr.write(`[remote] sync-files: bootstrap complete, base=${headSha}\n`);
+            process.stderr.write(`[h2a] sync-files: bootstrap complete, base=${headSha}\n`);
             const { writeSyncStatus, emptyMetrics: em } = await import("./sync-status.js");
             writeSyncStatus(sessionId, {
                 state: "synced",
@@ -2300,11 +2300,11 @@ export async function main(argv) {
         }
         else {
             // Incremental push.
-            process.stderr.write(`[remote] sync-files: incremental push base=${baseSha} → HEAD=${headSha}\n`);
+            process.stderr.write(`[h2a] sync-files: incremental push base=${baseSha} → HEAD=${headSha}\n`);
             const manifest = buildIncrementalManifest(cwd, baseSha);
             const untrackedPaths = manifest.untrackedManifest.map((e) => e.path);
             const trackedBytes = Buffer.from(manifest.tracked, "base64").byteLength;
-            process.stderr.write(`[remote] sync-files: tracked diff ${(trackedBytes / 1024).toFixed(1)} KiB, ${untrackedPaths.length} untracked file(s)\n`);
+            process.stderr.write(`[h2a] sync-files: tracked diff ${(trackedBytes / 1024).toFixed(1)} KiB, ${untrackedPaths.length} untracked file(s)\n`);
             // Upload manifest.
             const manifestRes = await fetch(`${remote.replace(/\/$/, "")}/sessions/${sessionId}/workspace/incremental`, {
                 method: "POST",
@@ -2332,7 +2332,7 @@ export async function main(argv) {
                     throw new Error(`untracked upload failed: ${tarRes.status} ${tarRes.statusText}`);
                 }
             }
-            process.stderr.write(`[remote] sync-files: incremental complete, base=${headSha}\n`);
+            process.stderr.write(`[h2a] sync-files: incremental complete, base=${headSha}\n`);
             const { writeSyncStatus: wss, emptyMetrics: em2 } = await import("./sync-status.js");
             wss(sessionId, {
                 state: "synced",
@@ -2355,7 +2355,7 @@ export async function main(argv) {
         .action(async (sessionId, podPort, localPort, opts) => {
         const port = Number(podPort);
         if (!Number.isInteger(port) || port < 1 || port > 65535) {
-            process.stderr.write(`[remote] invalid pod port "${podPort}"\n`);
+            process.stderr.write(`[h2a] invalid pod port "${podPort}"\n`);
             process.exitCode = 1;
             return;
         }
@@ -2363,7 +2363,7 @@ export async function main(argv) {
         if (localPort !== undefined) {
             local = Number(localPort);
             if (!Number.isInteger(local) || local < 1 || local > 65535) {
-                process.stderr.write(`[remote] invalid local port "${localPort}"\n`);
+                process.stderr.write(`[h2a] invalid local port "${localPort}"\n`);
                 process.exitCode = 1;
                 return;
             }
@@ -2387,7 +2387,7 @@ export async function main(argv) {
     browserCommand
         .command("open <sessionId>")
         .description("Print the steps to open the headful browser view for a session: the " +
-        "`remote forward` command to run and the token-gated noVNC URL to open. " +
+        "`h2a forward` command to run and the token-gated noVNC URL to open. " +
         "Default exposure is session-private (owner only, token-gated) and interactive (you drive the 2FA).")
         .option("--local-port <port>", "local port to bind the forward to")
         .option("--policy <policy>", "uat exposure policy: operator-only | session-private | public-expiring (default session-private)")
@@ -2400,7 +2400,7 @@ export async function main(argv) {
             if (!Number.isInteger(localPort) ||
                 localPort < 1 ||
                 localPort > 65535) {
-                process.stderr.write(`[remote] invalid local port "${opts.localPort}"\n`);
+                process.stderr.write(`[h2a] invalid local port "${opts.localPort}"\n`);
                 process.exitCode = 1;
                 return;
             }
@@ -2410,7 +2410,7 @@ export async function main(argv) {
             policy !== "operator-only" &&
             policy !== "session-private" &&
             policy !== "public-expiring") {
-            process.stderr.write(`[remote] invalid --policy "${policy}" (operator-only | session-private | public-expiring)\n`);
+            process.stderr.write(`[h2a] invalid --policy "${policy}" (operator-only | session-private | public-expiring)\n`);
             process.exitCode = 1;
             return;
         }
@@ -2418,7 +2418,7 @@ export async function main(argv) {
         if (opts.ttl !== undefined) {
             ttlMs = Number(opts.ttl);
             if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
-                process.stderr.write(`[remote] invalid --ttl "${opts.ttl}"\n`);
+                process.stderr.write(`[h2a] invalid --ttl "${opts.ttl}"\n`);
                 process.exitCode = 1;
                 return;
             }
@@ -2431,7 +2431,7 @@ export async function main(argv) {
             ...(opts.viewOnly ? { interactive: false } : {}),
         });
         if (!plan.ok) {
-            process.stderr.write(`[remote] ${plan.reason}\n`);
+            process.stderr.write(`[h2a] ${plan.reason}\n`);
             process.exitCode = 1;
             return;
         }
@@ -2454,7 +2454,7 @@ export async function main(argv) {
         .option("-r, --resume [convId]", "resume the most recent (or a specific) conversation on the remote CLI")
         .option("--no-attach", "create the remote session without hijacking this terminal; print the attach command instead (for bulk migration / reconnecting your own terminal)")
         .option("--reconnect", "revive a session on the EXISTING workspace without re-pushing files (preserves work done remotely) — use after an accidental exit (Ctrl+C/Ctrl+D) to bring the session back from its retained PVC with path parity + --resume")
-        .option("--with <tools>", `comma-separated tool CLIs whose local auth to also bundle into the Pod (known: ${KNOWN_TOOLS.join(", ")}); defaults to 'remote config tools'`)
+        .option("--with <tools>", `comma-separated tool CLIs whose local auth to also bundle into the Pod (known: ${KNOWN_TOOLS.join(", ")}); defaults to 'h2a config tools'`)
         .option("--force", "migrate even if the conversation already has a live writer (risk: conversation .jsonl corruption)")
         .action(async (profile, opts) => {
         const remoteUrl = getConfiguredRemote(opts.remote);
@@ -2503,7 +2503,7 @@ export async function main(argv) {
         const now = Date.now();
         const candidates = listMigrationCandidates();
         if (candidates.length === 0) {
-            process.stdout.write("[remote] no local claude sessions found under ~/.claude/projects\n");
+            process.stdout.write("[h2a] no local claude sessions found under ~/.claude/projects\n");
             return;
         }
         process.stdout.write("#    AGE    SIZE    CONVS  GIT  MIGRATED  PATH\n");
@@ -2517,8 +2517,8 @@ export async function main(argv) {
             const missing = c.exists ? "" : "  (dir missing)";
             process.stdout.write(`${n} ${age} ${size} ${convs} ${git} ${mig} ${c.path}${missing}\n`);
         });
-        process.stdout.write("\nMigrate one: cd <path> && remote migrate forward claude --resume\n" +
-            "Pick interactively: remote migrate pick\n");
+        process.stdout.write("\nMigrate one: cd <path> && h2a migrate forward claude --resume\n" +
+            "Pick interactively: h2a migrate pick\n");
     });
     migrateCommand
         .command("pick")
@@ -2526,7 +2526,7 @@ export async function main(argv) {
         .option("--remote <url>", "control-plane URL (defaults to configured remote)")
         .option("--profile <profile>", "CLI profile to start remotely", "claude")
         .option("--no-resume", "do not resume the conversation on the remote CLI")
-        .option("--with <tools>", `comma-separated tool CLIs whose auth to bundle (known: ${KNOWN_TOOLS.join(", ")}); defaults to 'remote config tools'`)
+        .option("--with <tools>", `comma-separated tool CLIs whose auth to bundle (known: ${KNOWN_TOOLS.join(", ")}); defaults to 'h2a config tools'`)
         .action(async (opts) => {
         const remoteUrl = getConfiguredRemote(opts.remote);
         await ensureConnected(remoteUrl);
@@ -2535,7 +2535,7 @@ export async function main(argv) {
         const now = Date.now();
         const candidates = listMigrationCandidates().filter((c) => c.exists && c.isGit);
         if (candidates.length === 0) {
-            process.stdout.write("[remote] no migratable git-backed sessions found\n");
+            process.stdout.write("[h2a] no migratable git-backed sessions found\n");
             return;
         }
         process.stdout.write("Local sessions you can migrate:\n\n");
@@ -2559,7 +2559,7 @@ export async function main(argv) {
             .filter((n) => Number.isInteger(n) && n >= 1 && n <= candidates.length)
             .map((n) => candidates[n - 1]);
         if (chosen.length === 0) {
-            process.stdout.write("[remote] nothing selected — cancelled\n");
+            process.stdout.write("[h2a] nothing selected — cancelled\n");
             return;
         }
         for (const c of chosen) {
@@ -2575,7 +2575,7 @@ export async function main(argv) {
                 });
             }
             catch (err) {
-                process.stderr.write(`[remote] failed to migrate ${c.path}: ${String(err)}\n`);
+                process.stderr.write(`[h2a] failed to migrate ${c.path}: ${String(err)}\n`);
             }
         }
     });
@@ -2604,15 +2604,15 @@ export async function main(argv) {
             if (match) {
                 const lastWs = match.wsHistory[match.wsHistory.length - 1];
                 if (lastWs && !workspaceId) {
-                    process.stderr.write(`[remote] --lineage ${lineageId} → workspace history includes ${lastWs}\n`);
+                    process.stderr.write(`[h2a] --lineage ${lineageId} → workspace history includes ${lastWs}\n`);
                 }
                 if (match.incarnation.remote?.sessionId) {
                     knownSessionId = match.incarnation.remote.sessionId;
-                    process.stderr.write(`[remote] targeting session ${knownSessionId} (from lineage)\n`);
+                    process.stderr.write(`[h2a] targeting session ${knownSessionId} (from lineage)\n`);
                 }
             }
             else {
-                process.stderr.write(`[remote] warning: lineage ${lineageId} not found locally; proceeding without lineage filter\n`);
+                process.stderr.write(`[h2a] warning: lineage ${lineageId} not found locally; proceeding without lineage filter\n`);
             }
         }
         await migrateBack({
@@ -2637,14 +2637,14 @@ export async function main(argv) {
         // Step 1: checkReadiness
         const readiness = checkReadiness({ cwd, profile: resolvedProfile });
         if (readiness.blockers.length > 0) {
-            process.stderr.write(`[remote] migration blocked:\n${readiness.blockers.map((b) => `  • ${b}`).join("\n")}\n`);
+            process.stderr.write(`[h2a] migration blocked:\n${readiness.blockers.map((b) => `  • ${b}`).join("\n")}\n`);
             process.exitCode = 1;
             return;
         }
         if (readiness.warnings.length > 0) {
-            process.stderr.write(`[remote] readiness warnings:\n${readiness.warnings.map((w) => `  ⚠ ${w}`).join("\n")}\n`);
+            process.stderr.write(`[h2a] readiness warnings:\n${readiness.warnings.map((w) => `  ⚠ ${w}`).join("\n")}\n`);
         }
-        process.stderr.write(`[remote] readiness ok (mode: ${readiness.mode}, pending: ${readiness.pending.files} files / ${(readiness.pending.bytes / 1024).toFixed(0)} KiB)\n`);
+        process.stderr.write(`[h2a] readiness ok (mode: ${readiness.mode}, pending: ${readiness.pending.files} files / ${(readiness.pending.bytes / 1024).toFixed(0)} KiB)\n`);
         // Step 2: compute durable workspace id (best-effort)
         let wsHex = "ws:unknown";
         try {
@@ -2685,21 +2685,21 @@ export async function main(argv) {
         const TTL_MS = 300_000; // 5 minutes
         const leaseResult = acquireLease(lineageId, thisInstance, localSlug, "local", TTL_MS, cwd);
         if ("error" in leaseResult) {
-            process.stderr.write(`[remote] lease conflict: lineage ${lineageId} is held by ${leaseResult.current.holder} (${leaseResult.current.location}) until ${leaseResult.current.expiresAt}\n` +
-                `[remote] wait for the lease to expire or use \`remote migrate to-remote --force\` (not yet implemented)\n`);
+            process.stderr.write(`[h2a] lease conflict: lineage ${lineageId} is held by ${leaseResult.current.holder} (${leaseResult.current.location}) until ${leaseResult.current.expiresAt}\n` +
+                `[h2a] wait for the lease to expire or use \`h2a migrate to-remote --force\` (not yet implemented)\n`);
             process.exitCode = 1;
             return;
         }
-        process.stderr.write(`[remote] lineage: ${lineageId} (epoch ${leaseResult.epoch}, holder ${thisInstance})\n`);
+        process.stderr.write(`[h2a] lineage: ${lineageId} (epoch ${leaseResult.epoch}, holder ${thisInstance})\n`);
         if (opts.dryRun) {
-            process.stderr.write(`[remote] --dry-run: would call migrate forward ${resolvedProfile} (mode: ${readiness.mode})\n`);
-            process.stderr.write(`[remote] dry-run complete — no session created, lease NOT handed off\n`);
+            process.stderr.write(`[h2a] --dry-run: would call migrate forward ${resolvedProfile} (mode: ${readiness.mode})\n`);
+            process.stderr.write(`[h2a] dry-run complete — no session created, lease NOT handed off\n`);
             // Release the lease on dry-run (we only acquired it to check)
             return;
         }
         // Step 5: suspend local incarnation BEFORE handoff
         suspendLocalIncarnation(lineageId, cwd);
-        process.stderr.write(`[remote] local incarnation suspended (sentinel written)\n`);
+        process.stderr.write(`[h2a] local incarnation suspended (sentinel written)\n`);
         // Step 6: call existing migrate forward
         const remoteUrl = getConfiguredRemote(opts.remote);
         await ensureConnected(remoteUrl);
@@ -2718,8 +2718,8 @@ export async function main(argv) {
         catch (err) {
             // On error: resume local incarnation (undo suspend)
             resumeLocalIncarnation(lineageId, cwd);
-            process.stderr.write(`[remote] migrate forward failed: ${err.message}\n` +
-                `[remote] local incarnation resumed\n`);
+            process.stderr.write(`[h2a] migrate forward failed: ${err.message}\n` +
+                `[h2a] local incarnation resumed\n`);
             process.exitCode = 1;
             return;
         }
@@ -2727,10 +2727,10 @@ export async function main(argv) {
         const remoteHolder = `remote:pod:${sessionId ?? "unknown"}`;
         const handoffResult = handoffLease(lineageId, thisInstance, leaseResult.epoch, remoteHolder, sessionId ?? "unknown", "remote", TTL_MS, cwd);
         if ("error" in handoffResult) {
-            process.stderr.write(`[remote] warning: lease handoff failed (${handoffResult.error}) — lease may be stale\n`);
+            process.stderr.write(`[h2a] warning: lease handoff failed (${handoffResult.error}) — lease may be stale\n`);
         }
         else {
-            process.stderr.write(`[remote] lease handed off to remote (epoch ${handoffResult.epoch})\n`);
+            process.stderr.write(`[h2a] lease handed off to remote (epoch ${handoffResult.epoch})\n`);
         }
         // Persist remote session id in the lineage record so `migrate back
         // --lineage <id>` can target it without listing all sessions.
@@ -2748,7 +2748,7 @@ export async function main(argv) {
             }
         }
         // Step 8: summary
-        process.stderr.write(`[remote] migration complete:\n` +
+        process.stderr.write(`[h2a] migration complete:\n` +
             `  lineage:  ${lineageId}\n` +
             `  session:  ${sessionId ?? "unknown"}\n` +
             `  remote:   ${remoteUrl}\n`);
@@ -2770,7 +2770,7 @@ export async function main(argv) {
         const repoBlocker = readiness.blockers.find((b) => b.startsWith("repo:"));
         const toLocalBlockers = [authBlocker, repoBlocker].filter((b) => b !== undefined);
         if (toLocalBlockers.length > 0) {
-            process.stderr.write(`[remote] migration blocked:\n${toLocalBlockers.map((b) => `  • ${b}`).join("\n")}\n`);
+            process.stderr.write(`[h2a] migration blocked:\n${toLocalBlockers.map((b) => `  • ${b}`).join("\n")}\n`);
             process.exitCode = 1;
             return;
         }
@@ -2778,13 +2778,13 @@ export async function main(argv) {
         const lineages = listLineages(cwd);
         const remoteLineage = lineages.find((l) => l.incarnation.remote !== null);
         if (!remoteLineage) {
-            process.stderr.write(`[remote] no active remote lineage found in ${cwd}/.remote/lineages/\n` +
-                `[remote] run \`remote migrate to-remote\` first, or check \`ls .remote/lineages/\`\n`);
+            process.stderr.write(`[h2a] no active remote lineage found in ${cwd}/.remote/lineages/\n` +
+                `[h2a] run \`h2a migrate to-remote\` first, or check \`ls .remote/lineages/\`\n`);
             process.exitCode = 1;
             return;
         }
         const lineageId = remoteLineage.lineage;
-        process.stderr.write(`[remote] found remote lineage ${lineageId} (session ${remoteLineage.incarnation.remote?.sessionId ?? "unknown"})\n`);
+        process.stderr.write(`[h2a] found remote lineage ${lineageId} (session ${remoteLineage.incarnation.remote?.sessionId ?? "unknown"})\n`);
         // Step 3: try to acquire the local lease
         const localSlug = basename(cwd);
         const thisInstance = `claude:local:${randomUUID().replace(/-/g, "").slice(0, 12)}`;
@@ -2793,23 +2793,23 @@ export async function main(argv) {
         if ("error" in leaseResult) {
             const current = leaseResult.current;
             if (current.location === "remote") {
-                process.stderr.write(`[remote] un agent remote tient le lease ; attendez l'expiry (${current.expiresAt}) ou utilisez \`remote migrate to-local --force\` pour forcer\n`);
+                process.stderr.write(`[h2a] un agent remote tient le lease ; attendez l'expiry (${current.expiresAt}) ou utilisez \`h2a migrate to-local --force\` pour forcer\n`);
             }
             else {
-                process.stderr.write(`[remote] lease conflict: held by ${current.holder} until ${current.expiresAt}\n`);
+                process.stderr.write(`[h2a] lease conflict: held by ${current.holder} until ${current.expiresAt}\n`);
             }
             process.exitCode = 1;
             return;
         }
-        process.stderr.write(`[remote] lease acquired (epoch ${leaseResult.epoch}, holder ${thisInstance})\n`);
+        process.stderr.write(`[h2a] lease acquired (epoch ${leaseResult.epoch}, holder ${thisInstance})\n`);
         if (opts.dryRun) {
-            process.stderr.write(`[remote] --dry-run: would call migrate back (lineage ${lineageId})\n`);
-            process.stderr.write(`[remote] dry-run complete — no session stopped, lease NOT committed\n`);
+            process.stderr.write(`[h2a] --dry-run: would call migrate back (lineage ${lineageId})\n`);
+            process.stderr.write(`[h2a] dry-run complete — no session stopped, lease NOT committed\n`);
             return;
         }
         // Step 4: reset suspend sentinel (local incarnation resumes)
         resumeLocalIncarnation(lineageId, cwd);
-        process.stderr.write(`[remote] local incarnation resumed (sentinel cleared)\n`);
+        process.stderr.write(`[h2a] local incarnation resumed (sentinel cleared)\n`);
         // Step 5: call existing migrate back
         const remoteUrl = getConfiguredRemote(opts.remote);
         const onConflict = opts.onConflict === "backup"
@@ -2824,12 +2824,12 @@ export async function main(argv) {
             });
         }
         catch (err) {
-            process.stderr.write(`[remote] migrate back failed: ${err.message}\n`);
+            process.stderr.write(`[h2a] migrate back failed: ${err.message}\n`);
             process.exitCode = 1;
             return;
         }
         // Step 6: summary
-        process.stderr.write(`[remote] to-local complete (lineage ${lineageId})\n`);
+        process.stderr.write(`[h2a] to-local complete (lineage ${lineageId})\n`);
     });
     // ---------------------------------------------------------------------------
     // plugin — npm packages providing a CLI + an MCP server, for all agent CLIs
@@ -2847,7 +2847,7 @@ export async function main(argv) {
         .option("--install <shell>", "install in Pods by running this shell command (non-npm)")
         .action((pkgOrName, opts) => {
         if (opts.curl !== undefined && opts.install !== undefined) {
-            process.stderr.write("[remote] pass only one of --curl / --install\n");
+            process.stderr.write("[h2a] pass only one of --curl / --install\n");
             process.exitCode = 1;
             return;
         }
@@ -2936,7 +2936,7 @@ export async function main(argv) {
         .option("--no-gw", "alias for --no-llm-gateway")
         .action(async (slug, opts) => {
         if (!tmuxAvailable()) {
-            process.stderr.write("[remote] tmux is not installed locally — `remote resume` needs it (e.g. `sudo apt install tmux`).\n");
+            process.stderr.write("[h2a] tmux is not installed locally — `h2a resume` needs it (e.g. `sudo apt install tmux`).\n");
             process.exitCode = 1;
             return;
         }
@@ -2946,7 +2946,7 @@ export async function main(argv) {
                 ? "codex"
                 : undefined;
         if (opts.claude !== undefined && opts.codex !== undefined) {
-            process.stderr.write("[remote] pass only one of --claude or --codex.\n");
+            process.stderr.write("[h2a] pass only one of --claude or --codex.\n");
             process.exitCode = 1;
             return;
         }
@@ -2956,17 +2956,17 @@ export async function main(argv) {
                 ? opts.codex.trim()
                 : undefined;
         if (opts.last && !explicitProfile) {
-            process.stderr.write("[remote] --last is only valid with --claude or --codex.\n");
+            process.stderr.write("[h2a] --last is only valid with --claude or --codex.\n");
             process.exitCode = 1;
             return;
         }
         if (opts.last && explicitConvId) {
-            process.stderr.write("[remote] pass either a conversation id or --last, not both.\n");
+            process.stderr.write("[h2a] pass either a conversation id or --last, not both.\n");
             process.exitCode = 1;
             return;
         }
         if (slug === undefined && !explicitProfile) {
-            process.stderr.write("[remote] resume needs a known session name, or `remote resume --claude [conversation-id]` / `remote resume --codex [conversation-id]` from the repo directory.\n");
+            process.stderr.write("[h2a] resume needs a known session name, or `h2a resume --claude [conversation-id]` / `h2a resume --codex [conversation-id]` from the repo directory.\n");
             process.exitCode = 1;
             return;
         }
@@ -2978,7 +2978,7 @@ export async function main(argv) {
             ? localConvStat(process.cwd())?.convId
             : explicitConvId;
         if (explicitProfile === "claude" && opts.last && !resolvedConvId) {
-            process.stderr.write(`[remote] cannot resume last Claude conversation: no local Claude conversation found for ${process.cwd()}.\n`);
+            process.stderr.write(`[h2a] cannot resume last Claude conversation: no local Claude conversation found for ${process.cwd()}.\n`);
             process.exitCode = 1;
             return;
         }
@@ -2998,31 +2998,31 @@ export async function main(argv) {
             : registryEntry;
         const localIdle = local ? localSessionIdle(local.name) : false;
         if (!entry && local && !localIdle && !opts.replace) {
-            process.stderr.write(`[remote] local session ${displaySlug} already exists and does not look idle; no new CLI was started.\n`);
+            process.stderr.write(`[h2a] local session ${displaySlug} already exists and does not look idle; no new CLI was started.\n`);
             if (opts.attach || explicitProfile) {
-                process.stderr.write(`[remote] switching to existing session ${displaySlug}\n`);
+                process.stderr.write(`[h2a] switching to existing session ${displaySlug}\n`);
                 process.exitCode = attachLocalSession(local.name);
                 return;
             }
-            process.stderr.write(`[remote] attach: remote attach ${displaySlug}\n`);
+            process.stderr.write(`[h2a] attach: h2a attach ${displaySlug}\n`);
             process.exitCode = 2;
             return;
         }
         if (!entry) {
-            process.stderr.write(`[remote] cannot resume ${displaySlug}: registry has no single local-tmux entry with profile, cwd and convId.\n`);
+            process.stderr.write(`[h2a] cannot resume ${displaySlug}: registry has no single local-tmux entry with profile, cwd and convId.\n`);
             if (local) {
-                process.stderr.write(`[remote] local session ${displaySlug} exists but cannot be relaunched without a recorded convId.\n`);
-                process.stderr.write(`[remote] attach: remote attach ${displaySlug}\n`);
+                process.stderr.write(`[h2a] local session ${displaySlug} exists but cannot be relaunched without a recorded convId.\n`);
+                process.stderr.write(`[h2a] attach: h2a attach ${displaySlug}\n`);
             }
             else {
-                process.stderr.write(`[remote] start explicitly: remote resume ${displaySlug} --claude [convId]\n`);
+                process.stderr.write(`[h2a] start explicitly: h2a resume ${displaySlug} --claude [convId]\n`);
             }
             process.exitCode = 1;
             return;
         }
         const resumeSlug = entry.id;
         if (!entry.cwd || !entry.tool || (!entry.convId && !explicitProfile)) {
-            process.stderr.write(`[remote] cannot resume ${displaySlug}: registry entry is incomplete (need profile, cwd and convId).\n`);
+            process.stderr.write(`[h2a] cannot resume ${displaySlug}: registry entry is incomplete (need profile, cwd and convId).\n`);
             process.exitCode = 1;
             return;
         }
@@ -3032,7 +3032,7 @@ export async function main(argv) {
             gatewayMode = gatewayModeFromOptions(opts);
         }
         catch (error) {
-            process.stderr.write(`[remote] ${error.message}.\n`);
+            process.stderr.write(`[h2a] ${error.message}.\n`);
             process.exitCode = 1;
             return;
         }
@@ -3044,7 +3044,7 @@ export async function main(argv) {
             last: Boolean(opts.last),
         });
         if (args.length === 0) {
-            process.stderr.write(`[remote] cannot resume ${displaySlug}: profile "${profile}" has no verified local resume argv.\n`);
+            process.stderr.write(`[h2a] cannot resume ${displaySlug}: profile "${profile}" has no verified local resume argv.\n`);
             process.exitCode = 1;
             return;
         }
@@ -3059,49 +3059,49 @@ export async function main(argv) {
                 })
                 : "unknown";
             if (gatewayEnvStatus === "missing" || gatewayEnvStatus === "stale") {
-                process.stderr.write(`[remote] local session ${displaySlug} is running without current llm-mesh env (${gatewayEnvStatus}); not restarting an active session automatically.\n`);
-                process.stderr.write(`[remote] to relaunch with gateway env, confirm explicitly: remote resume ${displaySlug} --replace\n`);
+                process.stderr.write(`[h2a] local session ${displaySlug} is running without current llm-mesh env (${gatewayEnvStatus}); not restarting an active session automatically.\n`);
+                process.stderr.write(`[h2a] to relaunch with gateway env, confirm explicitly: h2a resume ${displaySlug} --replace\n`);
             }
-            process.stderr.write(`[remote] local session ${displaySlug} already exists and does not look idle; no new ${profile} was started.\n`);
+            process.stderr.write(`[h2a] local session ${displaySlug} already exists and does not look idle; no new ${profile} was started.\n`);
             if (opts.attach || explicitProfile) {
                 if (explicitProfile && currentTmuxSessionIs(local.name)) {
-                    process.stderr.write(`[remote] already inside ${displaySlug}; running ${profile} resume in this pane\n`);
+                    process.stderr.write(`[h2a] already inside ${displaySlug}; running ${profile} resume in this pane\n`);
                     process.exitCode = runLocalCliForeground(command, args);
                     return;
                 }
-                process.stderr.write(`[remote] switching to existing session ${displaySlug}\n`);
+                process.stderr.write(`[h2a] switching to existing session ${displaySlug}\n`);
                 process.exitCode = attachLocalSession(local.name);
                 return;
             }
-            process.stderr.write(`[remote] attach: remote attach ${displaySlug}\n`);
+            process.stderr.write(`[h2a] attach: h2a attach ${displaySlug}\n`);
             process.exitCode = 2;
             return;
         }
         if (local) {
             if (!localIdle && opts.replace) {
-                process.stderr.write(`[remote] local session ${displaySlug} does not look idle; --replace will kill tmux session ${local.name} before resuming${entry.convId ? ` ${entry.convId}` : ""}.\n`);
+                process.stderr.write(`[h2a] local session ${displaySlug} does not look idle; --replace will kill tmux session ${local.name} before resuming${entry.convId ? ` ${entry.convId}` : ""}.\n`);
             }
             if (!opts.replace) {
-                process.stderr.write(`[remote] local session ${displaySlug} already exists.\n`);
-                process.stderr.write(`[remote] pane appears idle; replacing it will kill tmux session ${local.name} and resume${entry.convId ? ` conversation ${entry.convId}` : ""} in ${entry.cwd}.\n`);
-                process.stderr.write(`[remote] If another CLI is still writing this conversation, replacing can corrupt the .jsonl.\n`);
+                process.stderr.write(`[h2a] local session ${displaySlug} already exists.\n`);
+                process.stderr.write(`[h2a] pane appears idle; replacing it will kill tmux session ${local.name} and resume${entry.convId ? ` conversation ${entry.convId}` : ""} in ${entry.cwd}.\n`);
+                process.stderr.write(`[h2a] If another CLI is still writing this conversation, replacing can corrupt the .jsonl.\n`);
                 if (!(await confirmReplace(displaySlug))) {
-                    process.stderr.write(`[remote] takeover requires confirmation.\n`);
-                    process.stderr.write(`[remote] interactive: remote resume ${displaySlug}\n`);
-                    process.stderr.write(`[remote] explicit replace: remote resume ${displaySlug} --replace\n`);
-                    process.stderr.write(`[remote] manual path: remote stop ${displaySlug} --reason restart && remote resume ${displaySlug}\n`);
+                    process.stderr.write(`[h2a] takeover requires confirmation.\n`);
+                    process.stderr.write(`[h2a] interactive: h2a resume ${displaySlug}\n`);
+                    process.stderr.write(`[h2a] explicit replace: h2a resume ${displaySlug} --replace\n`);
+                    process.stderr.write(`[h2a] manual path: h2a stop ${displaySlug} --reason restart && h2a resume ${displaySlug}\n`);
                     process.exitCode = 1;
                     return;
                 }
             }
             const rechecked = findLocalSession(displaySlug);
             if (!rechecked) {
-                process.stderr.write(`[remote] local session ${displaySlug} changed state before replace; aborting.\n`);
+                process.stderr.write(`[h2a] local session ${displaySlug} changed state before replace; aborting.\n`);
                 process.exitCode = 1;
                 return;
             }
             if (!opts.replace && !localSessionIdle(rechecked.name)) {
-                process.stderr.write(`[remote] local session ${displaySlug} is no longer idle; aborting.\n`);
+                process.stderr.write(`[h2a] local session ${displaySlug} is no longer idle; aborting.\n`);
                 process.exitCode = 1;
                 return;
             }
@@ -3121,11 +3121,11 @@ export async function main(argv) {
                 }
             }
             if (!killLocalSession(rechecked.name)) {
-                process.stderr.write(`[remote] local session ${displaySlug} could not be killed; no new ${profile} was started.\n`);
+                process.stderr.write(`[h2a] local session ${displaySlug} could not be killed; no new ${profile} was started.\n`);
                 process.exitCode = 1;
                 return;
             }
-            process.stderr.write(`[remote] replaced local session ${displaySlug} (${rechecked.name})\n`);
+            process.stderr.write(`[h2a] replaced local session ${displaySlug} (${rechecked.name})\n`);
         }
         else {
             if (entry.convId) {
@@ -3153,19 +3153,19 @@ export async function main(argv) {
             ...(entry.convId ? { convId: entry.convId } : {}),
             ...(gatewayMode !== "auto" ? { gatewayMode } : {}),
         });
-        process.stderr.write(`[remote] resumed local session ${resumeSlug} (${profile} resume${entry.convId ? ` ${entry.convId}` : ""} in ${entry.cwd})\n`);
+        process.stderr.write(`[h2a] resumed local session ${resumeSlug} (${profile} resume${entry.convId ? ` ${entry.convId}` : ""} in ${entry.cwd})\n`);
         if (gateway) {
-            process.stderr.write(`[remote] gateway active: ${gateway}\n`);
+            process.stderr.write(`[h2a] gateway active: ${gateway}\n`);
         }
         if (opts.attach) {
             process.exitCode = attachLocalSession(name);
             return;
         }
-        process.stderr.write(`[remote] attach: remote attach ${resumeSlug}\n`);
+        process.stderr.write(`[h2a] attach: h2a attach ${resumeSlug}\n`);
     });
     program
         .command("run <profile> [path]")
-        .description("Start a LOCAL session in tmux (claude/codex/…) in <path> (default: cwd), then attach this terminal by default. Remote applies its embedded scroll-safe tmux profile at launch; no ~/.tmux.conf is required. Manage it like a remote one: `remote ls`, `remote attach <slug>`, `remote stop <slug>`. Detach with Ctrl-b d; the session keeps running.")
+        .description("Start a LOCAL session in tmux (claude/codex/…) in <path> (default: cwd), then attach this terminal by default. Remote applies its embedded scroll-safe tmux profile at launch; no ~/.tmux.conf is required. Manage it like a remote one: `h2a ls`, `h2a attach <slug>`, `h2a stop <slug>`. Detach with Ctrl-b d; the session keeps running.")
         .option("--no-attach", "start detached and print the attach command instead (for scripts / fan-out orchestration)")
         .option("-r, --resume <convId>", "resume a specific conversation in the CLI")
         .option("--force", "start even if the conversation already has a live writer (risk: conversation .jsonl corruption)")
@@ -3178,7 +3178,7 @@ export async function main(argv) {
         .option("--no-gw", "alias for --no-llm-gateway")
         .action(async (profile, path, opts) => {
         if (!tmuxAvailable()) {
-            process.stderr.write("[remote] tmux is not installed locally — `remote run` needs it (e.g. `sudo apt install tmux`).\n");
+            process.stderr.write("[h2a] tmux is not installed locally — `h2a run` needs it (e.g. `sudo apt install tmux`).\n");
             process.exitCode = 1;
             return;
         }
@@ -3186,14 +3186,14 @@ export async function main(argv) {
         if (opts.count !== undefined) {
             count = Number(opts.count);
             if (!Number.isInteger(count) || count < 1) {
-                process.stderr.write(`[remote] --count must be a whole number ≥ 1\n`);
+                process.stderr.write(`[h2a] --count must be a whole number ≥ 1\n`);
                 process.exitCode = 1;
                 return;
             }
             // Fanning out N agents on the SAME conversation = N writers on one
             // .jsonl (corruption). A fan-out is N FRESH conversations.
             if (count > 1 && opts.resume) {
-                process.stderr.write(`[remote] --count > 1 cannot combine with -r/--resume (each fanned agent is a fresh conversation; resuming one into N would corrupt it)\n`);
+                process.stderr.write(`[h2a] --count > 1 cannot combine with -r/--resume (each fanned agent is a fresh conversation; resuming one into N would corrupt it)\n`);
                 process.exitCode = 1;
                 return;
             }
@@ -3213,9 +3213,9 @@ export async function main(argv) {
             .filter((slug) => slug !== undefined);
         if (existingLocalSessions.length > 0) {
             for (const slug of existingLocalSessions) {
-                process.stderr.write(`[remote] local session ${slug} already exists; no new ${profile} was started.\n`);
-                process.stderr.write(`[remote] attach: remote attach ${slug}\n`);
-                process.stderr.write(`[remote] stop first: remote stop ${slug} --reason restart\n`);
+                process.stderr.write(`[h2a] local session ${slug} already exists; no new ${profile} was started.\n`);
+                process.stderr.write(`[h2a] attach: h2a attach ${slug}\n`);
+                process.stderr.write(`[h2a] stop first: h2a stop ${slug} --reason restart\n`);
             }
             process.exitCode = 1;
             return;
@@ -3244,7 +3244,7 @@ export async function main(argv) {
             gatewayMode = gatewayModeFromOptions(opts);
         }
         catch (error) {
-            process.stderr.write(`[remote] ${error.message}.\n`);
+            process.stderr.write(`[h2a] ${error.message}.\n`);
             process.exitCode = 1;
             return;
         }
@@ -3255,7 +3255,7 @@ export async function main(argv) {
             ? localResumeArgs(profile, opts.resume, { bare: useBare })
             : localStartArgs(profile, { bare: useBare });
         if (opts.resume && args.length === 0) {
-            process.stderr.write(`[remote] profile "${profile}" has no verified local resume argv; start it without -r/--resume\n`);
+            process.stderr.write(`[h2a] profile "${profile}" has no verified local resume argv; start it without -r/--resume\n`);
             process.exitCode = 1;
             return;
         }
@@ -3279,22 +3279,22 @@ export async function main(argv) {
             // it the default. Never fails the run.
             if (opts.h2a || h2a.enabled) {
                 if (startH2aWindow(name, cwd, h2a.command)) {
-                    process.stderr.write(`[remote] h2a window started in ${slug} (${h2a.command})\n`);
+                    process.stderr.write(`[h2a] h2a window started in ${slug} (${h2a.command})\n`);
                 }
             }
         }
         if (count > 1) {
-            process.stderr.write(`[remote] ${started.length} ${profile} agents started in ${cwd}: ${started.map((s) => s.slug).join(", ")}\n` +
-                `[remote] attach one with: remote attach <slug>\n`);
+            process.stderr.write(`[h2a] ${started.length} ${profile} agents started in ${cwd}: ${started.map((s) => s.slug).join(", ")}\n` +
+                `[h2a] attach one with: h2a attach <slug>\n`);
             return; // never auto-attach a fleet
         }
         const only = started[0];
-        process.stderr.write(`[remote] local session ${only.slug} started (${profile}${opts.resume ? ` --resume ${opts.resume}` : ""} in ${cwd})\n`);
+        process.stderr.write(`[h2a] local session ${only.slug} started (${profile}${opts.resume ? ` --resume ${opts.resume}` : ""} in ${cwd})\n`);
         // Single local runs hand off the terminal by default: there is no value
         // in making users type a second `remote attach <slug>` command. Commander
         // sets opts.attach=false only for --no-attach.
         if (opts.attach === false) {
-            process.stderr.write(`[remote] attach with: remote attach ${only.slug}\n`);
+            process.stderr.write(`[h2a] attach with: h2a attach ${only.slug}\n`);
             return;
         }
         process.exitCode = attachLocalSession(only.name);
@@ -3320,7 +3320,7 @@ export async function main(argv) {
         .option("--account <id>", "force a specific account from the pool (bypass selectAccountWithFallback). E.g. claude-code-1234567890.")
         .action(async (type, task, opts) => {
         if (!isDelegateType(type)) {
-            process.stderr.write(`[remote] unknown agent type "${type}" (use: claude | codex | agy)\n`);
+            process.stderr.write(`[h2a] unknown agent type "${type}" (use: claude | codex | agy)\n`);
             process.exitCode = 1;
             return;
         }
@@ -3332,7 +3332,7 @@ export async function main(argv) {
             assertSafeName(jobId);
         }
         catch (err) {
-            process.stderr.write(`[remote] ${err.message}\n`);
+            process.stderr.write(`[h2a] ${err.message}\n`);
             process.exitCode = 1;
             return;
         }
@@ -3345,7 +3345,7 @@ export async function main(argv) {
             : undefined;
         const depthBudget = inheritedDepthBudget(requestedDepth, process.env);
         if (!canDelegateAtDepth(depthBudget)) {
-            process.stderr.write("[remote] spawn-depth budget exhausted (REMOTE_DELEGATE_DEPTH=0) — this job has reached its --max-depth and may not delegate further.\n");
+            process.stderr.write("[h2a] spawn-depth budget exhausted (REMOTE_DELEGATE_DEPTH=0) — this job has reached its --max-depth and may not delegate further.\n");
             process.exitCode = 1;
             return;
         }
@@ -3370,13 +3370,13 @@ export async function main(argv) {
                 remoteTarget = getConfiguredRemote(typeof opts.remote === "string" ? opts.remote : undefined);
             }
             catch (err) {
-                process.stderr.write(`[remote] ${err.message}\n`);
+                process.stderr.write(`[h2a] ${err.message}\n`);
                 process.exitCode = 1;
                 return;
             }
         }
         else if (!tmuxAvailable()) {
-            process.stderr.write("[remote] tmux is not installed locally — local `remote delegate` needs it (use --remote for a Pod).\n");
+            process.stderr.write("[h2a] tmux is not installed locally — local `h2a delegate` needs it (use --remote for a Pod).\n");
             process.exitCode = 1;
             return;
         }
@@ -3444,7 +3444,7 @@ export async function main(argv) {
         }
         if (!claimed && listJobs().some((e) => e.id === jobId)) {
             // The entry exists but the cap is full → stay queued.
-            process.stderr.write(`[remote] queued job ${jobId} (${jobType}${opts.headless ? " headless" : ""}${isRemote ? " remote" : ""}) — ` +
+            process.stderr.write(`[h2a] queued job ${jobId} (${jobType}${opts.headless ? " headless" : ""}${isRemote ? " remote" : ""}) — ` +
                 `${effectiveCap} concurrent slot(s) busy. Start it with: remote jobs conduct\n`);
             process.stdout.write(`${jobId}\n`);
             return;
@@ -3452,7 +3452,7 @@ export async function main(argv) {
         if (!claimed) {
             // Registry write failed entirely (no entry at all) — fall back to a
             // throwaway in-memory entry so the launch still happens.
-            process.stderr.write(`[remote] job ${jobId} not in registry after enroll — launching from an in-memory spec\n`);
+            process.stderr.write(`[h2a] job ${jobId} not in registry after enroll — launching from an in-memory spec\n`);
         }
         const launchEntry = claimed ??
             {
@@ -3484,12 +3484,12 @@ export async function main(argv) {
             // only reclaim it on a later reconcile pass).
             if (claimed)
                 advanceJob(jobId, "failed");
-            process.stderr.write(`[remote] failed to start job ${jobId}: ${result.error}\n`);
+            process.stderr.write(`[h2a] failed to start job ${jobId}: ${result.error}\n`);
             process.exitCode = 1;
             return;
         }
-        process.stderr.write(`[remote] delegated ${result.target === "remote" ? "REMOTE " : ""}job ${jobId} (${jobType}${opts.headless ? " headless" : ""}) ${result.target === "remote" ? "→ " : "in "}${result.detail}\n` +
-            `[remote] supervise: remote jobs status ${jobId}` +
+        process.stderr.write(`[h2a] delegated ${result.target === "remote" ? "REMOTE " : ""}job ${jobId} (${jobType}${opts.headless ? " headless" : ""}) ${result.target === "remote" ? "→ " : "in "}${result.detail}\n` +
+            `[h2a] supervise: remote jobs status ${jobId}` +
             (opts.headless ? "" : `   attach: remote jobs attach ${jobId}`) +
             "\n");
         process.stdout.write(`${jobId}\n`);
@@ -3517,7 +3517,7 @@ export async function main(argv) {
         const projection = buildAgentsProjection();
         const agent = findProjectedAgent(projection.agents, id);
         if (!agent) {
-            process.stderr.write(`[remote] no projected agent \"${id}\" (see: remote agents ls --json)\n`);
+            process.stderr.write(`[h2a] no projected agent \"${id}\" (see: h2a agents ls --json)\n`);
             process.exitCode = 1;
             return;
         }
@@ -3528,7 +3528,7 @@ export async function main(argv) {
     // ---------------------------------------------------------------------------
     const jobsCommand = program
         .command("jobs")
-        .description("Supervise delegated agent jobs (see `remote delegate`).");
+        .description("Supervise delegated agent jobs (see `h2a delegate`).");
     const jobLive = (e) => isLive(e);
     // S1 — resolve the `actor.instance` a job envelope MUST carry to be trusted,
     // off the registry: `job.done`/`decision.requested` (ABOUT the job) must come
@@ -3627,7 +3627,7 @@ export async function main(argv) {
         if (step.action === "fail") {
             const advanced = advanceJob(job.id, "failed");
             if (advanced) {
-                process.stderr.write(`[remote] job ${job.id} (${job.tool}) failed: rate-limited ` +
+                process.stderr.write(`[h2a] job ${job.id} (${job.tool}) failed: rate-limited ` +
                     `(gave up after ${job.throttle?.attempts ?? THROTTLE_MAX_ATTEMPTS} resume attempts)\n`);
                 emitJobDone(advanced, { state: "failed" });
                 realizeTrackMirror(advanced);
@@ -3655,7 +3655,7 @@ export async function main(argv) {
             return { entries, result: true };
         });
         if (ok) {
-            process.stderr.write(`[remote] job ${job.id} (${job.tool}) throttled (${verdict.signature ?? "rate-limited"}) — ` +
+            process.stderr.write(`[h2a] job ${job.id} (${job.tool}) throttled (${verdict.signature ?? "rate-limited"}) — ` +
                 `attempt ${step.attempts}/${THROTTLE_MAX_ATTEMPTS}, resume at ${step.nextRetryAt}\n`);
         }
         return ok;
@@ -3805,7 +3805,7 @@ export async function main(argv) {
         await reconcileJobs();
         const job = listJobs().find((e) => e.id === id);
         if (!job) {
-            process.stderr.write(`[remote] no job "${id}" (see: remote jobs ls)\n`);
+            process.stderr.write(`[h2a] no job "${id}" (see: remote jobs ls)\n`);
             process.exitCode = 1;
             return;
         }
@@ -3854,7 +3854,7 @@ export async function main(argv) {
     });
     jobsCommand
         .command("attach <id>")
-        .description("Attach into the job's tmux session (Ctrl-b d to detach). Remote jobs exec into the Pod's tmux, like `remote attach <id> --exec`.")
+        .description("Attach into the job's tmux session (Ctrl-b d to detach). Remote jobs exec into the Pod's tmux, like `h2a attach <id> --exec`.")
         .action(async (id) => {
         const job = listJobs().find((e) => e.id === id);
         // REMOTE job (P2): exec into the Pod's tmux over the configured tunnel,
@@ -3862,13 +3862,13 @@ export async function main(argv) {
         if (job?.kind === "remote") {
             const remoteId = job.remoteId;
             if (!remoteId) {
-                process.stderr.write(`[remote] remote job "${id}" has no session id recorded (see: remote jobs status ${id})\n`);
+                process.stderr.write(`[h2a] remote job "${id}" has no session id recorded (see: remote jobs status ${id})\n`);
                 process.exitCode = 1;
                 return;
             }
             const tunnel = getTunnel();
             if (!tunnel) {
-                process.stderr.write("[remote] attaching a remote job needs a tunnel configured (remote config tunnel …)\n");
+                process.stderr.write("[h2a] attaching a remote job needs a tunnel configured (h2a config tunnel …)\n");
                 process.exitCode = 1;
                 return;
             }
@@ -3878,14 +3878,14 @@ export async function main(argv) {
             catch {
                 // best-effort: the kubectl exec below works off the tunnel regardless
             }
-            process.stderr.write(`[remote] exec-attaching into Pod tmux for job ${id} (${remoteId}) (Ctrl-b d to detach)\n`);
+            process.stderr.write(`[h2a] exec-attaching into Pod tmux for job ${id} (${remoteId}) (Ctrl-b d to detach)\n`);
             process.exitCode = attachPodTmux(tunnel, remoteId);
             return;
         }
         // LOCAL job (P1): attach into the detached tmux session.
         const name = job?.tmuxSession ?? localSessionName(id);
         if (!findLocalSession(name)) {
-            process.stderr.write(`[remote] no live tmux session for job "${id}" (it may have ended; see: remote jobs status ${id})\n`);
+            process.stderr.write(`[h2a] no live tmux session for job "${id}" (it may have ended; see: remote jobs status ${id})\n`);
             process.exitCode = 1;
             return;
         }
@@ -3897,7 +3897,7 @@ export async function main(argv) {
         .action((id) => {
         const job = listJobs().find((e) => e.id === id);
         if (!job) {
-            process.stderr.write(`[remote] no job "${id}" (see: remote jobs ls)\n`);
+            process.stderr.write(`[h2a] no job "${id}" (see: remote jobs ls)\n`);
             process.exitCode = 1;
             return;
         }
@@ -3909,7 +3909,7 @@ export async function main(argv) {
         }
         // REMOTE job: the output lives in the Pod's tmux, not a local pane.
         if (job.kind === "remote") {
-            process.stderr.write(`[remote] remote job "${id}" runs in a Pod — view it live with: remote jobs attach ${id}\n`);
+            process.stderr.write(`[h2a] remote job "${id}" runs in a Pod — view it live with: remote jobs attach ${id}\n`);
             process.exitCode = 1;
             return;
         }
@@ -3919,7 +3919,7 @@ export async function main(argv) {
             process.stdout.write(pane);
             return;
         }
-        process.stderr.write(`[remote] no logs for job "${id}" (no output.log and the tmux pane is gone)\n`);
+        process.stderr.write(`[h2a] no logs for job "${id}" (no output.log and the tmux pane is gone)\n`);
         process.exitCode = 1;
     });
     // P3 — the decision channel (h2a). A delegated INTERACTIVE job can emit a
@@ -3937,7 +3937,7 @@ export async function main(argv) {
             envelopes = authenticateJobEnvelopes(readInboxEnvelopes(), expectedInstanceOf);
         }
         catch (error) {
-            process.stderr.write(`[remote] cannot read the h2a inbox: ${(error instanceof Error ? error.message : String(error)).slice(0, 160)}\n`);
+            process.stderr.write(`[h2a] cannot read the h2a inbox: ${(error instanceof Error ? error.message : String(error)).slice(0, 160)}\n`);
             process.exitCode = 1;
             return;
         }
@@ -3954,13 +3954,13 @@ export async function main(argv) {
             assertSafeName(jobId);
         }
         catch (err) {
-            process.stderr.write(`[remote] ${err.message}\n`);
+            process.stderr.write(`[h2a] ${err.message}\n`);
             process.exitCode = 1;
             return;
         }
         const job = listJobs().find((e) => e.id === jobId);
         if (!job) {
-            process.stderr.write(`[remote] no job "${jobId}" (see: remote jobs ls)\n`);
+            process.stderr.write(`[h2a] no job "${jobId}" (see: remote jobs ls)\n`);
             process.exitCode = 1;
             return;
         }
@@ -3972,13 +3972,13 @@ export async function main(argv) {
         });
         try {
             const { path, written } = dropEnvelope(envelope, envelopeFileName("decision.reply", jobId, Date.now()));
-            process.stderr.write(`[remote] decision.reply for ${jobId} → ${envelope.to}` +
+            process.stderr.write(`[h2a] decision.reply for ${jobId} → ${envelope.to}` +
                 `${written ? "" : " (already present, not overwritten)"}\n` +
-                `[remote] envelope: ${path}\n` +
-                `[remote] delivered to the job's Pod on the next: remote h2a bridge\n`);
+                `[h2a] envelope: ${path}\n` +
+                `[h2a] delivered to the job's Pod on the next: remote h2a bridge\n`);
         }
         catch (error) {
-            process.stderr.write(`[remote] failed to write decision.reply: ${(error instanceof Error ? error.message : String(error)).slice(0, 160)}\n`);
+            process.stderr.write(`[h2a] failed to write decision.reply: ${(error instanceof Error ? error.message : String(error)).slice(0, 160)}\n`);
             process.exitCode = 1;
         }
     });
@@ -4033,10 +4033,10 @@ export async function main(argv) {
             const r = resumeThrottledJob(job);
             if (r.started) {
                 resumed += 1;
-                process.stderr.write(`[remote] conduct: resumed throttled ${job.id} (${job.tool}) in ${r.detail}\n`);
+                process.stderr.write(`[h2a] conduct: resumed throttled ${job.id} (${job.tool}) in ${r.detail}\n`);
             }
             else {
-                process.stderr.write(`[remote] conduct: could not resume throttled ${job.id}: ${r.error}\n`);
+                process.stderr.write(`[h2a] conduct: could not resume throttled ${job.id}: ${r.error}\n`);
             }
         }
         // AIMD effective cap: a provider rate-limit is account-wide, so admit FEWER
@@ -4046,7 +4046,7 @@ export async function main(argv) {
         const effectiveCap = aimdEffectiveCap(cap, recentThrottleEvents(refreshed), nowMs, aimdLastCap);
         aimdLastCap = effectiveCap;
         if (effectiveCap < cap) {
-            process.stderr.write(`[remote] conduct: AIMD breaker — admitting up to ${effectiveCap}/${cap} (rate-limit pressure)\n`);
+            process.stderr.write(`[h2a] conduct: AIMD breaker — admitting up to ${effectiveCap}/${cap} (rate-limit pressure)\n`);
         }
         // (b) start pending jobs under the EFFECTIVE cap (oldest-first FIFO).
         let started = 0;
@@ -4057,13 +4057,13 @@ export async function main(argv) {
             const result = await startJob(job);
             if (result.started) {
                 started += 1;
-                process.stderr.write(`[remote] conduct: started ${id} (${job.tool}) ${result.target === "remote" ? "→ " : "in "}${result.detail}\n`);
+                process.stderr.write(`[h2a] conduct: started ${id} (${job.tool}) ${result.target === "remote" ? "→ " : "in "}${result.detail}\n`);
             }
             else {
                 // A launch failure fails the job (frees nothing it didn't hold) so the
                 // queue keeps moving; the error is recorded on stderr.
                 advanceJob(id, "failed");
-                process.stderr.write(`[remote] conduct: failed to start ${id}: ${result.error}\n`);
+                process.stderr.write(`[h2a] conduct: failed to start ${id}: ${result.error}\n`);
             }
         }
         // Count a resume as "started" work for the pass recap.
@@ -4071,7 +4071,7 @@ export async function main(argv) {
     };
     jobsCommand
         .command("conduct")
-        .description("Conductor: reconcile job state, consume finished jobs, and START queued (pending) jobs while running < cap — the SAME launch path as `remote delegate`. One pass by default; `--watch <min>` loops in the FOREGROUND (run in a dedicated tmux window, no daemon; Ctrl-C to stop).")
+        .description("Conductor: reconcile job state, consume finished jobs, and START queued (pending) jobs while running < cap — the SAME launch path as `h2a delegate`. One pass by default; `--watch <min>` loops in the FOREGROUND (run in a dedicated tmux window, no daemon; Ctrl-C to stop).")
         .option("--watch <minutes>", "loop in the foreground every <minutes> (whole number >= 1); without it, runs a single pass and exits")
         .option("--max-concurrent <n>", "concurrency cap (default: config maxConcurrent / REMOTE_MAX_CONCURRENT / 16)")
         .option("--max-depth <d>", "spawn-depth budget recorded for jobs this conductor starts (clamp 1–3, default: each job's recorded budget)")
@@ -4091,10 +4091,10 @@ export async function main(argv) {
         const minutes = opts.watch === undefined ? undefined : parseWatchMinutes(opts.watch);
         if (minutes === undefined) {
             const { started, finished } = await conductPass(cap);
-            process.stderr.write(`[remote] conduct: cap ${cap} — ${started} started, ${finished} finished\n`);
+            process.stderr.write(`[h2a] conduct: cap ${cap} — ${started} started, ${finished} finished\n`);
             return;
         }
-        process.stderr.write(`[remote] conducting (cap ${cap}, every ${minutes} min) — Ctrl-C to stop\n`);
+        process.stderr.write(`[h2a] conducting (cap ${cap}, every ${minutes} min) — Ctrl-C to stop\n`);
         process.exitCode = await conductLoop(minutes, () => conductPass(cap));
     });
     // ---------------------------------------------------------------------------
@@ -4184,7 +4184,7 @@ export async function main(argv) {
         // proceed — the envelope's workspaceId is authoritative for the launch.
         const localId = localDurableWorkspaceId();
         if (localId && localId !== request.workspaceId) {
-            process.stderr.write(`[remote] conductor-launch: workspace id mismatch — envelope ${request.workspaceId} vs local ${localId} ` +
+            process.stderr.write(`[h2a] conductor-launch: workspace id mismatch — envelope ${request.workspaceId} vs local ${localId} ` +
                 `(proceeding with the envelope's id; align canonicalization with a2a-cli)\n`);
         }
         const liveConductors = countLiveConductors(request.workspaceId, slug);
@@ -4199,7 +4199,7 @@ export async function main(argv) {
         if (!gate.launch) {
             if (confirm)
                 markLaunchEnvelopeProcessed(env.path, `skip: ${gate.reason}`);
-            process.stderr.write(`[remote] conductor-launch: SKIP — ${gate.reason}\n`);
+            process.stderr.write(`[h2a] conductor-launch: SKIP — ${gate.reason}\n`);
             return { launched: false, detail: gate.reason };
         }
         const available = detectAvailableHosts();
@@ -4208,12 +4208,12 @@ export async function main(argv) {
             const detail = `no preferred host available on PATH (wanted ${request.hostPref.join("/")}, found ${[...available].join("/") || "none"})`;
             if (confirm)
                 markLaunchEnvelopeProcessed(env.path, `skip: ${detail}`);
-            process.stderr.write(`[remote] conductor-launch: SKIP — ${detail}\n`);
+            process.stderr.write(`[h2a] conductor-launch: SKIP — ${detail}\n`);
             return { launched: false, detail };
         }
         const task = buildConductorTask(request);
         if (!confirm) {
-            process.stderr.write(`[remote] conductor-launch DRY-RUN — would launch a ${host} conductor "${slug}" ` +
+            process.stderr.write(`[h2a] conductor-launch DRY-RUN — would launch a ${host} conductor "${slug}" ` +
                 `for ${request.workspaceId} (${request.stalled.length} stalled item(s)). ` +
                 `Re-run with --confirm to launch.\n`);
             return { launched: false, detail: `dry-run (${host})` };
@@ -4258,18 +4258,18 @@ export async function main(argv) {
             : `launch-failed: ${result.error}`);
         if (!result.started) {
             advanceJob(slug, "failed");
-            process.stderr.write(`[remote] conductor-launch: FAILED to launch ${slug}: ${result.error}\n`);
+            process.stderr.write(`[h2a] conductor-launch: FAILED to launch ${slug}: ${result.error}\n`);
             return { launched: false, detail: result.error };
         }
-        process.stderr.write(`[remote] conductor-launch: launched ${host} conductor ${slug} for ${request.workspaceId} in ${result.detail}\n` +
-            `[remote] supervise: remote jobs status ${slug}   attach: remote jobs attach ${slug}\n`);
+        process.stderr.write(`[h2a] conductor-launch: launched ${host} conductor ${slug} for ${request.workspaceId} in ${result.detail}\n` +
+            `[h2a] supervise: remote jobs status ${slug}   attach: remote jobs attach ${slug}\n`);
         return { launched: true, detail: `${host} ${slug}` };
     };
     /** One pass: handle the freshest unprocessed launch envelope (or report none). */
     const launchPass = async (confirm, cooldownMs) => {
         const fresh = freshestLaunchEnvelope(readLaunchEnvelopes());
         if (!fresh) {
-            process.stderr.write("[remote] conductor-launch: no unprocessed conductor-launch-request in the h2a inbox\n");
+            process.stderr.write("[h2a] conductor-launch: no unprocessed conductor-launch-request in the h2a inbox\n");
             return { started: 0, finished: 0 };
         }
         const r = await processLaunchRequest(fresh, confirm, cooldownMs);
@@ -4277,7 +4277,7 @@ export async function main(argv) {
     };
     program
         .command("conductor-launch")
-        .description("Handle an h2a `conductor-launch-request` envelope: when h2a reports stalled work and no live conductor, launch one (claude/codex/agy, first available on PATH) via the same delegation path as `remote delegate`, instructed to claim the conductor role at boot. DRY-RUN unless --confirm. Idempotent (skips when a conductor is already alive) and rate-limited per workspace (cooldown). One pass by default; --watch loops in the FOREGROUND (no daemon; Ctrl-C to stop).")
+        .description("Handle an h2a `conductor-launch-request` envelope: when h2a reports stalled work and no live conductor, launch one (claude/codex/agy, first available on PATH) via the same delegation path as `h2a delegate`, instructed to claim the conductor role at boot. DRY-RUN unless --confirm. Idempotent (skips when a conductor is already alive) and rate-limited per workspace (cooldown). One pass by default; --watch loops in the FOREGROUND (no daemon; Ctrl-C to stop).")
         .option("--confirm", "actually launch (default: dry-run — decide and print what WOULD launch, launch nothing)")
         .option("--watch <minutes>", "loop in the foreground every <minutes> (whole number >= 1); without it, runs a single pass and exits")
         .option("--cooldown <min>", "minimum minutes between launches for the SAME workspace (default 30)")
@@ -4290,13 +4290,13 @@ export async function main(argv) {
         const cooldownMs = cooldownMin * 60_000;
         const minutes = opts.watch === undefined ? undefined : parseWatchMinutes(opts.watch);
         if (!confirm) {
-            process.stderr.write("[remote] conductor-launch: DRY-RUN (no --confirm) — nothing will be launched\n");
+            process.stderr.write("[h2a] conductor-launch: DRY-RUN (no --confirm) — nothing will be launched\n");
         }
         if (minutes === undefined) {
             await launchPass(confirm, cooldownMs);
             return;
         }
-        process.stderr.write(`[remote] conductor-launch watching (every ${minutes} min, cooldown ${cooldownMin} min${confirm ? "" : ", DRY-RUN"}) — Ctrl-C to stop\n`);
+        process.stderr.write(`[h2a] conductor-launch watching (every ${minutes} min, cooldown ${cooldownMin} min${confirm ? "" : ", DRY-RUN"}) — Ctrl-C to stop\n`);
         process.exitCode = await conductLoop(minutes, () => launchPass(confirm, cooldownMs));
     });
     // ---------------------------------------------------------------------------
@@ -4417,12 +4417,12 @@ export async function main(argv) {
             const lastWake = readWakeStampMs(localRoot, target);
             if (lastWake !== undefined &&
                 now - lastWake < WAKE_REQUEST_IDEMPOTENCE_MS) {
-                process.stderr.write(`[remote] wake-request: skipping ${target} (already woken ${Math.round((now - lastWake) / 1000)}s ago)\n`);
+                process.stderr.write(`[h2a] wake-request: skipping ${target} (already woken ${Math.round((now - lastWake) / 1000)}s ago)\n`);
                 continue;
             }
             const pane = resolveAgentPaneForInstance(target);
             if (!pane) {
-                process.stderr.write(`[remote] wake-request: no agent pane for ${target} — not launched by remote, skipping (reason: ${reason || "none"})\n`);
+                process.stderr.write(`[h2a] wake-request: no agent pane for ${target} — not launched by remote, skipping (reason: ${reason || "none"})\n`);
                 continue;
             }
             // Guard (h2a 0.74.0 parity): defer send-keys if a human was active in the
@@ -4441,7 +4441,7 @@ export async function main(argv) {
                             .map((s) => Number.parseInt(s.trim(), 10) * 1000)
                             .filter((n) => !Number.isNaN(n)));
                         if (maxActivity > now - 4000) {
-                            process.stderr.write(`[remote] wake-request: deferring ${target} — human active ${Math.round((now - maxActivity) / 1000)}s ago, retrying next pass\n`);
+                            process.stderr.write(`[h2a] wake-request: deferring ${target} — human active ${Math.round((now - maxActivity) / 1000)}s ago, retrying next pass\n`);
                             continue;
                         }
                     }
@@ -4466,7 +4466,7 @@ export async function main(argv) {
             markLaunchEnvelopeProcessed(envelopePath, `woke ${target}`);
             writeWakeStampMs(localRoot, target, now);
             woken += 1;
-            process.stderr.write(`[remote] wake-request: woke ${target} → pane ${pane} (reason: ${reason || "none"})\n`);
+            process.stderr.write(`[h2a] wake-request: woke ${target} → pane ${pane} (reason: ${reason || "none"})\n`);
         }
         return woken;
     };
@@ -4482,7 +4482,7 @@ export async function main(argv) {
         .option("--interval <seconds>", "poll interval in seconds (default: 30)", "30")
         .action(async (opts) => {
         if (!tmuxAvailable()) {
-            process.stderr.write("[remote] tmux is not installed locally\n");
+            process.stderr.write("[h2a] tmux is not installed locally\n");
             process.exitCode = 1;
             return;
         }
@@ -4490,10 +4490,10 @@ export async function main(argv) {
         const intervalMs = Math.max(1, Number.parseInt(opts.interval ?? "30", 10)) * 1000;
         if (!opts.watch) {
             const woken = wakeRequestPass(localRoot);
-            process.stderr.write(`[remote] wake-request: ${woken} pane(s) woken this pass\n`);
+            process.stderr.write(`[h2a] wake-request: ${woken} pane(s) woken this pass\n`);
             return;
         }
-        process.stderr.write(`[remote] wake-request watching (every ${Math.round(intervalMs / 1000)}s) — Ctrl-C to stop\n`);
+        process.stderr.write(`[h2a] wake-request watching (every ${Math.round(intervalMs / 1000)}s) — Ctrl-C to stop\n`);
         let stopped = false;
         const onSigint = () => {
             stopped = true;
@@ -4502,7 +4502,7 @@ export async function main(argv) {
         try {
             while (!stopped) {
                 const woken = wakeRequestPass(localRoot);
-                process.stderr.write(`[remote] wake-request: ${woken} pane(s) woken — ${new Date().toISOString()}\n`);
+                process.stderr.write(`[h2a] wake-request: ${woken} pane(s) woken — ${new Date().toISOString()}\n`);
                 if (stopped)
                     break;
                 await new Promise((resolve) => {
@@ -4517,7 +4517,7 @@ export async function main(argv) {
         finally {
             process.removeListener("SIGINT", onSigint);
         }
-        process.stderr.write("[remote] wake-request watch stopped\n");
+        process.stderr.write("[h2a] wake-request watch stopped\n");
     });
     // ---------------------------------------------------------------------------
     // relaunch — bring idle local sessions back in situ, each resuming its OWN conv
@@ -4528,7 +4528,7 @@ export async function main(argv) {
         .option("--apply", "actually relaunch (default: dry-run, just print the plan)")
         .action((filter, opts) => {
         if (!tmuxAvailable()) {
-            process.stderr.write("[remote] tmux is not installed locally\n");
+            process.stderr.write("[h2a] tmux is not installed locally\n");
             process.exitCode = 1;
             return;
         }
@@ -4549,14 +4549,14 @@ export async function main(argv) {
                 : {}),
         })));
         if (plan.actions.length === 0) {
-            process.stderr.write(`[remote] nothing to relaunch${filter ? ` matching "${filter}"` : ""} (${plan.skipped.length} skipped)\n`);
+            process.stderr.write(`[h2a] nothing to relaunch${filter ? ` matching "${filter}"` : ""} (${plan.skipped.length} skipped)\n`);
             for (const s of plan.skipped) {
                 process.stderr.write(`  - ${s.slug}: ${s.reason}\n`);
             }
             return;
         }
         if (!opts.apply) {
-            process.stderr.write(`[remote] would relaunch ${plan.actions.length} session(s) — dry-run, pass --apply:\n`);
+            process.stderr.write(`[h2a] would relaunch ${plan.actions.length} session(s) — dry-run, pass --apply:\n`);
             for (const a of plan.actions) {
                 process.stderr.write(`  ${a.slug}: ${a.cmd}\n`);
             }
@@ -4569,13 +4569,13 @@ export async function main(argv) {
         for (const a of plan.actions) {
             if (relaunchInSession(a.name, a.cmd)) {
                 ok += 1;
-                process.stderr.write(`[remote] relaunched ${a.slug}: ${a.cmd}\n`);
+                process.stderr.write(`[h2a] relaunched ${a.slug}: ${a.cmd}\n`);
             }
             else {
-                process.stderr.write(`[remote] FAILED to relaunch ${a.slug}\n`);
+                process.stderr.write(`[h2a] FAILED to relaunch ${a.slug}\n`);
             }
         }
-        process.stderr.write(`[remote] relaunched ${ok}/${plan.actions.length}${plan.skipped.length ? `, ${plan.skipped.length} skipped` : ""}\n`);
+        process.stderr.write(`[h2a] relaunched ${ok}/${plan.actions.length}${plan.skipped.length ? `, ${plan.skipped.length} skipped` : ""}\n`);
     });
     // ---------------------------------------------------------------------------
     // Reliability slice 2 (throttle phase 2) — auto-resume RATE-LIMITED INTERACTIVE
@@ -4675,17 +4675,17 @@ export async function main(argv) {
                 // already excluded attached panes, but re-read in case a human just
                 // attached between capture and nudge — belt and braces on a live pane).
                 if (!isDetachedNow(r.name)) {
-                    process.stderr.write(`[remote] ${r.name} (${r.type}) just got attached — skipping the nudge\n`);
+                    process.stderr.write(`[h2a] ${r.name} (${r.type}) just got attached — skipping the nudge\n`);
                     continue;
                 }
                 const ok = relaunchInSession(r.name, interactiveResumeNudge(r.type));
                 if (ok) {
                     nudged += 1;
                     throttleState.set(r.name, r.next);
-                    process.stderr.write(`[remote] nudged ${r.name} (${r.type}) — continue (attempt ${r.next.attempts})\n`);
+                    process.stderr.write(`[h2a] nudged ${r.name} (${r.type}) — continue (attempt ${r.next.attempts})\n`);
                 }
                 else {
-                    process.stderr.write(`[remote] FAILED to nudge ${r.name}\n`);
+                    process.stderr.write(`[h2a] FAILED to nudge ${r.name}\n`);
                 }
             }
         }
@@ -4699,7 +4699,7 @@ export async function main(argv) {
         .option("--max-concurrent <n>", "AIMD cap: max sessions nudged per pass (default: config maxConcurrent / REMOTE_MAX_CONCURRENT / 16)")
         .action(async (filter, opts) => {
         if (!tmuxAvailable()) {
-            process.stderr.write("[remote] tmux is not installed locally\n");
+            process.stderr.write("[h2a] tmux is not installed locally\n");
             process.exitCode = 1;
             return;
         }
@@ -4719,11 +4719,11 @@ export async function main(argv) {
             for (const line of plan.advisories)
                 process.stderr.write(`${line}\n`);
             if (!apply) {
-                process.stderr.write(`[remote] DRY-RUN — would resume ${plan.toResume.length} session(s) ` +
+                process.stderr.write(`[h2a] DRY-RUN — would resume ${plan.toResume.length} session(s) ` +
                     `(${plan.throttled.length} throttled, cap ${cap}). Pass --apply to nudge them.\n`);
             }
             else {
-                process.stderr.write(`[remote] resume-throttled: nudged ${nudged}/${plan.toResume.length} ` +
+                process.stderr.write(`[h2a] resume-throttled: nudged ${nudged}/${plan.toResume.length} ` +
                     `(${plan.throttled.length} throttled, cap ${cap})\n`);
             }
             return { failed: 0 };
@@ -4732,7 +4732,7 @@ export async function main(argv) {
             runOnce();
             return;
         }
-        process.stderr.write(`[remote] resume-throttled watching (cap ${cap}, every ${minutes} min) — Ctrl-C to stop\n`);
+        process.stderr.write(`[h2a] resume-throttled watching (cap ${cap}, every ${minutes} min) — Ctrl-C to stop\n`);
         process.exitCode = await watchRefreshLoop(minutes, async () => runOnce());
     });
     // ---------------------------------------------------------------------------
@@ -4756,14 +4756,14 @@ export async function main(argv) {
             cwd: process.cwd(),
             ...(opts.root !== undefined ? { localRoot: opts.root } : {}),
         });
-        process.stderr.write(`[remote] h2a ping ${ping.written ? "queued" : "already queued"} for ${instance}: ${ping.path}\n`);
+        process.stderr.write(`[h2a] h2a ping ${ping.written ? "queued" : "already queued"} for ${instance}: ${ping.path}\n`);
         if (opts.bridge === undefined)
             return;
         const sessionId = typeof opts.bridge === "string"
             ? opts.bridge
             : remoteSessionIdFromInstance(instance);
         if (!sessionId) {
-            process.stderr.write("[remote] --bridge needs a session id, or an instance shaped like <tool>:remote:<sessionId>\n");
+            process.stderr.write("[h2a] --bridge needs a session id, or an instance shaped like <tool>:remote:<sessionId>\n");
             process.exitCode = 1;
             return;
         }
@@ -4774,13 +4774,13 @@ export async function main(argv) {
         const { bridgeSession } = await import("./h2a-bridge.js");
         try {
             const r = await bridgeSession(sessionId, { profile });
-            process.stderr.write(`[remote] h2a bridge ${sessionId} (${profile}) pulled=${r.pulled} pushed=${r.pushed} skipped=${r.skipped}` +
+            process.stderr.write(`[h2a] h2a bridge ${sessionId} (${profile}) pulled=${r.pulled} pushed=${r.pushed} skipped=${r.skipped}` +
                 `${r.failed > 0 ? ` failed=${r.failed}` : ""}\n`);
             if (r.failed > 0)
                 process.exitCode = 1;
         }
         catch (error) {
-            process.stderr.write(`[remote] h2a bridge ${sessionId} failed: ${(error instanceof Error ? error.message : String(error)).slice(0, 200)}\n`);
+            process.stderr.write(`[h2a] h2a bridge ${sessionId} failed: ${(error instanceof Error ? error.message : String(error)).slice(0, 200)}\n`);
             process.exitCode = 1;
         }
     });
@@ -4821,7 +4821,7 @@ export async function main(argv) {
                     profile: s.profile,
                 }));
             if (sessions.length === 0) {
-                process.stderr.write("[remote] no live remote sessions to bridge\n");
+                process.stderr.write("[h2a] no live remote sessions to bridge\n");
                 return { failed: 0 };
             }
             let failed = 0;
@@ -4841,13 +4841,13 @@ export async function main(argv) {
                     const r = await bridgeSession(s.id, { profile: s.profile });
                     if (r.failed > 0)
                         failed += 1;
-                    process.stderr.write(`[remote] h2a bridge ${s.id} (${s.profile}) pulled=${r.pulled} pushed=${r.pushed} skipped=${r.skipped}` +
+                    process.stderr.write(`[h2a] h2a bridge ${s.id} (${s.profile}) pulled=${r.pulled} pushed=${r.pushed} skipped=${r.skipped}` +
                         `${r.failed > 0 ? ` failed=${r.failed}` : ""}` +
                         `${r.scaffolded ? " (pod .h2a scaffolded)" : ""}\n`);
                 }
                 catch (error) {
                     failed += 1;
-                    process.stderr.write(`[remote] h2a bridge ${s.id} failed: ${(error instanceof Error ? error.message : String(error)).slice(0, 200)}\n`);
+                    process.stderr.write(`[h2a] h2a bridge ${s.id} failed: ${(error instanceof Error ? error.message : String(error)).slice(0, 200)}\n`);
                 }
             }
             return { failed };
@@ -4862,7 +4862,7 @@ export async function main(argv) {
     });
     program
         .command("restore [group]")
-        .description('Relance les sessions dev dans leur layout (fenêtre par groupe, onglet par session). Sans argument: tous les groupes. Avec [group]: ce lot seulement (ex: `remote restore "full remote"`). Groupes LOCAUX = claude/codex sous ~/src/* (tmux via `remote run`); groupes REMOTE = sessions SCW (`remote attach <id> --exec`). Layout: champ `layout` de la config.')
+        .description('Relance les sessions dev dans leur layout (fenêtre par groupe, onglet par session). Sans argument: tous les groupes. Avec [group]: ce lot seulement (ex: `h2a restore "full remote"`). Groupes LOCAUX = claude/codex sous ~/src/* (tmux via `h2a run`); groupes REMOTE = sessions SCW (`h2a attach <id> --exec`). Layout: champ `layout` de la config.')
         .option("--dry-run", "affiche le layout calculé sans ouvrir de terminaux")
         .option("--reattach", "ouvre aussi un onglet pour les sessions déjà actives en tmux (ré-attache)")
         .option("--llm-gateway", "force TOUTES les sessions sur la gateway llm-mesh (ignore le pin par instance; relance les sessions vivantes via --replace)")
@@ -4871,7 +4871,7 @@ export async function main(argv) {
         .option("--no-gw", "alias de --no-llm-gateway")
         .action(async (group, opts) => {
         if (!tmuxAvailable()) {
-            process.stderr.write("[remote] tmux requis pour restore (sudo apt install tmux)\n");
+            process.stderr.write("[h2a] tmux requis pour restore (sudo apt install tmux)\n");
             process.exitCode = 1;
             return;
         }
@@ -4896,7 +4896,7 @@ export async function main(argv) {
                 forceGateway = mode;
         }
         catch (error) {
-            process.stderr.write(`[remote] ${error.message}.\n`);
+            process.stderr.write(`[h2a] ${error.message}.\n`);
             process.exitCode = 1;
             return;
         }
@@ -4912,7 +4912,7 @@ export async function main(argv) {
                 return { id: s.id, label: projectName(s), cwd };
             });
             if (restoreOpts.remoteTabs.length === 0) {
-                process.stderr.write("[remote] aucune session SCW (remote ls vide) pour le groupe remote\n");
+                process.stderr.write("[h2a] aucune session SCW (h2a ls vide) pour le groupe remote\n");
             }
         }
         if (opts.reattach)
@@ -4924,10 +4924,10 @@ export async function main(argv) {
         }
         const { total } = restoreLayout(restoreOpts);
         if (total === 0) {
-            process.stderr.write(`[remote] rien à relancer${group ? ` pour le groupe "${group}"` : ""}\n`);
+            process.stderr.write(`[h2a] rien à relancer${group ? ` pour le groupe "${group}"` : ""}\n`);
         }
         else {
-            process.stderr.write(`[remote] ${total} onglet(s)${opts.dryRun ? " (dry-run, rien ouvert)" : " relancé(s)"}\n`);
+            process.stderr.write(`[h2a] ${total} onglet(s)${opts.dryRun ? " (dry-run, rien ouvert)" : " relancé(s)"}\n`);
         }
     });
     // ---------------------------------------------------------------------------
@@ -4935,11 +4935,11 @@ export async function main(argv) {
     // ---------------------------------------------------------------------------
     program
         .command("enroll")
-        .description("Plumbing for the live-session registry (feeds `remote ls`/`remote restore`). " +
+        .description("Plumbing for the live-session registry (feeds `h2a ls`/`h2a restore`). " +
         "Hook mode (--hook claude-start|claude-end) is wired by --install-hooks into " +
         "~/.claude/settings.json (idempotent; backs up settings.json.bak.<epoch>) and " +
         "always exits 0 so it can never break the host claude session. " +
-        "codex has no reliable session hook: codex sessions are enrolled by `remote run` " +
+        "codex has no reliable session hook: codex sessions are enrolled by `h2a run` " +
         "and by the restore filesystem-scan fallback. Manual mode: --tool/--cwd/--conv/--pid/--label.")
         .option("--hook <name>", "hook mode: claude-start | claude-end (reads the Claude Code hook JSON on stdin)")
         .option("--install-hooks", "merge the SessionStart/SessionEnd enroll hooks into Claude Code's settings.json (idempotent)")
@@ -4953,13 +4953,13 @@ export async function main(argv) {
         if (opts.installHooks) {
             const result = installClaudeHooks(opts.settings);
             if (!result.changed) {
-                process.stderr.write(`[remote] enroll hooks already installed in ${result.settingsPath}\n`);
+                process.stderr.write(`[h2a] enroll hooks already installed in ${result.settingsPath}\n`);
                 return;
             }
             if (result.backupPath) {
-                process.stderr.write(`[remote] backup: ${result.backupPath}\n`);
+                process.stderr.write(`[h2a] backup: ${result.backupPath}\n`);
             }
-            process.stderr.write(`[remote] installed ${result.installed.join(" + ")} enroll hooks in ${result.settingsPath}\n`);
+            process.stderr.write(`[h2a] installed ${result.installed.join(" + ")} enroll hooks in ${result.settingsPath}\n`);
             return;
         }
         if (opts.hook) {
@@ -4968,11 +4968,11 @@ export async function main(argv) {
                 const raw = await readStdin();
                 const result = handleClaudeHook(opts.hook, raw);
                 if (!result.ok) {
-                    process.stderr.write(`[remote] enroll hook ignored: ${result.error}\n`);
+                    process.stderr.write(`[h2a] enroll hook ignored: ${result.error}\n`);
                 }
             }
             catch (error) {
-                process.stderr.write(`[remote] enroll hook ignored: ${String(error)}\n`);
+                process.stderr.write(`[h2a] enroll hook ignored: ${String(error)}\n`);
             }
             return;
         }
@@ -4986,21 +4986,21 @@ export async function main(argv) {
             });
             if (!result.ok)
                 throw new Error(result.error ?? "enroll failed");
-            process.stderr.write(`[remote] enrolled (${opts.tool})\n`);
+            process.stderr.write(`[h2a] enrolled (${opts.tool})\n`);
             return;
         }
-        process.stderr.write("[remote] enroll: pass --hook <name>, --install-hooks, or --tool <tool> (see --help)\n");
+        process.stderr.write("[h2a] enroll: pass --hook <name>, --install-hooks, or --tool <tool> (see --help)\n");
     });
     const layoutCommand = program
         .command("layout")
-        .description("Layout auto-enregistré par `remote restore` (layout-last.json)");
+        .description("Layout auto-enregistré par `h2a restore` (layout-last.json)");
     layoutCommand
         .command("show")
         .description("Affiche le dernier layout lancé (fenêtres, onglets, commandes)")
         .action(() => {
         const last = readLastLayout();
         if (!last) {
-            process.stderr.write("[remote] aucun layout enregistré (lance `remote restore` d'abord)\n");
+            process.stderr.write("[h2a] aucun layout enregistré (lance `h2a restore` d'abord)\n");
             return;
         }
         process.stdout.write(`at: ${last.at}\n`);
@@ -5023,13 +5023,22 @@ export async function main(argv) {
         // Local tmux session? (unless an explicit URL/sessionId pair is given).
         if (second === undefined && !looksLikeUrl(first)) {
             const local = findLocalSession(first);
-            if (opts.local || local) {
-                if (!local) {
-                    process.stderr.write(`[remote] no local session "${first}" (see: remote ls)\n`);
+            // A session started by `remote run` is enrolled in the registry as
+            // kind:"local-tmux". Trust that durable record even when a transient
+            // `tmux list-sessions` miss hides the live session — otherwise a purely
+            // LOCAL session is mis-routed to a k8s Pod (kubectl exec session-<name>
+            // → NotFound → reconnect loop) as soon as a tunnel is configured.
+            // `remote ls` already merges registry + tmux; attach must not be less
+            // reliable. When the registry says local but tmux can't reach it,
+            // attachLocalSession fails with a clear LOCAL error (never a Pod).
+            const localName = local?.name ?? localTmuxSessionForName(first, loadRegistry());
+            if (opts.local || localName) {
+                if (!localName) {
+                    process.stderr.write(`[h2a] no local session "${first}" (see: h2a ls)\n`);
                     process.exitCode = 1;
                     return;
                 }
-                process.exitCode = attachLocalSession(local.name);
+                process.exitCode = attachLocalSession(localName);
                 return;
             }
         }
@@ -5052,15 +5061,15 @@ export async function main(argv) {
         // fallback. Force either path with --exec / --ws.
         if (!opts.ws && (opts.exec || tunnel)) {
             if (!tunnel) {
-                process.stderr.write("[remote] --exec needs a tunnel configured (remote config tunnel …)\n");
+                process.stderr.write("[h2a] --exec needs a tunnel configured (h2a config tunnel …)\n");
                 process.exitCode = 1;
                 return;
             }
-            process.stderr.write(`[remote] exec-attaching into Pod tmux for ${sessionId} (Ctrl-b d to detach)\n`);
+            process.stderr.write(`[h2a] exec-attaching into Pod tmux for ${sessionId} (Ctrl-b d to detach)\n`);
             process.exitCode = attachPodTmux(tunnel, sessionId);
             return;
         }
-        process.stderr.write(`[remote] attaching to ${url}/sessions/${sessionId} (WS)\n`);
+        process.stderr.write(`[h2a] attaching to ${url}/sessions/${sessionId} (WS)\n`);
         const session = await attach({ baseUrl: url, sessionId });
         await session.finished;
     });
@@ -5068,7 +5077,7 @@ export async function main(argv) {
         .command("refresh [urlOrSessionId] [sessionId]")
         .description("Re-bundle the local CLI credentials and push them to an existing remote session's Secret. The session's Pod is restarted by the control-plane so the new tokens take effect. Profile is auto-detected from the session.")
         .option("--profile <profile>", "override the auto-detected profile (rarely needed)")
-        .option("--name <name>", "set the session's display name (shown as PROJECT in `remote ls`); applied on the hard refresh (Pod recreate), ignored with --soft")
+        .option("--name <name>", "set the session's display name (shown as PROJECT in `h2a ls`); applied on the hard refresh (Pod recreate), ignored with --soft")
         .option("--no-auth", "skip bundling local credentials")
         .option("--no-auth-refresh", "skip local auth status preflight before bundling credentials")
         .option("--soft", "push fresh creds INTO the running Pod + relaunch the CLI in place (no Pod recreate; keeps HOME + conversation; fixes the ~8h token logout)")
@@ -5077,12 +5086,12 @@ export async function main(argv) {
         .addHelpText("after", [
         "",
         "Examples:",
-        "  $ remote refresh sess-abc --soft     refresh one session's creds in place",
-        "  $ remote refresh --soft --all        refresh every live session once",
-        "  $ remote refresh --all --watch 30    foreground loop: every 30 min, all sessions;",
+        "  $ h2a refresh sess-abc --soft     refresh one session's creds in place",
+        "  $ h2a refresh --soft --all        refresh every live session once",
+        "  $ h2a refresh --all --watch 30    foreground loop: every 30 min, all sessions;",
         "                                       unchanged creds = no-op (no CLI respawn)",
         "  Run the watch in a dedicated tmux window, e.g.:",
-        "    tmux new-window -n creds 'remote refresh --all --watch 30'",
+        "    tmux new-window -n creds 'h2a refresh --all --watch 30'",
         "",
     ].join("\n"))
         .action(async (first, second, opts) => {
@@ -5116,7 +5125,7 @@ export async function main(argv) {
             return;
         }
         if (first === undefined) {
-            throw new Error("Missing session id. Usage: remote refresh [url] <sessionId> [--soft] (or --soft --all).");
+            throw new Error("Missing session id. Usage: h2a refresh [url] <sessionId> [--soft] (or --soft --all).");
         }
         const { url, sessionId } = resolveUrlAndSessionId(first, second);
         if (watchMinutes !== undefined) {
@@ -5137,7 +5146,7 @@ export async function main(argv) {
             if (opts.authRefresh !== false) {
                 const fresh = await ensureProfileAuthFresh(resolved);
                 if (fresh.checked)
-                    process.stderr.write(`[remote] auth status ok: ${fresh.command}\n`);
+                    process.stderr.write(`[h2a] auth status ok: ${fresh.command}\n`);
             }
             await softRefreshSession(sessionId, resolved);
             return;
@@ -5164,13 +5173,13 @@ export async function main(argv) {
         }
         if (opts.local) {
             if (local.length === 0)
-                process.stderr.write("[remote] no local sessions\n");
+                process.stderr.write("[h2a] no local sessions\n");
             return;
         }
         const remote = url ?? getConfiguredRemoteOptional();
         if (!remote) {
             if (local.length === 0) {
-                process.stderr.write("[remote] no local sessions and no remote configured\n");
+                process.stderr.write("[h2a] no local sessions and no remote configured\n");
             }
             return;
         }
@@ -5178,7 +5187,7 @@ export async function main(argv) {
         const sessions = await listRemoteSessions(remote);
         if (sessions.length === 0) {
             if (local.length === 0)
-                process.stderr.write("[remote] no sessions\n");
+                process.stderr.write("[h2a] no sessions\n");
             return;
         }
         if (local.length > 0)
@@ -5208,7 +5217,7 @@ export async function main(argv) {
             const local = findLocalSession(first);
             if (local) {
                 const ok = killLocalSession(local.name);
-                process.stderr.write(`[remote] local session ${local.slug} ${ok ? "killed" : "could not be killed"}\n`);
+                process.stderr.write(`[h2a] local session ${local.slug} ${ok ? "killed" : "could not be killed"}\n`);
                 if (!ok)
                     process.exitCode = 1;
                 return;
@@ -5216,7 +5225,7 @@ export async function main(argv) {
         }
         const { url, sessionId } = resolveUrlAndSessionId(first, second);
         const result = await stopRemoteSession(url, sessionId, opts.reason);
-        process.stderr.write(`[remote] stop ${result.accepted ? "accepted" : "rejected"} for ${sessionId}\n`);
+        process.stderr.write(`[h2a] stop ${result.accepted ? "accepted" : "rejected"} for ${sessionId}\n`);
     });
     program
         .command("rename <slugOrId> <newName>")
@@ -5229,7 +5238,7 @@ export async function main(argv) {
         const local = findLocalSession(slugOrId);
         if (local) {
             setLocalSessionDisplayName(local.name, newName);
-            process.stderr.write(`[remote] local session display name set to "${newName}"\n`);
+            process.stderr.write(`[h2a] local session display name set to "${newName}"\n`);
         }
         // Rename on the control-plane.
         const url = getConfiguredRemote(opts.remote);
@@ -5251,7 +5260,7 @@ export async function main(argv) {
             }
         }
         const result = await renameRemoteSession(url, sessionId, newName);
-        process.stderr.write(`[remote] session ${result.sessionId} renamed to "${result.displayName}" (accepted: ${String(result.accepted)})\n`);
+        process.stderr.write(`[h2a] session ${result.sessionId} renamed to "${result.displayName}" (accepted: ${String(result.accepted)})\n`);
     });
     // ---------------------------------------------------------------------------
     // account — WP16 Layer-C: local LLM account pool (enroll / ls / rm / select)
@@ -5275,7 +5284,7 @@ export async function main(argv) {
         .action((opts) => {
         const provider = opts.provider;
         if (provider !== "claude-code" && provider !== "codex") {
-            process.stderr.write(`[remote] account enroll: unknown provider "${opts.provider}" (known: claude-code, codex)\n`);
+            process.stderr.write(`[h2a] account enroll: unknown provider "${opts.provider}" (known: claude-code, codex)\n`);
             process.exitCode = 1;
             return;
         }
@@ -5285,18 +5294,18 @@ export async function main(argv) {
                 ? readClaudeCredential(opts.configDir)
                 : readCodexCredential(opts.configDir);
             if (!result.ok) {
-                process.stderr.write(`[remote] account enroll: ${result.error}\n`);
+                process.stderr.write(`[h2a] account enroll: ${result.error}\n`);
                 process.exitCode = 1;
                 return;
             }
             accessToken = result.accessToken;
-            process.stderr.write(`[remote] account enroll: read token from ${provider === "claude-code" ? "~/.claude/.credentials.json" : "~/.codex/auth.json"}\n`);
+            process.stderr.write(`[h2a] account enroll: read token from ${provider === "claude-code" ? "~/.claude/.credentials.json" : "~/.codex/auth.json"}\n`);
         }
         else {
             accessToken = process.env.REMOTE_ACCOUNT_TOKEN ?? "";
             if (!accessToken.trim()) {
-                process.stderr.write("[remote] account enroll: REMOTE_ACCOUNT_TOKEN env var is not set or empty\n" +
-                    "[remote] (tip: use --from-credentials to read from the CLI's local config)\n");
+                process.stderr.write("[h2a] account enroll: REMOTE_ACCOUNT_TOKEN env var is not set or empty\n" +
+                    "[h2a] (tip: use --from-credentials to read from the CLI's local config)\n");
                 process.exitCode = 1;
                 return;
             }
@@ -5312,11 +5321,11 @@ export async function main(argv) {
                 : {}),
         });
         if (!result.ok) {
-            process.stderr.write(`[remote] account enroll: ${result.error}\n`);
+            process.stderr.write(`[h2a] account enroll: ${result.error}\n`);
             process.exitCode = 1;
             return;
         }
-        process.stderr.write(`[remote] account enrolled: ${result.descriptor.id} (${result.descriptor.provider}) "${result.descriptor.label}"\n`);
+        process.stderr.write(`[h2a] account enrolled: ${result.descriptor.id} (${result.descriptor.provider}) "${result.descriptor.label}"\n`);
     });
     accountCommand
         .command("ls")
@@ -5329,7 +5338,7 @@ export async function main(argv) {
             return;
         }
         if (accounts.length === 0) {
-            process.stderr.write("[remote] no accounts enrolled\n");
+            process.stderr.write("[h2a] no accounts enrolled\n");
             return;
         }
         const hasConfigDir = accounts.some((a) => a.configDir !== undefined);
@@ -5359,11 +5368,11 @@ export async function main(argv) {
         .action((id) => {
         const result = removeAccount(id);
         if (!result.ok) {
-            process.stderr.write(`[remote] account rm: ${result.error}\n`);
+            process.stderr.write(`[h2a] account rm: ${result.error}\n`);
             process.exitCode = 1;
             return;
         }
-        process.stderr.write(`[remote] account removed: ${result.id}\n`);
+        process.stderr.write(`[h2a] account removed: ${result.id}\n`);
     });
     accountCommand
         .command("exhausted <id>")
@@ -5385,7 +5394,7 @@ export async function main(argv) {
         })();
         const rec = markExhausted(id, windowMs, opts.reason);
         const resetsAt = new Date(new Date(rec.exhaustedAt).getTime() + windowMs).toISOString();
-        process.stderr.write(`[remote] account ${id} marked exhausted — resets at ${resetsAt}` +
+        process.stderr.write(`[h2a] account ${id} marked exhausted — resets at ${resetsAt}` +
             (opts.reason ? ` (reason: ${opts.reason})` : "") +
             "\n");
     });
@@ -5395,7 +5404,7 @@ export async function main(argv) {
         "becomes immediately available for selection again).")
         .action((id) => {
         clearExhaustion(id);
-        process.stderr.write(`[remote] account ${id} quota cleared — available for selection\n`);
+        process.stderr.write(`[h2a] account ${id} quota cleared — available for selection\n`);
     });
     accountCommand
         .command("select")
@@ -5409,14 +5418,14 @@ export async function main(argv) {
         if (opts.fallback) {
             if (!opts.provider ||
                 (opts.provider !== "claude-code" && opts.provider !== "codex")) {
-                process.stderr.write("[remote] account select --fallback requires --provider claude-code|codex\n");
+                process.stderr.write("[h2a] account select --fallback requires --provider claude-code|codex\n");
                 process.exitCode = 1;
                 return;
             }
             const provider = opts.provider;
             const sel = selectAccountWithFallback(provider, opts.affinityKey);
             if (!sel.candidate) {
-                process.stderr.write("[remote] account select: all accounts exhausted — no usable account available\n");
+                process.stderr.write("[h2a] account select: all accounts exhausted — no usable account available\n");
                 process.exitCode = 1;
                 return;
             }
@@ -5434,7 +5443,7 @@ export async function main(argv) {
         const candidates = loadCandidates(provider).map(({ accessToken: _t, ...d }) => d);
         const pick = selectAccount(candidates, opts.lastUsed);
         if (!pick) {
-            process.stderr.write("[remote] account select: no candidates available\n");
+            process.stderr.write("[h2a] account select: no candidates available\n");
             return;
         }
         process.stdout.write(JSON.stringify({ selected: pick, totalCandidates: candidates.length }, null, 2) + "\n");
@@ -5454,15 +5463,15 @@ export async function main(argv) {
                 ? opts.exportS3
                 : process.env.REMOTE_ACCOUNT_LOG_S3;
             if (!uri) {
-                process.stderr.write("[remote] account log --export-s3: no S3 URI provided and REMOTE_ACCOUNT_LOG_S3 is not set\n");
+                process.stderr.write("[h2a] account log --export-s3: no S3 URI provided and REMOTE_ACCOUNT_LOG_S3 is not set\n");
                 process.exit(1);
             }
             try {
                 await exportSessionLogToS3(uri);
-                process.stdout.write(`[remote] session log exported to ${uri}\n`);
+                process.stdout.write(`[h2a] session log exported to ${uri}\n`);
             }
             catch (err) {
-                process.stderr.write(`[remote] account log --export-s3: ${err instanceof Error ? err.message : String(err)}\n`);
+                process.stderr.write(`[h2a] account log --export-s3: ${err instanceof Error ? err.message : String(err)}\n`);
                 process.exit(1);
             }
             return;
@@ -5473,7 +5482,7 @@ export async function main(argv) {
             raw = readFileSync(logFile, "utf8");
         }
         catch {
-            process.stderr.write("[remote] account log: no session log yet (no jobs launched with accounts enrolled)\n");
+            process.stderr.write("[h2a] account log: no session log yet (no jobs launched with accounts enrolled)\n");
             return;
         }
         const lines = raw.split("\n").filter(Boolean);
@@ -5484,7 +5493,7 @@ export async function main(argv) {
             return;
         }
         if (tail.length === 0) {
-            process.stderr.write("[remote] account log: empty\n");
+            process.stderr.write("[h2a] account log: empty\n");
             return;
         }
         process.stdout.write([
@@ -5522,7 +5531,7 @@ export async function main(argv) {
         .action((affinityKey) => {
         const existing = lookupBinding(affinityKey);
         if (!existing) {
-            process.stderr.write(`[remote] no binding for "${affinityKey}"\n`);
+            process.stderr.write(`[h2a] no binding for "${affinityKey}"\n`);
             process.exitCode = 1;
             return;
         }
@@ -5530,7 +5539,7 @@ export async function main(argv) {
         const accounts = listAccounts();
         const label = accounts.find((a) => a.id === existing.accountId)?.label ??
             existing.accountId.slice(0, 8);
-        process.stderr.write(`[remote] binding removed: ${affinityKey} → ${label} (${existing.provider})\n`);
+        process.stderr.write(`[h2a] binding removed: ${affinityKey} → ${label} (${existing.provider})\n`);
     });
     accountCommand
         .command("bindings")
@@ -5544,7 +5553,7 @@ export async function main(argv) {
             return;
         }
         if (bindings.length === 0) {
-            process.stderr.write("[remote] no active bindings (no jobs launched with accounts enrolled)\n");
+            process.stderr.write("[h2a] no active bindings (no jobs launched with accounts enrolled)\n");
             return;
         }
         const accounts = listAccounts();
@@ -5581,7 +5590,7 @@ export async function main(argv) {
         .action(async (opts) => {
         const accounts = listAccountsWithTokens();
         if (accounts.length === 0) {
-            process.stderr.write("[remote] no enrolled accounts with tokens found — run `remote account enroll` first\n");
+            process.stderr.write("[h2a] no enrolled accounts with tokens found — run `h2a account enroll` first\n");
             process.exit(1);
         }
         // Build the gateway-format JSON (token field, not accessToken)
@@ -5616,10 +5625,10 @@ export async function main(argv) {
             encoding: "utf-8",
         });
         if (result.status !== 0) {
-            process.stderr.write(`[remote] kubectl apply failed (exit ${result.status ?? "?"}) — try --dry-run to inspect the YAML\n`);
+            process.stderr.write(`[h2a] kubectl apply failed (exit ${result.status ?? "?"}) — try --dry-run to inspect the YAML\n`);
             process.exit(result.status ?? 1);
         }
-        process.stdout.write(`[remote] pushed ${accounts.length} account(s) to ${opts.namespace}/${opts.secretName}\n`);
+        process.stdout.write(`[h2a] pushed ${accounts.length} account(s) to ${opts.namespace}/${opts.secretName}\n`);
     });
     void accountPushClusterCommand; // suppress unused-var lint
     // ---------------------------------------------------------------------------
@@ -5642,10 +5651,10 @@ export async function main(argv) {
         .action(async (provider, opts) => {
         let account;
         if (provider === "claude") {
-            process.stderr.write(`[remote] llm-mesh: Claude Code OAuth is not a supported upstream transport yet.\n` +
+            process.stderr.write(`[h2a] llm-mesh: Claude Code OAuth is not a supported upstream transport yet.\n` +
                 `  Do not import ~/.claude/.credentials.json as an Anthropic API credential.\n` +
                 `  Use the existing gateway token with codex/openai, or enroll a real Anthropic API key via:\n` +
-                `  remote llm-mesh enroll anthropic --token sk-ant-api...\n`);
+                `  h2a llm-mesh enroll anthropic --token sk-ant-api...\n`);
             process.exitCode = 1;
             return;
         }
@@ -5658,8 +5667,8 @@ export async function main(argv) {
         }
         else if (provider === "openai") {
             if (!opts.token) {
-                process.stderr.write(`[remote] llm-mesh: --token <sk-...> is required for provider "openai"\n` +
-                    `  Example: remote llm-mesh enroll openai --token sk-proj-...\n`);
+                process.stderr.write(`[h2a] llm-mesh: --token <sk-...> is required for provider "openai"\n` +
+                    `  Example: h2a llm-mesh enroll openai --token sk-proj-...\n`);
                 process.exitCode = 1;
                 return;
             }
@@ -5672,12 +5681,12 @@ export async function main(argv) {
         }
         else if (provider === "anthropic") {
             if (!opts.token) {
-                process.stderr.write(`[remote] llm-mesh: --token <sk-ant-api...> is required for provider "anthropic"\n`);
+                process.stderr.write(`[h2a] llm-mesh: --token <sk-ant-api...> is required for provider "anthropic"\n`);
                 process.exitCode = 1;
                 return;
             }
             if (opts.token.startsWith("sk-ant-oat")) {
-                process.stderr.write(`[remote] llm-mesh: refused Claude Code OAuth token for provider "anthropic".\n` +
+                process.stderr.write(`[h2a] llm-mesh: refused Claude Code OAuth token for provider "anthropic".\n` +
                     `  Claude Code OAuth uses a separate Claude Code transport, not Anthropic /v1/messages.\n`);
                 process.exitCode = 1;
                 return;
@@ -5690,7 +5699,7 @@ export async function main(argv) {
             };
         }
         else {
-            process.stderr.write(`[remote] llm-mesh: unsupported provider "${provider}".\n` +
+            process.stderr.write(`[h2a] llm-mesh: unsupported provider "${provider}".\n` +
                 `  Supported: codex (OAuth), openai (API key), anthropic (API key)\n`);
             process.exitCode = 1;
             return;
@@ -5699,18 +5708,18 @@ export async function main(argv) {
         const accounts = existing.accounts.filter((a) => a.id !== account.id);
         accounts.push(account);
         writeLlmMeshConfig({ ...existing, accounts });
-        process.stdout.write(`[remote] llm-mesh: enrolled ${account.label} (id: ${account.id}, provider: ${account.provider})\n`);
+        process.stdout.write(`[h2a] llm-mesh: enrolled ${account.label} (id: ${account.id}, provider: ${account.provider})\n`);
         if ("expiresAt" in account && account.expiresAt) {
             const exp = new Date(account.expiresAt);
             const minsLeft = Math.round((exp.getTime() - Date.now()) / 60_000);
-            process.stdout.write(`[remote] llm-mesh: token expires ${account.expiresAt} (${minsLeft > 0 ? `in ${minsLeft}min` : "EXPIRED"})\n`);
+            process.stdout.write(`[h2a] llm-mesh: token expires ${account.expiresAt} (${minsLeft > 0 ? `in ${minsLeft}min` : "EXPIRED"})\n`);
         }
         if (provider === "codex") {
-            process.stdout.write(`[remote] NOTE: Codex OAuth token works locally via codex app-server,\n` +
+            process.stdout.write(`[h2a] NOTE: Codex OAuth token works locally via codex app-server,\n` +
                 `  but NOT with api.openai.com (missing model.request scope).\n` +
-                `  For a fully working gateway, use: remote llm-mesh enroll openai --token sk-...\n`);
+                `  For a fully working gateway, use: h2a llm-mesh enroll openai --token sk-...\n`);
         }
-        process.stdout.write(`[remote] Run \`remote llm-mesh start\` to launch the gateway.\n`);
+        process.stdout.write(`[h2a] Run \`h2a llm-mesh start\` to launch the gateway.\n`);
     });
     llmMeshCommand
         .command("start")
@@ -5719,23 +5728,23 @@ export async function main(argv) {
         .action(async (opts) => {
         const config = readLlmMeshConfig();
         if (!config || config.accounts.length === 0) {
-            process.stderr.write(`[remote] llm-mesh: no accounts configured. Run \`remote llm-mesh enroll codex\` first.\n`);
+            process.stderr.write(`[h2a] llm-mesh: no accounts configured. Run \`h2a llm-mesh enroll codex\` first.\n`);
             process.exitCode = 1;
             return;
         }
         const existing = readGatewayPid();
         if (existing) {
             setLlmMeshRuntimeConfig({ enabled: true });
-            process.stdout.write(`[remote] llm-mesh: already running (pid ${existing})\n`);
-            process.stdout.write(`[remote] llm-mesh: restore config enabled\n`);
+            process.stdout.write(`[h2a] llm-mesh: already running (pid ${existing})\n`);
+            process.stdout.write(`[h2a] llm-mesh: restore config enabled\n`);
             return;
         }
-        process.stdout.write(`[remote] llm-mesh: starting gateway…\n`);
+        process.stdout.write(`[h2a] llm-mesh: starting gateway…\n`);
         const result = await startGateway(config, { verbose: opts.verbose });
         setLlmMeshRuntimeConfig({ enabled: true });
         const port = result.port;
-        process.stdout.write(`[remote] llm-mesh: gateway started (pid ${result.pid}, port ${port})\n`);
-        process.stdout.write(`[remote] llm-mesh: restore config enabled\n`);
+        process.stdout.write(`[h2a] llm-mesh: gateway started (pid ${result.pid}, port ${port})\n`);
+        process.stdout.write(`[h2a] llm-mesh: restore config enabled\n`);
         process.stdout.write(`\nTo use with Claude Code:\n`);
         process.stdout.write(`  export ANTHROPIC_BASE_URL=http://localhost:${port}\n`);
         process.stdout.write(`  export ANTHROPIC_AUTH_TOKEN=${result.gatewayToken}\n`);
@@ -5745,14 +5754,14 @@ export async function main(argv) {
         .description("Enable llm-mesh auto-reactivation for local sessions and remote restore")
         .action(() => {
         setLlmMeshRuntimeConfig({ enabled: true });
-        process.stdout.write(`[remote] llm-mesh: restore/local auto-reactivation enabled\n`);
+        process.stdout.write(`[h2a] llm-mesh: restore/local auto-reactivation enabled\n`);
     });
     llmMeshCommand
         .command("disable")
         .description("Disable llm-mesh auto-reactivation for local sessions and remote restore")
         .action(() => {
         setLlmMeshRuntimeConfig({ enabled: false });
-        process.stdout.write(`[remote] llm-mesh: restore/local auto-reactivation disabled\n`);
+        process.stdout.write(`[h2a] llm-mesh: restore/local auto-reactivation disabled\n`);
     });
     llmMeshCommand
         .command("stop")
@@ -5760,10 +5769,10 @@ export async function main(argv) {
         .action(() => {
         const res = stopGateway();
         if (res.stopped) {
-            process.stdout.write(`[remote] llm-mesh: stopped (pid ${res.pid})\n`);
+            process.stdout.write(`[h2a] llm-mesh: stopped (pid ${res.pid})\n`);
         }
         else {
-            process.stdout.write(`[remote] llm-mesh: not running\n`);
+            process.stdout.write(`[h2a] llm-mesh: not running\n`);
         }
     });
     llmMeshCommand
@@ -5773,23 +5782,23 @@ export async function main(argv) {
         .action(async (opts) => {
         const config = readLlmMeshConfig();
         if (!config || config.accounts.length === 0) {
-            process.stderr.write(`[remote] llm-mesh: no accounts configured. Run \`remote llm-mesh enroll codex\` first.\n`);
+            process.stderr.write(`[h2a] llm-mesh: no accounts configured. Run \`h2a llm-mesh enroll codex\` first.\n`);
             process.exitCode = 1;
             return;
         }
         const stopped = stopGateway();
         if (stopped.stopped) {
-            process.stdout.write(`[remote] llm-mesh: stopped gateway (pid ${stopped.pid})\n`);
+            process.stdout.write(`[h2a] llm-mesh: stopped gateway (pid ${stopped.pid})\n`);
         }
         else {
-            process.stdout.write(`[remote] llm-mesh: gateway was not running\n`);
+            process.stdout.write(`[h2a] llm-mesh: gateway was not running\n`);
         }
-        process.stdout.write(`[remote] llm-mesh: starting gateway…\n`);
+        process.stdout.write(`[h2a] llm-mesh: starting gateway…\n`);
         const result = await startGateway(config, { verbose: opts.verbose });
         setLlmMeshRuntimeConfig({ enabled: true });
-        process.stdout.write(`[remote] llm-mesh: gateway restarted (pid ${result.pid}, port ${result.port})\n`);
-        process.stdout.write(`[remote] llm-mesh: restore config enabled\n`);
-        process.stdout.write(`[remote] llm-mesh: no tmux/Claude session was restarted; active sessions may keep their old gateway token until explicitly relaunched.\n`);
+        process.stdout.write(`[h2a] llm-mesh: gateway restarted (pid ${result.pid}, port ${result.port})\n`);
+        process.stdout.write(`[h2a] llm-mesh: restore config enabled\n`);
+        process.stdout.write(`[h2a] llm-mesh: no tmux/Claude session was restarted; active sessions may keep their old gateway token until explicitly relaunched.\n`);
         process.stdout.write(`\nTo use with new Claude Code processes:\n`);
         process.stdout.write(`  export ANTHROPIC_BASE_URL=http://localhost:${result.port}\n`);
         process.stdout.write(`  export ANTHROPIC_AUTH_TOKEN=${result.gatewayToken}\n`);
@@ -5804,10 +5813,10 @@ export async function main(argv) {
         const pid = readGatewayPid();
         const port = config?.port ?? 3002;
         if (pid) {
-            process.stdout.write(`[remote] llm-mesh: running (pid ${pid}, port ${port})\n`);
+            process.stdout.write(`[h2a] llm-mesh: running (pid ${pid}, port ${port})\n`);
         }
         else {
-            process.stdout.write(`[remote] llm-mesh: stopped\n`);
+            process.stdout.write(`[h2a] llm-mesh: stopped\n`);
         }
         process.stdout.write(`  restore/local auto-reactivation: ${runtime.enabled ? "enabled" : "disabled"}\n`);
         if (config) {
@@ -5825,7 +5834,7 @@ export async function main(argv) {
             }
         }
         else {
-            process.stdout.write(`  no config. Run \`remote llm-mesh enroll codex\` first.\n`);
+            process.stdout.write(`  no config. Run \`h2a llm-mesh enroll codex\` first.\n`);
         }
     });
     llmMeshCommand
@@ -5839,7 +5848,7 @@ export async function main(argv) {
             stdio: "inherit",
         });
         if (tail.error) {
-            process.stderr.write(`[remote] llm-mesh: log tail failed: ${String(tail.error)}\n`);
+            process.stderr.write(`[h2a] llm-mesh: log tail failed: ${String(tail.error)}\n`);
             process.exitCode = 1;
         }
     });
@@ -5855,7 +5864,7 @@ export async function main(argv) {
         .description("Suspend the local incarnation for a lineage: writes a sentinel file that prevents the agent from starting a new turn. Does NOT kill the process.")
         .action((id) => {
         suspendLocalIncarnation(id);
-        process.stderr.write(`[remote] lineage ${id} suspended\n`);
+        process.stderr.write(`[h2a] lineage ${id} suspended\n`);
     });
     lineageCommand
         .command("resume <id>")
@@ -5864,8 +5873,8 @@ export async function main(argv) {
         const wasSuspended = isIncarnationSuspended(id);
         resumeLocalIncarnation(id);
         process.stderr.write(wasSuspended
-            ? `[remote] lineage ${id} resumed\n`
-            : `[remote] lineage ${id} was not suspended (no-op)\n`);
+            ? `[h2a] lineage ${id} resumed\n`
+            : `[h2a] lineage ${id} was not suspended (no-op)\n`);
     });
     await program.parseAsync([...argv]);
     const code = process.exitCode;
@@ -5889,7 +5898,7 @@ if (isEntryPoint()) {
             console.error(error.message);
         }
         else {
-            console.error("[remote] fatal:", error);
+            console.error("[h2a] fatal:", error);
         }
         process.exitCode = 1;
     });