@nonbot/cli 0.9.13 → 0.10.0

package/dist/lib/choir/hub.js

@@ -9,6 +9,41 @@ import { makeEvent, sanitizeForEgress, assertNoForbiddenFields } from './progres
 import { LOCAL_TEXT_MAX, SUMMARY_MAX, } from './types.js';
 const DEFAULT_POLL_MS = 5_000;
 const DEFAULT_HEARTBEAT_MS = 30_000;
+const EGRESS_CHUNK = 25;
+const CLIENT_MINTED_SESSION_PREFIX = 'choir_';
+export function isClientMintedSessionId(sessionId) {
+    return typeof sessionId === 'string' && sessionId.startsWith(CLIENT_MINTED_SESSION_PREFIX);
+}
+export const EGRESS_RETRY_MAX = 200;
+const EGRESS_RETRY_BASE_MS = 5_000;
+const EGRESS_RETRY_MAX_MS = 5 * 60_000;
+export function retryQueueKey(ev) {
+    const s = typeof ev.sessionId === 'string' ? ev.sessionId : '';
+    const p = typeof ev.paneId === 'string' ? ev.paneId : '';
+    return `${s}|${p}`;
+}
+export function trimRetryQueue(queue, cap, keyOf = retryQueueKey) {
+    const limit = Number.isFinite(cap) && cap > 0 ? Math.floor(cap) : 0;
+    if (queue.length <= limit)
+        return queue;
+    const cut = queue.length - limit;
+    const tail = queue.slice(cut);
+    const covered = new Set();
+    for (const ev of tail)
+        covered.add(keyOf(ev));
+    const survivors = [];
+    for (let i = cut - 1; i >= 0; i--) {
+        const k = keyOf(queue[i]);
+        if (covered.has(k))
+            continue;
+        covered.add(k);
+        survivors.push([i, queue[i]]);
+    }
+    if (survivors.length === 0)
+        return tail;
+    survivors.reverse();
+    return [...survivors.map(([, ev]) => ev), ...tail];
+}
 const DEFAULT_WRITE_RATE_LIMIT = 60;
 const DEFAULT_WRITE_RATE_WINDOW_MS = 60_000;
 const READ_TOOLS = new Set(['run_radar', 'run_check', 'run_status']);
@@ -34,6 +69,7 @@ function constantTimeEqual(a, b) {
 export function createHub(opts) {
     const now = opts.now ?? (() => Date.now());
     const fetchImpl = opts.fetchImpl ?? fetch;
+    const log = opts.log ?? ((_s) => { });
     const spawnImpl = opts.spawnImpl;
     const journalFs = opts.journalFs ?? {
         appendFileSync: nodeAppendFileSync,
@@ -55,6 +91,10 @@ export function createHub(opts) {
     const rateWindows = new Map();
     const gate = new EmissionGate();
     let pendingEvents = [];
+    let retryQueue = [];
+    let retryNotBefore = 0;
+    let retryBackoffMs = EGRESS_RETRY_BASE_MS;
+    const localOnly = isClientMintedSessionId(opts.sessionId);
     let server = null;
     let pollTimer = null;
     let heartbeatTimer = null;
@@ -350,25 +390,76 @@ export function createHub(opts) {
                 return null;
         }
     }
-    function flushEgress() {
-        if (pendingEvents.length === 0)
-            return;
-        const batch = pendingEvents.map((e) => sanitizeForEgress(e));
-        pendingEvents = [];
-        const safe = [];
-        for (const ev of batch) {
-            try {
-                assertNoForbiddenFields(ev);
-                safe.push(ev);
+    async function flushEgress() {
+        try {
+            if (pendingEvents.length > 0) {
+                const batch = pendingEvents.map((e) => sanitizeForEgress(e));
+                pendingEvents = [];
+                for (const ev of batch) {
+                    try {
+                        assertNoForbiddenFields(ev);
+                        retryQueue.push(ev);
+                    }
+                    catch {
+                    }
+                }
+                retryQueue = trimRetryQueue(retryQueue, EGRESS_RETRY_MAX);
             }
-            catch {
+            if (localOnly) {
+                retryQueue = [];
+                return;
+            }
+            if (retryQueue.length === 0)
+                return;
+            if (now() < retryNotBefore)
+                return;
+            while (retryQueue.length > 0) {
+                const chunk = retryQueue.slice(0, EGRESS_CHUNK);
+                const outcome = await postEvents(chunk);
+                if (outcome === 'throttled') {
+                    retryQueue = trimRetryQueue(retryQueue, EGRESS_RETRY_MAX);
+                    retryNotBefore = now() + retryBackoffMs;
+                    retryBackoffMs = Math.min(retryBackoffMs * 2, EGRESS_RETRY_MAX_MS);
+                    return;
+                }
+                retryQueue = retryQueue.slice(chunk.length);
+                retryBackoffMs = EGRESS_RETRY_BASE_MS;
             }
         }
-        if (safe.length === 0)
-            return;
-        postJson(`${baseUrl}/api/cli/choir/events`, { sessionId: state.sessionId, events: safe });
+        catch {
+        }
+    }
+    async function postEvents(events) {
+        const res = await postJson(`${baseUrl}/api/cli/choir/events`, {
+            sessionId: state.sessionId,
+            events,
+        });
+        if (!res)
+            return 'dropped';
+        const status = res.status;
+        if (status === 429)
+            return 'throttled';
+        try {
+            if (typeof res.json !== 'function')
+                return 'sent';
+            const body = (await res.json());
+            if (!body || typeof body !== 'object')
+                return 'sent';
+            const skipped = body.skipped;
+            if (typeof skipped === 'number' && skipped > 0) {
+                const accepted = body.accepted;
+                log(`⚠ choir events: server skipped ${skipped} of ${events.length} ` +
+                    `(accepted ${typeof accepted === 'number' ? accepted : '?'}) — ` +
+                    `session not persisted server-side\n`);
+            }
+        }
+        catch {
+        }
+        return 'sent';
     }
     function sendHeartbeat() {
+        if (localOnly)
+            return;
         const panes = Object.values(state.panes);
         const body = {
             sessionId: state.sessionId,
@@ -407,17 +498,21 @@ export function createHub(opts) {
                 },
                 body: JSON.stringify(body),
             });
-            if (p && typeof p.catch === 'function') {
-                ;
-                p.catch(() => {
-                });
+            if (p && typeof p.then === 'function') {
+                return p.catch(() => null);
             }
+            return Promise.resolve(p ?? null);
         }
         catch {
+            return Promise.resolve(null);
         }
     }
     return {
         start() {
+            if (localOnly) {
+                log('ℹ choir hub: local session telemetry stays LOCAL — the web only ' +
+                    'persists events for server-issued run sessions.\n');
+            }
             try {
                 const impl = opts.netImpl;
                 if (!impl)
@@ -459,6 +554,9 @@ export function createHub(opts) {
         getState() {
             return state;
         },
+        retryQueueSize() {
+            return retryQueue.length;
+        },
         dispatch,
         pollOnce,
         flushEgress,

package/dist/lib/cloud-repo.js

@@ -0,0 +1,306 @@
+import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from 'node:child_process';
+import { readdirSync as nodeReaddirSync, rmSync as nodeRmSync, statSync as nodeStatSync, writeFileSync as nodeWriteFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { validateActivationId, validateRepoRef, repoUrlLooksSafe } from './payload-validator.js';
+const defaultWorkspaceFs = {
+    readdirSync: (p) => nodeReaddirSync(p),
+    statSync: (p) => nodeStatSync(p),
+    rmSync: (p, opts) => nodeRmSync(p, opts),
+    writeFileSync: (p, data) => nodeWriteFileSync(p, data),
+};
+const CLONE_TIMEOUT_MS = 45_000;
+const GIT_TIMEOUT_MS = 30_000;
+export const DEFAULT_CLOUD_BASE_DIR = path.join(tmpdir(), 'nonbot-cloud');
+export const MAX_CLOUD_WORKSPACES = 20;
+export const WORKSPACE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const REASON_TOO_MANY_WORKSPACES = 'too many workspaces';
+export const REASON_ORIGIN_TOO_BROAD = 'allowlist entry too broad';
+const OWN_REASONS = new Set([
+    'invalid repo url',
+    'origin not allowed',
+    REASON_ORIGIN_TOO_BROAD,
+    'invalid repo ref',
+    'invalid activation id',
+    REASON_TOO_MANY_WORKSPACES,
+]);
+const EXIT_CODED_REASON_RE = /^(clone|checkout) failed \(exit [-\w]+\)$/;
+const REASON_MAX = 200;
+function runGit(spawnImpl, cwd, args) {
+    return spawnImpl('git', ['-C', cwd, ...args], {
+        encoding: 'utf-8',
+        timeout: GIT_TIMEOUT_MS,
+        windowsHide: true,
+    });
+}
+function exitLabel(r) {
+    const status = r?.status;
+    return status === null || status === undefined ? 'unknown' : String(status);
+}
+function exitLabelFor(code) {
+    return code === null ? 'unknown' : String(code);
+}
+function runGitAsync(spawnImpl, args, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(code);
+        };
+        let child;
+        try {
+            child = spawnImpl('git', args, {
+                timeout: timeoutMs,
+                windowsHide: true,
+                stdio: 'ignore',
+            });
+        }
+        catch {
+            done(null);
+            return;
+        }
+        try {
+            child.on('error', () => done(null));
+            child.on('close', (code) => done(typeof code === 'number' ? code : null));
+        }
+        catch {
+            done(null);
+        }
+    });
+}
+export function countCloudWorkspaces(baseDir = DEFAULT_CLOUD_BASE_DIR, fsImpl = defaultWorkspaceFs) {
+    try {
+        return fsImpl.readdirSync(baseDir).length;
+    }
+    catch {
+        return 0;
+    }
+}
+export function removeCloudWorkspace(repoPath, opts = {}) {
+    const baseDir = opts.baseDir ?? DEFAULT_CLOUD_BASE_DIR;
+    const fsImpl = opts.fsImpl ?? defaultWorkspaceFs;
+    if (typeof repoPath !== 'string' || repoPath.length === 0)
+        return false;
+    const resolved = path.resolve(repoPath);
+    const base = path.resolve(baseDir);
+    if (path.dirname(resolved) !== base)
+        return false;
+    try {
+        fsImpl.rmSync(resolved, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const WORKSPACE_LIVENESS_FILE = '.nonbot-live';
+export function touchWorkspaceLiveness(repoPath, opts = {}) {
+    const baseDir = opts.baseDir ?? DEFAULT_CLOUD_BASE_DIR;
+    const fsImpl = opts.fsImpl ?? defaultWorkspaceFs;
+    const now = opts.now ?? Date.now;
+    if (typeof repoPath !== 'string' || repoPath.length === 0)
+        return false;
+    const resolved = path.resolve(repoPath);
+    if (path.dirname(resolved) !== path.resolve(baseDir))
+        return false;
+    if (typeof fsImpl.writeFileSync !== 'function')
+        return false;
+    try {
+        fsImpl.writeFileSync(path.join(resolved, WORKSPACE_LIVENESS_FILE), `${now()}\n`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function reapStaleWorkspaces(opts = {}) {
+    const baseDir = opts.baseDir ?? DEFAULT_CLOUD_BASE_DIR;
+    const maxAgeMs = opts.maxAgeMs ?? WORKSPACE_MAX_AGE_MS;
+    const now = opts.now ?? Date.now;
+    const fsImpl = opts.fsImpl ?? defaultWorkspaceFs;
+    const active = new Set(opts.activeIds ?? []);
+    let removed = 0;
+    let entries;
+    try {
+        entries = fsImpl.readdirSync(baseDir);
+    }
+    catch {
+        return 0;
+    }
+    const cutoff = now() - maxAgeMs;
+    for (const name of entries) {
+        if (active.has(name))
+            continue;
+        const full = path.join(baseDir, name);
+        try {
+            const st = fsImpl.statSync(full);
+            if (!st.isDirectory())
+                continue;
+            if (st.mtimeMs >= cutoff)
+                continue;
+            if (isMarkedLive(full, cutoff, fsImpl))
+                continue;
+            fsImpl.rmSync(full, { recursive: true, force: true });
+            removed++;
+        }
+        catch {
+        }
+    }
+    return removed;
+}
+function isMarkedLive(workspaceDir, cutoff, fsImpl) {
+    const marker = path.join(workspaceDir, WORKSPACE_LIVENESS_FILE);
+    let st;
+    try {
+        st = fsImpl.statSync(marker);
+    }
+    catch {
+        return false;
+    }
+    if (!st || typeof st.mtimeMs !== 'number' || !Number.isFinite(st.mtimeMs))
+        return true;
+    return st.mtimeMs >= cutoff;
+}
+export function normalizeRepoPrefix(url) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    let pathname = u.pathname.replace(/\/+$/, '');
+    while (pathname.endsWith('.git')) {
+        pathname = pathname.slice(0, -4).replace(/\/+$/, '');
+    }
+    return `${u.origin}${pathname}/`;
+}
+export function isHostWidePrefix(normalized) {
+    if (typeof normalized !== 'string' || normalized.length === 0)
+        return false;
+    try {
+        return new URL(normalized).pathname === '/';
+    }
+    catch {
+        return false;
+    }
+}
+export function classifyRepoUrl(repoUrl, allowedOrigins) {
+    if (!repoUrlLooksSafe(repoUrl))
+        return 'not_allowed';
+    if (!Array.isArray(allowedOrigins))
+        return 'not_allowed';
+    const candidate = normalizeRepoPrefix(repoUrl);
+    if (candidate === null)
+        return 'not_allowed';
+    let sawHostWideCover = false;
+    for (const o of allowedOrigins) {
+        if (typeof o !== 'string' || o.length === 0)
+            continue;
+        const entry = normalizeRepoPrefix(o);
+        if (entry === null)
+            continue;
+        if (!candidate.startsWith(entry))
+            continue;
+        if (isHostWidePrefix(entry)) {
+            sawHostWideCover = true;
+            continue;
+        }
+        return 'allowed';
+    }
+    return sawHostWideCover ? 'too_broad' : 'not_allowed';
+}
+export function repoUrlAllowed(repoUrl, allowedOrigins) {
+    return classifyRepoUrl(repoUrl, allowedOrigins) === 'allowed';
+}
+export function runBranchFor(activationId) {
+    return `run/${activationId.replace(/^act_/, '').slice(0, 8)}`;
+}
+export async function prepareCloneWorkspace(args) {
+    const spawnImpl = args.spawnImpl ?? nodeSpawn;
+    if (!repoUrlLooksSafe(args.repoUrl)) {
+        throw new Error('invalid repo url');
+    }
+    const verdict = classifyRepoUrl(args.repoUrl, args.allowedOrigins);
+    if (verdict === 'too_broad') {
+        throw new Error(REASON_ORIGIN_TOO_BROAD);
+    }
+    if (verdict !== 'allowed') {
+        throw new Error('origin not allowed');
+    }
+    let ref;
+    try {
+        ref = validateRepoRef(args.repoRef);
+    }
+    catch {
+        throw new Error('invalid repo ref');
+    }
+    try {
+        validateActivationId(args.activationId);
+    }
+    catch {
+        throw new Error('invalid activation id');
+    }
+    const baseDir = args.baseDir ?? DEFAULT_CLOUD_BASE_DIR;
+    if (countCloudWorkspaces(baseDir, args.fsImpl ?? defaultWorkspaceFs) >= MAX_CLOUD_WORKSPACES) {
+        throw new Error(REASON_TOO_MANY_WORKSPACES);
+    }
+    const repoPath = path.join(baseDir, args.activationId);
+    const branch = runBranchFor(args.activationId);
+    const cloneArgs = [
+        'clone',
+        '--depth',
+        '1',
+        '--filter=blob:none',
+        ...(ref ? ['--branch', ref] : []),
+        args.repoUrl,
+        repoPath,
+    ];
+    const cloneCode = await runGitAsync(spawnImpl, cloneArgs, CLONE_TIMEOUT_MS);
+    if (cloneCode !== 0) {
+        throw new Error(`clone failed (exit ${exitLabelFor(cloneCode)})`);
+    }
+    const checkoutCode = await runGitAsync(spawnImpl, ['-C', repoPath, 'checkout', '-b', branch], GIT_TIMEOUT_MS);
+    if (checkoutCode !== 0) {
+        throw new Error(`checkout failed (exit ${exitLabelFor(checkoutCode)})`);
+    }
+    touchWorkspaceLiveness(repoPath, { baseDir, fsImpl: args.fsImpl ?? defaultWorkspaceFs });
+    return { repoPath, branch };
+}
+export function pushRunBranch(args) {
+    const spawnImpl = args.spawnImpl ?? nodeSpawnSync;
+    const { repoPath, branch, activationId } = args;
+    const status = runGit(spawnImpl, repoPath, ['status', '--porcelain']);
+    if (!status || status.status !== 0) {
+        return { pushed: false, reason: `status failed (exit ${exitLabel(status)})` };
+    }
+    const dirty = String(status.stdout ?? '').trim() !== '';
+    if (dirty) {
+        const added = runGit(spawnImpl, repoPath, ['add', '-A']);
+        if (!added || added.status !== 0) {
+            return { pushed: false, reason: `add failed (exit ${exitLabel(added)})` };
+        }
+        const committed = runGit(spawnImpl, repoPath, [
+            'commit',
+            '-m',
+            `wip(run): ${activationId} — auto-push on exit`,
+        ]);
+        if (!committed || committed.status !== 0) {
+            return { pushed: false, reason: `commit failed (exit ${exitLabel(committed)})` };
+        }
+    }
+    const pushed = runGit(spawnImpl, repoPath, ['push', '-u', 'origin', branch]);
+    if (!pushed || pushed.status !== 0) {
+        return { pushed: false, reason: `push failed (exit ${exitLabel(pushed)})` };
+    }
+    return { pushed: true };
+}
+export function shortCloneFailureReason(e) {
+    const msg = e instanceof Error && typeof e.message === 'string' ? e.message : '';
+    if (OWN_REASONS.has(msg) || EXIT_CODED_REASON_RE.test(msg)) {
+        return msg.slice(0, REASON_MAX);
+    }
+    return 'workspace preparation failed';
+}

package/dist/lib/command-builders.js

@@ -12,6 +12,33 @@ const ESC_GREEN = '\\033[32m';
 const ESC_RED = '\\033[31m';
 const ESC_CYAN = '\\033[36m';
 const ESC_PRIMARY = '\\033[38;5;141m';
+export const RUN_TIMEOUT_DEFAULT_MIN = 95;
+export const RUN_TIMEOUT_KILL_AFTER = '60s';
+export const RUN_TIMEOUT_BIN_VAR = 'NB_RUN_TIMEOUT_BIN';
+export function resolveRunTimeoutMinutes(env = process.env) {
+    const raw = env.NONBOT_RUN_TIMEOUT_MIN;
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return RUN_TIMEOUT_DEFAULT_MIN;
+    const n = Number(raw.trim());
+    if (!Number.isInteger(n) || n < 1)
+        return RUN_TIMEOUT_DEFAULT_MIN;
+    return n;
+}
+export function wallClockExceededReason(minutes) {
+    return `wall clock exceeded (${minutes}m)`;
+}
+const RUN_TIMEOUT_MISSING_NOTE = 'wall clock unenforced: no timeout/gtimeout on PATH (install coreutils)';
+export function buildRunTimeoutPrelude() {
+    const warn = emitBanner('  ' + ESC_RED + '⚠' + ESC_RESET + ' ' + ESC_DIM + RUN_TIMEOUT_MISSING_NOTE + ESC_RESET + '\n');
+    return (`if command -v timeout >/dev/null 2>&1; then ${RUN_TIMEOUT_BIN_VAR}=timeout; ` +
+        `elif command -v gtimeout >/dev/null 2>&1; then ${RUN_TIMEOUT_BIN_VAR}=gtimeout; ` +
+        `else ${RUN_TIMEOUT_BIN_VAR}=; ${warn}; fi; `);
+}
+export function buildRunTimeoutPrefix() {
+    return (`\${${RUN_TIMEOUT_BIN_VAR}:+\$${RUN_TIMEOUT_BIN_VAR} --signal=TERM ` +
+        `--kill-after=${RUN_TIMEOUT_KILL_AFTER} ` +
+        `\${NONBOT_RUN_TIMEOUT_MIN:-${RUN_TIMEOUT_DEFAULT_MIN}}m} `);
+}
 export const PROVIDER_PROFILES = {
     claude: {
         realCli: 'claude',
@@ -294,7 +321,11 @@ export function buildRealCommand(params) {
     const settingsFlag = wantHook
         ? `--settings ${shellQuoteSingle(params.hookSettingsPath)} `
         : '';
-    return `${head}${agentsMdPrefix}${hookHeredocPrefix}${bannerEmit}${cli} ${settingsFlag}${shellQuoteSingle(prompt)}`;
+    const wallClock = params.wallClock !== false;
+    const timeoutPrelude = wallClock ? buildRunTimeoutPrelude() : '';
+    const timeoutPrefix = wallClock ? buildRunTimeoutPrefix() : '';
+    return (`${head}${agentsMdPrefix}${hookHeredocPrefix}${timeoutPrelude}` +
+        `${bannerEmit}${timeoutPrefix}${cli} ${settingsFlag}${shellQuoteSingle(prompt)}`);
 }
 export function buildCommandFromParams(params) {
     switch (params.template) {

package/dist/lib/completion.js

@@ -1,4 +1,6 @@
 import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import * as nodeFs from 'node:fs';
+import { exitFilePathFor } from './activations.js';
 export function listLivePaneIds(spawnImpl = nodeSpawnSync) {
     try {
         const r = spawnImpl('tmux', ['list-panes', '-a', '-F', '#{pane_id}'], {
@@ -43,6 +45,55 @@ export async function postCompletion(baseUrl, pat, activationId, fetchImpl = fet
         return false;
     }
 }
+export function readExitCodeFile(activationId, fsImpl = nodeFs) {
+    try {
+        const raw = fsImpl.readFileSync(exitFilePathFor(activationId), 'utf-8').trim();
+        if (raw.length === 0)
+            return null;
+        const n = Number(raw);
+        return Number.isInteger(n) && n >= 0 && n <= 255 ? n : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function removeExitFile(activationId, fsImpl = nodeFs) {
+    try {
+        fsImpl.unlinkSync(exitFilePathFor(activationId));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function postFailure(baseUrl, pat, activationId, failureReason, fetchImpl = fetch) {
+    try {
+        const res = await fetchImpl(`${baseUrl}/api/portfolio/activations/${activationId}`, {
+            method: 'PATCH',
+            headers: {
+                Authorization: `Bearer ${pat}`,
+                'Content-Type': 'application/json',
+                'X-Requested-With': 'ConradPM-Native',
+            },
+            body: JSON.stringify({ status: 'failed', failureReason: failureReason.slice(0, 1000) }),
+        });
+        return res.ok || res.status === 409;
+    }
+    catch {
+        return false;
+    }
+}
+export const MAX_REPORT_ATTEMPTS = 8;
+export const TIMEOUT_EXIT_CODE = 124;
+const reportAttemptsByTracker = new WeakMap();
+function reportAttemptsFor(tracked) {
+    let m = reportAttemptsByTracker.get(tracked);
+    if (!m) {
+        m = new Map();
+        reportAttemptsByTracker.set(tracked, m);
+    }
+    return m;
+}
 export async function checkCompletions(opts) {
     const { tracked, killed, baseUrl, pat } = opts;
     if (tracked.size === 0)
@@ -51,14 +102,84 @@ export async function checkCompletions(opts) {
     if (live === null)
         return [];
     const completed = detectCompletedActivations(tracked, live, killed);
+    const attempts = opts.cloud ? reportAttemptsFor(tracked) : null;
+    const noteFailedReport = (id) => {
+        if (!attempts)
+            return;
+        const n = (attempts.get(id) ?? 0) + 1;
+        if (n < MAX_REPORT_ATTEMPTS) {
+            attempts.set(id, n);
+            return;
+        }
+        attempts.delete(id);
+        tracked.delete(id);
+        opts.cloud?.forgetWorkspace?.(id);
+        opts.log?.(`⚠ ${id} · giving up after ${MAX_REPORT_ATTEMPTS} failed completion reports\n`);
+    };
     for (const [id, pane] of [...tracked.entries()]) {
         if (!live.has(pane) && killed.has(id)) {
             tracked.delete(id);
             killed.delete(id);
+            opts.cloud?.forgetWorkspace?.(id);
+            attempts?.delete(id);
         }
     }
     const reported = [];
+    const outcomes = new Map();
     for (const id of completed) {
+        if (opts.cloud) {
+            const push = opts.cloud.pushWorkspace(id);
+            const code = opts.cloud.readExitCode(id);
+            const branchNote = (push.pushed
+                ? `branch ${push.branch ?? 'unknown'} pushed`
+                : push.reason === 'no workspace'
+                    ? 'no workspace'
+                    : `push failed: ${push.reason ?? 'unknown'}`).slice(0, 200);
+            if (code === 0 && (push.pushed || push.kind === 'no-workspace')) {
+                const ok = await postCompletion(baseUrl, pat, id, opts.fetchImpl);
+                if (!ok) {
+                    noteFailedReport(id);
+                    continue;
+                }
+                attempts?.delete(id);
+                tracked.delete(id);
+                reported.push(id);
+                outcomes.set(id, 'completed');
+                const card = opts.renderComplete?.(id);
+                opts.log?.(card && card.length > 0 ? card : `✓ ${id} · run completed (pane closed)\n`);
+                continue;
+            }
+            const codeLabel = code === null
+                ? 'unknown (no exit file)'
+                : code === TIMEOUT_EXIT_CODE
+                    ? `${TIMEOUT_EXIT_CODE} (wall clock timeout)`
+                    : String(code);
+            const ok = await postFailure(baseUrl, pat, id, `agent exited ${codeLabel} · ${branchNote}`, opts.fetchImpl);
+            if (!ok) {
+                noteFailedReport(id);
+                continue;
+            }
+            attempts?.delete(id);
+            tracked.delete(id);
+            reported.push(id);
+            outcomes.set(id, 'failed');
+            opts.log?.(`✗ ${id} · run failed (exit ${codeLabel})\n`);
+            continue;
+        }
+        const localCode = opts.readExitCode ? opts.readExitCode(id) : null;
+        if (localCode !== null && localCode !== 0) {
+            const label = localCode === TIMEOUT_EXIT_CODE
+                ? `${TIMEOUT_EXIT_CODE} (wall clock timeout)`
+                : String(localCode);
+            const failedOk = await postFailure(baseUrl, pat, id, `agent exited ${label}`, opts.fetchImpl);
+            if (!failedOk)
+                continue;
+            tracked.delete(id);
+            reported.push(id);
+            outcomes.set(id, 'failed');
+            opts.log?.(`✗ ${id} · run failed (exit ${label})\n`);
+            continue;
+        }
         const ok = await postCompletion(baseUrl, pat, id, opts.fetchImpl);
         if (!ok) {
             continue;
@@ -68,5 +189,8 @@ export async function checkCompletions(opts) {
         const card = opts.renderComplete?.(id);
         opts.log?.(card && card.length > 0 ? card : `✓ ${id} · run completed (pane closed)\n`);
     }
-    return reported;
+    const result = reported;
+    if (opts.cloud || opts.readExitCode)
+        result.outcomes = outcomes;
+    return result;
 }