@phnx-labs/agents-cli 1.20.76 → 1.20.77

package/dist/lib/session/state.js

@@ -14,6 +14,7 @@
  * markers. Codex has no such tools, so it falls back to last-role + question
  * shape + mtime — same function, driven off the normalized events.
  */
+import * as path from 'path';
 import { summarizeToolUse } from './parse.js';
 /**
  * Detect per-session rate-limit / usage-limit signals in assistant or error
@@ -47,9 +48,9 @@ const PROSE_QUESTION_FRESH_MS = 30 * 60_000;
 /** Claude tool names that structurally mean "the agent handed control back to you". */
 const PLAN_TOOL = 'ExitPlanMode';
 const ASK_TOOL = 'AskUserQuestion';
-/** The live plan/checklist tools: Claude's `TodoWrite` and Codex's `update_plan`. */
-const TODO_TOOL = 'TodoWrite';
-const CODEX_PLAN_TOOL = 'update_plan';
+const SNAPSHOT_TODO_TOOLS = new Set(['TodoWrite', 'todo_write', 'update_plan']);
+const TASK_CREATE_TOOL = 'TaskCreate';
+const TASK_UPDATE_TOOL = 'TaskUpdate';
 /**
  * Derive live plan progress from a checklist tool call's args. Accepts both
  * Claude's `TodoWrite` (`todos: [{content,status,activeForm}]`) and Codex's
@@ -58,10 +59,11 @@ const CODEX_PLAN_TOOL = 'update_plan';
  * list, so a session with no plan carries no `todos` field.
  */
 export function extractTodoProgress(args) {
-    const raw = Array.isArray(args?.todos)
-        ? args.todos
-        : Array.isArray(args?.plan)
-            ? args.plan
+    const input = args?.input && typeof args.input === 'object' ? args.input : args;
+    const raw = Array.isArray(input?.todos)
+        ? input.todos
+        : Array.isArray(input?.plan)
+            ? input.plan
             : undefined;
     if (!Array.isArray(raw) || raw.length === 0)
         return undefined;
@@ -78,7 +80,8 @@ export function extractTodoProgress(args) {
         if (!content)
             continue;
         const status = t?.status === 'completed' || t?.status === 'in_progress' ? t.status : 'pending';
-        items.push(activeForm ? { content, status, activeForm } : { content, status });
+        const description = typeof t?.description === 'string' && t.description ? t.description : undefined;
+        items.push({ content, status, ...(description ? { description } : {}), ...(activeForm ? { activeForm } : {}) });
     }
     if (items.length === 0)
         return undefined;
@@ -91,6 +94,86 @@ export function extractTodoProgress(args) {
         activeForm: inProgress ? inProgress.activeForm ?? inProgress.content : undefined,
     };
 }
+/** Fold snapshot checklist tools and Claude TaskCreate/TaskUpdate event logs. */
+export function extractTodoProgressFromEvents(events) {
+    let items = [];
+    let nextTaskId = 1;
+    let sawChecklist = false;
+    for (const event of events) {
+        if (event.type !== 'tool_use')
+            continue;
+        const args = event.args ?? {};
+        if (SNAPSHOT_TODO_TOOLS.has(event.tool ?? '')) {
+            const input = args.input && typeof args.input === 'object' ? args.input : args;
+            const raw = Array.isArray(input.todos) ? input.todos : Array.isArray(input.plan) ? input.plan : undefined;
+            if (raw) {
+                items = raw.map((item) => ({ ...item }));
+                sawChecklist = true;
+            }
+            continue;
+        }
+        if (event.tool === TASK_CREATE_TOOL) {
+            const content = args.subject || args.description;
+            if (typeof content !== 'string' || !content.trim())
+                continue;
+            items.push({
+                taskId: String(nextTaskId++),
+                content: content.trim(),
+                description: typeof args.description === 'string' ? args.description : undefined,
+                activeForm: typeof args.activeForm === 'string' ? args.activeForm : undefined,
+                status: 'pending',
+            });
+            sawChecklist = true;
+            continue;
+        }
+        if (event.tool === TASK_UPDATE_TOOL) {
+            const taskId = String(args.taskId ?? args.task_id ?? '');
+            const index = items.findIndex(item => String(item.taskId ?? '') === taskId);
+            if (index < 0)
+                continue;
+            if (args.status === 'deleted') {
+                items.splice(index, 1);
+                continue;
+            }
+            const prior = items[index];
+            items[index] = {
+                ...prior,
+                ...(typeof args.subject === 'string' ? { content: args.subject } : {}),
+                ...(typeof args.description === 'string' ? { description: args.description } : {}),
+                ...(typeof args.activeForm === 'string' ? { activeForm: args.activeForm } : {}),
+                ...(typeof args.status === 'string' ? { status: args.status } : {}),
+            };
+        }
+    }
+    return sawChecklist ? extractTodoProgress({ todos: items }) : undefined;
+}
+/** Derive a recency-ordered, de-duplicated list of directories touched by tools. */
+export function extractRecentDirectoriesTouched(events, cwd) {
+    const dirs = [];
+    const add = (value, file = false) => {
+        if (typeof value !== 'string' || !value.trim())
+            return;
+        const resolved = path.isAbsolute(value) ? value : path.resolve(cwd || process.cwd(), value);
+        const dir = file ? path.dirname(resolved) : resolved;
+        const old = dirs.indexOf(dir);
+        if (old >= 0)
+            dirs.splice(old, 1);
+        dirs.push(dir);
+    };
+    for (const event of events) {
+        if (event.type !== 'tool_use')
+            continue;
+        const tool = event.tool ?? '';
+        const args = event.args ?? {};
+        if (['Edit', 'Write', 'edit_file', 'write_file', 'create_file', 'edit', 'write'].includes(tool)) {
+            add(args.file_path ?? args.filePath ?? args.path ?? event.path, true);
+        }
+        else if (['Bash', 'exec_command', 'run_shell_command', 'shell', 'Execute'].includes(tool)) {
+            add(args.cwd ?? args.Cwd ?? args.workdir ?? args.working_directory ?? cwd);
+        }
+    }
+    return dirs.length ? dirs.slice(-10) : undefined;
+}
 /** Trailing '?' or a leading interrogative — a question aimed at the user. */
 const QUESTION_TRAILING = /\?["'”)\]]?\s*$/;
 const QUESTION_PHRASE = /\b(shall i|should i|do you want|would you like|which (?:one|option|approach|of)|can you (?:confirm|clarify)|please (?:confirm|clarify|advise)|let me know|are you (?:ok|okay|sure)|proceed\?)\b/i;
@@ -325,11 +408,10 @@ export function inferActivity(events, ctx = {}) {
         .slice(-3)
         .map(e => oneLine(e.content ?? ''))
         .filter(Boolean);
-    // Live plan progress: the most recent TodoWrite's checklist (RUSH-1380). Attached
+    // Live plan progress: snapshot checklist tools or the folded Task* event log. Attached
     // to `base` so every return path below carries it — a working, waiting, or idle
     // session all keep showing how far the plan got.
-    const lastTodo = lastOf(meaningful, e => e.type === 'tool_use' && (e.tool === TODO_TOOL || e.tool === CODEX_PLAN_TOOL));
-    const todos = lastTodo ? extractTodoProgress(lastTodo.args) : undefined;
+    const todos = extractTodoProgressFromEvents(meaningful);
     const base = {
         activity: 'idle',
         lastRole: lastMsg?.role,

package/dist/lib/session/types.d.ts

@@ -10,6 +10,12 @@
 export type SessionAgentId = 'claude' | 'codex' | 'gemini' | 'antigravity' | 'opencode' | 'openclaw' | 'rush' | 'hermes' | 'grok' | 'kimi' | 'droid';
 /** All agents with session discovery support, in display order. */
 export declare const SESSION_AGENTS: SessionAgentId[];
+/**
+ * True when `agent` stores session data `agents sessions` can discover (a member
+ * of {@link SESSION_AGENTS}). The single predicate every session-index writer
+ * gates on, so "is this a trackable agent?" is decided in exactly one place.
+ */
+export declare function isSessionTrackedAgent(agent: string): agent is SessionAgentId;
 /** A single normalized event within a session (message, tool call, thinking, etc.). */
 export interface SessionEvent {
     type: 'message' | 'tool_use' | 'tool_result' | 'thinking' | 'error' | 'init' | 'result' | 'usage' | 'attachment';
@@ -25,6 +31,16 @@ export interface SessionEvent {
     output?: string;
     /** Internal: marks tool_use events from local commands */
     _local?: boolean;
+    /**
+     * Internal: marks a `role=user` message that is harness-injected scaffolding
+     * (Claude `<bash-input>`/`<bash-stdout>` from `!`-prefix runs, `<system-reminder>`,
+     * `<task-notification>`, `<command-*>` wrappers, `[Request interrupted]`, skill
+     * bodies, hook feedback) rather than a genuine user turn. Set centrally in
+     * `parseSession` via `isSyntheticUserMessage`. Such events are excluded from
+     * `--include user` and are not counted as turn starts by `--first`/`--last`,
+     * but stay in the default full stream so `--markdown` keeps full fidelity.
+     */
+    _synthetic?: boolean;
     model?: string;
     inputTokens?: number;
     outputTokens?: number;
@@ -41,10 +57,12 @@ export interface SessionAttachment {
     mediaType: string;
     sizeBytes?: number;
 }
-/** One checklist item, as Claude's `TodoWrite` (`content`) or Codex's `update_plan` (`step`) emits it. */
+/** One normalized checklist/task item emitted by any transcript harness. */
 export interface TodoItem {
     content: string;
     status: 'pending' | 'in_progress' | 'completed';
+    /** Optional longer explanation supplied by task-based harnesses. */
+    description?: string;
     /** Present-continuous label shown while this item is the active step. */
     activeForm?: string;
 }
@@ -152,6 +170,12 @@ export interface SessionMeta {
      * instead of re-parsing the transcript. Absent when the session wrote no list.
      */
     todos?: TodoProgress;
+    /** Most-recent unique directories changed or used as a shell working directory. */
+    recentDirectoriesTouched?: string[];
+    /** Linear project containing ticketId, resolved lazily and cached in SQLite. */
+    linearProject?: string;
+    /** Browser URL for linearProject. */
+    linearProjectUrl?: string;
     /**
      * True when the session was spawned programmatically (SDK entrypoint) rather
      * than by a human at the Claude CLI. Captured at scan time from the JSONL

package/dist/lib/session/types.js

@@ -8,3 +8,11 @@
  */
 /** All agents with session discovery support, in display order. */
 export const SESSION_AGENTS = ['claude', 'codex', 'gemini', 'antigravity', 'opencode', 'openclaw', 'rush', 'hermes', 'grok', 'kimi', 'droid'];
+/**
+ * True when `agent` stores session data `agents sessions` can discover (a member
+ * of {@link SESSION_AGENTS}). The single predicate every session-index writer
+ * gates on, so "is this a trackable agent?" is decided in exactly one place.
+ */
+export function isSessionTrackedAgent(agent) {
+    return SESSION_AGENTS.includes(agent);
+}

package/dist/lib/state.d.ts

@@ -121,9 +121,13 @@ export declare function getSystemRoutinesDir(): string;
  * Path to a project-scoped routines directory (`<project>/.agents/routines/`),
  * or null when no project `.agents/` is found by walking up from cwd.
  *
- * Project routines participate in `list`/`view`/`run` for inspection but are
- * NOT fired by the daemon (which runs from $HOME and loads only user + system
- * routines). Opt-in firing for project routines is tracked as a follow-up.
+ * Project routines participate in `list`/`view` for inspection always. Daemon
+ * firing requires an explicit opt-in via `agents routines enable-project`
+ * (writes `meta.routines.projects`); after opt-in, `agents routines sync`
+ * materialises them into the user layer with `source:` provenance so the
+ * daemon (which loads user + system only) can fire them safely. A project's
+ * own `agents.yaml` `routines.enable: true` is a documentation signal only —
+ * it does not auto-enable firing. See `lib/routines-project.ts`.
  */
 export declare function getProjectRoutinesDir(cwd?: string): string | null;
 /** Path to routine execution logs (~/.agents/.history/runs/). */

package/dist/lib/state.js

@@ -319,9 +319,13 @@ export function getSystemRoutinesDir() { return SYSTEM_ROUTINES_DIR; }
  * Path to a project-scoped routines directory (`<project>/.agents/routines/`),
  * or null when no project `.agents/` is found by walking up from cwd.
  *
- * Project routines participate in `list`/`view`/`run` for inspection but are
- * NOT fired by the daemon (which runs from $HOME and loads only user + system
- * routines). Opt-in firing for project routines is tracked as a follow-up.
+ * Project routines participate in `list`/`view` for inspection always. Daemon
+ * firing requires an explicit opt-in via `agents routines enable-project`
+ * (writes `meta.routines.projects`); after opt-in, `agents routines sync`
+ * materialises them into the user layer with `source:` provenance so the
+ * daemon (which loads user + system only) can fire them safely. A project's
+ * own `agents.yaml` `routines.enable: true` is a documentation signal only —
+ * it does not auto-enable firing. See `lib/routines-project.ts`.
  */
 export function getProjectRoutinesDir(cwd = process.cwd()) {
     const projectAgentsDir = getProjectAgentsDir(cwd);
@@ -383,10 +387,21 @@ export function getTeamsDir() { return TEAMS_DIR; }
 export function getTeamsAgentsDir() { return TEAMS_AGENTS_DIR; }
 /** Path to the team registry — list of named teams with timestamps. Durable runtime, per-machine. */
 export function getTeamsRegistryPath() { return path.join(HISTORY_DIR, 'teams', 'registry.json'); }
+/**
+ * The devices dir (registry + ignore-list live here). Read at CALL time so a
+ * test can redirect it to a temp dir via AGENTS_DEVICES_DIR without racing the
+ * module-load capture of HISTORY_DIR — mirrors the AGENTS_EVENTS_PATH /
+ * AGENTS_SECRETS_AGENT_DIR test-isolation escape hatches. Never set in
+ * production code; it exists so the vitest fork's device-registry writes can
+ * never reach the user's real ~/.agents/.history/devices (RUSH-2042).
+ */
+function getDevicesDir() {
+    return process.env.AGENTS_DEVICES_DIR ?? path.join(HISTORY_DIR, 'devices');
+}
 /** Path to the device registry — SSH device profiles with platform/auth metadata. Durable runtime, per-machine (host list + addresses are NOT pulled by `agents repo push`). */
-export function getDevicesRegistryPath() { return path.join(HISTORY_DIR, 'devices', 'registry.json'); }
+export function getDevicesRegistryPath() { return path.join(getDevicesDir(), 'registry.json'); }
 /** Path to the device ignore-list — tailscale node names the user dismissed, so auto-discovery never re-suggests them. Per-machine, same dir as the registry. */
-export function getDevicesIgnoredPath() { return path.join(HISTORY_DIR, 'devices', 'ignored.json'); }
+export function getDevicesIgnoredPath() { return path.join(getDevicesDir(), 'ignored.json'); }
 /** Dir of "pending device" sentinels (~/.agents/.cache/state/devices-pending/) — one empty-ish file per newly-discovered, not-yet-approved tailnet node. Written by the daemon probe, read by the menu-bar helper (mirrors the attention sentinel dir). */
 export function getDevicesPendingDir() { return path.join(RUNTIME_STATE_DIR, 'devices-pending'); }
 /** Path to cloud dispatch cache (~/.agents/.cache/cloud/). */

package/dist/lib/types.d.ts

@@ -866,6 +866,16 @@ export interface Meta {
         };
         transports?: Record<string, string>;
     };
+    /**
+     * Routines daemon settings. `projects` is the allowlist of project roots
+     * whose `.agents/routines/*.yml` may be synced into `~/.agents/routines/`
+     * and fired by the daemon — never auto-discovered from a cloned public
+     * repo without an explicit opt-in (`agents routines enable-project`).
+     * Paths are stored absolute (or home-relative `~/…`).
+     */
+    routines?: {
+        projects?: string[];
+    };
 }
 /** Persisted agent-host entry in agents.yaml (overlay or inline). */
 export interface HostEntry {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.76",
+  "version": "1.20.77",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",