@phnx-labs/agents-cli 1.20.74 → 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,
@@ -378,8 +460,12 @@ export function inferActivity(events, ctx = {}) {
         // A prose question takes a free-text reply (no select-list), so no options/keys.
         // Unlike the structural plan/ask signals above, the prose heuristic DECAYS: a
         // question nobody answered within PROSE_QUESTION_FRESH_MS is a session that
-        // ended, not one that needs you (RUSH-1522). Unknown mtime keeps the question.
-        const questionFresh = ctx.mtimeMs == null || Date.now() - ctx.mtimeMs < PROSE_QUESTION_FRESH_MS;
+        // ended, not one that needs you (RUSH-1522). A prose "?" is only "waiting on
+        // you" while the file is DEMONSTRABLY fresh — with no mtime signal at all we
+        // cannot assert freshness, so the heuristic must not fire (an unknown-age
+        // prose question is a session that ended, closing RUSH-1522's null-mtime hole
+        // where a null mtime kept the question forever).
+        const questionFresh = ctx.mtimeMs != null && Date.now() - ctx.mtimeMs < PROSE_QUESTION_FRESH_MS;
         if (questionFresh && looksLikeQuestion(last.content ?? '')) {
             const text = oneLine(last.content ?? '');
             return { ...base, activity: 'waiting_input', awaitingReason: 'question', question: { text, reason: 'question' } };

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/shims.d.ts

@@ -77,7 +77,7 @@ export interface ConflictInfo {
  *         top-level entry add/remove — deep edits to plugin contents won't
  *         trigger auto-resync, run `agents sync` for that.
  */
-export declare const SHIM_SCHEMA_VERSION = 26;
+export declare const SHIM_SCHEMA_VERSION = 27;
 /**
  * Generate the full bash shim script for the given agent. The returned string
  * is written to ~/.agents/shims/{cliCommand} and made executable.

package/dist/lib/shims.js

@@ -222,7 +222,7 @@ async function promptConflictStrategy(conflictInfos) {
 //        The old dispatcher checked only the global dir, so a pinned grok that
 //        installed into the versioned home fell through to the "not installed"
 //        error.
-export const SHIM_SCHEMA_VERSION = 26;
+export const SHIM_SCHEMA_VERSION = 27;
 /** Internal marker string used to embed the schema version in shim scripts. */
 const SHIM_VERSION_MARKER = 'agents-shim-version:';
 function shellQuote(value) {
@@ -278,13 +278,20 @@ export COPILOT_HOME="$VERSION_DIR/home/${configDirName}"
 # This gives agents-cli full versioned isolation + resource sync for grok.
 export GROK_HOME="$VERSION_DIR/home/.grok"
 `
-                    : agent === 'kimi'
+                    : agent === 'opencode'
                         ? `
+# OpenCode reads plugins, agents, commands, and other config-directory
+# resources from OPENCODE_CONFIG_DIR. Point it at the versioned global config
+# tree where agents-cli syncs OpenCode resources.
+export OPENCODE_CONFIG_DIR="$VERSION_DIR/home/.config/opencode"
+`
+                        : agent === 'kimi'
+                            ? `
 # Kimi Code CLI honors KIMI_CODE_HOME to relocate ~/.kimi-code (config.toml,
 # mcp.json, sessions, skills, hooks). Point it at the versioned home.
 export KIMI_CODE_HOME="$VERSION_DIR/home/${configDirName}"
 `
-                        : '';
+                            : '';
     const launchArgs = agent === 'codex' ? ' -c check_for_update_on_startup=false' : '';
     return `#!/bin/bash
 # Auto-generated by agents-cli - do not edit
@@ -867,7 +874,7 @@ function assertSafeVersion(version) {
  * KEEP IN SYNC with the `managedEnv` switch in `generateVersionedAliasScript`.
  * The colocated test `shims.isolation-capability.test.ts` enforces this.
  */
-export const CONFIG_ENV_ISOLATED_AGENTS = ['claude', 'codex', 'copilot', 'grok', 'kimi'];
+export const CONFIG_ENV_ISOLATED_AGENTS = ['claude', 'codex', 'copilot', 'grok', 'kimi', 'opencode'];
 /**
  * Whether an agent supports a clean `--isolated` install — i.e. its config
  * location can be redirected by an env var so the isolated copy stays fully
@@ -912,13 +919,20 @@ export COPILOT_HOME="$HOME/.agents/.history/versions/${agent}/${version}/home/${
 # aliases at the versioned home for isolation parity with the main shim.
 export GROK_HOME="$HOME/.agents/.history/versions/${agent}/${version}/home/${configDirName}"
 `
-                    : agent === 'kimi'
+                    : agent === 'opencode'
                         ? `
+# OpenCode reads plugins, agents, commands, and other config-directory
+# resources from OPENCODE_CONFIG_DIR. Point direct aliases at the versioned
+# global config tree where agents-cli syncs OpenCode resources.
+export OPENCODE_CONFIG_DIR="$HOME/.agents/.history/versions/${agent}/${version}/home/.config/opencode"
+`
+                        : agent === 'kimi'
+                            ? `
 # Kimi Code CLI honors KIMI_CODE_HOME to relocate ~/.kimi-code (config.toml,
 # mcp.json, sessions, skills, hooks). Point direct aliases at the versioned home.
 export KIMI_CODE_HOME="$HOME/.agents/.history/versions/${agent}/${version}/home/${configDirName}"
 `
-                        : '';
+                            : '';
     const launchArgs = agent === 'codex' ? ' -c check_for_update_on_startup=false' : '';
     // Resolve the binary the same way the main shim does (see generateShimScript).
     // Grok and Droid do NOT ship into node_modules/.bin — Grok downloads a native

package/dist/lib/sqlite.d.ts

@@ -3,8 +3,9 @@
  *
  * Picks `bun:sqlite` under Bun and `node:sqlite` under Node (>=22.5). Avoids
  * the native `better-sqlite3` addon entirely so there is no prebuild compile
- * and no Node/Bun ABI mismatch when the same source runs in tests (Bun) and
- * production (Node).
+ * and no Node/Bun ABI mismatch. Both runtimes are production: `dist/index.js`
+ * runs under Node, while the signed standalone `dist/bin/agents` (what the
+ * shims exec) embeds Bun.
  *
  * Exposes the small better-sqlite3-shaped surface area the rest of the
  * codebase already uses: `prepare/exec/pragma/transaction/close` on the DB,

package/dist/lib/sqlite.js

@@ -3,8 +3,9 @@
  *
  * Picks `bun:sqlite` under Bun and `node:sqlite` under Node (>=22.5). Avoids
  * the native `better-sqlite3` addon entirely so there is no prebuild compile
- * and no Node/Bun ABI mismatch when the same source runs in tests (Bun) and
- * production (Node).
+ * and no Node/Bun ABI mismatch. Both runtimes are production: `dist/index.js`
+ * runs under Node, while the signed standalone `dist/bin/agents` (what the
+ * shims exec) embeds Bun.
  *
  * Exposes the small better-sqlite3-shaped surface area the rest of the
  * codebase already uses: `prepare/exec/pragma/transaction/close` on the DB,
@@ -21,9 +22,31 @@ const sqliteMod = isBun
 // bun:sqlite exports `Database`; node:sqlite exports `DatabaseSync`.
 const NativeDatabase = sqliteMod.Database
     ?? sqliteMod.DatabaseSync;
+/**
+ * bun:sqlite binds a named-parameter object ONLY when its keys carry the SQL
+ * sigil (`{ '@id': … }` for `VALUES (@id)`); bare keys (`{ id: … }`) match
+ * nothing and every parameter stays NULL, so the first NOT NULL column raises a
+ * constraint error and the write is lost. node:sqlite accepts the bare keys.
+ * `strict: true` makes bun accept them too, so the bare-key call shape this
+ * codebase uses works on both runtimes. node:sqlite has no such option and
+ * rejects a second argument that isn't an object, so the argument list is built
+ * per runtime.
+ *
+ * The two runtimes are still not interchangeable at the edges, and only bun's
+ * half is exercised by the shipped binary rather than by vitest — so keep binds
+ * inside the intersection:
+ *   - omit a named key: bun throws `Missing parameter "x"`, node binds NULL.
+ *   - pass an extra named key: bun accepts it, node throws `Unknown named
+ *     parameter`.
+ *   - use sigil keys (`{'@id': …}`): node accepts them, strict bun rejects them.
+ *   - a single non-plain object positional arg (e.g. `run(new Date())`) reaches
+ *     the named path via bindArgs below and throws under strict bun.
+ */
+const NATIVE_ARGS = isBun ? [{ strict: true }] : [];
 function bindArgs(params) {
     // Both bindings accept positional `(a, b, c)` and named `({ a, b, c })`
-    // forms. Pass an object through unchanged so callers using named binds work.
+    // forms — bun only under `strict: true` (see NATIVE_ARGS). Pass an object
+    // through unchanged so callers using named binds work.
     if (params.length === 1 &&
         params[0] !== null &&
         typeof params[0] === 'object' &&
@@ -51,7 +74,7 @@ class StatementImpl {
 class Database {
     inner;
     constructor(filename) {
-        this.inner = new NativeDatabase(filename);
+        this.inner = new NativeDatabase(filename, ...NATIVE_ARGS);
     }
     prepare(sql) {
         return new StatementImpl(this.inner.prepare(sql));

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

@@ -1,7 +1,7 @@
 /**
  * Commands detector — mirrors versions.ts:343-357. Inspects the version home,
  * returns command names. Honors the commands-as-skills marker for skills-only
- * agents (grok, kimi, Codex >= 0.117.0, …); falls back to scanning
+ * agents (kimi, Codex >= 0.117.0, …); falls back to scanning
  * `{agentDir}/<commandsSubdir>/` for the native path.
  */
 import * as fs from 'fs';

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

@@ -1,12 +1,14 @@
 /**
- * Workflows detector — scans `{versionHome}/workflows/` for subdirectories
- * containing WORKFLOW.md. Mirrors versions.ts:551-558.
+ * 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 { lazyAgentMap } from '../writers/lazy-map.js';
 function buildWorkflowsDetector(agent) {
     return {
@@ -93,6 +95,15 @@ function buildWorkflowsDetector(agent) {
                 })
                     .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 [];

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

@@ -4,10 +4,10 @@
  * Two physical formats, picked per-(agent, version) at write time:
  *
  *  - command-as-skill — fires when `shouldInstallCommandAsSkill(agent, version)`
- *    is true. Used for grok (no native commands, but skills/) and Codex
- *    >= 0.117.0 (commands capability ends, skills capability remains).
- *    Writes `{agentDir}/skills/<name>/SKILL.md` with the `agents_command`
- *    marker; the agent picks it up as a slash-command equivalent.
+ *    is true. Used for Codex >= 0.117.0 (commands capability ends, skills
+ *    capability remains) and agents with skills but no native command-file dir
+ *    such as kimi. Writes `{agentDir}/skills/<name>/SKILL.md` with the
+ *    `agents_command` marker; the agent picks it up as a slash-command equivalent.
  *
  *  - native command file — `{agentDir}/<commandsSubdir>/<name>.md` (or .toml
  *    when the agent's format is toml). Standard path for Claude, Codex
@@ -83,8 +83,8 @@ function buildCommandsWriter(agent) {
 // Built lazily on first access — see lazy-map.ts for the cycle rationale.
 //
 // Registration covers two cases:
-//   - native commands (claude, codex < 0.117.0, gemini, etc.) — `commands` cap
-//   - commands-as-skills (grok, codex >= 0.117.0)
+//   - native commands (claude, codex < 0.117.0, gemini, grok, etc.) — `commands` cap
+//   - commands-as-skills (kimi, codex >= 0.117.0)
 //
 // Agents that have skills but use a NATIVE non-file slash-command system
 // (openclaw → Gateway-based commands) are NOT registered. They declare
@@ -97,7 +97,7 @@ export const commandsWriters = lazyAgentMap(() => {
         if (cfg.capabilities.commands === false && (!cfg.skillsDir || cfg.skillsDir === ''))
             continue;
         // Skills-capable agent with no native command-file dir: convert commands to
-        // skills by default (grok, kimi, …). Opt out only agents with their own
+        // skills by default (kimi, …). Opt out only agents with their own
         // slash-command runtime (openclaw).
         if (cfg.capabilities.commands === false && (!cfg.commandsSubdir || cfg.commandsSubdir === '')) {
             if (cfg.nativeCommandRuntime)

package/dist/lib/staleness/writers/workflows.d.ts

@@ -1,6 +1,8 @@
 /**
- * Workflows writer — copies each workflow directory into
- * `<versionHome>/workflows/<name>/` via `syncWorkflowToVersion`.
+ * Workflows writer — copies each selected workflow into the agent-specific
+ * on-disk layout via `syncWorkflowToVersion` (Claude: WORKFLOW.md tree under
+ * `{versionHome}/workflows/`; Grok: native `.rhai` under
+ * `{versionHome}/.grok/workflows/`).
  */
 import type { AgentId } from '../../types.js';
 import type { ResourceWriter } from './types.js';

package/dist/lib/startup/command-registry.d.ts

@@ -57,6 +57,7 @@ export declare const loadApply: ModuleLoader;
 export declare const loadCheck: ModuleLoader;
 export declare const loadStatus: ModuleLoader;
 export declare const loadProfiles: ModuleLoader;
+export declare const loadHarness: ModuleLoader;
 export declare const loadSecrets: ModuleLoader;
 export declare const loadLogin: ModuleLoader;
 export declare const loadWallet: ModuleLoader;

package/dist/lib/startup/command-registry.js

@@ -35,6 +35,7 @@ export const loadApply = async () => (await import('../../commands/apply.js')).r
 export const loadCheck = async () => (await import('../../commands/check.js')).registerCheckCommand;
 export const loadStatus = async () => (await import('../../commands/status.js')).registerStatusCommand;
 export const loadProfiles = async () => (await import('../../commands/profiles.js')).registerProfilesCommands;
+export const loadHarness = async () => (await import('../../commands/harness.js')).registerHarnessCommands;
 export const loadSecrets = async () => (await import('../../commands/secrets.js')).registerSecretsCommands;
 export const loadLogin = async () => (await import('../../commands/login.js')).registerLoginCommands;
 export const loadWallet = async () => (await import('../../commands/wallet.js')).registerWalletCommands;
@@ -146,6 +147,8 @@ export const COMMAND_LOADERS = {
     status: [loadStatus],
     profile: [loadProfiles],
     profiles: [loadProfiles],
+    harness: [loadHarness],
+    harnesses: [loadHarness],
     secrets: [loadSecrets],
     login: [loadLogin],
     logout: [loadLogin],

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/). */
@@ -165,7 +169,7 @@ export declare function getDriveDir(): string;
 export declare function getTrashDir(): string;
 /** Path to local session indexer storage (~/.agents/.history/sessions/). */
 export declare function getSessionsDir(): string;
-/** Path to the session index database (~/.agents/.history/sessions.db). */
+/** Path to the session index database (~/.agents/.history/sessions/sessions.db). */
 export declare function getSessionsDbPath(): string;
 /** Path to teams config + registry (~/.agents/teams/). */
 export declare function getTeamsDir(): string;

package/dist/lib/state.js

@@ -27,7 +27,6 @@ import * as path from 'path';
 import * as os from 'os';
 import * as yaml from 'yaml';
 import { ensureLockTarget, atomicWriteFileSync, withFileLock } from './fs-atomic.js';
-import { SEEDED_REGISTRIES } from './types.js';
 import { machineId } from './machine-id.js';
 const HOME = process.env.HOME ?? os.homedir();
 /**
@@ -320,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);
@@ -376,7 +379,7 @@ export function getDriveDir() { return DRIVE_DIR; }
 export function getTrashDir() { return TRASH_DIR; }
 /** Path to local session indexer storage (~/.agents/.history/sessions/). */
 export function getSessionsDir() { return SESSIONS_DIR; }
-/** Path to the session index database (~/.agents/.history/sessions.db). */
+/** Path to the session index database (~/.agents/.history/sessions/sessions.db). */
 export function getSessionsDbPath() { return SESSIONS_DB_PATH; }
 /** Path to teams config + registry (~/.agents/teams/). */
 export function getTeamsDir() { return TEAMS_DIR; }
@@ -384,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/). */
@@ -680,29 +694,6 @@ function overlayMachineLocal(meta) {
     }
     return meta;
 }
-function applyRegistrySeeds(meta) {
-    const seeded = new Set(meta.seededPresets || []);
-    let changed = false;
-    for (const [type, presets] of Object.entries(SEEDED_REGISTRIES)) {
-        for (const [name, config] of Object.entries(presets)) {
-            const key = `${type}.${name}`;
-            if (seeded.has(key))
-                continue;
-            if (!meta.registries)
-                meta.registries = { mcp: {}, skill: {} };
-            if (!meta.registries[type])
-                meta.registries[type] = {};
-            if (!meta.registries[type][name]) {
-                meta.registries[type][name] = { ...config };
-            }
-            seeded.add(key);
-            changed = true;
-        }
-    }
-    if (changed)
-        meta.seededPresets = [...seeded];
-    return changed;
-}
 /**
  * One-shot migration: move agents.yaml from system repo to user repo.
  * Idempotent — no-ops if user file already exists or system file absent.
@@ -813,17 +804,10 @@ export function readMeta() {
             };
         }
         overlayMachineLocal(meta);
-        if (applyRegistrySeeds(meta)) {
-            writeMeta(meta);
-            return rememberMeta(meta);
-        }
         return rememberMeta(meta);
     }
     const meta = createDefaultMeta();
     overlayMachineLocal(meta);
-    if (applyRegistrySeeds(meta)) {
-        writeMeta(meta);
-    }
     return rememberMeta(meta);
 }
 /** Serialize and write agents.yaml to the user repo, invalidating the in-memory cache. */