@phnx-labs/agents-cli 1.22.116 → 1.22.118

package/dist/commands/exec.js

@@ -17,6 +17,7 @@ import { parseLoopInterval } from '../lib/loop.js';
 import { AGENTS, resolveAgentName, isAgentHardDeprecated, hardDeprecationError } from '../lib/agents.js';
 import { parseAgentVersionSpec } from '../lib/agent-spec/agents.js';
 import { recordDispatchedRun } from '../lib/audit/log.js';
+import { recordRunAuthOutcome } from '../lib/auth-health.js';
 import { maybeShowStarNudge } from '../lib/star-nudge.js';
 import { warnUnpushedWork, shouldWarnUnpushed } from '../lib/warn-unpushed.js';
 import { warnOrphanedOpenPr } from '../lib/pr-land-detach.js';
@@ -90,6 +91,24 @@ export function parseRunPickerMarkers(agentSpec) {
 export function hostTargetGiven(options) {
     return [options.host, options.device, options.on, options.computer].filter((v) => !!v);
 }
+/**
+ * Turn a host target that names THIS machine into an explicit local pin: the
+ * host-family flags are cleared and `local` is set, so no dispatch path
+ * self-SSHes and the bare-interactive default (`bareInteractiveRunDefaultsToDeviceAuto`)
+ * sees a decided placement. Returns true when the pin was applied. Pure over
+ * the `isSelf` predicate so the rule is testable without a device registry.
+ */
+export function pinLocalWhenTargetIsSelf(options, isSelf) {
+    const targets = hostTargetGiven(options);
+    if (targets.length === 0 || !targets.every(isSelf))
+        return false;
+    options.host = undefined;
+    options.device = undefined;
+    options.on = undefined;
+    options.computer = undefined;
+    options.local = true;
+    return true;
+}
 /**
  * Return every option whose selection semantics conflict with an account
  * choice (`agent#`). Device routing is deliberately absent: the marker rides
@@ -118,6 +137,8 @@ export function runAccountPickerConflicts(options) {
  */
 export function runDevicePickerConflicts(options) {
     const conflicts = hostTargetGiven(options).map((h) => `--device ${h}`);
+    if (options.local)
+        conflicts.push('--local');
     if (options.lease)
         conflicts.push('--lease');
     if (options.box)
@@ -145,6 +166,11 @@ export { RUN_AUTO_KEYWORD };
  * fleet. Pure so the pinning matrix is unit-testable.
  */
 export function runAutoDefaultsToAffinity(options, env = process.env) {
+    // An explicit local pin (--local, --where local, --device <this machine>)
+    // is a decided host layer with an empty host set; read it here so the
+    // `run auto` and bare-interactive defaults share one rule.
+    if (options.local)
+        return false;
     if (hostTargetGiven(options).length > 0)
         return false;
     if (env.AGENTS_RUN_AUTO_HOST_RESOLVED === '1')
@@ -639,7 +665,8 @@ export function registerRunCommand(program) {
         .option('--until <signal>', 'Loop stop condition. `signal` reads <runDir>/loop-signal.json {continue,reason} each iteration; absent or continue:false stops (fail-closed). Loop only.')
         .option('--interval <dur>', 'Loop delay between iterations ("0" back-to-back, "30m" paces). Loop only.')
         .option('--where <spec>', 'Where this run\'s body executes (one placement door): local | device:<name> | auto | lease[:backend] | cloud[:provider]. Expands to --device/--lease/--cloud. Do not combine with those flags. See docs/00-concepts.md#placement.')
-        .option('-D, --device <name>', 'Offload this run onto another machine over SSH — a registered device, or user@host. Pass "auto" to pick the least-loaded reachable device where the requested agent is installed and signed in, keeping the run local when no remote is better, or "interactive" for the machine pinned as interactive.host (the box a human is sitting at). Same as --where device:<name>. See `agents devices`.')
+        .option('--local', 'Run on this machine. A bare interactive run otherwise places itself like --device auto; --local pins it here. Same as --where local or --device <this machine>.')
+        .option('-D, --device <name>', 'Offload this run onto another machine over SSH — a registered device, or user@host. Pass "auto" to pick the least-loaded reachable device where the requested agent is installed and signed in, keeping the run local when no remote is better, or "interactive" for the machine pinned as interactive.host (the box a human is sitting at). Naming this machine runs locally, no SSH. Same as --where device:<name>. See `agents devices`.')
         .option('--remote-cwd <dir>', "Explicit device working directory for --device runs, used VERBATIM (overrides --cwd; usually --cwd suffices — it re-roots a local-home path onto the remote home). Pass a single-quoted '$HOME/…' or a valid remote absolute path; a local ~ expands here and won't exist there (/Users/you vs /home/you).")
         .option('--no-follow', 'With --device, dispatch detached and return immediately (track via `agents hosts ps/logs`).')
         .option('--any', 'With --device <cap> (a capability tag), pick any matching device instead of erroring when several match.')
@@ -680,9 +707,9 @@ export function registerRunCommand(program) {
       agents run claude "fix lint errors in src/" --mode edit
 
       # Interactive (TUI): a bare run places itself like --device auto (a fleet
-      # worker, TUI forwarded over SSH); pin the device to stay on this machine
+      # worker, TUI forwarded over SSH); --local keeps it on this machine
       agents run claude
-      agents run claude --device zion      # stay local (or pick this machine in claude@)
+      agents run claude --local            # stay local (or pick this machine in claude@)
 
       # Pick a signed-in account/version for only this run (# = account picker)
       agents run claude#
@@ -790,10 +817,10 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
       Interactive placement: a bare 'agents run <harness>' (no prompt, real TTY)
         places itself like --device auto — a fleet worker runs it, with the TUI
         forwarded over SSH. Headless runs (any prompt, --json, no TTY) are
-        unchanged: they run in place. To stay on this machine, pass
-        --device <this machine>, or pick this machine (listed first) in the
-        '<harness>@' device picker. When placement finds no healthy device the
-        run fails loud and names the local spellings.
+        unchanged: they run in place. To stay on this machine, pass --local
+        (--device <this machine> means the same), or pick this machine (listed
+        first) in the '<harness>@' device picker. When placement finds no
+        healthy device the run fails loud and names the local spelling.
 
       Fallback: --fallback codex,antigravity retries on rate-limit failure via /continue handoff. Each entry accepts @version.
 
@@ -891,6 +918,11 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             const { placementFromRunFlags, expandPlacementToRunFlags, PlacementError } = await import('../lib/placement.js');
             try {
                 const placement = placementFromRunFlags(options);
+                // An explicit local placement (--local, --where local) must outlive
+                // this block: expansion yields no host flag, and the bare-interactive
+                // default below reads an empty host set as "decide for me".
+                if (placement.kind === 'local' && placement.source !== 'default')
+                    options.local = true;
                 if (options.where) {
                     const expanded = expandPlacementToRunFlags(placement);
                     if (expanded.host !== undefined)
@@ -918,6 +950,16 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 throw err;
             }
         }
+        // --device naming this machine (short id, MagicDNS name, loopback, or the
+        // `interactive` sentinel pinned here) is a local run, not a self-SSH: the
+        // hop probes its own login shell and times out under load. Pinned here,
+        // ahead of every placement gate, so the bare-interactive default sees an
+        // explicit local choice rather than an empty host set.
+        {
+            const { isSelfHost } = await import('../lib/devices/self-host.js');
+            const { isDeviceInteractive, resolveInteractiveDevice } = await import('../lib/devices/interactive-host.js');
+            pinLocalWhenTargetIsSelf(options, (name) => isSelfHost(isDeviceInteractive(name) ? resolveInteractiveDevice() ?? name : name));
+        }
         // Cloud refinement flags without the placement are a typo, not a no-op.
         if (!options.cloud) {
             const { cloudFlagsWithoutCloud } = await import('./run-cloud.js');
@@ -1101,13 +1143,13 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             const { sessionRecoveryDestinationMatches, sessionRecoveryPeer, } = await import('../lib/session/recovery.js');
             const sourceMachine = resolvedResumeSource.machine;
             const sourcePeer = sessionRecoveryPeer(resolvedResumeSource);
-            const explicitPlacement = hostTargetGiven(options).length > 0;
+            const explicitPlacement = hostTargetGiven(options).length > 0 || options.local === true;
             if (sourcePeer && !explicitPlacement) {
                 options.host = sourcePeer;
             }
             else if (sourcePeer && explicitPlacement && !hostTargetGiven(options).some((host) => sessionRecoveryDestinationMatches(resolvedResumeSource, host))) {
                 console.error(chalk.red(`Session ${resolvedResumeSource.shortId} must recover on ${sourcePeer}, where its conversation state is stored; ` +
-                    `the requested device was ${hostTargetGiven(options).join(', ')}.`));
+                    `the requested device was ${hostTargetGiven(options).join(', ') || 'this machine'}.`));
                 process.exit(1);
             }
             // Recovery is resolved on the device that owns the transcript. A remote
@@ -1246,8 +1288,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                 if (!defaultPlacement)
                     throw err;
                 console.error(chalk.red(err.message));
-                const { machineId } = await import('../lib/machine-id.js');
-                console.error(chalk.gray(`Run here instead: agents run ${runBaseAgentName} --device ${machineId()}`));
+                console.error(chalk.gray(`Run here instead: agents run ${runBaseAgentName} --local`));
                 process.exit(1);
             }
             if (!options.quiet && result.banner) {
@@ -2641,6 +2682,37 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
         // the only `continue` is the preflight exhaustion handoff below, which
         // consumes one entry of the `--fallback` spec before retrying as that
         // alternate. The spec is finite, so this terminates (PHNX-3999 F19).
+        // A balanced pick or the no-fresh-usage picker returns a CANDIDATE. Since
+        // PHNX-3940 a native candidate is a registered account SLOT, not the
+        // version home the executable lives in, so the spawn must resolve that
+        // slot (home + durable env) through the canonical local launch resolver.
+        // Without this the run launched the version home and whichever login it
+        // held: on yosemite-m0 (2026-09-23) the picker chose trp and Claude
+        // started as a different account in its first-run wizard. A remote run
+        // re-resolves on the peer, which runs this same code locally.
+        const applyPickedCandidate = async (candidate) => {
+            if (!candidate.nativeAccount || options.host || options.device)
+                return;
+            const { resolveLocalAccountLaunch } = await import('../lib/accounting/account-launch.js');
+            try {
+                launchAccount = await resolveLocalAccountLaunch({
+                    agent,
+                    executableVersion: version ?? candidate.version,
+                    candidate,
+                    useDefault: false,
+                });
+            }
+            catch (err) {
+                console.error(chalk.red(err.message));
+                process.exit(1);
+            }
+            if (launchAccount.execHome)
+                execHome = launchAccount.execHome;
+            if (launchAccount.configVersion)
+                accountConfigVersion = launchAccount.configVersion;
+            if (Object.keys(launchAccount.env).length > 0)
+                accountEnv = { ...accountEnv, ...launchAccount.env };
+        };
         preflight: for (;;) {
             if (!accountPickerRequested && !configuredAccount && (!version || strategy !== 'pinned' || options.balanced || explicitStrategy)) {
                 if (version) {
@@ -2778,6 +2850,7 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                                 // Keep the rotation so mid-run failover can still cascade across
                                 // the other (stale) healthy accounts after a real rejection.
                                 rotationResult = resolved.rotation;
+                                await applyPickedCandidate(selected);
                                 if (!options.quiet) {
                                     const identity = selected.accountLabel || 'signed-in account';
                                     process.stderr.write(chalk.gray(`[agents] no fresh usage for any ${agent} account — you picked ${identity} · ${agent}@${selected.version}\n`));
@@ -2796,12 +2869,13 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
                             if (resolved.rotation) {
                                 launchSignedIn = resolved.rotation.picked.signedIn;
                                 launchEmail = resolved.rotation.picked.email;
+                                await applyPickedCandidate(resolved.rotation.picked);
                             }
                             // A balanced/available pick of a PROVIDER account (setup-token /
                             // API-key) carries `providerAccount`. Resolve its env through the
                             // same `resolveSpawnAccount` path an explicit `--account` uses, so
                             // exec injects the credential; a native pick has no providerAccount
-                            // and runs from its own version home unchanged (RUSH-3182).
+                            // and resolved its slot home in applyPickedCandidate above.
                             const pickedProviderAccount = resolved.rotation?.picked.providerAccount;
                             if (pickedProviderAccount) {
                                 try {
@@ -3521,6 +3595,24 @@ agents run auto --device yosemite-s0 "fix the flaky test"   # pin the device
             // Governance chokepoint (#347): every dispatched run finalizes here.
             // ONE tamper-evident audit record per run — non-fatal by contract.
             recordDispatchedRun({ agent: ranAgent, version: ranVersion ?? 'unknown', mode, cwd, exitCode });
+            // A clean headless exit is real auth evidence — the account authenticated
+            // and produced a result. Record it as the per-account FACT `agents view`
+            // renders (`last used ok`), keyed to the slot the run used so it lands on
+            // the right row and clears any stale failure fact (PHNX-4116). A non-zero
+            // exit is NOT recorded as an auth failure: the exit code alone does not
+            // prove the token was rejected (a task can fail for a hundred reasons), and
+            // a lying "auth failure" fact is worse than none. Real auth failures are
+            // recorded where they are actually detected (the routine runner's
+            // isAuthFailureFromLog sites) and by the daemon probe.
+            if (exitCode === 0) {
+                recordRunAuthOutcome({
+                    agent: ranAgent,
+                    accountId: execOptions.accountId ?? null,
+                    version: ranVersion ?? null,
+                    home: execHome ?? null,
+                    outcome: { ok: true },
+                });
+            }
             // First-successful-run star nudge (one-time, non-nagging). Only on a
             // clean run, and never when output is machine-readable/quiet.
             if (exitCode === 0)

package/dist/commands/repo.js

@@ -55,34 +55,13 @@ function syncMarketplacesForDefaults() {
         catch { /* best-effort */ }
     }
 }
-/** Write this device's account metadata before the user repo is committed. */
-async function publishUserRepoAccountState(provisionAuth) {
-    const { publishUsageSnapshotToSharedStore } = await import('../lib/accounting/usage-sync.js');
-    const usage = await publishUsageSnapshotToSharedStore();
-    if (usage.error)
-        console.error(chalk.yellow(`Usage snapshot: ${usage.error}`));
-    if (provisionAuth) {
-        const { syncReservedAuthBundle } = await import('../lib/secrets-policy.js');
-        const auth = await syncReservedAuthBundle();
-        if (auth.pushed.length > 0)
-            console.log(chalk.gray(`Auth bundle: pushed to ${auth.pushed.join(', ')}`));
-        for (const err of auth.errors)
-            console.error(chalk.yellow(`Auth bundle: ${err.device}: ${err.message}`));
-        return;
-    }
-    const { publishReservedAuthVerdict } = await import('../lib/secrets-policy.js');
-    const auth = await publishReservedAuthVerdict();
-    if (auth.error)
-        console.error(chalk.yellow(`Auth verdict: ${auth.device}: ${auth.error}`));
-}
-/** Consume freshly pulled usage/auth metadata from the local user-repo checkout. */
-async function consumeUserRepoAccountState() {
-    const { consumeUsageSnapshotsFromSharedStore } = await import('../lib/accounting/usage-sync.js');
-    const usage = consumeUsageSnapshotsFromSharedStore();
-    if (usage.merged > 0)
-        console.log(chalk.gray(`Usage snapshot: merged ${usage.merged} row(s) from ${usage.sources.join(', ')}`));
-    for (const err of usage.errors)
-        console.error(chalk.yellow(`Usage snapshot: ${err.device}: ${err.message}`));
+/**
+ * Push the reserved auth bundle to peers whose last-received verdict says
+ * `missing`. Daemon state (usage, verdicts, session digests) no longer rides the
+ * user repo — it moves over SSH on the usage-sync tick (PHNX-4116) — so a repo
+ * push/sync of human-authored resources only runs this credential half.
+ */
+async function syncUserRepoAuthBundle() {
     const { syncReservedAuthBundle } = await import('../lib/secrets-policy.js');
     const auth = await syncReservedAuthBundle();
     if (auth.pushed.length > 0)
@@ -1085,7 +1064,7 @@ export function registerRepoCommands(program) {
             ].filter(Boolean);
             if (parts.length > 0)
                 console.log(chalk.gray(`Device policy: ${parts.join(' · ')}`));
-            await consumeUserRepoAccountState();
+            await syncUserRepoAuthBundle();
         }
     });
     repoCmd
@@ -1121,10 +1100,8 @@ export function registerRepoCommands(program) {
             return;
         }
         for (const t of pushable) {
-            // Account snapshots must exist BEFORE commitAndPush or this push ships
-            // the previous tick's state and delays propagation by one repo cycle.
             if (t.alias === 'user')
-                await publishUserRepoAccountState(true);
+                await syncUserRepoAuthBundle();
             const spinner = interruptibleSpinner(`Pushing ${formatRepoTarget(t.alias, t.dir)}...`).start();
             const result = await commitAndPush(t.dir, options.message);
             if (result.success) {
@@ -1193,23 +1170,10 @@ Examples:
                 }
             }
             const push = t.alias !== 'system';
-            // syncRepoGit pulls then pushes. Seed our conflict-free owner file first
-            // so the same transaction carries it; consume peers after the pull.
-            if (t.alias === 'user')
-                await publishUserRepoAccountState(false);
+            // A plain pull/rebase (+ push) of human-authored resources for every
+            // alias, the user repo included: daemon state left git (PHNX-4116).
             const spinner = interruptibleSpinner(`Syncing ${formatRepoTarget(t.alias, t.dir)}...`).start();
-            const result = t.alias === 'user'
-                ? await (async () => {
-                    const { syncFleetSharedStateRepo } = await import('../lib/fleet-shared-repo-sync.js');
-                    const synced = await syncFleetSharedStateRepo({ userAgentsDir: t.dir });
-                    return {
-                        success: synced.success,
-                        commit: synced.commit ?? '',
-                        pushed: synced.pushed,
-                        error: synced.error ?? synced.skipped ?? undefined,
-                    };
-                })()
-                : await syncRepoGit(t.dir, { push });
+            const result = await syncRepoGit(t.dir, { push });
             if (result.success) {
                 const pushed = result.pushed ? ' (pushed)' : '';
                 spinner.succeed(`${formatRepoTarget(t.alias, t.dir)}: ${result.commit}${pushed}`);
@@ -1219,7 +1183,7 @@ Examples:
                         recordUserRepoRemote(t.dir, u);
                     const { reconcileDeviceDiscoveryPolicies } = await import('../lib/devices/discovery-policy.js');
                     await reconcileDeviceDiscoveryPolicies();
-                    await consumeUserRepoAccountState();
+                    await syncUserRepoAuthBundle();
                 }
             }
             else {

package/dist/commands/route.js

@@ -95,13 +95,13 @@ export function registerRouteCommands(program) {
     setHelpSections(routeCmd, {
         examples: `
       # Create a router scoped to two harnesses, capped at a tier
-      agents route add research --harness gemini,kimi --tier cheap,default
+      agents route add research --harness grok,kimi --tier cheap,default
 
       # Narrow one harness's model set
       agents route allow research kimi kimi-k2
 
       # Link accounts so routing under this router only ever picks them
-      agents route link-account research gemini personal
+      agents route link-account research grok personal
       agents route link-account research kimi work
 
       # Inspect, rename, remove it
@@ -126,7 +126,7 @@ export function registerRouteCommands(program) {
         .command('add <name>')
         .alias('create')
         .description('Create a named router with an initial harness + tier allowlist.')
-        .option('--harness <list>', 'Comma-separated harness ids to allow, e.g. gemini,kimi')
+        .option('--harness <list>', 'Comma-separated harness ids to allow, e.g. grok,kimi')
         .option('--tier <list>', 'Comma-separated tier tokens applied to every listed harness, e.g. cheap,default')
         .option('--task <type>', 'Free-text task type this router serves, e.g. research')
         .action((name, opts) => {
@@ -134,7 +134,7 @@ export function registerRouteCommands(program) {
             die(`Router '${name}' already exists. Use 'agents route allow ${name} <harness> <model|tier>...' to edit it.`);
         }
         if (!opts.harness) {
-            die("Missing --harness. Example: agents route add research --harness gemini,kimi --tier cheap,default");
+            die("Missing --harness. Example: agents route add research --harness grok,kimi --tier cheap,default");
         }
         const harnesses = opts.harness.split(',').map((h) => h.trim()).filter(Boolean);
         const tiers = (opts.tier ?? '').split(',').map((t) => t.trim()).filter(Boolean);
@@ -170,7 +170,7 @@ export function registerRouteCommands(program) {
         }
         if (routers.length === 0) {
             console.log(chalk.gray('No routers configured.'));
-            console.log(chalk.gray('Try: agents route add research --harness gemini,kimi --tier cheap,default'));
+            console.log(chalk.gray('Try: agents route add research --harness grok,kimi --tier cheap,default'));
             return;
         }
         for (const router of routers)

package/dist/commands/routines.js

@@ -246,7 +246,7 @@ function renderRoutineRows({ jobs, scheduler, overdueSet, link, now, local = tru
                     : lastStatus === 'missed' ? chalk.magenta
                         : chalk.gray;
         const overdueTag = overdueSet.has(job.name) ? chalk.yellow(' (overdue)') : '';
-        // Append the concrete reason a routine did not complete (auth_failed, wedged,
+        // Append the concrete reason a routine did not complete (auth_failed,
         // blocked, missed) right in the Last Status cell, so the list answers "why"
         // without a drill-in. Only for non-completed local runs; peer rows stay blank.
         const reason = latestRun ? runFailureReason(latestRun) : null;
@@ -650,12 +650,29 @@ function routineMatchesQuery(job, q) {
         .toLowerCase()
         .includes(q);
 }
-/** Friendly one-liners for the claim a `skipped` run lost. */
+/**
+ * Friendly one-liners for the claim a `skipped` run lost — the reasons whose
+ * message is static. `active_run` is dynamic (it names the live run that owns
+ * the slot and when it started), built in {@link runFailureReason}: since
+ * PHNX-4116 there is no "wedged" daemon state, so an overlapping routine reads
+ * as `blocked` on the live run, not "wedged".
+ */
 const SKIP_REASON_LABEL = {
-    active_run: 'wedged: a prior run is still active',
     duplicate_slot: 'duplicate slot (already fired)',
     wrong_owner: 'pinned to another device',
 };
+/**
+ * A run id is an ISO timestamp with `:`/`.` replaced by `-` (`slotRunId` /
+ * `generateRunId`), so it reverses losslessly to the run's start time. Returns
+ * the ISO string, or null when the id is not that shape (a hand-set id).
+ */
+function runIdToStartIso(runId) {
+    const m = /^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/.exec(runId);
+    if (!m)
+        return null;
+    const iso = `${m[1]}T${m[2]}:${m[3]}:${m[4]}.${m[5]}Z`;
+    return Number.isFinite(Date.parse(iso)) ? iso : null;
+}
 /**
  * The short, human reason a run did not simply complete — for inline display in
  * the list/detail so "why did it fail" needs no dig into the run dir. Prefers the
@@ -670,6 +687,21 @@ export function runFailureReason(run) {
         const one = s.replace(/\s+/g, ' ').trim();
         return one.length > 80 ? one.slice(0, 79) + '…' : one;
     };
+    // An overlap skip names the live run it lost to (PHNX-4116): `blocked: run
+    // <id> active since <t>`, not the removed "wedged" wording. The structured
+    // `activeRunId` is preferred; a legacy record without it falls back to the
+    // errorMessage (which embeds the same id) so nothing regresses to vaguer text.
+    if (run.skipReason === 'active_run') {
+        if (run.activeRunId) {
+            const since = runIdToStartIso(run.activeRunId);
+            return since
+                ? `blocked: run ${run.activeRunId} active since ${since}`
+                : `blocked: run ${run.activeRunId} still active`;
+        }
+        if (run.errorMessage)
+            return compact(run.errorMessage);
+        return 'blocked: a prior run is still active';
+    }
     if (run.errorMessage)
         return compact(run.errorMessage);
     if (run.status === 'blocked' && run.readiness) {
@@ -751,8 +783,8 @@ function buildRoutineDetail(job, scheduler, now) {
                     : chalk.yellow(run.status);
             const dur = run.completedAt ? ` ${formatRunDuration(run.startedAt, run.completedAt)}` : '';
             // Surface WHY a run did not complete, inline, so "looking at status" does not
-            // require digging into the run dir. auth_failed / OAuth-revoked, a wedged
-            // active-run skip, or a readiness block all live on the RunMeta already.
+            // require digging into the run dir. auth_failed / OAuth-revoked, an
+            // active-run overlap skip, or a readiness block all live on the RunMeta already.
             const reason = runFailureReason(run);
             const why = reason ? chalk.gray(` — ${reason}`) : '';
             lines.push(`  ${run.startedAt}  ${status}${dur}${why}`);
@@ -1941,7 +1973,7 @@ export function registerRoutinesCommands(program) {
             chalk.gray(`  ${run.startedAt}`) +
             chalk.gray(formatRunDuration(run.startedAt, run.completedAt)) +
             (run.exitCode !== null && run.exitCode !== undefined ? chalk.gray(`  exit ${run.exitCode}`) : ''));
-        // The structured reason (auth_failed, blocked readiness, wedged skip) — the
+        // The structured reason (auth_failed, blocked readiness, overlap skip) — the
         // report/stdout tail below often buries or omits it, so name it up front.
         const logsReason = runFailureReason(run);
         if (logsReason)
@@ -2300,9 +2332,7 @@ export function registerRoutinesCommands(program) {
         console.log(chalk.bold('Scheduler\n'));
         const stateLabel = schedulerState === 'running'
             ? chalk.green('running')
-            : schedulerState === 'wedged'
-                ? chalk.red('wedged')
-                : chalk.gray('stopped');
+            : chalk.gray('stopped');
         console.log(`  Status:    ${stateLabel}`);
         console.log(`  Daemon:    ${status.running ? chalk.green('running') : chalk.gray('stopped')}`);
         if (status.pid)
@@ -2316,9 +2346,6 @@ export function registerRoutinesCommands(program) {
         const jobs = listAllJobs();
         const enabled = jobs.filter((j) => j.enabled);
         console.log(`  Routines:  ${enabled.length} enabled / ${jobs.length} total`);
-        if (status.state === 'wedged') {
-            console.log(chalk.red('\n  The shared daemon is wedged (heartbeat stale). Restart deliberately with: agents daemon restart'));
-        }
         if (schedulerState === 'running' && enabled.length > 0) {
             const scheduler = new JobScheduler(async () => { });
             scheduler.loadAll();

package/dist/commands/sessions-render.d.ts

@@ -1,6 +1,6 @@
 import type { Command } from 'commander';
 import type { SessionMeta } from '../lib/session/types.js';
-export declare const MARKDOWN_RENDER_AGENTS: readonly ["claude", "codex", "gemini", "antigravity", "opencode", "grok", "rush", "hermes", "kimi", "droid", "cursor"];
+export declare const MARKDOWN_RENDER_AGENTS: readonly ["claude", "codex", "antigravity", "opencode", "grok", "rush", "hermes", "kimi", "droid", "cursor"];
 export type ReasoningMode = 'omit' | 'fold' | 'include';
 /** Build one shareable Markdown document from the canonical preview and event model. */
 export declare function renderSessionMarkdownDocument(session: SessionMeta, options?: {

package/dist/commands/sessions-render.js

@@ -14,7 +14,6 @@ import { selectSessions } from './sessions-export.js';
 export const MARKDOWN_RENDER_AGENTS = [
     'claude',
     'codex',
-    'gemini',
     'antigravity',
     'opencode',
     'grok',

package/dist/commands/sessions.test-fixture.d.ts

@@ -15,7 +15,6 @@ export declare const tsxLoaderUrl: string;
 export declare function writeUpdateCache(tempHome: string): void;
 export declare function writeClaudeSession(tempHome: string, projectKey: string, sessionId: string, cwd: string, content: string, timestamp: string): void;
 export declare function writeCodexSession(tempHome: string, sessionId: string, cwd: string, prompt: string, timestamp: string): void;
-export declare function writeGeminiSession(tempHome: string, sessionId: string, cwd: string, prompt: string, timestamp: string, version?: string): void;
 export declare function writeOpenClawSetup(tempHome: string, version?: string): string;
 export declare function runAgents(args: string[], cwd: string, home: string, envOverrides?: Record<string, string>): import("node:child_process").SpawnSyncReturns<string>;
 export declare function outputOf(result: {

package/dist/commands/sessions.test-fixture.js

@@ -1,7 +1,6 @@
 import { describe } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
-import * as crypto from 'crypto';
 import { spawnSync } from 'child_process';
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
@@ -121,42 +120,6 @@ export function writeCodexSession(tempHome, sessionId, cwd, prompt, timestamp) {
     ];
     fs.writeFileSync(filePath, lines.join('\n') + '\n', 'utf-8');
 }
-export function writeGeminiSession(tempHome, sessionId, cwd, prompt, timestamp, version = '0.29.5') {
-    const versionHome = path.join(tempHome, '.agents', '.history', 'versions', 'gemini', version, 'home');
-    const geminiHome = path.join(versionHome, '.gemini');
-    const projectHash = crypto.createHash('sha256').update(cwd).digest('hex');
-    const chatsDir = path.join(geminiHome, 'tmp', projectHash, 'chats');
-    fs.mkdirSync(cwd, { recursive: true });
-    fs.mkdirSync(chatsDir, { recursive: true });
-    fs.mkdirSync(path.dirname(path.join(tempHome, '.gemini')), { recursive: true });
-    const activeGeminiHome = path.join(tempHome, '.gemini');
-    if (!fs.existsSync(activeGeminiHome)) {
-        fs.symlinkSync(geminiHome, activeGeminiHome);
-    }
-    fs.writeFileSync(path.join(geminiHome, 'projects.json'), JSON.stringify({ projects: [cwd] }), 'utf-8');
-    fs.writeFileSync(path.join(chatsDir, `session-${timestamp.replace(/[:.]/g, '-')}-${sessionId.slice(0, 8)}.json`), JSON.stringify({
-        sessionId,
-        projectHash,
-        startTime: timestamp,
-        lastUpdated: timestamp,
-        messages: [
-            {
-                id: `${sessionId}-user`,
-                timestamp,
-                type: 'user',
-                content: [{ text: prompt }],
-            },
-            {
-                id: `${sessionId}-assistant`,
-                timestamp,
-                type: 'gemini',
-                content: 'Investigating now.',
-                model: 'gemini-3-flash-preview',
-                tokens: { total: 1234 },
-            },
-        ],
-    }, null, 2), 'utf-8');
-}
 export function writeOpenClawSetup(tempHome, version = '2026.3.8') {
     const managedHome = path.join(tempHome, '.agents', '.history', 'versions', 'openclaw', version, 'home', '.openclaw');
     fs.mkdirSync(managedHome, { recursive: true });

package/dist/commands/setup-browser.d.ts

@@ -1,20 +1,25 @@
 /**
- * `agents setup browser` — interactive wizard to get `agents browser` working on
- * a fresh machine: detect an installed Chromium-family browser, create the
- * `default` profile pinned to it, optionally make it this machine's default, and
- * point the user at the one manual step we can't automate (first-run + sign-in).
+ * `agents setup browser` — get `agents browser` working on a fresh machine:
+ * install the standalone `browser` CLI (@phnx-labs/browser-cli), let it detect
+ * installed browsers and create machine-local profiles (`browser profiles seed`),
+ * then pick this machine's default (`browser use`).
  *
- * Idempotent: re-running shows the current default profile and offers to change
- * the pinned browser or re-point the device default.
+ * The engine owns profile declarations and browser detection now (PHNX-4101), so
+ * this wizard DELEGATES to it rather than crafting profiles itself. What stays
+ * agents-cli's is the onboarding flow and the readiness check over the shared
+ * `browser.profile` config key both CLIs read/write.
+ *
+ * Idempotent: `profiles seed` leaves existing profiles untouched, and `use`
+ * re-points the device default.
  */
 import type { Command } from 'commander';
 /**
- * Interactive browser setup. Returns true if a usable default profile exists
- * afterwards, false if none exists / the user backed out. Non-interactively it
- * only RECOGNIZES an existing profile — it never creates one (PHNX-3296), since
- * silently minting a logged-out `auto-chrome` on a headless box is the exact bug
- * that removed; a headless box gets its browser from the fleet hub. Never throws
- * on cancel — the `agents setup` hub relies on that.
+ * Interactive browser setup. Returns true if a default profile is configured
+ * afterwards, false if none is / the user backed out. Non-interactively it only
+ * RECOGNIZES an existing default — it never creates one (PHNX-3296), since
+ * silently minting a logged-out profile on a headless box is the exact bug that
+ * removed; a headless box gets its browser from the fleet hub. Never throws on
+ * cancel — the `agents setup` hub relies on that.
  */
 export declare function runBrowserWizard(): Promise<boolean>;
 /** Register `agents setup browser` under the parent `setup` command. */