@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/version.js

@@ -5,7 +5,6 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 let cached = null;
-/** Read a `version` string from a package.json, or null if unreadable. */
 function readVersionAt(pkgPath) {
     try {
         const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
@@ -15,12 +14,6 @@ function readVersionAt(pkgPath) {
         return null;
     }
 }
-/**
- * Well-known locations of the `agents` launcher for PATH-less GUI/launchd
- * processes (the menu-bar helper inherits no login PATH). Also the anchor for
- * recovering the on-disk install layout when the CLI runs as a Bun single-file
- * binary — see {@link resolveInstalledLayout}.
- */
 export function resolveAgentsBin() {
     const home = os.homedir();
     const candidates = [
@@ -35,91 +28,41 @@ export function resolveAgentsBin() {
             return c;
         }
         catch {
-            /* try next */
         }
     }
     return null;
 }
-/**
- * Pure derivation (no I/O) of an install's on-disk layout from the realpath of
- * its `agents` launcher. A launcher lives at `<pkg>/dist/bin/agents`, so two
- * levels up is `<pkg>/dist`. Exported for unit testing so the dirname chain the
- * Bun-binary fallback depends on stays locked.
- */
 export function installLayoutFromBin(realBin) {
-    const distDir = path.dirname(path.dirname(realBin)); // <pkg>/dist/bin/agents -> <pkg>/dist
+    const distDir = path.dirname(path.dirname(realBin));
     return {
         distDir,
         entryPath: path.join(distDir, 'index.js'),
         pkgJsonPath: path.join(distDir, '..', 'package.json'),
     };
 }
-/**
- * Resolve the on-disk install layout of the running CLI by following the
- * `agents` launcher symlink.
- *
- * When the CLI runs as a Bun single-file executable, `import.meta.url` points
- * inside the virtual bundle (`/$bunfs/…`), so sibling-relative resolution can't
- * see the shipped `package.json`, `dist/index.js`, or `MenubarHelper.app` on
- * disk. The launcher symlink points at the real files; walk up from it. Returns
- * null when no launcher is found (dev/tsx runs, or a box without the helper) —
- * callers keep their in-bundle resolution as the primary path and use this only
- * as the fallback.
- */
 export function resolveInstalledLayout() {
     const bin = resolveAgentsBin();
     if (!bin)
         return null;
     try {
         const layout = installLayoutFromBin(fs.realpathSync(bin));
-        // Validate we landed on a real dist (guards an unexpected launcher layout).
         if (fs.existsSync(layout.entryPath))
             return layout;
     }
     catch {
-        /* ignore */
     }
     return null;
 }
-/**
- * Resolve the CLI version from the shipping package.json. Used by the daemon
- * to answer `IPCAction: 'version'` and by the client to detect daemon drift —
- * a dev-build CLI talking to a launchd-managed registry daemon would silently
- * get stale behavior without this check.
- *
- * Primary read is relative to this module; when that fails (the Bun single-file
- * binary can't read its own bundled package.json), fall back to the on-disk
- * install found via the launcher symlink so callers like the menu bar don't see
- * a bogus `unknown`.
- *
- * `pkgJsonPath` is an optional override of the shipping package.json path,
- * accepted by both this function and {@link getCliVersionFresh}. Every
- * production call site uses the zero-argument form and gets the real on-disk
- * path below; the parameter exists only so a unit test can point both
- * functions at a fixture package.json instead of the real one shared by every
- * parallel test fork.
- */
 export function getCliVersion(pkgJsonPath = path.join(__dirname, '..', '..', 'package.json')) {
     if (cached)
         return cached;
     cached = readVersionAt(pkgJsonPath) ?? readInstalledPackageVersion() ?? 'unknown';
     return cached;
 }
-/** Version from the on-disk install (Bun-binary fallback). */
 function readInstalledPackageVersion() {
     const layout = resolveInstalledLayout();
     return layout ? readVersionAt(layout.pkgJsonPath) : null;
 }
-/**
- * Read the version from package.json on disk every call, bypassing the cache.
- *
- * `getCliVersion()` memoizes the version a long-running process *started* with.
- * After `npm i -g` overwrites the install in place, the on-disk package.json
- * changes but the running process keeps its old in-memory code. Comparing this
- * fresh read against the cached startup value is how a daemon/broker detects it
- * is now stale and should reload onto the new code (self-healing). Returns
- * 'unknown' on any error.
- */
 export function getCliVersionFresh(pkgJsonPath = path.join(__dirname, '..', '..', 'package.json')) {
     return readVersionAt(pkgJsonPath) ?? readInstalledPackageVersion() ?? 'unknown';
 }

package/dist/lib/view-types.d.ts

@@ -5,29 +5,14 @@ import type { AuthVerdict } from './auth-health.js';
 import type { AccountListEntryJson } from './account-catalog.js';
 export type SyncState = 'synced' | 'new' | 'modified' | 'deleted';
 export interface ViewJsonVersion {
-    /** Stable installation label; retained for existing machine consumers. */
     version: string;
-    /** Actual vendor release, independent of the stable installation label. */
     releaseVersion?: string;
     isDefault: boolean;
     isolated: boolean;
     isIsolatedDefault: boolean;
     signedIn: boolean;
-    /**
-     * Whether THIS version home can actually spawn a signed-in agent — the strict
-     * per-version launch truth (`isLaunchableSignedIn`), not the display `signedIn`
-     * above. `signedIn` is true when the version *inherits* the active/global HOME
-     * login even with no per-version credential of its own; such a home shows "who
-     * is logged in" but dies at spawn once launch isolates HOME to it. Automatic
-     * `--device auto` placement gates on THIS field so a remote box is judged by
-     * the same launchability the local candidate uses (`collectRunCandidates` →
-     * `isLaunchableSignedIn`), closing the local/remote asymmetry (PHNX-3466).
-     * Absent on an older remote CLI, whose consumers fall back to `signedIn`.
-     */
     launchable: boolean;
-    /** Live cached authentication verdict for this installed version. */
     authVerdict: AuthVerdict | null;
-    /** Epoch milliseconds when authVerdict was last checked, or null if absent. */
     authCheckedAt: number | null;
     email: string | null;
     accountId?: string | null;
@@ -35,18 +20,11 @@ export interface ViewJsonVersion {
     organizationName?: string | null;
     plan: string | null;
     usageStatus: 'available' | 'rate_limited' | 'out_of_credits' | null;
-    /** ISO timestamp of the usage snapshot behind usageStatus, or null if absent. */
     usageCapturedAt: string | null;
     overageCredits?: {
         amount: number;
         currency: string;
     } | null;
-    /**
-     * Human-readable reason a usage snapshot is absent: a live-refresh failure, or
-     * (without `--refresh`, on a never-cached account) a plain "not collected yet"
-     * pending state. Always a full sentence — never the internal `'stale'` cache
-     * sentinel, which `usageErrorForDisplay` normalizes away (PHNX-3348).
-     */
     usageError?: string | null;
     windows: Array<{
         key: 'session' | 'week' | 'sonnet_week' | 'month';
@@ -66,27 +44,9 @@ export interface ViewJsonVersion {
     } | null;
     resources?: VersionResourcesJson;
 }
-/**
- * Whether a `run` on THIS box would find a launch-ready account for the agent,
- * computed from the SAME enumeration the local router uses
- * (`collectRunCandidates` → `readinessFromCandidate`), including native slots
- * (`fromSlot`) — NOT the per-version `versions[]` list, which enumerates version
- * homes and misses the account slots a run actually picks from (PHNX-4116). This
- * is the one readiness gate: `agents run --device auto` reads THIS answer off
- * `agents view --json` rather than re-deriving freshness on the dispatching box,
- * so the box that runs and the box that dispatches can never disagree.
- */
 export interface ViewJsonRunReady {
-    /** At least one account is launch-ready right now. */
     ready: boolean;
-    /**
-     * When ready, names a ready account (`ready (work)`); when not, the aggregate
-     * exclusion reason the dispatcher surfaces (`all signed_out`, `no accounts`, or
-     * a comma list of distinct reasons).
-     */
     reason: string;
-    /** Per-account verdict; `reason` is `'ready'` for a ready account, else the
-     *  `readinessFromCandidate` reason (`signed_out`/`revoked`/`rate_limited`/…). */
     accounts: Array<{
         name: string;
         ready: boolean;
@@ -96,15 +56,7 @@ export interface ViewJsonRunReady {
 export interface ViewJsonAgent {
     agent: AgentId;
     versions: ViewJsonVersion[];
-    /**
-     * The same public JSON v2 account projection `accounts list --json` emits —
-     * never the internal catalog row, so consumers (AGI EXT) read one shape.
-     */
     accounts?: AccountListEntryJson[];
-    /**
-     * The one run-readiness gate for this agent on this box (PHNX-4116). Absent on
-     * an older remote CLI, whose readers fall back to per-version `launchable`.
-     */
     runReady?: ViewJsonRunReady;
     harnesses: ProfileSummary[];
 }

package/dist/lib/warn-unpushed.d.ts

@@ -1,41 +1,14 @@
-/**
- * Whether a just-finished run should be checked for stranded work: only
- * writable modes can leave commits (plan is read-only), and only non-interactive
- * runs need the warning (an interactive user sees their own shell). Centralizes
- * the gate so every exit path in the run command applies it identically.
- */
 export declare function shouldWarnUnpushed(mode: string, interactive: boolean): boolean;
 interface UnpushedState {
-    /** cwd is inside a git work tree. */
     isRepo: boolean;
-    /** current branch, or null when detached / not a repo. */
     branch: string | null;
-    /** the branch has an upstream tracking ref configured. */
     hasUpstream: boolean;
-    /** commits reachable from HEAD but not from any remote-tracking ref. */
     unpushed: {
         sha: string;
         subject: string;
     }[];
 }
-/**
- * Inspect `cwd` for commits on the current branch that have not reached any
- * remote. Uses `git log --not --remotes` so it is correct even when the branch
- * has no upstream set: commits already present on some `origin/*` ref are NOT
- * reported (no false positive), and a never-pushed branch reports all its
- * commits. Returns an inert result — never throws — for a non-repo cwd, a
- * detached HEAD, or a repo with no remotes (nothing to push to).
- */
 export declare function getUnpushedState(cwd: string): Promise<UnpushedState>;
-/**
- * Render the warning for an unpushed state, or null when there is nothing to
- * warn about. Split out from the printer so it is directly testable.
- */
 export declare function formatUnpushedWarning(state: UnpushedState, cwd: string): string | null;
-/**
- * If the just-finished run left committed-but-unpushed work in `cwd`, print a
- * loud stderr warning with the exact push / PR commands. Non-fatal by contract:
- * any failure is swallowed so it can never break a run's exit path.
- */
 export declare function warnUnpushedWork(cwd: string): Promise<void>;
 export {};

package/dist/lib/warn-unpushed.js

@@ -1,59 +1,27 @@
-/**
- * Post-run guard against silently stranded work.
- *
- * A headless `agents run` in a writable mode can end with the agent having
- * committed on a branch but never pushed it — the CLI's exit path does no git
- * work, so those commits sit invisible in a worktree until someone audits the
- * box. This module detects that state and prints a loud stderr warning with the
- * exact push / PR commands. It is advisory only: it never pushes, never mutates
- * the repo, and never throws (a non-repo cwd or any git error yields an inert
- * result), so it can sit on the run's exit path without ever breaking it.
- */
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import chalk from 'chalk';
 const execFileAsync = promisify(execFile);
-// Unit-separator byte (0x1f) as the git-log field delimiter: it cannot occur in
-// a commit subject, so splitting on it never truncates a subject with spaces.
 const SEP = '\x1f';
-/**
- * Whether a just-finished run should be checked for stranded work: only
- * writable modes can leave commits (plan is read-only), and only non-interactive
- * runs need the warning (an interactive user sees their own shell). Centralizes
- * the gate so every exit path in the run command applies it identically.
- */
 export function shouldWarnUnpushed(mode, interactive) {
     return mode !== 'plan' && !interactive;
 }
 const INERT = { isRepo: false, branch: null, hasUpstream: false, unpushed: [] };
 async function git(args, cwd) {
-    // These are all local, non-prompting reads, but the call sits on a run's exit
-    // path — a hard timeout guarantees a wedged git can never delay exit unbounded.
     const { stdout } = await execFileAsync('git', args, { cwd, timeout: 5000 });
     return stdout.trim();
 }
-/**
- * Inspect `cwd` for commits on the current branch that have not reached any
- * remote. Uses `git log --not --remotes` so it is correct even when the branch
- * has no upstream set: commits already present on some `origin/*` ref are NOT
- * reported (no false positive), and a never-pushed branch reports all its
- * commits. Returns an inert result — never throws — for a non-repo cwd, a
- * detached HEAD, or a repo with no remotes (nothing to push to).
- */
 export async function getUnpushedState(cwd) {
     let branch;
     try {
         branch = await git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
     }
     catch {
-        return INERT; // not a git repo
+        return INERT;
     }
-    // Detached HEAD: agents commit on branches; nothing nameable to push.
     if (!branch || branch === 'HEAD') {
         return { isRepo: true, branch: null, hasUpstream: false, unpushed: [] };
     }
-    // No remote configured -> `--remotes` matches nothing and would report the
-    // entire history as "unpushed". There's nowhere to push, so stay silent.
     let hasRemote = false;
     try {
         hasRemote = (await git(['remote'], cwd)).length > 0;
@@ -66,8 +34,6 @@ export async function getUnpushedState(cwd) {
     }
     let unpushed = [];
     try {
-        // HEAD must precede `--not`: everything after `--not` is negated, so
-        // `--not --remotes HEAD` would negate HEAD too and always return empty.
         const out = await git(['log', 'HEAD', '--not', '--remotes', `--pretty=format:%h${SEP}%s`], cwd);
         unpushed = out
             ? out.split('\n').map((line) => {
@@ -91,10 +57,6 @@ export async function getUnpushedState(cwd) {
     }
     return { isRepo: true, branch, hasUpstream, unpushed };
 }
-/**
- * Render the warning for an unpushed state, or null when there is nothing to
- * warn about. Split out from the printer so it is directly testable.
- */
 export function formatUnpushedWarning(state, cwd) {
     if (!state.isRepo || !state.branch || state.unpushed.length === 0)
         return null;
@@ -111,11 +73,6 @@ export function formatUnpushedWarning(state, cwd) {
     lines.push(`  open a PR:  gh pr create --head ${state.branch}`);
     return lines.join('\n');
 }
-/**
- * If the just-finished run left committed-but-unpushed work in `cwd`, print a
- * loud stderr warning with the exact push / PR commands. Non-fatal by contract:
- * any failure is swallowed so it can never break a run's exit path.
- */
 export async function warnUnpushedWork(cwd) {
     try {
         const warning = formatUnpushedWarning(await getUnpushedState(cwd), cwd);
@@ -123,6 +80,5 @@ export async function warnUnpushedWork(cwd) {
             process.stderr.write(chalk.yellow(warning) + '\n');
     }
     catch {
-        // Advisory only — never break the run over a warning.
     }
 }

package/dist/lib/watchdog/history.d.ts

@@ -16,6 +16,5 @@ interface WatchdogHistoryOptions {
     includeTicks?: boolean;
     nowMs?: number;
 }
-/** Select newest history and deliberately remove raw transcript tailLines. */
 export declare function selectWatchdogHistory(events: WatchdogEvent[], options?: WatchdogHistoryOptions): WatchdogHistoryEntry[];
 export {};

package/dist/lib/watchdog/history.js

@@ -1,4 +1,3 @@
-/** Select newest history and deliberately remove raw transcript tailLines. */
 export function selectWatchdogHistory(events, options = {}) {
     const limit = options.limit ?? 50;
     const cutoff = options.sinceMs === undefined
@@ -34,8 +33,6 @@ export function selectWatchdogHistory(events, options = {}) {
         .sort((a, b) => b.ts - a.ts);
     if (matching.length <= limit)
         return matching;
-    // A busy tick can contain more inspections than the display limit. Keep the
-    // newest timeline, but reserve one row for the newest real action.
     const newest = matching.slice(0, limit);
     if (newest.some((entry) => entry.kind !== 'inspection'))
         return newest;

package/dist/lib/watchdog/index.js

@@ -1,5 +1,3 @@
-// Watchdog stall-detection + nudge-decision core. Pure logic ported from
-// Swarmify; terminal-injection delivery and menu-bar wiring live elsewhere.
 export * from './watchdog.js';
 export * from './watchdogTail.js';
 export * from './read.js';

package/dist/lib/watchdog/log.d.ts

@@ -1,8 +1,5 @@
-/** Same path the Fleet reader pulls (apps/ext/src/core/watchdogLog.ts). */
 export declare const WATCHDOG_LOG_PATH: string;
-/** Kinds the Factory reader accepts. Keep in lockstep with watchdogLog.ts. */
 export type WatchdogEventKind = 'tick' | 'decision' | 'nudge' | 'undelivered' | 'rotate' | 'error';
-/** JSONL row shape — a verbatim replica of the Factory reader's WatchdogEvent. */
 export interface WatchdogEvent {
     ts: number;
     kind: WatchdogEventKind;
@@ -10,16 +7,11 @@ export interface WatchdogEvent {
     agentType?: string;
     message: string;
     reason?: string;
-    /** For 'tick' events: the session lines the watchdog actually read. */
     tailLines?: string[];
-    /** For 'tick' / 'decision' events: how long the terminal had been stalled. */
     stalledForMs?: number;
-    /** Carried so the UI can show what the agent was stuck on. */
     lastUserMessage?: string;
     lastAssistantMessage?: string;
-    /** For a 'decision'/'nudge' that injects: the exact text delivered. */
     nudgeText?: string;
-    /** Compact per-session evaluations carried by heartbeat ticks. */
     inspections?: WatchdogInspection[];
 }
 export interface WatchdogInspection {
@@ -29,23 +21,12 @@ export interface WatchdogInspection {
     reason: string;
     stalledForMs?: number;
 }
-/** Parse the audit log without letting a partial final append hide valid rows. */
 export declare function parseWatchdogEvents(text: string): WatchdogEvent[];
 export declare function readWatchdogEvents(logPath?: string): WatchdogEvent[];
-/** Serialize one event to a JSONL line (no trailing newline). */
 export declare function formatEvent(ev: WatchdogEvent): string;
 export declare const WATCHDOG_TAIL_MAX_CHARS = 4096;
-/** Keep the newest transcript context without letting it consume the audit window. */
 export declare function boundTailLines(lines: string[], maxChars?: number): string[];
-/** Trim a JSONL body to the last `maxLines` events (same logic as the reader). */
 export declare function trimToLast(text: string, maxLines: number): string;
-/**
- * Append events to the log under a file lock, trimming to WATCHDOG_LOG_MAX_LINES
- * so the file never grows unbounded. Concurrent watchdog ticks share the lock so
- * their appends never interleave into a corrupt line. Best-effort: a filesystem
- * error is swallowed (the Factory card tolerates a stale/missing log), never
- * throwing into the tick.
- */
 export declare function appendWatchdogEvents(events: WatchdogEvent[], opts?: {
     logPath?: string;
     maxLines?: number;

package/dist/lib/watchdog/log.js

@@ -1,25 +1,9 @@
-/**
- * Canonical watchdog event log (watchdog-brain-v2).
- *
- * The Fleet renders a read-only "Watchdog activity" card from the JSONL
- * feed at ~/.agents/.cache/logs/watchdog.log. That feed was historically written
- * by the retired extension-side watchdog; now the always-on CLI watchdog owns it.
- *
- * The event SHAPE here is a deliberate, verbatim replica of the reader in
- * apps/ext/src/core/watchdogLog.ts (WatchdogEvent / WatchdogEventKind /
- * WATCHDOG_LOG_PATH / the trim cap). The repo forbids cross-app imports
- * (CLAUDE.md repo map), so the two files are kept in sync by hand — a change to
- * the Factory reader's shape must be mirrored here. There is no import between
- * them.
- */
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { withFileLock, atomicWriteFileSync, ensureLockTarget } from '../fs-atomic.js';
-/** Same path the Fleet reader pulls (apps/ext/src/core/watchdogLog.ts). */
 export const WATCHDOG_LOG_PATH = path.join(os.homedir(), '.agents', '.cache', 'logs', 'watchdog.log');
 const WATCHDOG_EVENT_KINDS = new Set(['tick', 'decision', 'nudge', 'undelivered', 'rotate', 'error']);
-/** Parse the audit log without letting a partial final append hide valid rows. */
 export function parseWatchdogEvents(text) {
     const events = [];
     for (const line of text.split('\n')) {
@@ -67,7 +51,6 @@ export function parseWatchdogEvents(text) {
             });
         }
         catch {
-            // Interrupted writers can leave one partial row; earlier rows remain useful.
         }
     }
     return events;
@@ -77,18 +60,11 @@ export function readWatchdogEvents(logPath = WATCHDOG_LOG_PATH) {
         return [];
     return parseWatchdogEvents(fs.readFileSync(logPath, 'utf8'));
 }
-/** Serialize one event to a JSONL line (no trailing newline). */
 export function formatEvent(ev) {
     return JSON.stringify(ev);
 }
-/**
- * Cap on retained log lines. Mirrors the Factory reader's expectation that the
- * writer trims (watchdogLog.ts trimToLast). Large enough to keep a useful
- * history, small enough to bound the file the UI polls.
- */
 const WATCHDOG_LOG_MAX_LINES = 5000;
 export const WATCHDOG_TAIL_MAX_CHARS = 4096;
-/** Keep the newest transcript context without letting it consume the audit window. */
 export function boundTailLines(lines, maxChars = WATCHDOG_TAIL_MAX_CHARS) {
     const kept = [];
     let remaining = maxChars;
@@ -105,20 +81,12 @@ export function boundTailLines(lines, maxChars = WATCHDOG_TAIL_MAX_CHARS) {
     }
     return kept;
 }
-/** Trim a JSONL body to the last `maxLines` events (same logic as the reader). */
 export function trimToLast(text, maxLines) {
     const lines = text.split('\n').filter((l) => l.trim().length > 0);
     if (lines.length <= maxLines)
         return lines.join('\n') + (lines.length ? '\n' : '');
     return lines.slice(lines.length - maxLines).join('\n') + '\n';
 }
-/**
- * Append events to the log under a file lock, trimming to WATCHDOG_LOG_MAX_LINES
- * so the file never grows unbounded. Concurrent watchdog ticks share the lock so
- * their appends never interleave into a corrupt line. Best-effort: a filesystem
- * error is swallowed (the Factory card tolerates a stale/missing log), never
- * throwing into the tick.
- */
 export function appendWatchdogEvents(events, opts = {}) {
     if (events.length === 0)
         return;
@@ -133,7 +101,6 @@ export function appendWatchdogEvents(events, opts = {}) {
                 existing = fs.readFileSync(logPath, 'utf8');
             }
             catch {
-                /* first write — no file yet */
             }
             const boundedEvents = events.map((event) => event.tailLines === undefined
                 ? event
@@ -144,6 +111,5 @@ export function appendWatchdogEvents(events, opts = {}) {
         });
     }
     catch {
-        /* best-effort: never let logging break a tick */
     }
 }

package/dist/lib/watchdog/read.d.ts

@@ -1,35 +1,8 @@
-/** Default watchdog thresholds, mirrored from the Swarmify VS Code runtime. */
 export declare const WATCHDOG_TAIL_LINES = 20;
 export declare const WATCHDOG_STALL_MS = 300000;
 export declare const WATCHDOG_COOLDOWN_MS = 1200000;
 export declare const WATCHDOG_DORMANT_MS = 3600000;
-/**
- * Read the last `maxLines` non-empty lines of a JSONL transcript by seeking
- * backward from EOF in 64KB chunks. A tail that begins mid-line yields one
- * malformed leading line, which the callers' per-line JSON try/catch tolerates.
- * Returns `[]` on any read error or empty file.
- */
 export declare function readTailLines(filePath: string, maxLines: number): string[];
-/**
- * Given candidate transcript-root directories, find the transcript file for a
- * session. Handles the flat Claude layout (`<sessionId>.jsonl` inside a
- * per-project `<enc>/` subfolder), Codex-style names that merely embed the uuid
- * (`rollout-…-<sessionId>.jsonl`), and — critically — the DEEP date partitions
- * Codex/Droid use (`sessions/YYYY/MM/DD/rollout-…-<uuid>.jsonl`). The scan is
- * fully recursive via `walkForFiles` (the same walker session/discover.ts uses),
- * so no fixed number of subdir levels is assumed — a hand-rolled one-level scan
- * silently missed every Codex transcript. Newest mtime wins when a uuid appears
- * in more than one root (e.g. across version homes). Pure over its `dirs`
- * argument, so it is testable without touching the real home directory.
- */
 export declare function findSessionJsonlIn(dirs: string[], sessionId: string, ext?: string): string | undefined;
-/**
- * Resolve a session transcript path from its id + agent, reusing the CLI's
- * per-version transcript roots. Returns `undefined` if no transcript is found.
- */
 export declare function resolveWatchdogSessionPath(sessionId: string, agent: string): string | undefined;
-/**
- * Read the last `maxLines` JSONL lines for a session by id + agent. Returns
- * `[]` when the transcript cannot be located or read.
- */
 export declare function readWatchdogTail(sessionId: string, agent: string, maxLines?: number): string[];

package/dist/lib/watchdog/read.js

@@ -1,48 +1,20 @@
-// Watchdog tail reader: locate a session transcript from its id + agent and
-// pull the last N raw JSONL lines. The raw lines feed the pure detectors in
-// watchdog.ts (isLikelyTrulyBlocked / renderWatchdogPrompt) and the pure
-// summarizer in watchdogTail.ts.
-//
-// Adapted from Swarmify's readTailLines (extension/src/vscode/sessions.vscode.ts)
-// to agents-cli's session layout. Path resolution REUSES getAgentSessionDirs()
-// from src/lib/session/discover.ts — the same resolver the rest of the CLI uses
-// to enumerate per-version transcript roots — instead of hardcoding
-// ~/.agents/.history/versions/<agent>/.../projects/<enc>/<sessionId>.jsonl.
 import * as fs from 'fs';
 import * as path from 'path';
 import { getAgentSessionDirs } from '../session/discover.js';
 import { walkForFiles } from '../fs-walk.js';
-/** Default watchdog thresholds, mirrored from the Swarmify VS Code runtime. */
 export const WATCHDOG_TAIL_LINES = 20;
-export const WATCHDOG_STALL_MS = 300_000; // 5m — stallSeconds default
-export const WATCHDOG_COOLDOWN_MS = 1_200_000; // 20m — cooldownSeconds default
-export const WATCHDOG_DORMANT_MS = 3_600_000; // 1h — DORMANT_MS
+export const WATCHDOG_STALL_MS = 300_000;
+export const WATCHDOG_COOLDOWN_MS = 1_200_000;
+export const WATCHDOG_DORMANT_MS = 3_600_000;
 const CHUNK_SIZE = 64 * 1024;
 const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
-/** Cap on files walked per transcript root — matches session/discover.ts. */
 const WATCHDOG_WALK_CAP = 100_000;
-/**
- * Per-agent transcript layout, mirroring the `getAgentSessionDirs()` call sites
- * in session/discover.ts so the resolver never diverges from the rest of the CLI:
- * Claude keeps per-project folders under `projects/` (discover.ts:486); Codex and
- * Droid date-/work-partition rollout `.jsonl` deep under `sessions/`
- * (discover.ts:665, :1673); Gemini nests chat `.json` under `tmp/<hash>/chats/`
- * (discover.ts:820). Subdir + extension are driven from this table instead of the
- * old hardcoded `codex ? 'sessions' : 'projects'` ternary, which sent every
- * non-Codex agent (Gemini included) to the wrong root.
- */
 const WATCHDOG_SESSION_LAYOUT = {
     claude: { subdir: 'projects', ext: '.jsonl' },
     codex: { subdir: 'sessions', ext: '.jsonl' },
     droid: { subdir: 'sessions', ext: '.jsonl' },
 };
 const WATCHDOG_SESSION_LAYOUT_DEFAULT = { subdir: 'projects', ext: '.jsonl' };
-/**
- * Read the last `maxLines` non-empty lines of a JSONL transcript by seeking
- * backward from EOF in 64KB chunks. A tail that begins mid-line yields one
- * malformed leading line, which the callers' per-line JSON try/catch tolerates.
- * Returns `[]` on any read error or empty file.
- */
 export function readTailLines(filePath, maxLines) {
     let fd;
     try {
@@ -76,22 +48,9 @@ export function readTailLines(filePath, maxLines) {
             fs.closeSync(fd);
         }
         catch {
-            /* fd already gone */
         }
     }
 }
-/**
- * Given candidate transcript-root directories, find the transcript file for a
- * session. Handles the flat Claude layout (`<sessionId>.jsonl` inside a
- * per-project `<enc>/` subfolder), Codex-style names that merely embed the uuid
- * (`rollout-…-<sessionId>.jsonl`), and — critically — the DEEP date partitions
- * Codex/Droid use (`sessions/YYYY/MM/DD/rollout-…-<uuid>.jsonl`). The scan is
- * fully recursive via `walkForFiles` (the same walker session/discover.ts uses),
- * so no fixed number of subdir levels is assumed — a hand-rolled one-level scan
- * silently missed every Codex transcript. Newest mtime wins when a uuid appears
- * in more than one root (e.g. across version homes). Pure over its `dirs`
- * argument, so it is testable without touching the real home directory.
- */
 export function findSessionJsonlIn(dirs, sessionId, ext = '.jsonl') {
     if (!sessionId)
         return undefined;
@@ -101,7 +60,6 @@ export function findSessionJsonlIn(dirs, sessionId, ext = '.jsonl') {
         const stem = name.slice(0, -ext.length);
         if (stem === sessionId)
             return true;
-        // Codex embeds the uuid in a longer filename (rollout-<ts>-<uuid>.jsonl).
         return name.includes(sessionId) || (UUID_RE.test(sessionId) && stem.includes(sessionId));
     };
     let best;
@@ -122,24 +80,11 @@ export function findSessionJsonlIn(dirs, sessionId, ext = '.jsonl') {
     }
     return best?.file;
 }
-/**
- * Resolve a session transcript path from its id + agent, reusing the CLI's
- * per-version transcript roots. Returns `undefined` if no transcript is found.
- */
 export function resolveWatchdogSessionPath(sessionId, agent) {
-    // Subdir + transcript extension are driven per-agent from WATCHDOG_SESSION_LAYOUT
-    // (which mirrors the getAgentSessionDirs() convention in session/discover.ts),
-    // not a hardcoded `codex ? 'sessions' : 'projects'` — that ternary sent Codex to
-    // a root it only scanned one level deep, and every other agent (Gemini included)
-    // to the wrong subdir entirely.
     const layout = WATCHDOG_SESSION_LAYOUT[agent] ?? WATCHDOG_SESSION_LAYOUT_DEFAULT;
     const dirs = getAgentSessionDirs(agent, layout.subdir);
     return findSessionJsonlIn(dirs, sessionId, layout.ext);
 }
-/**
- * Read the last `maxLines` JSONL lines for a session by id + agent. Returns
- * `[]` when the transcript cannot be located or read.
- */
 export function readWatchdogTail(sessionId, agent, maxLines = WATCHDOG_TAIL_LINES) {
     const filePath = resolveWatchdogSessionPath(sessionId, agent);
     if (!filePath)