@phnx-labs/agents-cli 1.20.88 → 1.20.90

package/dist/lib/commands.js

@@ -11,6 +11,7 @@ import * as path from 'path';
 import * as yaml from 'yaml';
 import { AGENTS, ensureCommandsDir, agentConfigDirName, resolveAgentName } from './agents.js';
 import { capableAgents, isCapable, supports } from './capabilities.js';
+import { isDirectoryDoc } from './resources.js';
 import { markdownToToml } from './convert.js';
 import { getCommandsDir, getUserCommandsDir, getEnabledExtraRepos, getProjectAgentsDir, getSkillsDir, getTrashCommandsDir } from './state.js';
 import { getEffectiveHome, getVersionHomePath, listInstalledVersions, resolveVersion } from './versions.js';
@@ -150,6 +151,8 @@ export function discoverCommands(repoPath) {
         for (const file of fs.readdirSync(commandsDir)) {
             if (file.endsWith('.md')) {
                 const name = file.replace('.md', '');
+                if (isDirectoryDoc('commands', name))
+                    continue;
                 const sourcePath = path.join(commandsDir, file);
                 const metadata = parseCommandMetadata(sourcePath);
                 const validation = validateCommandMetadata(metadata, name);
@@ -694,7 +697,12 @@ export function listCentralCommands() {
         if (!fs.existsSync(dir))
             continue;
         for (const f of fs.readdirSync(dir).filter((f) => f.endsWith('.md'))) {
-            seen.add(f.replace('.md', ''));
+            const name = f.replace('.md', '');
+            // A directory's README/AGENTS/CLAUDE/GEMINI documents the dir, it is not a
+            // command. Without this the picker offers a name resolveResource refuses.
+            if (isDirectoryDoc('commands', name))
+                continue;
+            seen.add(name);
         }
     }
     return Array.from(seen);

package/dist/lib/daemon.d.ts

@@ -86,6 +86,23 @@ export declare function log(level: string, message: string): void;
  * anchoring failed (logged, non-fatal).
  */
 export declare function anchorDaemonCwd(): string | null;
+/**
+ * Surface, at the daemon's OWN startup, that it was launched from an ephemeral
+ * root that will wedge it if the directory is removed. This is the runtime
+ * companion to the launch-time check in validateDaemonBinary (which only runs
+ * when the daemon is *spawned* via getDaemonLaunch): a direct
+ * `agents __daemon-run` from a temp or worktree build — e.g. a review/verify
+ * checkout under /tmp — never passes through that path, so without this the
+ * wedge risk stays invisible until jobs start ENOENT-ing on their dynamic
+ * imports. Best-effort and non-fatal; the cwd is already handled by
+ * anchorDaemonCwd, but a deleted module root can only be flagged, not repaired.
+ *
+ * `resolveBin` is injectable (defaults to getAgentsBinPath) so the wiring — the
+ * predicate call, the WARN, and the non-fatal guard around a throwing resolver —
+ * is testable. Returns the warning message it logged, or null when the launch
+ * root is stable (or could not be resolved).
+ */
+export declare function warnEphemeralDaemonRoot(resolveBin?: () => string): string | null;
 export declare function runDaemon(): Promise<void>;
 /**
  * Write a launchd plist or systemd unit with owner-only permissions atomically.
@@ -175,6 +192,18 @@ export declare function getAgentsInvocation(subArgs: string[], agentsBin?: strin
     command: string;
     args: string[];
 };
+/**
+ * A daemon binary living under an ephemeral path — a git worktree, or a temp
+ * directory (`/tmp`, `/var/folders`, `/dev/shm`) — is a latent wedge. The daemon
+ * is long-lived but resolves its own job modules by dynamic `import()` rooted at
+ * this entry (getAgentsBinPath → process.argv[1]). If that directory is later
+ * removed (`git worktree remove`, a `/tmp` cleanup, a review/verify checkout
+ * teardown) the running daemon keeps ENOENT-ing on every job it loads —
+ * `anchorDaemonCwd` rescues the cwd, but nothing can re-root a deleted module
+ * tree. Returns a human phrase naming the ephemeral kind, or null for a stable
+ * install path (version home, a global npm prefix, a normal source checkout).
+ */
+export declare function describeEphemeralDaemonRoot(binPath: string): string | null;
 export declare function validateDaemonBinary(binPath: string): {
     warnings: string[];
 };

package/dist/lib/daemon.js

@@ -321,6 +321,39 @@ export function anchorDaemonCwd() {
         return null;
     }
 }
+/**
+ * Surface, at the daemon's OWN startup, that it was launched from an ephemeral
+ * root that will wedge it if the directory is removed. This is the runtime
+ * companion to the launch-time check in validateDaemonBinary (which only runs
+ * when the daemon is *spawned* via getDaemonLaunch): a direct
+ * `agents __daemon-run` from a temp or worktree build — e.g. a review/verify
+ * checkout under /tmp — never passes through that path, so without this the
+ * wedge risk stays invisible until jobs start ENOENT-ing on their dynamic
+ * imports. Best-effort and non-fatal; the cwd is already handled by
+ * anchorDaemonCwd, but a deleted module root can only be flagged, not repaired.
+ *
+ * `resolveBin` is injectable (defaults to getAgentsBinPath) so the wiring — the
+ * predicate call, the WARN, and the non-fatal guard around a throwing resolver —
+ * is testable. Returns the warning message it logged, or null when the launch
+ * root is stable (or could not be resolved).
+ */
+export function warnEphemeralDaemonRoot(resolveBin = getAgentsBinPath) {
+    try {
+        const bin = resolveBin();
+        const ephemeralRoot = describeEphemeralDaemonRoot(bin);
+        if (!ephemeralRoot)
+            return null;
+        const message = `Daemon launched from ${ephemeralRoot} (${bin}); if that directory is removed, ` +
+            `every routine will fail with ENOENT on its module imports. Run the daemon from the ` +
+            `globally installed binary instead (npm i -g @phnx-labs/agents-cli), then restart it.`;
+        log('WARN', message);
+        return message;
+    }
+    catch (err) {
+        log('WARN', `Could not check daemon launch root: ${err.message}`);
+        return null;
+    }
+}
 export async function runDaemon() {
     // Single-instance guard: a direct `agents __daemon-run` (manual, or a
     // service-manager restart racing a live predecessor) must not clobber a
@@ -334,6 +367,7 @@ export async function runDaemon() {
     }
     log('INFO', `Daemon started (PID: ${process.pid})`);
     anchorDaemonCwd();
+    warnEphemeralDaemonRoot();
     // The daemon holds NO Claude credential of its own. Routine runs authenticate
     // exactly like an interactive `agents run`: through the per-account
     // CLAUDE_CONFIG_DIR login on this device (its own auto-refreshing
@@ -1106,15 +1140,35 @@ function daemonPathValue(agentsBin, systemDirs) {
 export function getAgentsInvocation(subArgs, agentsBin = getAgentsBinPath()) {
     return getCliLaunch(subArgs, agentsBin);
 }
+/**
+ * A daemon binary living under an ephemeral path — a git worktree, or a temp
+ * directory (`/tmp`, `/var/folders`, `/dev/shm`) — is a latent wedge. The daemon
+ * is long-lived but resolves its own job modules by dynamic `import()` rooted at
+ * this entry (getAgentsBinPath → process.argv[1]). If that directory is later
+ * removed (`git worktree remove`, a `/tmp` cleanup, a review/verify checkout
+ * teardown) the running daemon keeps ENOENT-ing on every job it loads —
+ * `anchorDaemonCwd` rescues the cwd, but nothing can re-root a deleted module
+ * tree. Returns a human phrase naming the ephemeral kind, or null for a stable
+ * install path (version home, a global npm prefix, a normal source checkout).
+ */
+export function describeEphemeralDaemonRoot(binPath) {
+    if (/[/\\]\.agents[/\\]worktrees[/\\]/.test(binPath))
+        return 'a git worktree';
+    if (/^(?:\/private)?\/tmp[/\\]|^(?:\/private)?\/var\/folders[/\\]|^\/dev\/shm[/\\]/.test(binPath)) {
+        return 'a temporary directory';
+    }
+    return null;
+}
 export function validateDaemonBinary(binPath) {
     const warnings = [];
     if (BUN_VIRTUAL_ROOT.test(binPath)) {
         throw new Error(`Refusing to supervise daemon: resolved binary is a bun virtual path (${binPath}). ` +
             `Install agents globally (npm i -g @phnx-labs/agents-cli) and restart.`);
     }
-    if (/[/\\]\.agents[/\\]worktrees[/\\]/.test(binPath)) {
-        warnings.push(`Warning: daemon binary is inside a git worktree (${binPath}). ` +
-            `A worktree deletion will wedge the daemon. Use the globally installed binary instead.`);
+    const ephemeralRoot = describeEphemeralDaemonRoot(binPath);
+    if (ephemeralRoot) {
+        warnings.push(`Warning: daemon binary is inside ${ephemeralRoot} (${binPath}). ` +
+            `Deleting it will wedge the daemon. Use the globally installed binary instead.`);
     }
     if (!fs.existsSync(binPath) && !/\.(c|m)?js$/.test(binPath)) {
         warnings.push(`Warning: daemon binary does not exist on disk (${binPath}).`);
@@ -1132,7 +1186,7 @@ export function startDetached(opts = {}) {
     // and a console-close event tears it down when the launcher exits (#556).
     const child = spawn(command, args, {
         stdio: ['ignore', logFd, logFd],
-        ...backgroundSpawnOptions({ fdStdio: true }),
+        ...backgroundSpawnOptions({ cwd: os.homedir(), fdStdio: true }),
         env: opts.env ?? process.env,
     });
     // A failed spawn (ENOENT/EACCES) emits 'error' asynchronously; without a

package/dist/lib/events.d.ts

@@ -13,7 +13,7 @@
  */
 import { type ActorKind } from './actor.js';
 export type EventLevel = 'audit' | 'warn' | 'info' | 'debug';
-export type EventType = 'agent.run.start' | 'agent.run.end' | 'agent.spawn.start' | 'agent.spawn.end' | 'version.install' | 'version.switch' | 'version.remove' | 'skill.install' | 'skill.remove' | 'browser.launch' | 'browser.close' | 'browser.navigate' | 'browser.screenshot' | 'secrets.get' | 'secrets.unlocked' | 'secrets.set' | 'secrets.delete' | 'secrets.rename' | 'cloud.dispatch' | 'cloud.complete' | 'cloud.cancel' | 'cloud.message' | 'teams.create' | 'teams.add' | 'teams.start' | 'teams.complete' | 'teams.disband' | 'hook.fire' | 'hook.complete' | 'hook.error' | 'mcp.add' | 'mcp.remove' | 'mcp.register' | 'resource.sync' | 'rotation.resolved' | 'command.start' | 'command.end' | 'perf.timing' | 'session.start' | 'session.end' | 'plan.created' | 'pr.opened' | 'pr.merged' | 'worktree.created' | 'worktree.removed' | 'commit.created' | 'pushed' | 'subagent.spawned' | 'artifact.created' | 'task.completed' | 'checklist.created' | 'status.posted' | 'file.edited' | 'friction' | 'error' | 'warn' | 'info' | 'debug';
+export type EventType = 'agent.run.start' | 'agent.run.end' | 'agent.spawn.start' | 'agent.spawn.end' | 'version.install' | 'version.switch' | 'version.remove' | 'skill.install' | 'skill.remove' | 'browser.launch' | 'browser.close' | 'browser.navigate' | 'browser.screenshot' | 'secrets.get' | 'secrets.unlocked' | 'secrets.set' | 'secrets.delete' | 'secrets.rename' | 'cloud.dispatch' | 'cloud.complete' | 'cloud.cancel' | 'cloud.message' | 'teams.create' | 'teams.add' | 'teams.start' | 'teams.complete' | 'teams.disband' | 'hook.fire' | 'hook.complete' | 'hook.error' | 'mcp.add' | 'mcp.remove' | 'mcp.register' | 'resource.sync' | 'rotation.resolved' | 'command.start' | 'command.end' | 'perf.timing' | 'session.start' | 'session.end' | 'webhook.received' | 'webhook.authorized' | 'webhook.rejected' | 'webhook.matched' | 'webhook.fired' | 'webhook.handler.start' | 'webhook.handler.end' | 'plan.created' | 'pr.opened' | 'pr.merged' | 'worktree.created' | 'worktree.removed' | 'commit.created' | 'pushed' | 'subagent.spawned' | 'artifact.created' | 'task.completed' | 'checklist.created' | 'status.posted' | 'file.edited' | 'friction' | 'error' | 'warn' | 'info' | 'debug';
 export declare function levelFor(event: EventType): EventLevel;
 export interface EventMeta {
     ts: string;

package/dist/lib/factory/snapshot.d.ts

@@ -0,0 +1,78 @@
+import { type ActiveSession } from '../session/active.js';
+import { serializeActiveSessionsForJson } from '../../commands/sessions.js';
+import { readAuthHealthCache, type AuthVerdict } from '../auth-health.js';
+import { readStatsCache } from '../devices/stats-cache.js';
+export declare const FACTORY_PROJECTS: readonly [{
+    readonly name: "Prix";
+    readonly repo: "phnx-labs/prix";
+}, {
+    readonly name: "Rush App";
+    readonly repo: "phnx-labs/rush";
+}, {
+    readonly name: "Rush CLI";
+    readonly repo: "phnx-labs/rush-cli";
+}, {
+    readonly name: "Agents CLI";
+    readonly repo: "phnx-labs/agents-cli";
+}, {
+    readonly name: "Linear CLI";
+    readonly repo: "phnx-labs/linear-cli";
+}];
+export interface FactoryConfig {
+    source: 'default' | 'file';
+    ceiling: number;
+    max_dispatch_per_tick: number;
+    per_project: Record<string, {
+        weight: number;
+        cap: number;
+    }>;
+    idle_boxes: string[];
+    digest: {
+        times: string[];
+        tz: string;
+    };
+}
+export interface FactorySnapshot {
+    generatedAt: string;
+    sessions: ReturnType<typeof serializeActiveSessionsForJson>;
+    queues: Record<string, {
+        todo: number;
+        inProgress: number;
+        blocked: number;
+    }>;
+    prs: Array<{
+        repo: string;
+        number: number;
+        ci: string;
+        review: string;
+        mergeable: string;
+    }>;
+    devices: Array<{
+        name: string;
+        load: number | null;
+        idle: boolean;
+    }>;
+    recentRuns: Array<{
+        routine: string;
+        status: string;
+        durationMs: number | null;
+    }>;
+    auth: {
+        claude: AuthVerdict | null;
+    };
+    config: FactoryConfig;
+}
+export interface SnapshotDependencies {
+    home: string;
+    now: () => Date;
+    activeSessions: () => Promise<ActiveSession[]>;
+    run: (file: string, args: string[]) => Promise<string>;
+    readAuth: () => ReturnType<typeof readAuthHealthCache>;
+    readDeviceStats: () => ReturnType<typeof readStatsCache>;
+}
+export declare function readFactoryConfig(home: string): FactoryConfig;
+export declare function queueCounts(todoPayload: unknown, openPayload: unknown): FactorySnapshot['queues'][string];
+export declare function parsePullRequests(repo: string, payload: unknown): FactorySnapshot['prs'];
+export declare function parseDevices(payload: unknown, cached?: ReturnType<typeof readStatsCache>): FactorySnapshot['devices'];
+export declare function readRecentRuns(home: string, limit?: number): FactorySnapshot['recentRuns'];
+export declare function buildFactorySnapshot(overrides?: Partial<SnapshotDependencies>): Promise<FactorySnapshot>;

package/dist/lib/factory/snapshot.js

@@ -0,0 +1,209 @@
+/**
+ * Read-only Software Factory state aggregation.
+ *
+ * ~/.agents/factory.yml example:
+ *
+ * ceiling: 4
+ * max_dispatch_per_tick: 2
+ * per_project:
+ *   Agents CLI: { weight: 2, cap: 2 }
+ * idle_boxes: [yosemite-m1, yosemite-m2]
+ * digest: { times: ["09:00", "17:00"], tz: America/Los_Angeles }
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { execFile as execFileCallback } from 'child_process';
+import { promisify } from 'util';
+import * as yaml from 'yaml';
+import { getActiveSessions } from '../session/active.js';
+import { serializeActiveSessionsForJson } from '../../commands/sessions.js';
+import { readAuthHealthCache } from '../auth-health.js';
+import { readStatsCache } from '../devices/stats-cache.js';
+const execFile = promisify(execFileCallback);
+export const FACTORY_PROJECTS = [
+    { name: 'Prix', repo: 'phnx-labs/prix' },
+    { name: 'Rush App', repo: 'phnx-labs/rush' },
+    { name: 'Rush CLI', repo: 'phnx-labs/rush-cli' },
+    { name: 'Agents CLI', repo: 'phnx-labs/agents-cli' },
+    { name: 'Linear CLI', repo: 'phnx-labs/linear-cli' },
+];
+const defaults = () => ({
+    source: 'default',
+    ceiling: 4,
+    max_dispatch_per_tick: 2,
+    per_project: {},
+    idle_boxes: [],
+    digest: { times: [], tz: Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC' },
+});
+export function readFactoryConfig(home) {
+    const file = path.join(home, '.agents', 'factory.yml');
+    if (!fs.existsSync(file))
+        return defaults();
+    const raw = yaml.parse(fs.readFileSync(file, 'utf8'));
+    if (!raw || typeof raw !== 'object')
+        throw new Error(`${file} must contain a YAML mapping`);
+    const base = defaults();
+    return {
+        source: 'file',
+        ceiling: integer(raw.ceiling ?? base.ceiling, 'ceiling'),
+        max_dispatch_per_tick: integer(raw.max_dispatch_per_tick ?? base.max_dispatch_per_tick, 'max_dispatch_per_tick'),
+        per_project: parseProjectConfig(raw.per_project),
+        idle_boxes: stringArray(raw.idle_boxes, 'idle_boxes'),
+        digest: raw.digest ? {
+            times: stringArray(raw.digest.times, 'digest.times'),
+            tz: typeof raw.digest.tz === 'string' ? raw.digest.tz : base.digest.tz,
+        } : base.digest,
+    };
+}
+function integer(value, name) {
+    if (!Number.isInteger(value) || value < 0)
+        throw new Error(`factory.yml ${name} must be a non-negative integer`);
+    return value;
+}
+function stringArray(value, name) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.some((v) => typeof v !== 'string'))
+        throw new Error(`factory.yml ${name} must be a string array`);
+    return value;
+}
+function parseProjectConfig(value) {
+    if (value === undefined)
+        return {};
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('factory.yml per_project must be a mapping');
+    return Object.fromEntries(Object.entries(value).map(([name, item]) => {
+        const record = item;
+        return [name, { weight: integer(record?.weight, `per_project.${name}.weight`), cap: integer(record?.cap, `per_project.${name}.cap`) }];
+    }));
+}
+function json(text) {
+    return JSON.parse(text);
+}
+function issueCount(payload) {
+    if (Array.isArray(payload))
+        return payload.length;
+    if (payload && typeof payload === 'object') {
+        const record = payload;
+        if (typeof record.count === 'number')
+            return record.count;
+        if (Array.isArray(record.issues))
+            return record.issues.length;
+    }
+    return 0;
+}
+export function queueCounts(todoPayload, openPayload) {
+    const issues = openPayload && typeof openPayload === 'object' && Array.isArray(openPayload.issues)
+        ? openPayload.issues : [];
+    const blocked = issues.filter((issue) => {
+        const state = issue.state && typeof issue.state === 'object' ? issue.state : {};
+        const labels = issue.labels && typeof issue.labels === 'object' && Array.isArray(issue.labels.nodes)
+            ? issue.labels.nodes : [];
+        return String(state.name ?? '').toLowerCase().includes('block') || labels.some((label) => String(label.name ?? '').toLowerCase() === 'blocked');
+    }).length;
+    const inProgress = issues.filter((issue) => {
+        const state = issue.state && typeof issue.state === 'object' ? issue.state : {};
+        return String(state.type ?? '').toLowerCase() === 'started' && !String(state.name ?? '').toLowerCase().includes('block');
+    }).length;
+    return { todo: issueCount(todoPayload), inProgress, blocked };
+}
+export function parsePullRequests(repo, payload) {
+    if (!Array.isArray(payload))
+        return [];
+    return payload.map((raw) => {
+        const pr = raw;
+        const checks = Array.isArray(pr.statusCheckRollup) ? pr.statusCheckRollup : [];
+        const states = checks.map((check) => String(check.conclusion ?? check.state ?? check.status ?? '').toUpperCase());
+        const ci = states.some((s) => ['FAILURE', 'ERROR', 'CANCELLED', 'TIMED_OUT'].includes(s)) ? 'failing'
+            : states.some((s) => ['', 'PENDING', 'QUEUED', 'IN_PROGRESS'].includes(s)) ? 'pending'
+                : states.length > 0 ? 'passing' : 'none';
+        return {
+            repo,
+            number: Number(pr.number),
+            ci,
+            review: String(pr.reviewDecision ?? 'none').toLowerCase(),
+            mergeable: String(pr.mergeable ?? 'unknown').toLowerCase(),
+        };
+    });
+}
+export function parseDevices(payload, cached = {}) {
+    const rows = Array.isArray(payload) ? payload : [];
+    return rows.map((raw) => {
+        const row = raw;
+        const name = String(row.name ?? row.host ?? '');
+        const stats = row.stats && typeof row.stats === 'object' ? row.stats : cached[name] ?? row;
+        const candidate = stats.loadPercent ?? stats.load ?? stats.loadPct;
+        const load = typeof candidate === 'number' && Number.isFinite(candidate) ? candidate : null;
+        return { name, load, idle: row.idle === true || (load !== null && load < 20) };
+    }).filter((row) => row.name.length > 0);
+}
+export function readRecentRuns(home, limit = 3) {
+    const root = path.join(home, '.agents', '.history', 'runs');
+    if (!fs.existsSync(root))
+        return [];
+    const found = [];
+    for (const routine of fs.readdirSync(root)) {
+        const routineDir = path.join(root, routine);
+        if (!fs.statSync(routineDir).isDirectory())
+            continue;
+        const routineRuns = [];
+        for (const run of fs.readdirSync(routineDir)) {
+            const file = path.join(routineDir, run, 'meta.json');
+            if (!fs.existsSync(file))
+                continue;
+            try {
+                const meta = JSON.parse(fs.readFileSync(file, 'utf8'));
+                const started = Date.parse(String(meta.startedAt ?? meta.createdAt ?? ''));
+                const ended = Date.parse(String(meta.finishedAt ?? meta.completedAt ?? meta.updatedAt ?? ''));
+                const duration = typeof meta.durationMs === 'number' ? meta.durationMs : Number.isFinite(started) && Number.isFinite(ended) ? ended - started : null;
+                routineRuns.push({ routine, status: String(meta.status ?? 'unknown'), durationMs: duration, mtime: fs.statSync(file).mtimeMs });
+            }
+            catch { /* A concurrently-written or malformed run is not a completed outcome. */ }
+        }
+        found.push(...routineRuns.sort((a, b) => b.mtime - a.mtime).slice(0, limit));
+    }
+    return found.sort((a, b) => b.mtime - a.mtime).map(({ mtime: _, ...run }) => run);
+}
+function latestClaudeVerdict(entries) {
+    return Object.entries(entries)
+        .filter(([key]) => key.split(':').includes('claude'))
+        .map(([, value]) => value)
+        .sort((a, b) => b.checkedAt - a.checkedAt)[0]?.verdict ?? null;
+}
+export async function buildFactorySnapshot(overrides = {}) {
+    const deps = {
+        home: os.homedir(),
+        now: () => new Date(),
+        activeSessions: () => getActiveSessions(),
+        run: async (file, args) => (await execFile(file, args, { maxBuffer: 10 * 1024 * 1024 })).stdout,
+        readAuth: readAuthHealthCache,
+        readDeviceStats: readStatsCache,
+        ...overrides,
+    };
+    const linear = path.join(deps.home, '.agents', 'skills', 'linear', 'scripts', 'linear');
+    const safeRun = async (file, args) => {
+        try {
+            return json(await deps.run(file, args));
+        }
+        catch {
+            return null;
+        }
+    };
+    const sessionsPromise = deps.activeSessions().then(serializeActiveSessionsForJson);
+    const queuePromise = Promise.all(FACTORY_PROJECTS.map(async ({ name }) => {
+        const query = (status) => safeRun(linear, ['tasks', '--project', name, '--label', 'pilot', '--status', status, '--cycle', 'all', '--all', '--json']);
+        const [todo, open] = await Promise.all([query('todo'), query('open')]);
+        return [name, queueCounts(todo, open)];
+    })).then(Object.fromEntries);
+    const prsPromise = Promise.all(FACTORY_PROJECTS.map(async ({ repo }) => parsePullRequests(repo, await safeRun('gh', ['pr', 'list', '--repo', repo, '--state', 'open', '--json', 'number,title,statusCheckRollup,reviewDecision,mergeable'])))).then((rows) => rows.flat());
+    // `devices list --json` is the registry's read-only JSON surface. Load comes
+    // from the daemon-warmed cache so snapshot never probes or writes reachability.
+    const devicesPromise = safeRun('agents', ['devices', 'list', '--json']).then((payload) => parseDevices(payload, deps.readDeviceStats()));
+    const [sessions, queues, prs, devices] = await Promise.all([sessionsPromise, queuePromise, prsPromise, devicesPromise]);
+    return {
+        generatedAt: deps.now().toISOString(), sessions, queues, prs, devices,
+        recentRuns: readRecentRuns(deps.home), auth: { claude: latestClaudeVerdict(deps.readAuth()) },
+        config: readFactoryConfig(deps.home),
+    };
+}

package/dist/lib/fs-atomic.d.ts

@@ -16,9 +16,22 @@ export declare function atomicWriteFileSync(filePath: string, content: string, o
  * releases the lock. Retries with capped linear back-off until either the lock
  * is acquired or LOCK_ACQUIRE_TIMEOUT_MS elapses. Breaks stale locks older than
  * LOCK_STALE_MS, so a crashed holder never blocks past the stale window.
+ *
+ * `fn` is handed a `heartbeat()` it can call during a long, fully SYNCHRONOUS
+ * critical section. proper-lockfile keeps a held lock "alive" by refreshing its
+ * lockfile mtime on a `setTimeout` every `stale/2` — but that timer only fires
+ * when the event loop gets a turn. A synchronous hold that outruns `stale`
+ * (e.g. the scrypt-bound rotation loop in filestore.ts, ~16s on a real store)
+ * never yields, so the timer cannot run: the lock ages past `stale` mid-hold and a
+ * peer contending for it treats the live holder as crashed, breaks the lock, and
+ * interleaves — corrupting the invariant the lock exists to protect, with no crash
+ * involved. `heartbeat()` drives the same refresh synchronously (bumps the lockfile
+ * mtime), so a long sync holder stays fresh while the short `stale` window still
+ * detects a genuinely crashed holder within LOCK_STALE_MS. Callers whose critical
+ * section is short (a single read-modify-write) can ignore it.
  */
 export interface FileLockOptions {
     staleMs?: number;
     acquireTimeoutMs?: number;
 }
-export declare function withFileLock<T>(filePath: string, fn: () => T, opts?: FileLockOptions): T;
+export declare function withFileLock<T>(filePath: string, fn: (heartbeat: () => void) => T, opts?: FileLockOptions): T;

package/dist/lib/fs-atomic.js

@@ -58,12 +58,20 @@ export function atomicWriteFileSync(filePath, content, options = 'utf-8') {
 export function withFileLock(filePath, fn, opts = {}) {
     let release = null;
     let lastError;
+    // Set if a peer breaks this lock while we hold it. proper-lockfile reports that
+    // from its own refresh TIMER, so the default handler rethrows asynchronously —
+    // an uncatchable crash of the whole CLI process, from a callback no caller is
+    // on the stack for. Capture it instead and surface it synchronously below.
+    let compromised = null;
     const staleMs = opts.staleMs ?? LOCK_STALE_MS;
     const acquireTimeoutMs = opts.acquireTimeoutMs ?? LOCK_ACQUIRE_TIMEOUT_MS;
     const deadline = Date.now() + acquireTimeoutMs;
     for (let attempt = 0;; attempt++) {
         try {
-            release = lockfile.lockSync(filePath, { stale: staleMs });
+            release = lockfile.lockSync(filePath, {
+                stale: staleMs,
+                onCompromised: (err) => { compromised = err; },
+            });
             break;
         }
         catch (err) {
@@ -78,10 +86,34 @@ export function withFileLock(filePath, fn, opts = {}) {
         const message = lastError instanceof Error ? lastError.message : String(lastError);
         throw new Error(`Could not acquire lock for ${filePath} after ${acquireTimeoutMs}ms: ${message}`);
     }
+    // proper-lockfile's lock dir is `<filePath>.lock`; touching its mtime is exactly
+    // what proper-lockfile's own async updater does, so the staleness check keys off
+    // a fresh mtime. Best-effort: a failed touch just leaves the async updater's
+    // behaviour unchanged (no worse than before this heartbeat existed).
+    const lockDir = `${filePath}.lock`;
+    const heartbeat = () => {
+        try {
+            const now = new Date();
+            fs.utimesSync(lockDir, now, now);
+        }
+        catch { /* best effort */ }
+    };
     try {
-        return fn();
+        const result = fn(heartbeat);
+        // A compromised lock means a peer may have written under us — the caller must
+        // not treat the result as if it held exclusivity throughout.
+        if (compromised) {
+            throw new Error(`Lock for ${filePath} was broken by another process while held: ` +
+                `${compromised.message}`);
+        }
+        return result;
     }
     finally {
-        release();
+        // Releasing a lock a peer already stole throws ENOTACQUIRED; that is the
+        // stolen case, already reported above, so don't mask it with a teardown error.
+        try {
+            release();
+        }
+        catch { /* already gone */ }
     }
 }

package/dist/lib/funnel.d.ts

@@ -2,4 +2,5 @@ export declare const FUNNEL_PORTS: readonly [443, 8443, 10000];
 export type FunnelPort = typeof FUNNEL_PORTS[number];
 export declare function parseFunnelPort(value: string | number): FunnelPort;
 export declare function buildFunnelStatusCommand(): string;
+export declare function buildFunnelDownCommand(publicPort: FunnelPort): string;
 export declare function buildFunnelUpCommand(publicPort: FunnelPort, localPort: number): string;

package/dist/lib/funnel.js

@@ -9,6 +9,14 @@ export function parseFunnelPort(value) {
 export function buildFunnelStatusCommand() {
     return 'tailscale funnel status';
 }
+export function buildFunnelDownCommand(publicPort) {
+    return [
+        'tailscale',
+        'funnel',
+        `--https=${publicPort}`,
+        'off',
+    ].map(shellQuote).join(' ');
+}
 export function buildFunnelUpCommand(publicPort, localPort) {
     if (!Number.isInteger(localPort) || localPort <= 0 || localPort > 65535) {
         throw new Error('Local port must be between 1 and 65535');

package/dist/lib/hosts/dispatch.js

@@ -93,7 +93,25 @@ export function remoteCdPrefix(remoteCwd, opts = {}) {
  * collision, mirroring `buildExecEnv`'s `...options.env` precedence (exec.ts).
  */
 export function withActorEnv(env) {
-    return { ...actorEnv(resolveActor()), ...(env ?? {}) };
+    return { ...actorEnv(resolveActor()), ...terminalIdEnv(), ...(env ?? {}) };
+}
+/**
+ * Forward the launching editor tab's `AGENT_TERMINAL_ID` across the SSH hop.
+ *
+ * Factory stamps it on every terminal it spawns, and the remote `agents run`
+ * records it in its pid registry (`writePidSessionEntry`) — which is what lets a
+ * tab ask the device "which session is MY terminal running?" instead of guessing
+ * from local state. Without the forward the remote registry has no terminal id,
+ * that question is unanswerable, and the tab is stuck with its spawn-time id even
+ * after the agent has moved to a different session (a `/clear`, or an exit and
+ * rerun in the same tab).
+ *
+ * Same shape as the actor provenance above: absent when the launch did not come
+ * from a tracked terminal, never fabricated.
+ */
+function terminalIdEnv() {
+    const terminalId = process.env.AGENT_TERMINAL_ID?.trim();
+    return terminalId ? { AGENT_TERMINAL_ID: terminalId } : {};
 }
 /**
  * Launch a detached login-shell command in its own Unix session/process group.

package/dist/lib/hq/floor.js

@@ -30,6 +30,18 @@ function teammateName(session, teammatesById) {
 function moodForSession(session, hasOpenBlock) {
     if (session.status === 'abandoned')
         return 'blocked';
+    // A crashed session is NOT `done` — it stopped without finishing, and its last
+    // parsed turn often still says `working`, which would otherwise reach the Floor
+    // as a happily-running agent. Both lost-host states need a human.
+    if (session.status === 'crashed')
+        return 'blocked';
+    // An orphaned session that is genuinely mid-question needs an answer; one that
+    // is merely idle-and-unwatched needs someone to reattach or clean it up. Same
+    // distinction `isAwaitingUser` draws — giving both the high-intensity "needs
+    // input" alert would train the operator to ignore it.
+    if (session.status === 'orphaned') {
+        return session.activity === 'waiting_input' ? 'waiting' : 'blocked';
+    }
     if (session.status === 'closed')
         return 'done';
     if (session.status === 'input_required' || session.activity === 'waiting_input' || hasOpenBlock)

package/dist/lib/menubar/MenubarHelper.app/Contents/_CodeSignature/CodeResources

@@ -6,7 +6,7 @@
 	<dict>
 		<key>Resources/AppIcon.icns</key>
 		<data>
-		DFq5H08EkhgWIC3UvGMR9B58BZw=
+		jOjZVimcFRHoP2VPzgn8uM8mjkA=
 		</data>
 	</dict>
 	<key>files2</key>
@@ -15,7 +15,7 @@
 		<dict>
 			<key>hash2</key>
 			<data>
-			mBSjM6jlvN7J1jQowsvqTl7CHM0pur0e6qsHMuzk5k0=
+			GFvSLeNYJ3ASxW3OzcuiB4aID0gZUBkpozmWZkbTFNw=
 			</data>
 		</dict>
 	</dict>