@phnx-labs/agents-cli 1.22.83 → 1.22.85

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

@@ -43,7 +43,13 @@ export declare function sessionDisplayAgent(session: {
 }): string;
 /** 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' | 'hook' | 'interrupt';
+    /**
+     * `file_change` is the harness's own file ledger (Claude `file-history-delta`,
+     * Codex `FileChange`, OpenCode `patch`) rather than a tool call. It is emitted
+     * only on request (`includeFileHistory`) or by the Codex item reader, never in
+     * the default published stream — see `ParseSessionOptions.includeFileHistory`.
+     */
+    type: 'message' | 'tool_use' | 'tool_result' | 'thinking' | 'error' | 'init' | 'result' | 'usage' | 'attachment' | 'hook' | 'interrupt' | 'file_change';
     agent: SessionAgentId;
     timestamp: string;
     role?: 'user' | 'assistant';
@@ -57,6 +63,13 @@ export interface SessionEvent {
     success?: boolean;
     /** Structured harness outcome; never inferred from free-text output. */
     outcome?: 'ok' | 'error' | 'unknown';
+    /**
+     * The call never RAN: a permission rule or hook denied it (Claude
+     * `toolDenialKind`), or the turn was aborted. Distinct from a failure — a
+     * blocked call says nothing about whether the work would have succeeded, so
+     * the timeline counts the two separately.
+     */
+    blocked?: boolean;
     exitCode?: number;
     statusCode?: number;
     errorCode?: string;
@@ -93,6 +106,35 @@ export interface SessionEvent {
      * programmatically, not the user). Undefined for every other event.
      */
     slashCommand?: string;
+    /**
+     * The label the HARNESS itself wrote for this call — Claude's Bash
+     * `input.description` ("Locate the prior session transcript on disk"), Kimi's
+     * `tool.call.description`, OpenCode's `state.title` / `state.input.description`,
+     * Codex's `CommandExecution.command`. Human-written, one per call, and exactly
+     * what a now-line needs; `summarizeToolUse` renders the mechanical form
+     * instead, which is why this is kept separately rather than folded into it.
+     */
+    label?: string;
+    /**
+     * Verb class the HARNESS assigned (Codex `parsed_cmd.type`, a typed tool
+     * name). Absent when the harness does not classify its own call — then the
+     * consumer derives one from `command`.
+     */
+    verbClass?: SessionVerbClass;
+    /**
+     * Per-path file operations the harness recorded for this call (Codex
+     * `FileChange.changes`, OpenCode `patch.files`). The exact edit ledger, as
+     * opposed to inferring one from Edit/Write arguments.
+     */
+    changes?: Array<{
+        path: string;
+        op: 'created' | 'modified' | 'deleted';
+    }>;
+    /**
+     * Codex tags an `AgentMessage` with the role it played in the turn
+     * (`commentary` is the narration between tool calls). Absent elsewhere.
+     */
+    phase?: string;
 }
 /** A displayable file attachment discovered in a session transcript. */
 export interface SessionAttachment {
@@ -148,6 +190,110 @@ export interface SessionChecklistItem {
  *                 left no summary; the row deliberately carries no goal/checkpoints.
  */
 export type SummaryState = 'pending' | 'ready' | 'skipped';
+/**
+ * How a tool call is bucketed on a timeline step (PHNX-3939). Coarse on purpose
+ * — a step renders as "6 run · 2 blocked", not as a tool histogram. Taken from
+ * the harness when it classifies its own call (Codex `parsed_cmd.type`, a
+ * harness tool name) and derived from the command otherwise.
+ */
+export type SessionVerbClass = 'read' | 'edit' | 'run' | 'git' | 'test' | 'browser' | 'agent' | 'other';
+/**
+ * One step of the narration-anchored timeline (PHNX-3939): the agent's own
+ * short line about what it is doing, plus the tool calls that ran under it.
+ *
+ * The text is never model-written — it is the harness's own narration (Claude
+ * assistant text, Codex `AgentMessage` commentary, Gemini thought subject), a
+ * thinking block when there is no narration, the user's tidied turn, or a
+ * mix-derived line when tools ran with nothing said. `source` says which.
+ */
+export interface SessionStep {
+    /** Headline: the first sentence of the narration, capped. */
+    text: string;
+    /** ISO time this step opened. */
+    at: string;
+    /** ISO time of the last event folded into it. */
+    endedAt?: string;
+    source: 'narration' | 'thinking' | 'derived' | 'user';
+    /** Tool calls attached to this step. */
+    tools: number;
+    /** Calls that RAN and failed (non-zero exit, `is_error`, harness error status). */
+    failed: number;
+    /** Calls that never ran: a permission rule, a hook denial, an aborted turn. */
+    blocked: number;
+    /** Per-verb-class tally of the attached calls. */
+    mix?: Partial<Record<SessionVerbClass, number>>;
+    /** Milestones recognized under this step ("worktree created", "PR opened", "files changed"). */
+    marks?: string[];
+    /** True on the newest step while the session is working. */
+    live?: boolean;
+    /** Harness label of the running tool on a live step — the now-line. */
+    now?: string;
+}
+/**
+ * The bounded projection of a session's timeline that rides the row (PHNX-3939).
+ *
+ * `steps` is the tail; everything before it collapses into `earlier` so the
+ * payload stays flat as a session grows. `state` is honest about harnesses that
+ * cannot supply one: `partial` when an event cap was hit, `unavailable` with a
+ * `reason` when the harness writes no parseable transcript (OpenClaw) — never
+ * an empty step list presented as "nothing happened".
+ */
+export interface SessionTimeline {
+    /** Newest last, at most `keep` (8). */
+    steps: SessionStep[];
+    earlier: {
+        steps: number;
+        tools: number;
+        failed: number;
+    };
+    /** Totals across the WHOLE session, not just `steps`. */
+    tools: number;
+    failed: number;
+    blocked: number;
+    spanMs: number;
+    state: 'ready' | 'partial' | 'unavailable';
+    reason?: string;
+}
+/**
+ * The session's operative request: the latest genuine user turn, tidied but
+ * never rewritten (PHNX-3939). `turns` counts every genuine user turn so a
+ * consumer can say "latest of 6"; `continues` names the session a `/continue`
+ * picked up.
+ */
+export type SessionRequest = import('./prompt.js').TidyRequest & {
+    /**
+     * Genuine user turns in the session so far, so a consumer can say "latest of
+     * 6". Present only when the daemon's timeline fold counted them; a request
+     * tidied inline from the indexed turn alone does not know the count and says
+     * nothing rather than claiming 1.
+     */
+    turns?: number;
+    continues?: {
+        id: string;
+        label?: string;
+    };
+};
+/** One file the session created, modified or deleted. */
+export interface SessionFileChange {
+    path: string;
+    op: 'created' | 'modified' | 'deleted';
+    /** How many times the session touched it. */
+    edits: number;
+    /** ISO time of the last touch. */
+    at: string;
+}
+/**
+ * The files a session changed (PHNX-3939). `source: 'harness'` means the
+ * harness recorded the change itself (Codex `FileChange`, OpenCode `patch`,
+ * Claude `file-history-delta`); `'tools'` means it was derived from Edit/Write
+ * calls because the harness records no file ledger. `changes` is bounded to 8
+ * rows; `total` is the real count.
+ */
+export interface SessionFiles {
+    changes: SessionFileChange[];
+    total: number;
+    source: 'harness' | 'tools';
+}
 /** Metadata attached when a session was spawned by `agents teams`. */
 export interface TeamOrigin {
     /** Teammate name if set, otherwise first 8 chars of the agent UUID. */
@@ -256,6 +402,14 @@ export interface SessionMeta {
     topic?: string;
     /** Full, cleaned first genuine user turn; distinct from the one-line topic. */
     firstUserMessage?: string;
+    /**
+     * Full, cleaned LATEST genuine user turn. For a `/continue`, a redirect, or an
+     * interrupted-and-restated session the operative request is the last thing the
+     * user said, not the first — which is what the session row and the sidebar's
+     * Request card show (PHNX-3939). Equal to {@link firstUserMessage} for a
+     * single-turn session; absent for rows indexed before this field shipped.
+     */
+    lastUserMessage?: string;
     /**
      * The session's human-readable name — one field, several sources with a plain
      * priority: an agent-generated title / Claude `/rename` wins; else the launch

package/dist/lib/sha256-asset.d.ts

@@ -3,22 +3,17 @@
  *
  * These live in their own LEAF module — importing only `node:crypto` and
  * `node:fs` — on purpose. They used to sit in `computer/ssh-tunnel.ts`, whose
- * own import graph reaches `browser/drivers/ssh.ts` -> `browser/chrome.ts` ->
- * `secrets/*`. `helper-download.ts` needs nothing from that graph but these two
- * pure functions, and importing them from there closed a module-initialization
- * cycle:
- *
- *   helper-download.ts
- *     -> computer/ssh-tunnel.ts        (evaluated BEFORE `EXPECTED_TEAM_ID`)
- *       -> browser/drivers/ssh.ts -> browser/chrome.ts
- *         -> secrets/bundles.ts -> secrets/index.ts -> secrets/install-helper.ts
- *           -> secrets/download-keychain.ts
- *             -> helper-download.ts    (still evaluating; const not yet bound)
- *
- * which threw `ReferenceError: Cannot access 'EXPECTED_TEAM_ID' before
- * initialization` at `secrets/download-keychain.ts:45` for any entry point that
- * reached `helper-download.ts` first (RUSH-3113). Keep this module a leaf: adding
- * a local import here can reintroduce that cycle.
+ * own import graph reached `browser/drivers/ssh.ts` -> `browser/chrome.ts` ->
+ * the in-repo secrets engine's own keychain-helper downloader, which imported
+ * back into `helper-download.ts` while it was still evaluating — before
+ * `EXPECTED_TEAM_ID` was bound, throwing `ReferenceError: Cannot access
+ * 'EXPECTED_TEAM_ID' before initialization` for any entry point that reached
+ * `helper-download.ts` first (RUSH-3113). The secrets engine that closed that
+ * cycle is gone now (PHNX-3989 — the standalone `secrets` CLI downloads its own
+ * helper), but the discipline that fixed it still holds: keep this module a
+ * leaf, since `helper-download.ts` needs nothing beyond these two pure
+ * functions and adding a local import here can reintroduce a cycle with
+ * whatever imports it next.
  */
 /** Pull the digest out of a `<sha256>  <filename>` release asset. */
 export declare function parseSha256Asset(text: string): string;

package/dist/lib/sha256-asset.js

@@ -3,22 +3,17 @@
  *
  * These live in their own LEAF module — importing only `node:crypto` and
  * `node:fs` — on purpose. They used to sit in `computer/ssh-tunnel.ts`, whose
- * own import graph reaches `browser/drivers/ssh.ts` -> `browser/chrome.ts` ->
- * `secrets/*`. `helper-download.ts` needs nothing from that graph but these two
- * pure functions, and importing them from there closed a module-initialization
- * cycle:
- *
- *   helper-download.ts
- *     -> computer/ssh-tunnel.ts        (evaluated BEFORE `EXPECTED_TEAM_ID`)
- *       -> browser/drivers/ssh.ts -> browser/chrome.ts
- *         -> secrets/bundles.ts -> secrets/index.ts -> secrets/install-helper.ts
- *           -> secrets/download-keychain.ts
- *             -> helper-download.ts    (still evaluating; const not yet bound)
- *
- * which threw `ReferenceError: Cannot access 'EXPECTED_TEAM_ID' before
- * initialization` at `secrets/download-keychain.ts:45` for any entry point that
- * reached `helper-download.ts` first (RUSH-3113). Keep this module a leaf: adding
- * a local import here can reintroduce that cycle.
+ * own import graph reached `browser/drivers/ssh.ts` -> `browser/chrome.ts` ->
+ * the in-repo secrets engine's own keychain-helper downloader, which imported
+ * back into `helper-download.ts` while it was still evaluating — before
+ * `EXPECTED_TEAM_ID` was bound, throwing `ReferenceError: Cannot access
+ * 'EXPECTED_TEAM_ID' before initialization` for any entry point that reached
+ * `helper-download.ts` first (RUSH-3113). The secrets engine that closed that
+ * cycle is gone now (PHNX-3989 — the standalone `secrets` CLI downloads its own
+ * helper), but the discipline that fixed it still holds: keep this module a
+ * leaf, since `helper-download.ts` needs nothing beyond these two pure
+ * functions and adding a local import here can reintroduce a cycle with
+ * whatever imports it next.
  */
 import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';

package/dist/lib/share/config.js

@@ -9,8 +9,7 @@
 //   `cloudflare` bundle.
 import { randomBytes } from 'node:crypto';
 import { readMeta, updateMeta } from '../state.js';
-import { bundleExists, bundleItemStore, bundlePolicy, keychainRef, readAndResolveBundleEnv, readBundle, writeBundle, } from '../secrets/bundles.js';
-import { secretsKeychainItem } from '../secrets/index.js';
+import { bundleExistsSync as bundleExists, keychainRef, readAndResolveBundleEnvSync as readAndResolveBundleEnv, readBundleSync as readBundle, secretsKeychainItem, writeBundleWithItemsSync as writeBundleWithItems, } from '../secrets-client.js';
 export const SHARE_BUNDLE = 'share';
 export const SHARE_TOKEN_KEY = 'WRITE_TOKEN';
 export const SHARE_TOKEN_ENV_KEY = 'SHARE_WRITE_TOKEN';
@@ -113,10 +112,12 @@ export function storeWriteToken(token) {
             vars: {},
         };
     }
-    const store = bundleItemStore(bundle.backend, { noAcl: bundlePolicy(bundle) === 'never' });
-    store.set(secretsKeychainItem(bundle.name, SHARE_TOKEN_KEY), token);
+    // writeBundleWithItems decides the ACL (keychain backend) purely from
+    // `bundle.policy === 'never'` — the fresh-bundle case above sets it
+    // explicitly, and an existing bundle already carries its own explicit tier.
     bundle.vars[SHARE_TOKEN_KEY] = keychainRef(SHARE_TOKEN_KEY);
-    writeBundle(bundle);
+    const item = secretsKeychainItem(bundle.name, SHARE_TOKEN_KEY);
+    writeBundleWithItems(bundle, new Map([[item, token]]));
 }
 /** Read the raw write token from the `share` secrets bundle. */
 export function readWriteTokenFromBundle() {
@@ -178,6 +179,14 @@ export function readCloudflareCreds(bundle = DEFAULT_CF_BUNDLE, override) {
     if (override?.apiToken) {
         return { apiToken: override.apiToken, accountId: override.accountId ?? '' };
     }
+    // Check existence first (same guard as readShareToken above): resolving a
+    // missing bundle through the process client surfaces an opaque transport code
+    // (e.g. LOCKED), never naming the bundle the user typed — so name it here.
+    if (!bundleExists(bundle)) {
+        throw new Error(`The '${bundle}' bundle does not exist. ` +
+            `Pass credentials directly with --token <t> [--account <id>], or create it: ` +
+            `agents secrets add ${bundle} CLOUDFLARE_API_TOKEN`);
+    }
     const { env } = readAndResolveBundleEnv(bundle, {
         caller: 'share',
         // Setup is still a read; only `agents secrets unlock` may authenticate.

package/dist/lib/signin-badge.d.ts

@@ -1,5 +1,8 @@
 import type { AccountInfo } from './agents.js';
+import type { AuthVerdict } from './auth-health.js';
 import type { AgentId } from './types.js';
+export type AccountVerdict = Exclude<AuthVerdict, 'unconfigured' | 'error'> | 'missing' | 'per-device' | 'ready';
+export type AccountProvisioning = 'portable' | 'per-device';
 /**
  * The exact command that logs a given agent in — for warn banners and nudges.
  * Driven off the registry `cliCommand` with the per-agent subcommand overrides
@@ -8,6 +11,29 @@ import type { AgentId } from './types.js';
  * remaining agents (kimi, gemini, …) start their device/oauth flow on launch.
  */
 export declare function loginHint(agentId: AgentId): string;
+/**
+ * Exact action shown beside a non-live account. Every emitted command exists
+ * today — never a planned surface and never a hidden verb:
+ * - Per-device harnesses repair per box via `agents devices login`.
+ * - Named accounts re-auth through `agents accounts login <harness>#<name>`.
+ *   A known account with no slot on a headed device is onboarded with
+ *   `agents accounts add <harness> <name>`. A worker never runs an
+ *   interactive login — the hint is `add.ts`'s worker refusal (add on the
+ *   personal device; this box is provisioned from the durable credential).
+ * - Unnamed legacy homes use the same version-targeted command shape as
+ *   doctor, so the hint never logs a different/default home in by accident.
+ * - `unverified` emits nothing: the probe could not confirm state (e.g. a
+ *   worker whose token lacks the usage scope), so there is nothing to repair.
+ */
+export declare function fixFor(input: {
+    agent: AgentId;
+    verdict: AccountVerdict;
+    name?: string | null;
+    version?: string | null;
+    provisioning?: AccountProvisioning;
+    /** When false, this named account has no slot on this device yet. */
+    hasSlot?: boolean;
+}): string | null;
 /**
  * Whether `agents run` should probe login state before launching. True only for
  * a launch that actually opens the interactive TUI — where discovering a logged-out

package/dist/lib/signin-badge.js

@@ -9,7 +9,9 @@
  * on it (the run preflight) WARN and continue; they never block.
  */
 import chalk from 'chalk';
+import { addWorkerRefusal } from './accounts/add.js';
 import { AGENTS } from './agents.js';
+import { CONFIG_ENV_ISOLATED_AGENTS } from './installations/shims.js';
 /**
  * The exact command that logs a given agent in — for warn banners and nudges.
  * Driven off the registry `cliCommand` with the per-agent subcommand overrides
@@ -34,6 +36,46 @@ export function loginHint(agentId) {
             return cli;
     }
 }
+/**
+ * Exact action shown beside a non-live account. Every emitted command exists
+ * today — never a planned surface and never a hidden verb:
+ * - Per-device harnesses repair per box via `agents devices login`.
+ * - Named accounts re-auth through `agents accounts login <harness>#<name>`.
+ *   A known account with no slot on a headed device is onboarded with
+ *   `agents accounts add <harness> <name>`. A worker never runs an
+ *   interactive login — the hint is `add.ts`'s worker refusal (add on the
+ *   personal device; this box is provisioned from the durable credential).
+ * - Unnamed legacy homes use the same version-targeted command shape as
+ *   doctor, so the hint never logs a different/default home in by accident.
+ * - `unverified` emits nothing: the probe could not confirm state (e.g. a
+ *   worker whose token lacks the usage scope), so there is nothing to repair.
+ */
+export function fixFor(input) {
+    const { agent, verdict } = input;
+    if (verdict === 'live' || verdict === 'rate_limited' || verdict === 'unverified' || verdict === 'ready')
+        return null;
+    if (input.provisioning === 'per-device' || verdict === 'per-device') {
+        return `agents devices login --agents ${agent}`;
+    }
+    if (input.name) {
+        const worker = addWorkerRefusal(agent, input.name);
+        if (worker)
+            return worker;
+        if (input.hasSlot === false)
+            return `agents accounts add ${agent} ${input.name}`;
+        return `agents accounts login ${agent}#${input.name}`;
+    }
+    const version = input.version ?? null;
+    if (!version || !CONFIG_ENV_ISOLATED_AGENTS.includes(agent))
+        return loginHint(agent);
+    if (agent === 'claude')
+        return `agents run ${agent}@${version}, then /login`;
+    if (agent === 'codex' || agent === 'grok')
+        return `agents run ${agent}@${version} -- login`;
+    if (agent === 'opencode')
+        return `agents run ${agent}@${version} -- auth login`;
+    return `agents run ${agent}@${version}`;
+}
 /**
  * Whether `agents run` should probe login state before launching. True only for
  * a launch that actually opens the interactive TUI — where discovering a logged-out

package/dist/lib/staleness/detectors/workflows.js

@@ -1,115 +1,13 @@
-/**
- * Workflows detector — scans the agent-specific on-disk layout for synced
- * workflow names (Claude WORKFLOW.md trees, Kimi flow skills, Antigravity
- * global_workflows, Goose recipes, OpenClaw Lobster, Grok Rhai).
- */
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import * as yaml from 'yaml';
 import { capableAgents } from '../../capabilities.js';
-import { grokWorkflowMarker } from '../../workflows.js';
+import { workflowTarget } from '../../workflows-registry.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';
 function buildWorkflowsDetector(agent) {
     return {
         kind: 'workflows',
         agent,
         list({ versionHome }) {
-            if (agent === 'kimi') {
-                const skillsDir = path.join(versionHome, '.kimi-code', 'skills');
-                if (!fs.existsSync(skillsDir))
-                    return [];
-                return fs.readdirSync(skillsDir, { withFileTypes: true })
-                    .filter(d => d.isDirectory() && fs.existsSync(path.join(skillsDir, d.name, 'SKILL.md')))
-                    .filter(d => {
-                    try {
-                        const skill = fs.readFileSync(path.join(skillsDir, d.name, 'SKILL.md'), 'utf-8');
-                        const lines = skill.split('\n');
-                        if (lines[0] !== '---')
-                            return false;
-                        const endIndex = lines.slice(1).findIndex(l => l === '---');
-                        if (endIndex < 0)
-                            return false;
-                        const parsed = yaml.parse(lines.slice(1, endIndex + 1).join('\n'));
-                        return parsed?.type === 'flow' && parsed.agents_workflow === d.name;
-                    }
-                    catch {
-                        return false;
-                    }
-                })
-                    .map(d => d.name);
-            }
-            if (agent === 'antigravity') {
-                // Antigravity user workflows are HOME-global and shared across versions,
-                // not version-isolated — see workflows.ts:antigravityWorkflowsDir(). agy
-                // scans the real ~/.gemini/config/global_workflows/, so the detector reads
-                // the same shared dir the writer targets (versionHome is intentionally unused).
-                const dir = path.join(process.env.HOME ?? os.homedir(), '.gemini', 'config', 'global_workflows');
-                if (!fs.existsSync(dir))
-                    return [];
-                return fs.readdirSync(dir, { withFileTypes: true })
-                    .filter(d => d.isFile() && d.name.endsWith('.md') && !d.name.startsWith('.'))
-                    .filter(d => {
-                    try {
-                        const content = fs.readFileSync(path.join(dir, d.name), 'utf-8');
-                        const lines = content.split('\n');
-                        if (lines[0] !== '---')
-                            return false;
-                        const endIndex = lines.slice(1).findIndex(l => l === '---');
-                        if (endIndex < 0)
-                            return false;
-                        const parsed = yaml.parse(lines.slice(1, endIndex + 1).join('\n'));
-                        return parsed?.agents_workflow === d.name.slice(0, -'.md'.length);
-                    }
-                    catch {
-                        return false;
-                    }
-                })
-                    .map(d => d.name.slice(0, -'.md'.length));
-            }
-            if (agent === 'goose') {
-                const recipesDir = path.join(versionHome, '.config', 'goose', 'recipes');
-                if (!fs.existsSync(recipesDir))
-                    return [];
-                return fs.readdirSync(recipesDir, { withFileTypes: true })
-                    .filter(d => d.isFile() && d.name.endsWith('.yaml') && !d.name.startsWith('.'))
-                    .map(d => d.name.slice(0, -'.yaml'.length));
-            }
-            if (agent === 'openclaw') {
-                const dir = path.join(versionHome, '.openclaw', 'workflows');
-                if (!fs.existsSync(dir))
-                    return [];
-                return fs.readdirSync(dir, { withFileTypes: true })
-                    .filter(d => d.isFile() && d.name.endsWith('.lobster') && !d.name.startsWith('.'))
-                    .filter(d => {
-                    try {
-                        const parsed = yaml.parse(fs.readFileSync(path.join(dir, d.name), 'utf-8'));
-                        const env = parsed && typeof parsed === 'object' && parsed.env && typeof parsed.env === 'object' && !Array.isArray(parsed.env)
-                            ? parsed.env
-                            : {};
-                        return env.AGENTS_CLI_WORKFLOW === d.name.slice(0, -'.lobster'.length);
-                    }
-                    catch {
-                        return false;
-                    }
-                })
-                    .map(d => d.name.slice(0, -'.lobster'.length));
-            }
-            if (agent === 'grok') {
-                const workflowsDir = path.join(versionHome, '.grok', 'workflows');
-                if (!fs.existsSync(workflowsDir))
-                    return [];
-                return fs.readdirSync(workflowsDir, { withFileTypes: true })
-                    .filter(d => d.isFile() && d.name.endsWith('.rhai') && !d.name.startsWith('.'))
-                    .filter(d => grokWorkflowMarker(path.join(workflowsDir, d.name)) === d.name.slice(0, -'.rhai'.length))
-                    .map(d => d.name.slice(0, -'.rhai'.length));
-            }
-            const workflowsDir = path.join(versionHome, 'workflows');
-            if (!fs.existsSync(workflowsDir))
-                return [];
-            return fs.readdirSync(workflowsDir, { withFileTypes: true })
-                .filter(d => d.isDirectory() && fs.existsSync(path.join(workflowsDir, d.name, 'WORKFLOW.md')))
-                .map(d => d.name);
+            const target = workflowTarget(agent);
+            return target.names(target.dir(versionHome));
         },
     };
 }

package/dist/lib/staleness/writers/workflows.js

@@ -1,5 +1,6 @@
 import { capableAgents } from '../../capabilities.js';
-import { listInstalledWorkflows, syncWorkflowToVersion } from '../../workflows.js';
+import { listInstalledWorkflows } from '../../workflows.js';
+import { syncWorkflowToVersion } from '../../workflows-registry.js';
 import { lazyAgentMap } from './lazy-map.js';
 function buildWorkflowsWriter(agent) {
     return {

package/dist/lib/state.d.ts

@@ -123,10 +123,13 @@ export declare function getUserSecretsDir(): string;
  * AGENTS_SECRETS_DB without racing the module-load capture of USER_SECRETS_DIR —
  * mirrors the AGENTS_EVENTS_PATH / AGENTS_DEVICES_DIR escape hatches. Holds only
  * value-free usage telemetry (which bundle was created/imported/exported/viewed/
- * accessed/unlocked, when, by whom), never a secret value. It is a derived index
- * fed FROM the emitSecretAudit chokepoint alongside the append-only
- * ~/.agents/.history/events/YYYY-MM-DD audit log — the same way sessions.db indexes session
- * metadata off the real session flow — not a second write path.
+ * accessed/unlocked, when, by whom), never a secret value. It used to be a
+ * derived index fed FROM the in-repo secrets engine's own emitSecretAudit
+ * chokepoint — not a second write path — the same way sessions.db indexes
+ * session metadata off the real session flow. That engine (and its audit
+ * emission) moved out of this repo entirely with the standalone `secrets`
+ * engine (PHNX-3989), so nothing writes this DB from agents-cli today; the
+ * read-side queries in `analytics/usage-db.ts` have no current caller.
  */
 export declare function getSecretsDbPath(): string;
 /**

package/dist/lib/state.js

@@ -396,10 +396,13 @@ export function getUserSecretsDir() { return USER_SECRETS_DIR; }
  * AGENTS_SECRETS_DB without racing the module-load capture of USER_SECRETS_DIR —
  * mirrors the AGENTS_EVENTS_PATH / AGENTS_DEVICES_DIR escape hatches. Holds only
  * value-free usage telemetry (which bundle was created/imported/exported/viewed/
- * accessed/unlocked, when, by whom), never a secret value. It is a derived index
- * fed FROM the emitSecretAudit chokepoint alongside the append-only
- * ~/.agents/.history/events/YYYY-MM-DD audit log — the same way sessions.db indexes session
- * metadata off the real session flow — not a second write path.
+ * accessed/unlocked, when, by whom), never a secret value. It used to be a
+ * derived index fed FROM the in-repo secrets engine's own emitSecretAudit
+ * chokepoint — not a second write path — the same way sessions.db indexes
+ * session metadata off the real session flow. That engine (and its audit
+ * emission) moved out of this repo entirely with the standalone `secrets`
+ * engine (PHNX-3989), so nothing writes this DB from agents-cli today; the
+ * read-side queries in `analytics/usage-db.ts` have no current caller.
  */
 export function getSecretsDbPath() {
     return process.env.AGENTS_SECRETS_DB ?? path.join(USER_SECRETS_DIR, 'secrets.db');
@@ -1332,7 +1335,9 @@ export function writeMetaUnlocked(meta) {
     // In-flight connect attempts (PHNX-3940), device-scoped like homes.
     const accountsPending = deviceAccounts?.pendingConnects && Object.keys(deviceAccounts.pendingConnects).length > 0
         ? deviceAccounts.pendingConnects : undefined;
-    if (accountsNative || accountsBindings || accountsHomes || accountsPending) {
+    const accountsSlots = deviceAccounts?.slots && Object.keys(deviceAccounts.slots).length > 0
+        ? deviceAccounts.slots : undefined;
+    if (accountsNative || accountsBindings || accountsHomes || accountsPending || accountsSlots) {
         const da = {};
         if (accountsNative)
             da.native = accountsNative;
@@ -1342,6 +1347,8 @@ export function writeMetaUnlocked(meta) {
             da.homes = accountsHomes;
         if (accountsPending)
             da.pendingConnects = accountsPending;
+        if (accountsSlots)
+            da.slots = accountsSlots;
         doc.accounts = da;
     }
     else if (writesDeviceAccounts)
@@ -1487,12 +1494,16 @@ function overlayMachineLocal(meta) {
                 if (acc.pendingConnects !== undefined && !isMap(acc.pendingConnects)) {
                     throw new Error(`Device config corrupted at ${devicePath}: accounts.pendingConnects must be a map.`);
                 }
+                if (acc.slots !== undefined && !isMap(acc.slots)) {
+                    throw new Error(`Device config corrupted at ${devicePath}: accounts.slots must be a map.`);
+                }
                 const native = acc.native;
                 const bindings = acc.bindings;
                 const homes = acc.homes;
                 const pendingConnects = acc.pendingConnects;
-                if (native || bindings || homes || pendingConnects)
-                    meta.deviceAccounts = { ...(native ? { native } : {}), ...(bindings ? { bindings } : {}), ...(homes ? { homes } : {}), ...(pendingConnects ? { pendingConnects } : {}) };
+                const slots = acc.slots;
+                if (native || bindings || homes || pendingConnects || slots)
+                    meta.deviceAccounts = { ...(native ? { native } : {}), ...(bindings ? { bindings } : {}), ...(homes ? { homes } : {}), ...(pendingConnects ? { pendingConnects } : {}), ...(slots ? { slots } : {}) };
             }
             if (Object.prototype.hasOwnProperty.call(dm, 'routines')) {
                 if (!Array.isArray(dm.routines) || dm.routines.some((name) => typeof name !== 'string')) {

package/dist/lib/summarizer/pass.d.ts

@@ -15,6 +15,8 @@ import { type SummarizerConfig } from './config.js';
 import { summarize as defaultSummarize } from './summarize.js';
 /** Max sessions summarized per tick — a debounce ceiling on local-model calls. */
 export declare const SUMMARIZER_MAX_PER_TICK = 8;
+/** Narration headlines handed to the model per session — the recent tail, not the history. */
+export declare const SUMMARIZER_STEP_INPUT = 12;
 export interface SummarizerPassOptions {
     now?: number;
     config?: SummarizerConfig;

package/dist/lib/summarizer/pass.js

@@ -17,6 +17,8 @@ import { resolveSummarizerConfig, isSummarizerRunnable } from './config.js';
 import { summarize as defaultSummarize } from './summarize.js';
 /** Max sessions summarized per tick — a debounce ceiling on local-model calls. */
 export const SUMMARIZER_MAX_PER_TICK = 8;
+/** Narration headlines handed to the model per session — the recent tail, not the history. */
+export const SUMMARIZER_STEP_INPUT = 12;
 /**
  * Merge model checkpoint TEXTS with any prior stored checkpoints so a line that
  * already existed keeps its original `at`, and only genuinely new lines get
@@ -87,7 +89,18 @@ export async function runSummarizerPass(opts = {}) {
         }
         let computed;
         try {
-            computed = await runSummarize(prompt, { todos: s.todos, plan: s.plan, phase: s.phase }, { baseUrl: config.baseUrl, model: config.model, ...(opts.signal ? { signal: opts.signal } : {}) });
+            computed = await runSummarize(prompt, {
+                todos: s.todos,
+                plan: s.plan,
+                phase: s.phase,
+                // The agent's own narration headlines, when the timeline pass has
+                // folded them (PHNX-3939) — the model's progress input was previously
+                // only the checklist, which many sessions never write. Optional by
+                // construction: a row with no timeline passes nothing extra.
+                ...(s.timeline?.steps.length
+                    ? { steps: s.timeline.steps.slice(-SUMMARIZER_STEP_INPUT).map((step) => step.text) }
+                    : {}),
+            }, { baseUrl: config.baseUrl, model: config.model, ...(opts.signal ? { signal: opts.signal } : {}) });
         }
         catch {
             computed = undefined;