@nonbot/cli 0.9.12 → 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, 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));
@@ -182,6 +233,15 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
             spawnImpl: deps.spawnSync,
         });
     }
+    if (args[0] === 'attach') {
+        const sessionFlag = args.indexOf('--session');
+        const sessionName = sessionFlag >= 0 ? args[sessionFlag + 1] : undefined;
+        return attachDaemonSession({
+            log: rawLog, errLog,
+            spawnImpl: deps.spawnSync,
+            ...(sessionName ? { sessionName } : {}),
+        });
+    }
     if (args.includes('--install')) {
         const install = deps.installService ?? installService;
         const res = await install();
@@ -211,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();
@@ -244,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();
@@ -485,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 = {
@@ -525,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) {
@@ -546,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))
@@ -564,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();
@@ -688,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;
@@ -742,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,
@@ -749,6 +1072,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         injected: injectedPrompts,
                         trackedPanes,
                         machineId,
+                        ...(wireAnsweredPrompts ? { prompts: wireAnsweredPrompts } : {}),
                         fetchImpl,
                         spawnImpl: deps.spawnSync,
                         log,
@@ -761,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,
@@ -788,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);
@@ -812,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');
@@ -823,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/index.js

@@ -21,7 +21,7 @@ const COMMANDS = [
     },
     {
         name: 'daemon',
-        description: 'Long-running listener — polls /api/cli/activations/pending every 2s. `nonbot daemon stop` stops it (local; --machine <id> / --all go remote).',
+        description: 'Long-running listener — polls /api/cli/activations/pending every 2s. `nonbot daemon stop` stops it (local; --machine <id> / --all go remote); `nonbot daemon attach` reattaches a lost tmux window.',
         run: (args) => runDaemonCommand(args),
     },
     {