@phnx-labs/agents-cli 1.20.74 → 1.20.76

package/dist/lib/session/parse.js

@@ -1014,44 +1014,144 @@ export function parseAntigravity(dbPath) {
  * Messages have role (user/assistant) and metadata.
  * Parts contain the actual content: text, tool, reasoning, patch, step-start/finish.
  */
+/**
+ * Parse a Grok (xAI CLI) session into normalized events.
+ *
+ * A Grok session dir holds several files; the conversation transcript is
+ * `chat_history.jsonl`, one JSON object per line with a `type`:
+ *   - `system`       — the system prompt (skipped; not conversational)
+ *   - `user`         — `content` is an array of `{ type: 'text', text }` blocks
+ *   - `assistant`    — `content` is a string, plus a `tool_calls[]` array of
+ *                      `{ id, name, arguments }` (arguments is a JSON string)
+ *   - `reasoning`    — chain-of-thought; text (when present) lives in `summary`
+ *   - `tool_result`  — `{ tool_call_id, content }`, correlated back to the call
+ *
+ * The scanner records `summary.json` as the session's filePath (see
+ * `readGrokMeta` in discover.ts), so resolve `chat_history.jsonl` from the same
+ * dir; also accept being handed the transcript file directly. Per-line
+ * timestamps aren't stored, so every event carries the session's `created_at`
+ * (from summary.json), falling back to the transcript's mtime.
+ */
 export function parseGrok(filePath) {
-    // Grok sessions are rich (summary.json + events.jsonl + chat_history.jsonl + updates.jsonl)
-    // This is a minimal stub for now so grok appears in `agents sessions`.
-    // Full parser (with subagents, tool calls, etc.) can be expanded later.
+    const sessionDir = path.dirname(filePath);
+    const historyPath = filePath.endsWith('chat_history.jsonl')
+        ? filePath
+        : path.join(sessionDir, 'chat_history.jsonl');
+    if (!fs.existsSync(historyPath))
+        return [];
+    let timestamp;
     try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        // If it's a summary.json, create a basic event
-        if (filePath.endsWith('summary.json')) {
-            const summary = JSON.parse(content);
-            return [{
-                    timestamp: summary.created_at || new Date().toISOString(),
-                    type: 'session_start',
-                    content: summary.session_summary || 'Grok session',
-                    agent: 'grok',
-                    metadata: { sessionId: summary.id, cwd: summary.cwd },
-                }];
+        const summaryPath = filePath.endsWith('summary.json')
+            ? filePath
+            : path.join(sessionDir, 'summary.json');
+        if (fs.existsSync(summaryPath)) {
+            const summary = JSON.parse(fs.readFileSync(summaryPath, 'utf-8'));
+            if (typeof summary?.created_at === 'string')
+                timestamp = summary.created_at;
         }
-        // For JSONL files (events, chat_history, updates), return basic parsed lines
-        if (filePath.endsWith('.jsonl')) {
-            const lines = content.trim().split('\n').filter(Boolean);
-            return lines.slice(0, 50).map((line, i) => {
-                try {
-                    const obj = JSON.parse(line);
-                    return {
-                        timestamp: obj.timestamp || obj.ts || new Date().toISOString(),
-                        type: obj.type || obj.method || 'grok_event',
-                        content: typeof obj.content === 'string' ? obj.content : JSON.stringify(obj).slice(0, 200),
-                        agent: 'grok',
-                    };
+    }
+    catch { /* fall back to mtime below */ }
+    if (!timestamp) {
+        let mtime = null;
+        try {
+            mtime = fs.statSync(historyPath).mtime;
+        }
+        catch {
+            mtime = null;
+        }
+        timestamp = (mtime ?? new Date()).toISOString();
+    }
+    const content = safeReadSessionFile(historyPath);
+    const lines = content.split('\n').filter(l => l.trim());
+    const events = [];
+    const toolCallMap = new Map();
+    // Grok text is either a plain string (assistant) or an array of typed blocks
+    // (user: `{ type: 'text', text }`; reasoning summary: `{ text | summary_text }`).
+    const extractText = (raw) => {
+        if (typeof raw === 'string')
+            return raw.trim();
+        if (Array.isArray(raw)) {
+            return raw
+                .map((part) => typeof part?.text === 'string'
+                ? part.text
+                : typeof part?.summary_text === 'string'
+                    ? part.summary_text
+                    : '')
+                .join('')
+                .trim();
+        }
+        return '';
+    };
+    for (const line of lines) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const type = msg?.type;
+        if (type === 'user') {
+            const text = extractText(msg.content);
+            if (text)
+                events.push({ type: 'message', agent: 'grok', timestamp, role: 'user', content: text });
+        }
+        else if (type === 'assistant') {
+            const text = extractText(msg.content);
+            if (text)
+                events.push({ type: 'message', agent: 'grok', timestamp, role: 'assistant', content: text });
+            const calls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+            for (const call of calls) {
+                const toolName = typeof call?.name === 'string' ? call.name : 'unknown';
+                let args = {};
+                if (call?.arguments && typeof call.arguments === 'object') {
+                    args = call.arguments;
                 }
-                catch {
-                    return { timestamp: new Date().toISOString(), type: 'raw', content: line.slice(0, 200), agent: 'grok' };
+                else if (typeof call?.arguments === 'string') {
+                    try {
+                        args = JSON.parse(call.arguments);
+                    }
+                    catch {
+                        args = { _raw: call.arguments };
+                    }
                 }
+                if (typeof call?.id === 'string')
+                    toolCallMap.set(call.id, toolName);
+                events.push({
+                    type: 'tool_use',
+                    agent: 'grok',
+                    timestamp,
+                    tool: toolName,
+                    args,
+                    path: args.path || args.file_path || undefined,
+                    command: typeof args.command === 'string' ? args.command : undefined,
+                });
+            }
+        }
+        else if (type === 'reasoning') {
+            const text = extractText(msg.summary);
+            if (text)
+                events.push({ type: 'thinking', agent: 'grok', timestamp, content: text });
+        }
+        else if (type === 'tool_result') {
+            const callId = typeof msg.tool_call_id === 'string' ? msg.tool_call_id : undefined;
+            const toolName = (callId && toolCallMap.get(callId)) || 'unknown';
+            const output = typeof msg.content === 'string' ? msg.content : extractText(msg.content);
+            const isError = typeof output === 'string' && output.startsWith('Error:');
+            events.push({
+                type: isError ? 'error' : 'tool_result',
+                agent: 'grok',
+                timestamp,
+                tool: toolName,
+                success: !isError,
+                output: output.length > 500 ? output.slice(0, 497) + '...' : output,
             });
+            if (callId)
+                toolCallMap.delete(callId);
         }
+        // `system` lines are the system prompt — intentionally skipped.
     }
-    catch { }
-    return [];
+    return events;
 }
 export function parseOpenCode(filePath) {
     const [dbPath, sessionId] = filePath.split('#');

package/dist/lib/session/pid-registry.d.ts

@@ -4,6 +4,23 @@ export interface PidSessionEntry {
     /** The launch session id. Present for agents launched with a known id (Claude). */
     sessionId?: string;
     cwd?: string;
+    /**
+     * The launch id minted by `ag run` and exported to the child as
+     * `AGENT_LAUNCH_ID`. The agent's SessionStart hook records the SAME id in its
+     * own state file (`terminals/sessions/<pid>.json`, `launch_id`), so the two
+     * records reconcile by this key even when the hook runs under a DIFFERENT pid
+     * (tmux pane leaf, cmd.exe wrapper) — see resolveHookSessionId in
+     * session/hook-sessions.ts. This
+     * is how a non-Claude launch (whose id we don't know at spawn) gets an exact
+     * session id at listing time instead of the newest-jsonl heuristic.
+     */
+    launchId?: string;
+    /**
+     * `AGENT_TERMINAL_ID` when the launch inherited one (a Factory VS Code tab).
+     * A secondary join key to the hook's `terminal_id`, for agents the extension
+     * spawned. Best-effort — undefined outside the extension.
+     */
+    terminalId?: string;
     /**
      * `$TMUX_PANE` at launch — stored for diagnostics and possible future
      * disambiguation. NOT currently consulted on read: the listing path keys
@@ -18,5 +35,20 @@ export declare function extractSessionIdArg(args: string[]): string | undefined;
 export declare function writePidSessionEntry(entry: PidSessionEntry): void;
 /** Look up a live pid's recorded session. Returns undefined if absent/corrupt. */
 export declare function readPidSessionEntry(pid: number): PidSessionEntry | undefined;
-/** Remove entries whose pid is no longer alive. Best-effort housekeeping. */
-export declare function prunePidSessionRegistry(isAlive: (pid: number) => boolean): void;
+/**
+ * Every recorded launch, one entry per live-or-dead pid. Used to index launches
+ * by their `tmuxPane` so the authoritative tmux source can attribute a pane it did
+ * NOT wrap (an agent bare-spawned into an existing pane) to its exact launch —
+ * the caller filters to live pids. Best-effort: unreadable/corrupt files are
+ * skipped, a missing dir yields `[]`.
+ */
+export declare function listPidSessionEntries(): PidSessionEntry[];
+/**
+ * Remove entries whose pid is no longer alive. Best-effort housekeeping.
+ *
+ * `isAlive` receives the entry's recorded `startedAtMs` so it can reject a pid
+ * that a newer process recycled (a "zombie" registry entry), not just one that
+ * no longer exists. An unreadable/corrupt entry falls back to the pid-only
+ * check.
+ */
+export declare function prunePidSessionRegistry(isAlive: (pid: number, startedAtMs?: number) => boolean): void;

package/dist/lib/session/pid-registry.js

@@ -81,7 +81,43 @@ export function readPidSessionEntry(pid) {
     }
     return undefined;
 }
-/** Remove entries whose pid is no longer alive. Best-effort housekeeping. */
+/**
+ * Every recorded launch, one entry per live-or-dead pid. Used to index launches
+ * by their `tmuxPane` so the authoritative tmux source can attribute a pane it did
+ * NOT wrap (an agent bare-spawned into an existing pane) to its exact launch —
+ * the caller filters to live pids. Best-effort: unreadable/corrupt files are
+ * skipped, a missing dir yields `[]`.
+ */
+export function listPidSessionEntries() {
+    let files;
+    try {
+        files = fs.readdirSync(pidRegistryDir()).filter(f => f.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const f of files) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(pidRegistryDir(), f), 'utf8'));
+            if (parsed && typeof parsed === 'object' && typeof parsed.pid === 'number') {
+                out.push(parsed);
+            }
+        }
+        catch {
+            /* raced with a writer/pruner, or corrupt — skip */
+        }
+    }
+    return out;
+}
+/**
+ * Remove entries whose pid is no longer alive. Best-effort housekeeping.
+ *
+ * `isAlive` receives the entry's recorded `startedAtMs` so it can reject a pid
+ * that a newer process recycled (a "zombie" registry entry), not just one that
+ * no longer exists. An unreadable/corrupt entry falls back to the pid-only
+ * check.
+ */
 export function prunePidSessionRegistry(isAlive) {
     let files;
     try {
@@ -92,7 +128,18 @@ export function prunePidSessionRegistry(isAlive) {
     }
     for (const f of files) {
         const pid = Number(f.slice(0, -'.json'.length));
-        if (!Number.isInteger(pid) || isAlive(pid))
+        if (!Number.isInteger(pid))
+            continue;
+        let startedAtMs;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(pidRegistryDir(), f), 'utf8'));
+            if (typeof parsed?.startedAtMs === 'number')
+                startedAtMs = parsed.startedAtMs;
+        }
+        catch {
+            /* unreadable/corrupt — fall back to the pid-only liveness check */
+        }
+        if (isAlive(pid, startedAtMs))
             continue;
         try {
             fs.unlinkSync(path.join(pidRegistryDir(), f));

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

@@ -12,10 +12,15 @@ import type { SessionEvent, SessionMeta } from './types.js';
  */
 export declare function relativeToCwd(absPath: string, cwd?: string): string;
 /**
- * Wrap label in an OSC 8 hyperlink when the terminal supports it.
- * Degrades to plain label otherwise.
+ * Wrap a filesystem path label in an OSC 8 `file://` hyperlink when the terminal
+ * supports it. Degrades to the plain label otherwise.
  */
 export declare function linkPath(absPath: string, label: string): string;
+/**
+ * Wrap a label in an OSC 8 hyperlink to an arbitrary URL (a PR on GitHub, a Linear
+ * issue, …) when the terminal supports it. Degrades to the plain label otherwise.
+ */
+export declare function linkUrl(url: string, label: string): string;
 /**
  * Unwrap wrapper prefixes to find the actual executable.
  */

package/dist/lib/session/render.js

@@ -28,19 +28,31 @@ export function relativeToCwd(absPath, cwd) {
     }
     return absPath;
 }
-/**
- * Wrap label in an OSC 8 hyperlink when the terminal supports it.
- * Degrades to plain label otherwise.
- */
-export function linkPath(absPath, label) {
-    if (process.stdout.isTTY &&
+/** Best-effort feature-detect for OSC 8 hyperlink support in the current TTY. */
+function supportsHyperlinks() {
+    return Boolean(process.stdout.isTTY &&
         (process.env.TERM_PROGRAM ||
             process.env.WT_SESSION ||
             process.env.KITTY_WINDOW_ID ||
-            process.env.WEZTERM_PANE)) {
-        return `\x1b]8;;file://${absPath}\x1b\\${label}\x1b]8;;\x1b\\`;
-    }
-    return label;
+            process.env.WEZTERM_PANE));
+}
+/** Wrap `label` in an OSC 8 hyperlink to `target`. Callers gate on {@link supportsHyperlinks}. */
+function osc8(target, label) {
+    return `\x1b]8;;${target}\x1b\\${label}\x1b]8;;\x1b\\`;
+}
+/**
+ * Wrap a filesystem path label in an OSC 8 `file://` hyperlink when the terminal
+ * supports it. Degrades to the plain label otherwise.
+ */
+export function linkPath(absPath, label) {
+    return supportsHyperlinks() ? osc8(`file://${absPath}`, label) : label;
+}
+/**
+ * Wrap a label in an OSC 8 hyperlink to an arbitrary URL (a PR on GitHub, a Linear
+ * issue, …) when the terminal supports it. Degrades to the plain label otherwise.
+ */
+export function linkUrl(url, label) {
+    return supportsHyperlinks() ? osc8(url, label) : label;
 }
 // ── Command grouping ──────────────────────────────────────────────────────────
 /**

package/dist/lib/session/short-id.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Canonical derivation of a session's 8-char `shortId`.
+ *
+ * Every session parser used to inline `id.slice(0, 8)` — some with a
+ * `.replace(prefix, '')` strip first (`session_`, `api-`, `ses_`). That strip is
+ * the bug: an id that is *only* its prefix (a bare `session_` directory, an id of
+ * exactly `api-`) strips to `''`, and `''.slice(0, 8)` is still `''`. An empty
+ * shortId then passes the `short_id TEXT NOT NULL` constraint (empty string is not
+ * NULL) yet matches nothing in the `short_id LIKE ?` picker lookups — a silently
+ * corrupt index row.
+ *
+ * This helper is the single source of truth: it strips the optional prefix, takes
+ * the first 8 chars, and — the whole point — guarantees a NON-EMPTY result by
+ * falling back to the unstripped id when the strip empties it, so a row always
+ * stays addressable by its shortId.
+ */
+export declare function deriveShortId(id: string, stripPrefix?: RegExp): string;

package/dist/lib/session/short-id.js

@@ -0,0 +1,20 @@
+/**
+ * Canonical derivation of a session's 8-char `shortId`.
+ *
+ * Every session parser used to inline `id.slice(0, 8)` — some with a
+ * `.replace(prefix, '')` strip first (`session_`, `api-`, `ses_`). That strip is
+ * the bug: an id that is *only* its prefix (a bare `session_` directory, an id of
+ * exactly `api-`) strips to `''`, and `''.slice(0, 8)` is still `''`. An empty
+ * shortId then passes the `short_id TEXT NOT NULL` constraint (empty string is not
+ * NULL) yet matches nothing in the `short_id LIKE ?` picker lookups — a silently
+ * corrupt index row.
+ *
+ * This helper is the single source of truth: it strips the optional prefix, takes
+ * the first 8 chars, and — the whole point — guarantees a NON-EMPTY result by
+ * falling back to the unstripped id when the strip empties it, so a row always
+ * stays addressable by its shortId.
+ */
+export function deriveShortId(id, stripPrefix) {
+    const stripped = stripPrefix ? id.replace(stripPrefix, '') : id;
+    return stripped.slice(0, 8) || id.slice(0, 8) || id;
+}

package/dist/lib/session/state.js

@@ -378,8 +378,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/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;