@nonbot/cli 0.9.13 → 0.10.0

package/dist/commands/daemon.js

@@ -1,24 +1,40 @@
 import { spawnSync as nodeSpawnSync } from 'node:child_process';
 import { loadAuth, getActiveProfile } from '../lib/auth.js';
 import * as activations from '../lib/activations.js';
-import { fireActivation, makeHeadlessSpawner, } from '../lib/activations.js';
-import { checkCompletions } from '../lib/completion.js';
+import { fireActivation, makeHeadlessSpawner, spawnTerminalDefault, } from '../lib/activations.js';
+import { checkCompletions, readExitCodeFile, removeExitFile, } from '../lib/completion.js';
 import { evictOldestToCap } from '../lib/bounded-set.js';
-import { deliverAnsweredPrompts, capturePane, parsePromptMenu, mintPromptId, reportPrompt, } from '../lib/run-prompt.js';
+import { deliverAnsweredPrompts, capturePane, normalizeAnsweredPrompts, parsePromptMenu, mintPromptId, reportPrompt, } from '../lib/run-prompt.js';
 import { serveSnapshotRequests } from '../lib/snapshot.js';
+import { createUpdateChecker } from '../lib/update-check.js';
+import { refreshPaneTails, flushExitTranscripts, exitTranscriptDisabled, } from '../lib/exit-transcript.js';
+import { validateActivationId } from '../lib/payload-validator.js';
+import { resolveRunTimeoutMinutes, wallClockExceededReason, } from '../lib/command-builders.js';
+import { prepareCloneWorkspace as defaultPrepareCloneWorkspace, pushRunBranch as defaultPushRunBranch, reapStaleWorkspaces as defaultReapStaleWorkspaces, removeCloudWorkspace as defaultRemoveCloudWorkspace, shortCloneFailureReason, touchWorkspaceLiveness as defaultTouchWorkspaceLiveness, } from '../lib/cloud-repo.js';
 import { loadOrCreateMachineId, resolveMachineName, shortMachineId } from '../lib/machine.js';
 import { emitRunStage as defaultEmitRunStage, startRunHeartbeat as defaultStartRunHeartbeat, RUN_STAGE, } from '../lib/choir/run-progress.js';
 import { groupBySession, launchCoordinatedSet, setIsIsolated, } from '../lib/choir/coordinated-set.js';
 import { IsolatedSessionTracker, reconcileAndCleanup as defaultReconcileAndCleanup, resolveBaseBranch as defaultResolveBaseBranch, } from '../lib/choir/isolated-session.js';
 import { applyPaneTitle, applyPaneState } from '../lib/pane-title.js';
 import { installService, uninstallService } from '../lib/service.js';
-import { probeTmuxAttached, postDaemonStopAck, requestRemoteDaemonStop, stopDaemonLocally, attachDaemonSession, writePidFile, removePidFile, } from '../lib/daemon-lifecycle.js';
+import { probeTmuxAttached, postDaemonStopAck, requestRemoteDaemonStop, stopDaemonLocally, attachDaemonSession, writePidFile, removePidFile, shutdownPredatesDaemon, } from '../lib/daemon-lifecycle.js';
 import { detectTmuxSession, inTmuxSession, nonbotTmuxOptOut, resolveTerminal, } from '../lib/terminal.js';
 import { VERSION } from '../version.js';
 import { errorBlock, statusRow, daemonOpener, daemonCloser, activationCard, runSummary, formatElapsed, liveFooter, needsYouBanner, resumedLine, buildPaneBorderFormat, buildTmuxStatusLeft, buildTmuxStatusRight, WORDMARK_WIDTH, c, } from '../lib/output.js';
 export const POLL_FAST_MS = 2000;
 export const POLL_MAX_MS = 30000;
 export const POLL_INTERVAL_MS = POLL_FAST_MS;
+export const MAX_CONCURRENT_RUNS_DEFAULT = 4;
+export function resolveMaxConcurrentRuns(env = process.env) {
+    const raw = env.NONBOT_MAX_CONCURRENT_RUNS;
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return MAX_CONCURRENT_RUNS_DEFAULT;
+    const n = Number(raw.trim());
+    if (!Number.isInteger(n) || n < 1)
+        return MAX_CONCURRENT_RUNS_DEFAULT;
+    return n;
+}
+export const CONCURRENCY_DEFERRED_REASON = 'queued: concurrency limit';
 const TERMINAL_KIND_BY_PROFILE_ID = {
     'terminal': 'terminal.app',
     'iterm': 'iterm',
@@ -66,6 +82,41 @@ export function sanitizeFailureReason(reason) {
         return null;
     return cleaned.slice(0, LAST_FAILURE_REASON_MAX);
 }
+async function readErrorCode(res) {
+    try {
+        if (typeof res.json !== 'function')
+            return '';
+        const body = (await res.json());
+        if (!body || typeof body !== 'object')
+            return '';
+        const code = body.code;
+        return typeof code === 'string' ? code.slice(0, 64) : '';
+    }
+    catch {
+        return '';
+    }
+}
+export function describeRegistrationRejection(status, code) {
+    if (status === 409 && code === 'machine_in_use') {
+        return 'machine id already in use — set a distinct NONBOT_MACHINE_ID';
+    }
+    if (status === 400 && code === 'machine_id_mismatch') {
+        return 'machine id header rejected — upgrade @nonbot/cli on this runner';
+    }
+    if (status === 400 && code === 'origin_too_broad') {
+        return 'allowed repos too broad — scope NONBOT_ALLOWED_REPO_ORIGINS to an owner or repo';
+    }
+    return `HTTP ${status}`;
+}
+export function isRepoLessProbe(act) {
+    if (act.kind !== 'diagnostic')
+        return false;
+    const payload = act.payload;
+    if (!payload || typeof payload !== 'object')
+        return false;
+    const template = payload.template;
+    return template === 'diagnostic' || template === 'provider-test';
+}
 export function applyNonbotTmuxConfig(deps = {}) {
     const spawnSync = deps.spawnSync ?? nodeSpawnSync;
     const stdoutWrite = deps.stdoutWrite ?? ((s) => process.stdout.write(s));
@@ -220,11 +271,15 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
             deps.spawnTerminal = makeHeadlessSpawner({ wait: false, log: rawLog, errLog });
         }
     }
+    const cloudMode = args.includes('--cloud');
     const auth = await loader();
     if (!auth) {
         errLog(errorBlock('Not logged in', 'Run `nonbot login` to authenticate.', { stream: process.stderr }));
         return 1;
     }
+    if (cloudMode && !deps.spawnTerminal) {
+        deps.spawnTerminal = (a) => spawnTerminalDefault(a, auth, { cloud: true });
+    }
     const detectTmux = deps.detectTmuxSession ?? detectTmuxSession;
     const tmuxSessionName = detectTmux();
     const machineId = deps.machineId ?? loadOrCreateMachineId();
@@ -253,6 +308,26 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     const reconcileBuildCommand = deps.reconcileBuildCommand ?? process.env.NONBOT_RECONCILE_BUILD_CMD ?? '';
     const trackedPanes = new Map();
     const killedByStop = new Set();
+    const cloudWorkspaces = deps.cloudWorkspaces ?? new Map();
+    const prepareCloneWorkspaceFn = deps.prepareCloneWorkspace ?? defaultPrepareCloneWorkspace;
+    const pushRunBranchFn = deps.pushRunBranch ?? defaultPushRunBranch;
+    const reapStaleWorkspacesFn = deps.reapStaleWorkspaces ?? defaultReapStaleWorkspaces;
+    const removeCloudWorkspaceFn = deps.removeCloudWorkspace ?? defaultRemoveCloudWorkspace;
+    const removeExitFileFn = deps.removeExitFile ?? removeExitFile;
+    const touchWorkspaceLivenessFn = deps.touchWorkspaceLiveness ?? defaultTouchWorkspaceLiveness;
+    const releaseCloudWorkspace = (activationId) => {
+        const ws = cloudWorkspaces.get(activationId);
+        cloudWorkspaces.delete(activationId);
+        if (!cloudMode)
+            return;
+        try {
+            if (ws)
+                removeCloudWorkspaceFn(ws.repoPath);
+            removeExitFileFn(activationId);
+        }
+        catch {
+        }
+    };
     const injectedPrompts = new Set();
     const servedSnapshots = new Set();
     const reportedPrompts = new Set();
@@ -494,7 +569,184 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     }) + '\n');
     log('\n');
     pushTmuxStatus();
+    const cloudEnv = deps.env ?? process.env;
+    const allowedRepoOrigins = (cloudEnv.NONBOT_ALLOWED_REPO_ORIGINS ?? '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const maxConcurrentRuns = deps.maxConcurrentRuns ?? resolveMaxConcurrentRuns(cloudEnv);
+    const runTimeoutMinutes = deps.runTimeoutMinutes ?? resolveRunTimeoutMinutes(cloudEnv);
+    const runTimeoutMs = runTimeoutMinutes * 60_000;
+    const nowMs = deps.now ?? Date.now;
+    const wallClockReason = wallClockExceededReason(runTimeoutMinutes);
+    const executeKillsFn = deps.executePendingKills ?? activations.executePendingKills;
+    const daemonStartedAt = nowMs();
+    let staleShutdownNoted = false;
+    const exitTranscriptsEnabled = !exitTranscriptDisabled(cloudEnv);
+    const paneTails = new Map();
+    const flushTranscripts = async (statusFor, opts = {}) => {
+        if (paneTails.size === 0)
+            return;
+        try {
+            await flushExitTranscripts({
+                tracked: opts.all ? new Map() : trackedPanes,
+                tails: paneTails,
+                statusFor,
+                profile: profileName,
+                now: nowMs,
+                log,
+            });
+        }
+        catch {
+        }
+    };
+    const updateChecker = createUpdateChecker({
+        env: cloudEnv,
+        fetchImpl: deps.updateCheckFetch === undefined
+            ? (process.env.VITEST ? null : fetch)
+            : deps.updateCheckFetch,
+        now: nowMs,
+        log: (line) => log(c.amber(line) + '\n'),
+    });
+    void updateChecker.maybeCheck();
+    const postActivationFailure = async (activationId, failureReason) => {
+        try {
+            validateActivationId(activationId);
+        }
+        catch {
+            errLog(statusRow('⚠', 'failure report skipped', 'malformed activation id', {
+                stream: process.stderr,
+            }) + '\n');
+            return false;
+        }
+        try {
+            const res = await fetchImpl(`${auth.baseUrl}/api/portfolio/activations/${activationId}`, {
+                method: 'PATCH',
+                headers: {
+                    Authorization: `Bearer ${auth.pat}`,
+                    'Content-Type': 'application/json',
+                    'X-Requested-With': 'ConradPM-Native',
+                },
+                body: JSON.stringify({ status: 'failed', failureReason: failureReason.slice(0, 200) }),
+            });
+            return res.ok || res.status === 409;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (cloudMode) {
+        try {
+            const reaped = reapStaleWorkspacesFn({ activeIds: cloudWorkspaces.keys() });
+            if (reaped > 0) {
+                log(statusRow('✓', 'stale workspaces reaped', `${reaped} older than 24h`) + '\n');
+            }
+        }
+        catch {
+        }
+        try {
+            const res = await fetchImpl(`${auth.baseUrl}/api/cli/cloud-runners`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${auth.pat}`,
+                    'Content-Type': 'application/json',
+                    'X-Requested-With': 'ConradPM-Native',
+                    'X-Machine-Id': machineId,
+                },
+                body: JSON.stringify({ machineId, kind: 'vps', allowedRepoOrigins }),
+            });
+            if (res.ok) {
+                log(statusRow('✓', 'cloud runner registration', shortMachineId(machineId)) + '\n');
+            }
+            else {
+                log(statusRow('⚠', 'cloud registration rejected', describeRegistrationRejection(res.status, await readErrorCode(res))) + '\n');
+            }
+        }
+        catch {
+            log(statusRow('⚠', 'cloud runner registration failed', 'continuing — server may be unreachable') + '\n');
+        }
+        try {
+            const spawnSyncImpl = deps.spawnSync ?? nodeSpawnSync;
+            spawnSyncImpl('tmux', ['set-environment', '-g', '-r', 'NONBOT_GIT_TOKEN'], {
+                timeout: 2000,
+                windowsHide: true,
+            });
+            log(statusRow('✓', 'tmux global env scrubbed', 'NONBOT_GIT_TOKEN') + '\n');
+        }
+        catch {
+            log(statusRow('⚠', 'tmux env scrub skipped', 'no tmux server reachable') + '\n');
+        }
+    }
+    const sweepLocalGuardrails = async () => {
+        if (cloudMode && cloudWorkspaces.size > 0) {
+            for (const ws of cloudWorkspaces.values()) {
+                try {
+                    touchWorkspaceLivenessFn(ws.repoPath);
+                }
+                catch {
+                }
+            }
+        }
+        try {
+            const deadline = nowMs() - runTimeoutMs;
+            const overdue = [];
+            for (const [id, paneId] of trackedPanes) {
+                if (killedByStop.has(id))
+                    continue;
+                const meta = trackedMeta.get(id);
+                if (!meta || meta.startedAt > deadline)
+                    continue;
+                overdue.push({ activationId: id, tmuxPaneId: paneId });
+            }
+            for (const k of overdue) {
+                const meta = trackedMeta.get(k.activationId);
+                log(activationCard({
+                    marker: '■',
+                    color: 'amber',
+                    id: k.activationId,
+                    headerSuffix: 'WALL CLOCK',
+                    kv: [
+                        ['STORY', meta?.story ?? 'unknown'],
+                        ['ELAPSED', meta ? formatElapsed(nowMs() - meta.startedAt) : 'unknown'],
+                        ['PANE', `${k.tmuxPaneId} · ^C -> 2s grace -> kill-pane`],
+                        ['REASON', wallClockReason],
+                    ],
+                }) + '\n');
+                if (cloudMode) {
+                    const ws = cloudWorkspaces.get(k.activationId);
+                    if (ws) {
+                        try {
+                            const push = pushRunBranchFn({
+                                repoPath: ws.repoPath,
+                                branch: ws.branch,
+                                activationId: k.activationId,
+                                spawnImpl: deps.spawnSync,
+                            });
+                            log(statusRow(push.pushed ? '✓' : '⚠', push.pushed ? 'run branch pushed' : 'run branch not pushed', ws.branch) + '\n');
+                        }
+                        catch {
+                        }
+                    }
+                }
+                killedByStop.add(k.activationId);
+                retitlePane('stopping', k.tmuxPaneId, meta?.story ?? '');
+                safeEmit(k.activationId, RUN_STAGE.FAILED);
+                stopHeartbeat(k.activationId, 'wall-clock');
+                failedCount++;
+                trackedMeta.delete(k.activationId);
+                await postActivationFailure(k.activationId, wallClockReason);
+            }
+            if (overdue.length > 0) {
+                void executeKillsFn(overdue, auth.baseUrl, auth.pat);
+                lastFailureReason = wallClockReason;
+                emitSummary();
+            }
+        }
+        catch {
+        }
+    };
     while (running) {
+        void updateChecker.maybeCheck();
         let firedThisPoll = false;
         try {
             const headers = {
@@ -534,6 +786,9 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
             if (res.ok) {
                 lastPollOk = true;
                 const body = (await res.json());
+                const wireAnsweredPrompts = Array.isArray(body?.answeredPrompts)
+                    ? normalizeAnsweredPrompts(body.answeredPrompts)
+                    : undefined;
                 const pendingKills = body?.pendingKills ?? [];
                 if (pendingKills.length > 0) {
                     for (const k of pendingKills) {
@@ -555,11 +810,19 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         safeEmit(k.activationId, RUN_STAGE.STOPPED);
                         stopHeartbeat(k.activationId);
                     }
-                    void activations.executePendingKills(pendingKills, auth.baseUrl, auth.pat);
+                    void executeKillsFn(pendingKills, auth.baseUrl, auth.pat);
                 }
-                if (body?.shutdown?.requested === true) {
+                const shutdownSignal = body?.shutdown?.requested === true ? body.shutdown : null;
+                if (shutdownSignal && shutdownPredatesDaemon(shutdownSignal, daemonStartedAt)) {
+                    if (!staleShutdownNoted) {
+                        staleShutdownNoted = true;
+                        const scopeLabel = shutdownSignal.scope === 'all' ? 'all machines' : 'this machine';
+                        log(statusRow('ℹ', 'stale stop signal ignored', `issued before this daemon started · ${scopeLabel}`) + '\n');
+                    }
+                }
+                else if (shutdownSignal) {
                     running = false;
-                    const scopeLabel = body.shutdown.scope === 'all' ? 'all machines' : 'this machine';
+                    const scopeLabel = shutdownSignal.scope === 'all' ? 'all machines' : 'this machine';
                     log('\n' + statusRow('⚠', 'daemon stop received', `remote stop · ${scopeLabel}`) + '\n');
                     const kills = [...trackedPanes.entries()]
                         .filter(([id]) => !killedByStop.has(id))
@@ -573,12 +836,13 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                     if (kills.length > 0) {
                         log(statusRow('⚠', `stopping ${kills.length} run${kills.length === 1 ? '' : 's'}`, '^C -> 2s grace -> kill-pane') + '\n');
                         try {
-                            await activations.executePendingKills(kills, auth.baseUrl, auth.pat);
+                            await executeKillsFn(kills, auth.baseUrl, auth.pat);
                         }
                         catch { }
                     }
                     for (const id of [...runHeartbeats.keys()])
                         stopHeartbeat(id);
+                    await flushTranscripts(() => 'stopped', { all: true });
                     await postDaemonStopAck({ baseUrl: auth.baseUrl, pat: auth.pat, machineId, fetchImpl });
                     pushTmuxStatus(0, true);
                     removePidFile();
@@ -697,14 +961,60 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         emitSummary();
                     }
                 }
+                let deferredThisPoll = 0;
                 for (const act of singletons) {
                     if (!act?.id || seen.has(act.id))
                         continue;
+                    if (trackedPanes.size >= maxConcurrentRuns) {
+                        deferredThisPoll = singletons.filter((a) => a?.id && !seen.has(a.id)).length;
+                        break;
+                    }
                     seen.add(act.id);
                     firedThisPoll = true;
                     const metrics = act.kind === 'real' ? seqMetrics(act) : undefined;
                     if (act.kind === 'real')
                         safeEmit(act.id, RUN_STAGE.LAUNCHING, metrics);
+                    if (cloudMode && !isRepoLessProbe(act)) {
+                        if (!act.repoUrl) {
+                            errLog(statusRow('⚠', `${act.id} · cloud workspace refused`, 'no clone url', {
+                                stream: process.stderr,
+                            }) + '\n');
+                            failedCount++;
+                            lastFailureReason = 'cloud runner requires a clone url';
+                            if (act.kind === 'real')
+                                safeEmit(act.id, RUN_STAGE.FAILED, metrics);
+                            await postActivationFailure(act.id, 'cloud runner requires a clone url');
+                            emitSummary();
+                            continue;
+                        }
+                        try {
+                            const ws = await prepareCloneWorkspaceFn({
+                                repoUrl: act.repoUrl,
+                                repoRef: act.repoRef ?? null,
+                                activationId: act.id,
+                                allowedOrigins: allowedRepoOrigins,
+                            });
+                            act.repoPath = ws.repoPath;
+                            if (act.payload && typeof act.payload === 'object') {
+                                ;
+                                act.payload.repoPath = ws.repoPath;
+                            }
+                            cloudWorkspaces.set(act.id, ws);
+                        }
+                        catch (e) {
+                            const reason = shortCloneFailureReason(e);
+                            errLog(statusRow('⚠', `${act.id} · cloud workspace failed`, reason, {
+                                stream: process.stderr,
+                            }) + '\n');
+                            failedCount++;
+                            lastFailureReason = sanitizeFailureReason(reason) ?? 'clone failed';
+                            if (act.kind === 'real')
+                                safeEmit(act.id, RUN_STAGE.FAILED, metrics);
+                            await postActivationFailure(act.id, `clone failed: ${reason}`);
+                            emitSummary();
+                            continue;
+                        }
+                    }
                     const outcome = await fireActivation(auth, act, deps, log, errLog);
                     if (outcome.status === 'launched') {
                         lastFailureReason = null;
@@ -751,6 +1061,10 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         emitSummary();
                     }
                 }
+                if (deferredThisPoll > 0) {
+                    log(statusRow('⚠', CONCURRENCY_DEFERRED_REASON, `${deferredThisPoll} waiting · ${trackedPanes.size}/${maxConcurrentRuns} running`) + '\n');
+                    lastFailureReason = CONCURRENCY_DEFERRED_REASON;
+                }
                 try {
                     await deliverAnsweredPrompts({
                         baseUrl: auth.baseUrl,
@@ -758,6 +1072,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         injected: injectedPrompts,
                         trackedPanes,
                         machineId,
+                        ...(wireAnsweredPrompts ? { prompts: wireAnsweredPrompts } : {}),
                         fetchImpl,
                         spawnImpl: deps.spawnSync,
                         log,
@@ -770,6 +1085,14 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                 }
                 catch {
                 }
+                if (exitTranscriptsEnabled && trackedPanes.size > 0) {
+                    try {
+                        refreshPaneTails({ tracked: trackedPanes, tails: paneTails, spawnImpl: spawnForTmux, now: nowMs });
+                    }
+                    catch {
+                    }
+                }
+                const stoppedBeforeSweep = new Set(killedByStop);
                 if (trackedPanes.size > 0) {
                     const reported = await checkCompletions({
                         tracked: trackedPanes,
@@ -797,12 +1120,39 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                                 kv,
                             }) + '\n';
                         },
+                        readExitCode: cloudMode ? undefined : (id) => readExitCodeFile(id),
+                        cloud: cloudMode
+                            ? {
+                                readExitCode: (id) => readExitCodeFile(id),
+                                pushWorkspace: (id) => {
+                                    const ws = cloudWorkspaces.get(id);
+                                    if (!ws)
+                                        return { pushed: false, reason: 'no workspace', kind: 'no-workspace' };
+                                    const result = pushRunBranchFn({
+                                        repoPath: ws.repoPath,
+                                        branch: ws.branch,
+                                        activationId: id,
+                                        spawnImpl: deps.spawnSync,
+                                    });
+                                    return {
+                                        ...result,
+                                        branch: ws.branch,
+                                        ...(result.pushed ? {} : { kind: 'push-failed' }),
+                                    };
+                                },
+                                forgetWorkspace: (id) => {
+                                    releaseCloudWorkspace(id);
+                                },
+                            }
+                            : undefined,
                     });
                     if (reported.length > 0) {
                         for (const id of reported) {
                             doneCount++;
                             trackedMeta.delete(id);
-                            safeEmit(id, RUN_STAGE.FINISHED);
+                            releaseCloudWorkspace(id);
+                            const outcome = reported.outcomes?.get(id);
+                            safeEmit(id, outcome === 'failed' ? RUN_STAGE.FAILED : RUN_STAGE.FINISHED);
                             stopHeartbeat(id, 'finished');
                             try {
                                 const session = isolatedSessions.noteTerminal(id);
@@ -821,6 +1171,14 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         }
                         emitSummary();
                     }
+                    await flushTranscripts((id) => {
+                        const outcome = reported.outcomes?.get(id);
+                        if (outcome)
+                            return outcome;
+                        if (reported.includes(id))
+                            return 'completed';
+                        return stoppedBeforeSweep.has(id) ? 'stopped' : 'untracked';
+                    });
                 }
                 if (!firedThisPoll && pendingKills.length === 0 && !tmuxChromeEnabled) {
                     log(heartbeatLine() + '\n');
@@ -832,6 +1190,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
             lastPollOk = false;
             errLog(statusRow('⚠', 'poll error', e.message, { stream: process.stderr }) + '\n');
         }
+        await sweepLocalGuardrails();
         if (options.oneShot)
             break;
         if (fixedInterval !== undefined) {

package/dist/commands/logs.js

@@ -1,4 +1,4 @@
-import { readActivityLog as readActivityLogDefault, } from '../lib/activity-log.js';
+import { readActivityLog as readActivityLogDefault, isExitTranscriptEntry, } from '../lib/activity-log.js';
 import { header, statusRow, eventRow } from '../lib/output.js';
 const FOLLOW_INTERVAL_MS = 1000;
 function parseArgs(args) {
@@ -49,6 +49,11 @@ function relativeTime(ts, now) {
     return `${days}d ago`;
 }
 function formatEntry(e, now) {
+    if (isExitTranscriptEntry(e)) {
+        const sigil = e.status === 'completed' ? '✓' : e.status === 'failed' ? '✗' : '⚠';
+        const size = `${e.lines} lines${e.truncated ? ' (clamped)' : ''}`;
+        return eventRow([e.id, e.kind, `${e.status} · ${size}`, relativeTime(e.ts, now)], { status: sigil }) + '\n';
+    }
     const status = e.status === 'launched' ? '✓' : '✗';
     const when = relativeTime(e.ts, now);
     const target = `${e.mode}/${e.target}`;

package/dist/lib/activations.js

@@ -7,8 +7,9 @@ import { resolveTerminal } from './terminal.js';
 import { getActiveProfile } from './auth.js';
 import { appendActivityLog } from './activity-log.js';
 import { activationCard, clockTime } from './output.js';
+import { scrubLine } from './snapshot.js';
 import { buildCommandFromParams, hookSettingsPathFor, shellQuoteSingle, } from './command-builders.js';
-import { validatePayload, validateActivationId, validateRepoPath, ValidationError, extractTerminalTheme, } from './payload-validator.js';
+import { validatePayload, validateActivationId, validateRepoPath, validateRepoUrl, validateRepoRef, ValidationError, extractTerminalTheme, } from './payload-validator.js';
 const PANE_ID_RE = /^%\d+$/;
 export const BUILT_COMMAND_MAX_LENGTH = 32 * 1024;
 export const WIRE_COMMAND_MAX_LENGTH = 4096;
@@ -56,7 +57,8 @@ export function resolveExecutableCommand(act, warn = (s) => console.warn(s), opt
     if (shell.length > BUILT_COMMAND_MAX_LENGTH) {
         throw new Error(`[${act.id}] built command is too large (${shell.length} chars, cap ${BUILT_COMMAND_MAX_LENGTH}). This indicates an oversized AGENTS.md or a builder bug.`);
     }
-    if (typeof act.command === 'string' && act.command.length > 0 && act.command !== shell) {
+    const driftBase = params.template === 'real' ? buildCommandFromParams({ ...params, wallClock: false }) : shell;
+    if (typeof act.command === 'string' && act.command.length > 0 && act.command !== driftBase) {
         warn(`[${act.id}] note: daemon-built command differs from server-supplied command (executing daemon-built; server text is informational).\n`);
     }
     if (opts.injectClaudeHook && params.template === 'real' && params.provider === 'claude') {
@@ -89,6 +91,16 @@ export function validateActivationEnvelope(act) {
             throw e;
         }
     }
+    try {
+        validateRepoUrl(act.repoUrl);
+        validateRepoRef(act.repoRef);
+    }
+    catch (e) {
+        if (e instanceof ValidationError) {
+            throw new Error(`[${act.id}] outer envelope validation failed (act.${e.field}): ${e.reason}`);
+        }
+        throw e;
+    }
     if (act.payload &&
         typeof act.payload === 'object' &&
         'repoPath' in act.payload) {
@@ -122,6 +134,23 @@ function truncate(s, max) {
         return s;
     return s.slice(0, max - 32) + `\n…[truncated to ${max}B]`;
 }
+const CHILD_ENV_ALLOW = new Set([
+    'PATH', 'HOME', 'SHELL', 'TERM', 'LANG', 'LC_ALL', 'USER', 'LOGNAME', 'TMPDIR',
+    'TMUX', 'TMUX_PANE', 'NODE_ENV', 'NONBOT_PAT', 'NONBOT_BASE_URL', 'NONBOT_RUN_ID',
+    'NONBOT_ROLE', 'NONBOT_CONFIG_DIR', 'CLAUDE_CODE_OAUTH_TOKEN',
+    'NONBOT_RUN_TIMEOUT_MIN',
+    'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'no_proxy',
+]);
+export function buildChildEnv(base, opts) {
+    const out = {};
+    for (const [k, v] of Object.entries(base)) {
+        if (CHILD_ENV_ALLOW.has(k))
+            out[k] = v;
+        else if (opts.byok && (k === 'ANTHROPIC_API_KEY' || k === 'ANTHROPIC_AUTH_TOKEN'))
+            out[k] = v;
+    }
+    return out;
+}
 export function makeHeadlessSpawner(opts) {
     return (act) => new Promise((resolve, reject) => {
         try {
@@ -140,8 +169,12 @@ export function makeHeadlessSpawner(opts) {
             return;
         }
         const cwd = act.repoPath || undefined;
+        const childEnv = buildChildEnv(process.env, {
+            byok: !process.env.CLAUDE_CODE_OAUTH_TOKEN &&
+                (!!process.env.ANTHROPIC_API_KEY || !!process.env.ANTHROPIC_AUTH_TOKEN),
+        });
         if (opts.wait) {
-            const proc = spawn('bash', ['-c', resolved.shell], { cwd, stdio: 'inherit' });
+            const proc = spawn('bash', ['-c', resolved.shell], { cwd, env: childEnv, stdio: 'inherit' });
             proc.on('error', (e) => {
                 const err = e;
                 reject(new Error(`failed to run headless: ${err.message}`));
@@ -151,13 +184,14 @@ export function makeHeadlessSpawner(opts) {
         }
         const proc = spawn('bash', ['-c', resolved.shell], {
             cwd,
+            env: childEnv,
             stdio: ['ignore', 'pipe', 'pipe'],
         });
         const prefixLines = (chunk, sink) => {
             const text = chunk.toString('utf-8');
             for (const line of text.split('\n')) {
                 if (line.length > 0)
-                    sink(`[${act.id}] ${line}\n`);
+                    sink(`[${act.id}] ${scrubLine(line)}\n`);
             }
         };
         proc.stdout?.on('data', (c) => prefixLines(c, opts.log));
@@ -207,7 +241,11 @@ async function captureSpawn(cmd, args) {
     });
 }
 export const _captureSpawnForTests = captureSpawn;
-export async function spawnTerminalDefault(act, auth) {
+export function exitFilePathFor(activationId) {
+    const ext = process.platform === 'darwin' ? 'command' : 'sh';
+    return path.join(tmpdir(), `nonbot-${activationId}.${ext}.exit`);
+}
+export async function spawnTerminalDefault(act, auth, opts) {
     validateActivationEnvelope(act);
     const resolved = resolveExecutableCommand(act, undefined, { injectClaudeHook: true });
     const ext = process.platform === 'darwin' ? 'command' : 'sh';
@@ -253,7 +291,9 @@ export async function spawnTerminalDefault(act, auth) {
                 `Switch to iTerm for theme support. Launching un-themed.`);
         }
     }
-    const { cmd, args } = profile.launch(scriptPath, itermProfileName ? { itermProfileName } : undefined);
+    const cloudExitFile = opts?.cloud && profile.id === 'tmux' ? exitFilePathFor(act.id) : undefined;
+    const launchOpts = itermProfileName || cloudExitFile ? { itermProfileName, cloudExitFile } : undefined;
+    const { cmd, args } = profile.launch(scriptPath, launchOpts);
     const result = await captureSpawn(cmd, args);
     const unlinkBest = async () => {
         try {

package/dist/lib/activity-log.js

@@ -1,6 +1,12 @@
 import { promises as fs } from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
+export function isExitTranscriptEntry(e) {
+    return (!!e &&
+        typeof e === 'object' &&
+        e.kind === 'exit-transcript' &&
+        typeof e.tail === 'string');
+}
 function configDir() {
     const override = process.env.NONBOT_CONFIG_DIR;
     if (override && override.length > 0)