claude-flow 3.58.0 → 3.59.0

package/v3/@claude-flow/cli/dist/src/commands/init.js

@@ -8,6 +8,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { spawnSync } from 'node:child_process';
 import { executeInit, executeUpgrade, executeUpgradeWithMissing, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
+import { executeGrokInit } from '../init/grok-generator.js';
 import { ENROLLMENT_SCREEN, recordEnrollmentOutcome, shouldOfferEnrollment, } from '../funnel/enrollment.js';
 import { commandExists } from '../services/harness-hosts.js';
 /**
@@ -361,6 +362,90 @@ async function maybeInstallSkillsSh(ctx) {
         // Skills.sh registration is a bonus, never a requirement — swallow everything.
     }
 }
+// Grok Build host initialization (ADR-402)
+async function initGrokAction(ctx, options) {
+    const { force, statusLine, dryRun } = options;
+    output.writeln();
+    output.writeln(output.bold(dryRun ? 'Grok Build init (dry run — nothing is written)' : 'Initializing RuFlo for Grok Build'));
+    output.writeln();
+    try {
+        const result = executeGrokInit({
+            targetDir: ctx.cwd,
+            force,
+            docs: true,
+            statusLine,
+            dryRun,
+        });
+        if (!result.success) {
+            output.printError('Grok initialization failed');
+            for (const err of result.errors) {
+                output.printError(err);
+            }
+            return { success: false, exitCode: 1, message: 'Grok init failed' };
+        }
+        output.printBox([
+            `.grok/config.toml — project MCP (ruflo) + permissions`,
+            `.grok/rules/ruflo-grok.md — host doctrine / tool map`,
+            `.grok/agents/ — ruflo-architect/coder/tester/reviewer`,
+            `.grok/skills/ — agent-teams-grok`,
+            `.grok/hooks/ — SubagentStop advances the team plan`,
+            `scripts/grok-team-bus.mjs (+ grok-team-store.mjs) — ADR-402 team bus CLI`,
+            `scripts/host-statusline.mjs — "what is loaded" row`,
+            `docs/grok/README.md — operator guide`,
+        ].join('\n'), 'Grok Build Integration (ADR-402)');
+        output.writeln();
+        const verb = dryRun ? 'Would write' : 'Wrote';
+        output.writeln(output.bold(`${verb} (${result.filesCreated.length}):`));
+        output.printList(result.filesCreated.map((f) => (path.relative(ctx.cwd, f).startsWith('..') ? f : path.relative(ctx.cwd, f))));
+        if (result.filesSkipped.length > 0) {
+            output.printInfo(`Skipped ${result.filesSkipped.length} existing file(s)${force ? '' : ' — use --force to overwrite'}`);
+        }
+        output.writeln();
+        const mcp = result.mcp;
+        output.printInfo(mcp.source === 'published'
+            ? `MCP server pinned to ruflo@${mcp.version} (the release that ships the team_* tools)`
+            : `MCP server points at this checkout: ${mcp.args[0]} — rebuild it before use, and re-run init from a published release before committing .grok/config.toml`);
+        const uc = result.userConfig;
+        if (uc.action === 'not-requested' || uc.action === 'snippet') {
+            output.writeln();
+            output.writeln(uc.action === 'snippet'
+                ? output.bold(`Did not change ${uc.path}: ${uc.reason}`)
+                : output.bold('Optional status row (Grok reads it only from your user config):'));
+            output.writeln(output.dim(`  Add this to ${uc.path}, or re-run with --grok-statusline to have init merge it`));
+            output.writeln(output.dim(`  (that also installs the script it runs under ~/.grok/ruflo/):`));
+            output.writeln(uc.snippet.trimEnd().split('\n').map((l) => `    ${l}`).join('\n'));
+        }
+        else if (uc.action === 'already-set') {
+            output.printInfo(uc.reason || `${uc.path} already has the Ruflo status row; refreshed the script it runs`);
+        }
+        output.writeln();
+        output.writeln(output.bold('Next steps:'));
+        output.printList([
+            'Trust this folder in Grok (/hooks-trust or grok --trust) so MCP, hooks, skills, and rules load together',
+            'Restart Grok so .grok/config.toml is applied',
+            'Read docs/grok/README.md — spawn contract checked on Grok Build 1.0.41',
+            'Verify: grok mcp list && grok mcp doctor ruflo',
+            'Optional: npx ruvnet-brain@latest then enable ruvnet-brain in .grok/config.toml',
+            'Teams: team_create / team_spawn MCP tools (or node scripts/grok-team-bus.mjs)',
+        ]);
+        output.writeln();
+        return {
+            success: true,
+            data: {
+                adapter: 'grok',
+                dryRun,
+                filesCreated: result.filesCreated,
+                filesSkipped: result.filesSkipped,
+                mcp: result.mcp,
+                userConfig: { action: uc.action, path: uc.path },
+            },
+        };
+    }
+    catch (e) {
+        output.printError(`Grok initialization failed: ${e.message}`);
+        return { success: false, exitCode: 1, message: e.message };
+    }
+}
 // Codex initialization action
 async function initCodexAction(ctx, options) {
     const { force, minimal, full, dualMode } = options;
@@ -848,6 +933,15 @@ const initAction = async (ctx) => {
     const full = ctx.flags.full;
     const codexMode = ctx.flags.codex;
     const dualMode = ctx.flags.dual;
+    const grokMode = ctx.flags.grok;
+    // Grok Build host (ADR-402) — separate surface under .grok/
+    if (grokMode) {
+        return initGrokAction(ctx, {
+            force,
+            statusLine: ctx.flags.grokStatusline === true || ctx.flags['grok-statusline'] === true,
+            dryRun: ctx.flags.dryRun === true || ctx.flags['dry-run'] === true,
+        });
+    }
     if (codexMode && !dualMode) {
         return initCodexAction(ctx, { codexMode, dualMode: false, force, minimal, full });
     }
@@ -1598,6 +1692,24 @@ export const initCommand = {
             type: 'boolean',
             default: false,
         },
+        {
+            name: 'grok',
+            description: 'Initialize for Grok Build host (creates .grok/, team bus scripts, ADR-402 surface)',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'grok-statusline',
+            description: 'With --grok: also merge the Ruflo status row into ~/.grok/config.toml (user file; off by default)',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'dry-run',
+            description: 'With --grok: list the files init would write, write nothing',
+            type: 'boolean',
+            default: false,
+        },
         {
             name: 'dual',
             description: 'Initialize for both Claude Code and OpenAI Codex',
@@ -1647,6 +1759,10 @@ export const initCommand = {
         { command: 'claude-flow init upgrade --verbose', description: 'Show detailed upgrade info' },
         { command: 'claude-flow init --codex', description: 'Initialize for OpenAI Codex (AGENTS.md)' },
         { command: 'claude-flow init --codex --full', description: 'Codex init with all canonical packaged skills' },
+        { command: 'claude-flow init --grok', description: 'Initialize for Grok Build (.grok/, team bus, ADR-402)' },
+        { command: 'claude-flow init --grok --force', description: 'Overwrite existing Grok host files' },
+        { command: 'claude-flow init --grok --dry-run', description: 'Show what init --grok would write' },
+        { command: 'claude-flow init --grok --grok-statusline', description: 'Also add the Ruflo status row to ~/.grok/config.toml' },
         { command: 'claude-flow init --dual', description: 'Initialize for both Claude Code and Codex' },
         { command: 'claude-flow init --no-codex-detect', description: 'Skip auto-configuring OpenAI Codex even if it is installed' },
         { command: 'claude-flow init --no-skills-sh', description: 'Skip the post-init skills.sh registration' },

package/v3/@claude-flow/cli/dist/src/commands/memory.js

@@ -814,11 +814,16 @@ const listCommand = {
         const namespace = ctx.flags.namespace;
         const limit = ctx.flags.limit;
         const includeEmbedding = ctx.flags.embeddings === true && ctx.flags.format === 'json';
+        // Mirrors memory_list's MCP tool handling: comma-separated flag →
+        // non-empty string array, require entries to carry every tag (AND).
+        const tags = ctx.flags.tags
+            ? ctx.flags.tags.split(',').map(t => t.trim()).filter((t) => t.length > 0)
+            : undefined;
         // Use sql.js directly for consistent data access
         try {
             const { listEntries, resolveDbPath: _rdbList } = await import('../memory/memory-initializer.js');
             const dbPathList = _rdbList(ctx.flags.path);
-            const listResult = await listEntries({ namespace, limit, offset: 0, dbPath: dbPathList, ...(includeEmbedding && { includeEmbedding: true }) });
+            const listResult = await listEntries({ namespace, limit, offset: 0, dbPath: dbPathList, tags, ...(includeEmbedding && { includeEmbedding: true }) });
             if (!listResult.success) {
                 output.printError(`Failed to list: ${listResult.error}`);
                 return { success: false, exitCode: 1 };

package/v3/@claude-flow/cli/dist/src/commands/status.js

@@ -484,11 +484,11 @@ const tasksCommand = {
                     { key: 'progress', header: 'Progress', width: 10 }
                 ],
                 data: result.tasks.map(t => ({
-                    id: t.id,
+                    id: t.taskId,
                     type: t.type,
                     status: formatHealth(t.status),
                     priority: t.priority,
-                    agent: t.agent || '-',
+                    agent: t.assignedTo?.length ? t.assignedTo.join(', ') : '-',
                     progress: `${t.progress}%`
                 }))
             });

package/v3/@claude-flow/cli/dist/src/index.d.ts

@@ -6,6 +6,9 @@
  */
 import './log-filters.js';
 export declare const VERSION: string;
+/** Commands that only observe the running system and must not start or write anything. */
+export declare const OBSERVE_ONLY_COMMANDS: ReadonlySet<string>;
+export declare function isObserveOnlyCommand(name: string | undefined): boolean;
 export interface CLIOptions {
     name?: string;
     description?: string;

package/v3/@claude-flow/cli/dist/src/index.js

@@ -36,6 +36,11 @@ function getPackageVersion() {
     }
 }
 export const VERSION = getPackageVersion();
+/** Commands that only observe the running system and must not start or write anything. */
+export const OBSERVE_ONLY_COMMANDS = new Set(['harness']);
+export function isObserveOnlyCommand(name) {
+    return name !== undefined && OBSERVE_ONLY_COMMANDS.has(name);
+}
 /**
  * V3 CLI Application
  */
@@ -113,8 +118,13 @@ export class CLI {
                 this.output.printDebug(`Flags: ${JSON.stringify(Object.fromEntries(Object.entries(flags).filter(([k]) => k !== '_')))}`);
                 this.output.printDebug(`CWD: ${process.cwd()}`);
             }
+            // Observe-only commands (e.g. `harness`, run from SessionStart hooks)
+            // report on the running system, so they must not change it: no update
+            // check, no policy migration, no helper refresh, no proven-config
+            // adoption, no daemon autostart.
+            const observeOnly = isObserveOnlyCommand(commandPath[0] ?? positional[0]);
             // Run startup update check (non-blocking, silent on skip)
-            if (!flags.noUpdate && flags.update !== false && commandPath[0] !== 'update' && !(commandPath[0] === 'doctor' && flags.json)) {
+            if (!flags.noUpdate && flags.update !== false && commandPath[0] !== 'update' && !(commandPath[0] === 'doctor' && flags.json) && !observeOnly) {
                 this.checkForUpdatesOnStartup().catch(() => { });
             }
             // Version-stamped helper auto-refresh — propagate hook fixes to an already
@@ -123,7 +133,7 @@ export class CLI {
             // command can't exit before the copy lands; the fast path is a single
             // stamp read + string compare (sub-ms), and the copy runs at most once per
             // version bump. Best-effort + silent — never blocks or fails a command.
-            if (commandPath[0] !== 'init' && commandPath[0] !== 'update') {
+            if (commandPath[0] !== 'init' && commandPath[0] !== 'update' && !observeOnly) {
                 // ADR-324: existing installations acquire a versioned policy state on
                 // first use. Migration is additive and starts in legacy mode, so older
                 // AgentDB, MCP, hooks, and swarm workflows keep their exact behavior.

package/v3/@claude-flow/cli/dist/src/init/grok-generator.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Grok Build host init (ADR-402).
+ *
+ * Mirrors `init --codex`: writes project-scoped `.grok/` surface + team bus scripts
+ * so any repo can run Ruflo Agent Teams under Grok without Claude SendMessage.
+ *
+ * Writes outside the project only with `statusLine: true` (`--grok-statusline`):
+ * the status row lives in the user's ~/.grok/config.toml, which is parsed and
+ * merged with a real TOML parser, never blindly appended to.
+ */
+import { grokTemplatesRoot } from './grok-templates.js';
+export interface GrokInitOptions {
+    targetDir: string;
+    force?: boolean;
+    /** Also write docs/grok/README.md operator guide */
+    docs?: boolean;
+    /** Install the status row into the user's ~/.grok/config.toml (opt-in). */
+    statusLine?: boolean;
+    /** Report what would be written; write nothing. */
+    dryRun?: boolean;
+    /** Home directory for the user-level status row (tests). */
+    homeDir?: string;
+}
+export type GrokUserConfigAction = 'not-requested' | 'created' | 'merged' | 'already-set' | 'snippet' | 'would-write';
+export interface GrokUserConfigResult {
+    action: GrokUserConfigAction;
+    /** ~/.grok/config.toml */
+    path: string;
+    /** TOML to paste when init did not write it */
+    snippet: string;
+    reason?: string;
+}
+export interface GrokMcpLaunch {
+    command: string;
+    args: string[];
+    /** published: pinned to this CLI's npm version; checkout: this local build */
+    source: 'published' | 'checkout';
+    version: string;
+}
+export interface GrokInitResult {
+    success: boolean;
+    dryRun: boolean;
+    /** Files written (or, in a dry run, that would be written) */
+    filesCreated: string[];
+    filesSkipped: string[];
+    errors: string[];
+    mcp: GrokMcpLaunch;
+    userConfig: GrokUserConfigResult;
+}
+export { grokTemplatesRoot };
+/**
+ * How the project .grok/config.toml starts the Ruflo MCP server.
+ *
+ * The team_* tools ship in the same release as `init --grok`, so the server is
+ * pinned to the version that is running this init — never `@latest`, which can
+ * be an older release without them. Running from a source checkout (not under
+ * node_modules) points at that checkout's CLI, since its version may not be
+ * published yet.
+ */
+export declare function rufloMcpLaunch(root?: string): GrokMcpLaunch;
+/**
+ * Fill the template placeholders. Every inserted value is escaped as a TOML
+ * string, so a Windows path such as C:\Users\x stays valid TOML.
+ */
+export declare function materializeGrokConfig(template: string, launch: GrokMcpLaunch, home: string): string;
+/** Where the opt-in status row script is installed: a stable absolute path. */
+export declare function grokStatusScriptPath(home: string): string;
+/** `node "<abs path>"` — no shell builtins, and never a repo-relative script. */
+export declare function grokStatusLineCommand(home: string): string;
+export declare function grokStatusLineSnippet(home: string): string;
+type MergeOutcome = {
+    kind: 'write';
+    text: string;
+} | {
+    kind: 'already-set';
+    ours: boolean;
+} | {
+    kind: 'unsafe';
+    reason: string;
+};
+/**
+ * Add the status row to an existing user config without disturbing it.
+ *
+ * Any existing `ui.status_line` — header, `[ ui.status_line ]`,
+ * `[ui."status_line"]`, dotted keys, or an inline table — is detected by
+ * parsing, and left alone. Otherwise the block is appended and the result is
+ * re-parsed: it is written only if it parses, carries exactly our status row,
+ * and every other value is unchanged. Anything else (unparseable file, `ui`
+ * as an inline table, …) falls back to printing the snippet.
+ */
+export declare function mergeGrokStatusLine(existing: string, home: string): MergeOutcome;
+/**
+ * Initialize Grok host surface in targetDir.
+ */
+export declare function executeGrokInit(options: GrokInitOptions): GrokInitResult;
+//# sourceMappingURL=grok-generator.d.ts.map