@phnx-labs/agents-cli 1.20.73 → 1.20.76

package/dist/lib/watchdog/watchdog.js

@@ -64,23 +64,32 @@ export function classifyTerminal(input) {
     }
     return { kind: 'stalled', stalledForMs: age };
 }
-export const WATCHDOG_SYSTEM_PROMPT = `You are a watchdog monitoring AI coding agents that run in terminals.
-For each stalled terminal below, decide: NUDGE (send a short message to unstick it) or SKIP.
+export const WATCHDOG_SYSTEM_PROMPT = `You are the watchdog for AI coding agents running in terminals. These agents are
+expected to DRIVE TO COMPLETION end-to-end. They too often stop to ask a needless
+question or pause with the task unfinished. For each stalled terminal below, decide
+NUDGE (send a message that unsticks it and pushes it to finish) or SKIP (it genuinely
+needs the human).
 
-Nudge when:
-- The last assistant turn announced an action ("I'll write X", "let me run Y")
-  but no matching tool call followed.
-- The agent appears stuck mid-task with no recent progress and the task is incomplete.
+NUDGE when the agent could have continued on its own:
+- It asked permission for an obvious or already-authorized next step
+  ("should I proceed?", "want me to continue?", "shall I run the tests?").
+- It asked a question it could answer itself from the available context or a
+  reasonable default.
+- It announced an action ("I'll run X", "let me write Y") but no tool call followed.
+- It paused with the task incomplete and no real blocker.
+The nudge text MUST: restate the goal, tell it to use best judgment and finish
+end-to-end WITHOUT asking again, and give ONE concrete hint — the specific next
+step, a tool it forgot, or the sensible default to take. Imperative, 1-2 sentences,
+no emojis, under 200 characters.
 
-Skip when:
-- The agent asked the user a direct question (waiting on human input).
-- The task looks complete.
+SKIP when the agent genuinely needs the human:
+- Credentials, auth, login, 2FA, or biometric.
+- An irreversible or outward-facing action that needs sign-off (force-push, delete
+  prod data, publish/release, spend money, send an external message).
+- A real product or intent decision with genuine ambiguity (not a trivial default).
+- The task is actually complete.
 - You cannot tell what the agent is doing.
 
-Nudge text must be:
-- One sentence, imperative ("Show me the file.", "Run the tests.").
-- No emojis. No apologies. Under 120 characters.
-
 Respond with ONLY a JSON array (no prose, no code fence):
 [{"terminalId":"<id>","action":"nudge"|"skip","text":"<message or empty>","reason":"<brief>"}]`;
 // User-editable playbook appended below the built-in prompt. The user maintains
@@ -137,15 +146,21 @@ export function parseWatchdogResponse(stdout) {
     return decisions;
 }
 export function isLikelyTrulyBlocked(candidate) {
-    if (candidate.stalledForMs >= FORCE_REVIEW_STALL_MS)
-        return true;
+    // With no tail to reason over, only a very long stall counts as blocked.
     if (candidate.tailLines.length === 0)
-        return false;
+        return candidate.stalledForMs >= FORCE_REVIEW_STALL_MS;
     const lowerTail = candidate.tailLines.join('\n').toLowerCase();
+    // Waiting-on-user and completion hints are checked BEFORE the 15m force-review
+    // short-circuit — a long-idle OPEN QUESTION must defer (not be blindly
+    // force-nudged) and a finished task is done. The old order tested stall age
+    // first, so a 15m-60m idle session whose tail said "waiting on user" / "done"
+    // was force-nudged anyway. Precedence fixed here (watchdog-brain-v2).
     if (WAITING_HINTS.some((hint) => lowerTail.includes(hint)))
         return false;
     if (COMPLETION_HINTS.some((hint) => lowerTail.includes(hint)))
         return false;
+    if (candidate.stalledForMs >= FORCE_REVIEW_STALL_MS)
+        return true;
     if (BLOCKED_HINTS.some((hint) => lowerTail.includes(hint)))
         return true;
     let sawToolAfter = false;

package/dist/lib/workflows.d.ts

@@ -296,6 +296,22 @@ export declare function transformWorkflowForKimi(workflowPath: string, name: str
 export declare function transformWorkflowForAntigravity(workflowPath: string, name: string): string;
 /** Convert a canonical agents-cli workflow bundle into an OpenClaw Lobster file. */
 export declare function transformWorkflowForOpenClaw(workflowPath: string, name: string): string;
+/** Marker comment prefix written into agents-cli-managed Grok `.rhai` files. */
+export declare const GROK_WORKFLOW_MARKER = "agents_workflow";
+/**
+ * Convert a canonical agents-cli workflow bundle into a Grok native Rhai
+ * workflow script. Grok discovers saved workflows as
+ * `~/.grok/workflows/<name>.rhai` (and project `.grok/workflows/`) and exposes
+ * each as a `/<name>` slash command (enabled by default since v0.2.111).
+ *
+ * The projection is a single-agent orchestrator that feeds the WORKFLOW.md
+ * body as the agent prompt plus the caller's `args.prompt` (or string args).
+ * Multi-phase fan-out is left to hand-authored Rhai — agents-cli's job is to
+ * land the orchestrator instructions in the native path.
+ */
+export declare function transformWorkflowForGrok(workflowPath: string, name: string): string;
+/** Read the agents_workflow marker from a Grok `.rhai` file, if present. */
+export declare function grokWorkflowMarker(filePath: string): string | null;
 /**
  * Resolve an `agents run <workflow>` reference.
  *

package/dist/lib/workflows.js

@@ -9,7 +9,7 @@ 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 { capableAgents, supports } from './capabilities.js';
 import { getProjectAgentsDir, getSystemWorkflowsDir, getUserWorkflowsDir, getTrashWorkflowsDir, getEnabledExtraRepos, } from './state.js';
 import { listInstalledVersions, getVersionHomePath } from './versions.js';
 /**
@@ -444,6 +444,67 @@ export function transformWorkflowForOpenClaw(workflowPath, name) {
         ],
     });
 }
+/** Marker comment prefix written into agents-cli-managed Grok `.rhai` files. */
+export const GROK_WORKFLOW_MARKER = 'agents_workflow';
+/** Escape a string for embedding inside a Rhai double-quoted literal. */
+function escapeRhaiString(s) {
+    return s
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\r\n/g, '\\n')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\n');
+}
+/**
+ * Convert a canonical agents-cli workflow bundle into a Grok native Rhai
+ * workflow script. Grok discovers saved workflows as
+ * `~/.grok/workflows/<name>.rhai` (and project `.grok/workflows/`) and exposes
+ * each as a `/<name>` slash command (enabled by default since v0.2.111).
+ *
+ * The projection is a single-agent orchestrator that feeds the WORKFLOW.md
+ * body as the agent prompt plus the caller's `args.prompt` (or string args).
+ * Multi-phase fan-out is left to hand-authored Rhai — agents-cli's job is to
+ * land the orchestrator instructions in the native path.
+ */
+export function transformWorkflowForGrok(workflowPath, name) {
+    const fm = parseWorkflowFrontmatter(workflowPath);
+    if (!fm)
+        throw new Error(`Invalid WORKFLOW.md in ${workflowPath}`);
+    const body = getWorkflowBody(workflowPath);
+    const description = (fm.description || name).trim();
+    const instructions = (body || description).trim();
+    return [
+        `// ${GROK_WORKFLOW_MARKER}: ${name}`,
+        `// Managed by agents-cli — re-sync from ~/.agents/workflows/${name}/; do not edit by hand.`,
+        `let meta = #{`,
+        `    name: "${escapeRhaiString(name)}",`,
+        `    description: "${escapeRhaiString(description)}",`,
+        `    phases: [ #{ title: "Run", detail: "orchestrator" } ],`,
+        `};`,
+        ``,
+        `let user_prompt = if args == () { () } else if type_of(args) == "string" { args } else { args.prompt };`,
+        `if user_prompt == () { pause("verification", "Pass a prompt as args.prompt or a string arg."); }`,
+        ``,
+        `phase("Run");`,
+        `let instructions = "${escapeRhaiString(instructions)}";`,
+        `let prompt = instructions + "\\n\\n---\\n\\nUser request:\\n" + user_prompt;`,
+        `let r = agent(prompt, #{ label: "orchestrator", capability_mode: "all" });`,
+        `if r != () && r.success { complete(r.output); }`,
+        `complete(#{ summary: "workflow failed", error: if r == () { "no result" } else { "agent failed" } });`,
+        ``,
+    ].join('\n');
+}
+/** Read the agents_workflow marker from a Grok `.rhai` file, if present. */
+export function grokWorkflowMarker(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const match = content.match(new RegExp(`^//\\s*${GROK_WORKFLOW_MARKER}:\\s*(\\S+)`, 'm'));
+        return match?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 function expandWorkflowPath(ref) {
     if (ref === '~')
         return process.env.HOME ?? ref;
@@ -622,6 +683,8 @@ function workflowTargetRoot(agent, versionHome) {
         return antigravityWorkflowsDir();
     if (agent === 'openclaw')
         return path.join(versionHome, '.openclaw', 'workflows');
+    if (agent === 'grok')
+        return path.join(versionHome, '.grok', 'workflows');
     return path.join(versionHome, 'workflows');
 }
 /** List workflow names synced into a specific agent version home. */
@@ -676,6 +739,20 @@ export function listWorkflowsForAgent(agent, versionHome) {
             return [];
         }
     }
+    if (agent === 'grok') {
+        const dir = workflowTargetRoot(agent, versionHome);
+        if (!fs.existsSync(dir))
+            return [];
+        try {
+            return fs.readdirSync(dir, { withFileTypes: true })
+                .filter(d => d.isFile() && d.name.endsWith('.rhai') && !d.name.startsWith('.'))
+                .map(d => d.name.slice(0, -'.rhai'.length))
+                .filter(base => grokWorkflowMarker(path.join(dir, `${base}.rhai`)) === base);
+        }
+        catch {
+            return [];
+        }
+    }
     const workflowsDir = workflowTargetRoot(agent, versionHome);
     if (!fs.existsSync(workflowsDir))
         return [];
@@ -823,6 +900,19 @@ export function syncWorkflowToVersion(workflowPath, name, agent, versionHome) {
             fs.writeFileSync(targetFile, transformWorkflowForOpenClaw(workflowPath, name), 'utf-8');
             return { success: true };
         }
+        if (agent === 'grok') {
+            const targetDir = workflowTargetRoot(agent, versionHome);
+            const targetFile = path.join(targetDir, `${name}.rhai`);
+            if (fs.existsSync(targetFile)) {
+                const marker = grokWorkflowMarker(targetFile);
+                if (marker !== name) {
+                    return { success: false, error: `Grok workflow '${name}' already exists and is not managed by agents-cli` };
+                }
+            }
+            fs.mkdirSync(targetDir, { recursive: true });
+            fs.writeFileSync(targetFile, transformWorkflowForGrok(workflowPath, name), 'utf-8');
+            return { success: true };
+        }
         const targetDir = path.join(workflowTargetRoot(agent, versionHome), name);
         fs.mkdirSync(workflowTargetRoot(agent, versionHome), { recursive: true });
         if (fs.existsSync(targetDir)) {
@@ -887,6 +977,22 @@ export function removeWorkflowFromVersion(agent, version, name) {
             return { success: false, error: err.message };
         }
     }
+    if (agent === 'grok') {
+        const targetFile = path.join(workflowTargetRoot(agent, versionHome), `${name}.rhai`);
+        if (!fs.existsSync(targetFile)) {
+            return { success: false, error: `Workflow '${name}' not synced to ${agent}@${version}` };
+        }
+        if (grokWorkflowMarker(targetFile) !== name) {
+            return { success: false, error: `Grok workflow '${name}' is not managed by agents-cli` };
+        }
+        try {
+            fs.rmSync(targetFile, { force: true });
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: err.message };
+        }
+    }
     const targetPath = path.join(workflowTargetRoot(agent, versionHome), name);
     if (!fs.existsSync(targetPath)) {
         return { success: false, error: `Workflow '${name}' not synced to ${agent}@${version}` };
@@ -958,6 +1064,9 @@ export function iterWorkflowsCapableVersions(filter) {
         for (const version of versions) {
             if (filter?.version && filter.version !== version)
                 continue;
+            // Honour version floors (e.g. grok workflows since 0.2.111).
+            if (!supports(agentId, 'workflows', version).ok)
+                continue;
             result.push({ agent: agentId, version });
         }
     }

package/package.json

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