@phnx-labs/agents-cli 1.22.119 → 1.22.121

package/dist/lib/factory/snapshot.js

@@ -1,15 +1,3 @@
-/**
- * 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';
@@ -159,7 +147,7 @@ function readRecentRuns(home, limit = 3) {
                 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. */ }
+            catch { }
         }
         found.push(...routineRuns.sort((a, b) => b.mtime - a.mtime).slice(0, limit));
     }
@@ -197,8 +185,6 @@ export async function buildFactorySnapshot(overrides = {}) {
         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 {

package/dist/lib/feed/activity-stream.d.ts

@@ -1,21 +1,10 @@
 import { type ActivityEvent } from './activity.js';
 interface ActivityStreamOptions {
-    /** Override the activity dir (tests). */
     root?: string;
-    /**
-     * Newest bytes read from one file in one tick. A burst larger than this keeps
-     * only the tail, exactly as `readRecentActivity`'s bounded tail does.
-     */
     maxBytesPerRead?: number;
-    /** Full stat sweep cadence, covering anything the directory watcher misses. */
     sweepMs?: number;
-    /** Subscribe to directory change notifications (default true). */
     watch?: boolean;
 }
-/**
- * A cursor over the activity directory. Construct it at the moment the caller's
- * activity cursor starts, then call {@link read} once per tick.
- */
 export declare class ActivityStream {
     private readonly dir;
     private readonly maxBytesPerRead;
@@ -25,31 +14,15 @@ export declare class ActivityStream {
     private watcher?;
     private watchRequested;
     private lastSweepMs;
-    /** False during the opening scan, so it registers history without reading it. */
     private started;
-    /** Bytes read from activity logs since construction. Observability + tests. */
     bytesRead: number;
     constructor(options?: ActivityStreamOptions);
-    /**
-     * Events appended since the last call, newest first, filtered to `sinceMs`
-     * inclusive — the same shape and order `readRecentActivity({ sinceMs })`
-     * returns for those events.
-     */
     read(sinceMs: number, nowMs?: number): ActivityEvent[];
-    /** Release the directory watcher. Safe to call more than once. */
     close(): void;
-    /** Which log names could have changed since the previous tick. */
     private candidates;
-    /**
-     * Stat every log, marking the ones that could have changed. Opens nothing: a
-     * log the opening scan sees is registered past its own bytes, so history is
-     * never replayed onto the stream.
-     */
     private sweep;
     private statOf;
-    /** A cursor starting at a bounded tail of the file as it stands right now. */
     private freshCursor;
-    /** Read and parse only the bytes appended to one log since its cursor. */
     private readFile;
     private readRange;
     private armWatcher;

package/dist/lib/feed/activity-stream.js

@@ -1,43 +1,17 @@
-/**
- * Incremental reader for the activity log directory.
- *
- * `readRecentActivity` answers "what happened since T?" by tailing and parsing
- * every session log in the directory. That is the right shape for a one-shot
- * `agents feed` render and the wrong shape for `agents feed watch`, which asks
- * the same question twice a second for as long as a VS Code window is open: on
- * a real operator box the directory holds 1,437 logs / 64 MB, so every tick
- * re-read and re-parsed the whole corpus to emit, almost always, nothing.
- *
- * This reader keeps a per-file cursor instead. The opening scan opens no files
- * at all — it records each log's size, inode, and mtime — so only bytes appended
- * *after* the stream started are ever read. Steady-state cost is one `stat` per
- * changed file plus a parse of exactly the appended bytes.
- *
- * The emitted events, their order, and the `sinceMs` filter match
- * `readRecentActivity` for everything appended while the stream is open; the
- * equivalence is pinned by `activity-stream.test.ts`.
- */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { getActivityDir } from '../state.js';
 import { ACTIVITY_TAIL_BYTES, parseActivityLine } from './activity.js';
-/** How often the stream falls back to a full directory stat sweep. */
 const ACTIVITY_SWEEP_MS = 5_000;
-/** Bytes behind the cursor re-verified before appended bytes are trusted. */
 const ACTIVITY_ANCHOR_BYTES = 64;
 const NEWLINE = 0x0a;
 const EMPTY = Buffer.alloc(0);
-/** Could this file have changed since its cursor last looked? */
 function changed(cursor, stat) {
     return stat.identity !== cursor.identity
         || stat.size !== cursor.size
         || stat.mtimeNs !== cursor.mtimeNs
         || stat.ctimeNs !== cursor.ctimeNs;
 }
-/**
- * A cursor over the activity directory. Construct it at the moment the caller's
- * activity cursor starts, then call {@link read} once per tick.
- */
 export class ActivityStream {
     dir;
     maxBytesPerRead;
@@ -47,32 +21,20 @@ export class ActivityStream {
     watcher;
     watchRequested;
     lastSweepMs = 0;
-    /** False during the opening scan, so it registers history without reading it. */
     started = false;
-    /** Bytes read from activity logs since construction. Observability + tests. */
     bytesRead = 0;
     constructor(options = {}) {
         this.dir = options.root ?? getActivityDir();
         this.maxBytesPerRead = options.maxBytesPerRead ?? ACTIVITY_TAIL_BYTES;
         this.sweepMs = options.sweepMs ?? ACTIVITY_SWEEP_MS;
         this.watchRequested = options.watch ?? true;
-        // A log directory that does not exist yet (nothing has logged activity
-        // since boot) means fs.watch below throws ENOENT and never retries except
-        // on the bounded sweep cadence — the very first session's activity can
-        // then sit unwatched for up to `sweepMs` before it is even noticed.
-        // Creating it up front lets the watcher arm immediately.
         try {
             fs.mkdirSync(this.dir, { recursive: true });
         }
-        catch { /* best-effort: sweep() covers a dir that still isn't there */ }
+        catch { }
         this.sweep(Date.now());
         this.armWatcher();
     }
-    /**
-     * Events appended since the last call, newest first, filtered to `sinceMs`
-     * inclusive — the same shape and order `readRecentActivity({ sinceMs })`
-     * returns for those events.
-     */
     read(sinceMs, nowMs = Date.now()) {
         const out = [];
         for (const name of this.candidates(nowMs)) {
@@ -85,17 +47,12 @@ export class ActivityStream {
         out.sort((a, b) => Date.parse(b.ts) - Date.parse(a.ts));
         return out;
     }
-    /** Release the directory watcher. Safe to call more than once. */
     close() {
         this.watchRequested = false;
         this.watcher?.close();
         this.watcher = undefined;
     }
-    /** Which log names could have changed since the previous tick. */
     candidates(nowMs) {
-        // A watcher that never armed (unsupported filesystem, or a directory that
-        // did not exist at construction) means every tick sweeps. That is the
-        // fallback: never a silent no-op that would drop events.
         if (!this.watcher)
             this.armWatcher();
         if (!this.watcher || nowMs - this.lastSweepMs >= this.sweepMs)
@@ -104,11 +61,6 @@ export class ActivityStream {
         this.dirty.clear();
         return names;
     }
-    /**
-     * Stat every log, marking the ones that could have changed. Opens nothing: a
-     * log the opening scan sees is registered past its own bytes, so history is
-     * never replayed onto the stream.
-     */
     sweep(nowMs) {
         this.lastSweepMs = nowMs;
         let names;
@@ -116,7 +68,7 @@ export class ActivityStream {
             names = fs.readdirSync(this.dir).filter((name) => name.endsWith('.jsonl'));
         }
         catch {
-            return; // The directory appears with the first logged event.
+            return;
         }
         const seen = new Set();
         for (const name of names) {
@@ -126,8 +78,6 @@ export class ActivityStream {
                 continue;
             const cursor = this.cursors.get(name);
             if (!cursor) {
-                // A log first seen after the opening scan is new work: left
-                // unregistered so `readFile` opens it from a bounded tail.
                 if (this.started)
                     this.dirty.add(name);
                 else
@@ -140,11 +90,6 @@ export class ActivityStream {
             if (changed(cursor, stat))
                 this.dirty.add(name);
         }
-        // A cursor is dropped only when its log is gone. There is deliberately no
-        // size cap: the map cannot outgrow the directory this sweep already had to
-        // enumerate, so a cap bounds nothing the readdir does not — while dropping
-        // a live log's cursor would re-register it as new work on the next sweep
-        // and replay a bounded tail of it onto the stream as duplicates.
         for (const name of [...this.cursors.keys()])
             if (!seen.has(name))
                 this.cursors.delete(name);
@@ -161,10 +106,9 @@ export class ActivityStream {
             };
         }
         catch {
-            return undefined; // Deleted between readdir and stat.
+            return undefined;
         }
     }
-    /** A cursor starting at a bounded tail of the file as it stands right now. */
     freshCursor(stat) {
         const offset = Math.max(0, stat.size - this.maxBytesPerRead);
         return {
@@ -172,7 +116,6 @@ export class ActivityStream {
             anchor: EMPTY, size: stat.size, mtimeNs: stat.mtimeNs, ctimeNs: stat.ctimeNs,
         };
     }
-    /** Read and parse only the bytes appended to one log since its cursor. */
     readFile(name, restarted = false) {
         const stat = this.statOf(name);
         if (!stat) {
@@ -180,14 +123,6 @@ export class ActivityStream {
             return [];
         }
         let cursor = this.cursors.get(name);
-        // Unseen, replaced, truncated, or rewritten in place at the same length:
-        // restart from a bounded tail of the file as it now stands. The caller's
-        // `sinceMs` drops whatever predates the stream.
-        //
-        // The same-length case is why ctime is tracked. Growth is caught by the
-        // 64-byte anchor and a shrink by the offset compare, but a rewrite that
-        // lands on exactly the previous size moves neither, and the early return
-        // below would otherwise retire the file for good with content unread.
         if (!cursor || cursor.identity !== stat.identity || stat.size < cursor.offset
             || (stat.size === cursor.size && stat.ctimeNs !== cursor.ctimeNs)) {
             cursor = this.freshCursor(stat);
@@ -198,8 +133,6 @@ export class ActivityStream {
         cursor.ctimeNs = stat.ctimeNs;
         if (stat.size <= cursor.offset)
             return [];
-        // A burst larger than the budget keeps the newest bytes; the skipped span is
-        // exactly what the bounded-tail reader would have dropped as well.
         const start = Math.max(cursor.offset, stat.size - this.maxBytesPerRead);
         if (start > cursor.offset) {
             cursor.partial = EMPTY;
@@ -209,10 +142,8 @@ export class ActivityStream {
         const verify = Math.min(cursor.anchor.length, start);
         const buf = this.readRange(name, start - verify, stat.size - start + verify);
         if (buf === undefined)
-            return []; // Transient I/O error: retry next tick.
+            return [];
         if (verify > 0 && !buf.subarray(0, verify).equals(cursor.anchor.subarray(cursor.anchor.length - verify))) {
-            // The bytes behind the cursor changed, so this file was rewritten rather
-            // than appended to. Restart it once from a bounded tail.
             if (restarted)
                 return [];
             this.cursors.delete(name);
@@ -224,16 +155,11 @@ export class ActivityStream {
         const chunk = Buffer.concat([cursor.partial, fresh]);
         const fragment = cursor.partialIsFragment;
         const end = chunk.lastIndexOf(NEWLINE);
-        // Hold an unterminated trailing line: the writer appends whole
-        // newline-terminated records (`appendActivityEvent`), so a tail without a
-        // newline is a write in progress and completes on a later tick.
         cursor.partial = end < 0 ? chunk : chunk.subarray(end + 1);
         cursor.partialIsFragment = end < 0 ? fragment : false;
         if (end < 0)
             return [];
         const lines = chunk.subarray(0, end).toString('utf-8').split('\n');
-        // A range that began mid-file starts inside a record; that leading fragment
-        // is not one, exactly as the bounded-tail reader drops it.
         if (fragment)
             lines.shift();
         const events = [];
@@ -269,8 +195,6 @@ export class ActivityStream {
                 if (typeof name === 'string' && name.endsWith('.jsonl'))
                     this.dirty.add(name);
             });
-            // A watch error (the directory is removed) degrades to sweeping rather
-            // than taking down the watcher process.
             this.watcher.on('error', () => { this.watcher?.close(); this.watcher = undefined; });
         }
         catch {