claude-flow 3.58.0 → 3.59.0

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

@@ -0,0 +1,371 @@
+/**
+ * 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 * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as TOML from '@iarna/toml';
+import { grokPackageRoot, grokTemplatesRoot } from './grok-templates.js';
+export { grokTemplatesRoot };
+function packageVersion(root) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8')).version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/**
+ * 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 function rufloMcpLaunch(root = grokPackageRoot()) {
+    const version = packageVersion(root);
+    const published = root.split(path.sep).includes('node_modules');
+    if (!published) {
+        return {
+            command: 'node',
+            args: [path.join(root, 'bin', 'cli.js'), 'mcp', 'start'],
+            source: 'checkout',
+            version,
+        };
+    }
+    const npxArgs = ['-y', `ruflo@${version}`, 'mcp', 'start'];
+    return process.platform === 'win32'
+        ? { command: 'cmd', args: ['/c', 'npx', ...npxArgs], source: 'published', version }
+        : { command: 'npx', args: npxArgs, source: 'published', version };
+}
+/** A TOML basic string. JSON escaping is a valid subset (\\, \", \uXXXX). */
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+/**
+ * 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 function materializeGrokConfig(template, launch, home) {
+    const homeInString = tomlString(home.replace(/[\\/]+$/, '')).slice(1, -1);
+    return template
+        .replaceAll('{{RUFLO_MCP_COMMAND}}', tomlString(launch.command))
+        .replaceAll('{{RUFLO_MCP_ARGS}}', `[${launch.args.map(tomlString).join(', ')}]`)
+        .replaceAll('{{HOME}}/', `${homeInString}/`);
+}
+// ---------------------------------------------------------------------------
+// User-level status row (~/.grok/config.toml [ui.status_line])
+// ---------------------------------------------------------------------------
+/** Where the opt-in status row script is installed: a stable absolute path. */
+export function grokStatusScriptPath(home) {
+    return path.join(home, '.grok', 'ruflo', 'host-statusline.mjs');
+}
+/** `node "<abs path>"` — no shell builtins, and never a repo-relative script. */
+export function grokStatusLineCommand(home) {
+    return `node "${grokStatusScriptPath(home)}"`;
+}
+export function grokStatusLineSnippet(home) {
+    return TOML.stringify({
+        ui: { status_line: { type: 'command', command: grokStatusLineCommand(home) } },
+    });
+}
+function stableJson(value) {
+    return JSON.stringify(value, (_k, v) => v && typeof v === 'object' && !Array.isArray(v) && !(v instanceof Date)
+        ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, v[k]]))
+        : v);
+}
+function statusLineOf(doc) {
+    const ui = doc.ui;
+    return ui && typeof ui === 'object' && !Array.isArray(ui) ? ui.status_line : undefined;
+}
+/**
+ * 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 function mergeGrokStatusLine(existing, home) {
+    let before;
+    try {
+        before = TOML.parse(existing);
+    }
+    catch (e) {
+        return { kind: 'unsafe', reason: `could not parse it as TOML (${e.message.split('\n')[0]})` };
+    }
+    const current = statusLineOf(before);
+    if (current !== undefined) {
+        const command = current && typeof current === 'object' ? current.command : undefined;
+        return { kind: 'already-set', ours: command === grokStatusLineCommand(home) };
+    }
+    const sep = existing.length === 0 || existing.endsWith('\n') ? '' : '\n';
+    const text = `${existing}${sep}\n# Ruflo loaded-status row (added by ruflo init --grok --grok-statusline)\n${grokStatusLineSnippet(home)}`;
+    let after;
+    try {
+        after = TOML.parse(text);
+    }
+    catch (e) {
+        return { kind: 'unsafe', reason: `appending [ui.status_line] would not parse (${e.message.split('\n')[0]})` };
+    }
+    const added = statusLineOf(after);
+    if (!added || added.type !== 'command' || added.command !== grokStatusLineCommand(home)) {
+        return { kind: 'unsafe', reason: 'the merged file did not contain the expected status row' };
+    }
+    const ui = after.ui;
+    delete ui.status_line;
+    if (before.ui === undefined && Object.keys(ui).length === 0)
+        delete after.ui;
+    if (stableJson(after) !== stableJson(before)) {
+        return { kind: 'unsafe', reason: 'the merge would change other settings' };
+    }
+    return { kind: 'write', text };
+}
+/**
+ * If `file` is a symlink, resolve it to what it actually points at. A rename
+ * onto a symlink path replaces the symlink itself with a plain file — in a
+ * dotfiles-managed setup where `~/.grok/config.toml` is a symlink, that
+ * silently destroys the symlink instead of updating the file it points to
+ * (ADR-402 round-2 review, minor item 1). A broken symlink (target missing)
+ * falls back to writing `file` itself, same as a plain non-existent path.
+ */
+function resolveWriteTarget(file) {
+    try {
+        if (fs.lstatSync(file).isSymbolicLink()) {
+            return fs.realpathSync(file);
+        }
+    }
+    catch {
+        /* missing, unreadable, or a broken symlink target: write `file` itself */
+    }
+    return file;
+}
+function writeFileAtomic(file, text, mode) {
+    const target = resolveWriteTarget(file);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmp, text, { encoding: 'utf-8', mode: mode ?? 0o600 });
+    fs.renameSync(tmp, target);
+}
+function wireGrokUserStatusLine(home, dryRun, created, errors) {
+    const dest = path.join(home, '.grok', 'config.toml');
+    const snippet = grokStatusLineSnippet(home);
+    const script = grokStatusScriptPath(home);
+    const result = (action, reason) => ({
+        action,
+        path: dest,
+        snippet,
+        reason,
+    });
+    let existing = null;
+    try {
+        existing = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf-8') : null;
+    }
+    catch (e) {
+        return result('snippet', `could not read ${dest}: ${e.message}`);
+    }
+    const outcome = existing === null
+        ? { kind: 'write', text: `# Ruflo loaded-status row (added by ruflo init --grok --grok-statusline)\n${snippet}` }
+        : mergeGrokStatusLine(existing, home);
+    if (outcome.kind === 'unsafe')
+        return result('snippet', `${dest}: ${outcome.reason}`);
+    if (outcome.kind === 'already-set' && !outcome.ours) {
+        return result('already-set', `${dest} already has its own [ui.status_line]; left it and did not install the Ruflo script`);
+    }
+    // Ours, or about to be ours: install/refresh the script it runs.
+    const needsConfig = outcome.kind === 'write';
+    if (dryRun) {
+        created.push(script);
+        if (needsConfig)
+            created.push(dest);
+        return result(needsConfig ? 'would-write' : 'already-set');
+    }
+    try {
+        const src = path.join(grokTemplatesRoot(), 'scripts', 'host-statusline.mjs');
+        writeFileAtomic(script, fs.readFileSync(src, 'utf-8'), 0o755);
+        created.push(script);
+        if (!needsConfig)
+            return result('already-set');
+        writeFileAtomic(dest, outcome.text);
+        created.push(dest);
+        return result(existing === null ? 'created' : 'merged');
+    }
+    catch (e) {
+        errors.push(`${dest}: ${e.message}`);
+        return result('snippet', e.message);
+    }
+}
+/** First `object.key` (or `[index]`) path to a BigInt value, or null. */
+function findBigIntKeyPath(value, path = []) {
+    if (typeof value === 'bigint')
+        return path.length ? path.join('.') : '(root)';
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const found = findBigIntKeyPath(value[i], [...path, `[${i}]`]);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    if (value && typeof value === 'object' && !(value instanceof Date)) {
+        for (const [k, v] of Object.entries(value)) {
+            const found = findBigIntKeyPath(v, [...path, k]);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+/**
+ * Whether an existing `~/.grok/config.toml` can be safely parsed and
+ * serialized before init touches anything. A TOML integer literal above
+ * 2^53 parses to a BigInt (@iarna/toml), and `JSON.stringify` — used by
+ * `mergeGrokStatusLine`'s stableJson comparison — throws "Do not know how
+ * to serialize a BigInt" on it. That merge used to run as the LAST step of
+ * `executeGrokInit`, so the crash left project files already written and
+ * nothing to show for the failure. Checked here, first, so init either
+ * fully succeeds or writes nothing at all (ADR-402 round-2 review, minor
+ * item 2). Returns a user-facing error message naming the offending key,
+ * or null if the file is fine (or absent, or already unparseable as
+ * TOML — mergeGrokStatusLine reports that case on its own, safely).
+ */
+function validateExistingUserConfig(dest) {
+    let existing;
+    try {
+        if (!fs.existsSync(dest))
+            return null;
+        existing = fs.readFileSync(dest, 'utf-8');
+    }
+    catch (e) {
+        return `could not read ${dest}: ${e.message}`;
+    }
+    let doc;
+    try {
+        doc = TOML.parse(existing);
+    }
+    catch {
+        return null;
+    }
+    // An existing status row is left as-is, so nothing in this file is
+    // serialized. A BigInt elsewhere must not fail init in that case
+    // (ADR-402 round-3 review). The status step reports already-set.
+    if (statusLineOf(doc) !== undefined)
+        return null;
+    try {
+        JSON.stringify(doc);
+    }
+    catch (e) {
+        const offending = findBigIntKeyPath(doc);
+        const where = offending ? ` at "${offending}"` : '';
+        return `${dest} has a value ruflo cannot serialize${where} (${e.message}) — fix or remove it before running init --grok --grok-statusline again`;
+    }
+    return null;
+}
+function writeProjectFile(ctx, dest, write) {
+    try {
+        if (fs.existsSync(dest) && !ctx.force) {
+            ctx.skipped.push(dest);
+            return;
+        }
+        if (!ctx.dryRun) {
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            write();
+        }
+        ctx.created.push(dest);
+    }
+    catch (e) {
+        ctx.errors.push(`${dest}: ${e.message}`);
+    }
+}
+function copyFile(ctx, src, dest) {
+    writeProjectFile(ctx, dest, () => {
+        fs.copyFileSync(src, dest);
+        fs.chmodSync(dest, fs.statSync(src).mode);
+    });
+}
+function walkCopy(ctx, srcDir, destDir) {
+    if (!fs.existsSync(srcDir)) {
+        ctx.errors.push(`Template directory missing: ${srcDir}`);
+        return;
+    }
+    for (const ent of fs.readdirSync(srcDir, { withFileTypes: true })) {
+        const src = path.join(srcDir, ent.name);
+        const dest = path.join(destDir, ent.name);
+        if (ent.isDirectory())
+            walkCopy(ctx, src, dest);
+        else
+            copyFile(ctx, src, dest);
+    }
+}
+/**
+ * Initialize Grok host surface in targetDir.
+ */
+export function executeGrokInit(options) {
+    const { targetDir, force = false, docs = true, statusLine = false, dryRun = false } = options;
+    const home = options.homeDir || os.homedir();
+    const ctx = { force, dryRun, created: [], skipped: [], errors: [] };
+    const tpl = grokTemplatesRoot();
+    const mcp = rufloMcpLaunch();
+    const userConfig = {
+        action: 'not-requested',
+        path: path.join(home, '.grok', 'config.toml'),
+        snippet: grokStatusLineSnippet(home),
+    };
+    const done = () => ({
+        success: ctx.errors.length === 0,
+        dryRun,
+        filesCreated: ctx.created,
+        filesSkipped: ctx.skipped,
+        errors: ctx.errors,
+        mcp,
+        userConfig,
+    });
+    if (!fs.existsSync(path.join(tpl, 'config.toml'))) {
+        ctx.errors.push(`Grok templates not found at ${tpl}. Reinstall @claude-flow/cli or run from a monorepo checkout that includes templates/grok.`);
+        return done();
+    }
+    // Validate any existing user-level config before writing a single project
+    // file — see validateExistingUserConfig for why (BigInt/serialization
+    // failures must not leave a half-initialized project).
+    if (statusLine) {
+        const problem = validateExistingUserConfig(userConfig.path);
+        if (problem) {
+            ctx.errors.push(problem);
+            return done();
+        }
+    }
+    // .grok/config.toml — placeholders filled, then checked with a TOML parser
+    const config = materializeGrokConfig(fs.readFileSync(path.join(tpl, 'config.toml'), 'utf-8'), mcp, home);
+    try {
+        TOML.parse(config);
+    }
+    catch (e) {
+        ctx.errors.push(`.grok/config.toml would not be valid TOML: ${e.message.split('\n')[0]}`);
+        return done();
+    }
+    writeProjectFile(ctx, path.join(targetDir, '.grok', 'config.toml'), () => fs.writeFileSync(path.join(targetDir, '.grok', 'config.toml'), config, 'utf-8'));
+    for (const dir of ['rules', 'agents', 'hooks', 'skills']) {
+        walkCopy(ctx, path.join(tpl, dir), path.join(targetDir, '.grok', dir));
+    }
+    // scripts/ team bus (project-local CLI + SubagentStop adapter + status row)
+    walkCopy(ctx, path.join(tpl, 'scripts'), path.join(targetDir, 'scripts'));
+    if (docs) {
+        walkCopy(ctx, path.join(tpl, 'docs'), path.join(targetDir, 'docs', 'grok'));
+    }
+    if (statusLine) {
+        Object.assign(userConfig, wireGrokUserStatusLine(home, dryRun, ctx.created, ctx.errors));
+    }
+    return done();
+}
+//# sourceMappingURL=grok-generator.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * Where the Grok host templates live (ADR-402).
+ *
+ * Kept apart from grok-generator.ts so the team_* MCP tools can find the team
+ * bus scripts without loading the TOML parser on every MCP client import.
+ */
+/** Root of the installed @claude-flow/cli package (the one holding templates/grok). */
+export declare function grokPackageRoot(): string;
+/** templates/grok inside the installed @claude-flow/cli package. */
+export declare function grokTemplatesRoot(): string;
+//# sourceMappingURL=grok-templates.d.ts.map

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

@@ -0,0 +1,28 @@
+/**
+ * Where the Grok host templates live (ADR-402).
+ *
+ * Kept apart from grok-generator.ts so the team_* MCP tools can find the team
+ * bus scripts without loading the TOML parser on every MCP client import.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Root of the installed @claude-flow/cli package (the one holding templates/grok). */
+export function grokPackageRoot() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(here, '../../..'), // dist/src/init → package root
+        path.resolve(here, '../..'), // src/init → package root
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(path.join(c, 'templates', 'grok', 'config.toml'))) {
+            return c;
+        }
+    }
+    return candidates[0];
+}
+/** templates/grok inside the installed @claude-flow/cli package. */
+export function grokTemplatesRoot() {
+    return path.join(grokPackageRoot(), 'templates', 'grok');
+}
+//# sourceMappingURL=grok-templates.js.map

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

@@ -10,4 +10,6 @@ export { generatePreCommitHook, generatePostCommitHook, generateSessionManager,
 export { generateClaudeMd, generateMinimalClaudeMd, CLAUDE_MD_TEMPLATES, } from './claudemd-generator.js';
 export { executeInit, executeUpgrade, executeUpgradeWithMissing, default } from './executor.js';
 export type { UpgradeResult } from './executor.js';
+export { executeGrokInit } from './grok-generator.js';
+export type { GrokInitOptions, GrokInitResult } from './grok-generator.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -12,4 +12,6 @@ export { generatePreCommitHook, generatePostCommitHook, generateSessionManager,
 export { generateClaudeMd, generateMinimalClaudeMd, CLAUDE_MD_TEMPLATES, } from './claudemd-generator.js';
 // Main executor
 export { executeInit, executeUpgrade, executeUpgradeWithMissing, default } from './executor.js';
+// Grok Build host (ADR-402)
+export { executeGrokInit } from './grok-generator.js';
 //# sourceMappingURL=index.js.map

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

@@ -73,6 +73,8 @@ import { businessPodTools } from './mcp-tools/business-pod-tools.js';
 // + auth headers; opt-in via CLAUDE_FLOW_HTTP_FETCH_ALLOW_PRIVATE / _AUTH=1.
 import { httpFetchTools } from './mcp-tools/http-fetch-tools.js';
 import { missionTools } from './mcp-tools/mission-tools.js';
+// ADR-402 — host-agnostic Agent Teams bus (team_create/send/inbox/spawn/…)
+import { teamTools } from './mcp-tools/team-tools.js';
 // #1916: coverage-aware routing tools — defined in ruvector/coverage-tools.ts
 // but were never registered, so the `ruflo hooks coverage-*` CLI subcommands
 // failed with `Tool not found: hooks_coverage-route`.
@@ -183,6 +185,8 @@ registerTools([
     ...httpFetchTools,
     // ADR-406 — mission semantic operations (create/plan/get/events/request_action)
     ...missionTools,
+    // ADR-402 — host-agnostic Agent Teams (9 tools)
+    ...teamTools,
 ]);
 // The capability brain consumes the completed live registry. This is injected
 // after registration to keep guidance honest and avoid a registry import cycle.

package/v3/@claude-flow/cli/dist/src/mcp-tools/agent-execute-core.js

@@ -152,7 +152,11 @@ export async function callAnthropicMessages(input) {
                 ...input,
                 apiKey: ollamaKey || persistedOllama?.apiKey || 'local',
                 baseUrl: resolvedBaseUrl,
-                model: input.model || persistedOllama?.model,
+                model: input.model,
+                // Local default for tier aliases / Anthropic ids (see
+                // resolveOllamaModel): OLLAMA_DEFAULT_MODEL, then the model saved by
+                // `providers configure -p ollama -m <tag>`.
+                defaultModel: process.env.OLLAMA_DEFAULT_MODEL || persistedOllama?.model,
             });
         }
         return { success: false, error: 'Ollama was selected but no API key or self-hosted endpoint is configured.' };
@@ -242,13 +246,15 @@ export async function callAnthropicMessages(input) {
  *
  * Translates the Anthropic-flavored input shape onto OpenAI chat-completions
  * and translates the response back so callers never see provider-specific
- * fields. Logical model names are mapped to Ollama Cloud defaults:
- *   - 'haiku'  / 'sonnet'  → 'gpt-oss:120b-cloud' (sensible single default)
- *   - 'opus'              → 'gpt-oss:120b-cloud' (no opus tier on Ollama)
- *   - explicit 'ollama:<model>' or bare provider-native name → passed through
+ * fields. Logical model names ('haiku' / 'sonnet' / 'opus' / a tier-routed
+ * `claude-*` id) resolve to the configured OLLAMA_DEFAULT_MODEL / persisted
+ * default; only when the endpoint is genuinely Ollama's cloud service AND no
+ * default is configured does this fall back to 'gpt-oss:120b-cloud' — a
+ * self-hosted/local endpoint with no default configured fails loudly instead
+ * (see resolveOllamaModel). An explicit 'ollama:<model>' or bare
+ * provider-native name always passes through unchanged.
  */
 async function callOllamaCompat(input) {
-    const model = resolveOllamaModel(input.model);
     const startedAt = Date.now();
     // #2962 — input.baseUrl (resolved by the caller from persisted
     // `providers configure` config, then OLLAMA_BASE_URL) takes precedence
@@ -257,6 +263,20 @@ async function callOllamaCompat(input) {
     // Cloud. Falls back to the original OLLAMA_BASE_URL-or-cloud behavior
     // for any direct caller that doesn't pass baseUrl.
     const base = (input.baseUrl || process.env.OLLAMA_BASE_URL || 'https://ollama.com').replace(/\/+$/, '');
+    // Only a base URL actually pointed at Ollama's real cloud endpoint may
+    // fall back to a `-cloud`-suffixed default model — see resolveOllamaModel.
+    const isCloudEndpoint = /^https:\/\/ollama\.com\/?$/i.test(base);
+    let model;
+    try {
+        model = resolveOllamaModel(input.model, input.defaultModel, isCloudEndpoint);
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: err instanceof Error ? err.message : String(err),
+            durationMs: Date.now() - startedAt,
+        };
+    }
     const url = `${base}/v1/chat/completions`;
     // Self-hosted endpoints typically don't need an Authorization header
     // (the daemon binds to 11434 with no auth by default), but Ollama Cloud
@@ -403,18 +423,45 @@ function resolveOpenAICompatModel(input, fallback) {
         return 'anthropic/claude-opus-4-8';
     return input;
 }
-function resolveOllamaModel(input) {
-    const DEFAULT = 'gpt-oss:120b-cloud';
+/**
+ * Resolve the model name to send to an Ollama-compatible endpoint.
+ *
+ * Self-hosted setups name their default via OLLAMA_DEFAULT_MODEL or
+ * `providers configure -p ollama -m <tag>` (`defaultModel`, resolved by the
+ * caller). When no default is configured AND the endpoint is not actually
+ * Ollama's real cloud service, this must NOT silently rewrite a tier-routed
+ * `claude-*` id (or a bare tier alias) to a `-cloud`-suffixed model name: a
+ * signed-in local Ollama daemon forwards any `-cloud`-suffixed model to
+ * Ollama's actual cloud service, so a silent rewrite would leak a prompt
+ * that was supposed to stay local. Fail loudly instead and tell the caller
+ * how to fix it — a loud, local failure beats silent cloud egress.
+ */
+function resolveOllamaModel(input, defaultModel, isCloudEndpoint = false) {
+    const cloudDefault = 'gpt-oss:120b-cloud';
+    const resolveDefault = () => {
+        if (defaultModel)
+            return defaultModel;
+        if (isCloudEndpoint)
+            return cloudDefault;
+        throw new Error('No Ollama model configured for this self-hosted/local endpoint — refusing to fall back to '
+            + `a cloud-suffixed default ("${cloudDefault}") a local Ollama daemon would forward to Ollama `
+            + 'Cloud. Set OLLAMA_DEFAULT_MODEL, or run `providers configure -p ollama -m <tag>`, to pin a '
+            + 'real local model.');
+    };
     if (!input)
-        return DEFAULT;
-    // Logical → cloud default
+        return resolveDefault();
+    // Logical tier alias → default
     if (input === 'haiku' || input === 'sonnet' || input === 'opus' || input === 'inherit') {
-        return DEFAULT;
+        return resolveDefault();
     }
     // Explicit provider prefix
     if (input.startsWith('ollama:'))
         return input.slice('ollama:'.length);
-    // Bare name with cloud suffix (e.g. 'llama3:70b-cloud') passes through
+    // Anthropic model ids (what executeAgentTask sends for a tier-routed agent
+    // via MODEL_MAP) never exist on an Ollama endpoint → default.
+    if (/^claude-/i.test(input))
+        return resolveDefault();
+    // Bare name (e.g. 'qwen3-coder:30b', 'llama3:70b-cloud') passes through
     return input;
 }
 /**

package/v3/@claude-flow/cli/dist/src/mcp-tools/capability-brain.d.ts

@@ -97,7 +97,7 @@ export interface CapabilityBrain {
     };
 }
 /** Top-level commands from the CLI command loader. Kept as a checked manifest. */
-export declare const RUFLO_CLI_COMMANDS: readonly ["init", "start", "status", "task", "session", "agent", "swarm", "memory", "mcp", "config", "migrate", "hooks", "workflow", "hive-mind", "process", "daemon", "version", "neural", "security", "performance", "providers", "plugins", "deployment", "claims", "policy", "embeddings", "completions", "doctor", "verify", "analyze", "route", "progress", "issues", "update", "ruvector", "benchmark", "guidance", "appliance", "appliance-advanced", "transfer-store", "cleanup", "autopilot", "gaia-bench", "metaharness", "eject", "funnel", "settings", "auth", "proxy", "advisor", "spinner", "announcements", "tui"];
+export declare const RUFLO_CLI_COMMANDS: readonly ["init", "start", "status", "task", "session", "agent", "swarm", "memory", "mcp", "config", "migrate", "hooks", "workflow", "hive-mind", "process", "daemon", "version", "neural", "security", "performance", "providers", "plugins", "deployment", "claims", "policy", "embeddings", "completions", "doctor", "verify", "analyze", "route", "progress", "issues", "update", "ruvector", "benchmark", "guidance", "appliance", "appliance-advanced", "transfer-store", "cleanup", "autopilot", "gaia-bench", "metaharness", "eject", "funnel", "settings", "auth", "proxy", "advisor", "spinner", "announcements", "tui", "harness"];
 export interface ImplementationLoopStep {
     id: string;
     name: string;

package/v3/@claude-flow/cli/dist/src/mcp-tools/capability-brain.js

@@ -16,7 +16,7 @@ export const RUFLO_CLI_COMMANDS = [
     'ruvector', 'benchmark', 'guidance', 'appliance', 'appliance-advanced',
     'transfer-store', 'cleanup', 'autopilot', 'gaia-bench', 'metaharness',
     'eject', 'funnel', 'settings', 'auth', 'proxy', 'advisor', 'spinner',
-    'announcements', 'tui',
+    'announcements', 'tui', 'harness',
 ];
 export const IMPLEMENTATION_LOOP = [
     {
@@ -284,9 +284,10 @@ export const CAPABILITY_DOMAINS = [
     {
         id: 'swarm-coordination',
         name: 'Swarm & Coordination',
-        prefixes: ['swarm_', 'coordination_', 'daa_'],
+        // team_: host-agnostic Agent Teams bus (ADR-402)
+        prefixes: ['swarm_', 'coordination_', 'daa_', 'team_'],
         description: 'Topology-aware multi-agent coordination, task ownership, and collective scheduling.',
-        taskSignals: ['swarm', 'concurrent', 'parallel', 'coordinate', 'multi-agent'],
+        taskSignals: ['swarm', 'concurrent', 'parallel', 'coordinate', 'multi-agent', 'agent team'],
         commands: ['swarm init', 'swarm status', 'swarm coordinate'],
         skills: ['swarm-orchestration', 'swarm-advanced'],
         agents: ['coordinator', 'coder', 'tester', 'reviewer'],
@@ -553,6 +554,7 @@ const TOOL_OWNERSHIP = [
     { prefixes: ['guidance_'], packageOwner: '@claude-flow/guidance', pluginOwner: 'ruflo-core' },
     { prefixes: ['seraphina_'], packageOwner: '@claude-flow/cli', pluginOwner: 'ruflo-core' },
     { prefixes: ['x_federation_'], packageOwner: '@claude-flow/cli', pluginOwner: 'ruflo-x-gateway' },
+    { prefixes: ['team_'], packageOwner: '@claude-flow/cli' },
 ];
 function ownershipForTool(toolName, definition) {
     const explicit = TOOL_OWNERSHIP.find((entry) => entry.prefixes.some((prefix) => toolName.startsWith(prefix)));

package/v3/@claude-flow/cli/dist/src/mcp-tools/embeddings-tools.js

@@ -928,15 +928,22 @@ export const embeddingsTools = [
             const v = vt(params.query, 'query');
             if (!v.valid)
                 return { success: false, error: v.error };
-            const { searchRabitq } = await import('../memory/rabitq-index.js');
+            const { ensureRabitqIndex, searchRabitq } = await import('../memory/rabitq-index.js');
             const { generateEmbedding } = await import('../memory/memory-initializer.js');
             const queryEmb = await generateEmbedding(params.query);
-            const results = await searchRabitq(queryEmb.embedding, {
+            const searchOptions = {
                 k: params.k || 10,
                 namespace: params.namespace,
-            });
+            };
+            // #4203: the index is built on demand, so a search no longer requires a
+            // separate `embeddings_rabitq_build` call first.
+            let results = await searchRabitq(queryEmb.embedding, searchOptions);
+            if (!results) {
+                await ensureRabitqIndex({ dimensions: queryEmb.embedding.length });
+                results = await searchRabitq(queryEmb.embedding, searchOptions);
+            }
             if (!results) {
-                return { success: false, error: 'RaBitQ index not built. Call embeddings_rabitq_build first.' };
+                return { success: false, error: 'RaBitQ index not built (needs at least 10 embedded entries). Call embeddings_rabitq_build first.' };
             }
             return {
                 success: true,

package/v3/@claude-flow/cli/dist/src/mcp-tools/hooks-tools.js

@@ -5,7 +5,7 @@ import { feedbackPatternsSchema, validateFeedbackPatterns } from '../memory/feed
  */
 import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync, unlinkSync, readdirSync } from 'fs';
 import * as nodeFs from 'fs';
-import { dirname, join, resolve } from 'path';
+import { dirname, join, resolve, sep } from 'path';
 import { getProjectCwd } from './types.js';
 import { validateIdentifier, validateText, validatePath } from './validate-input.js';
 import { commandRecordingDisabled, redactCommandForStorage } from '../services/command-recording.js';
@@ -5136,7 +5136,17 @@ export const hooksCodemod = {
                 if (!v.valid)
                     return v.error;
                 const abs = resolve(cwd, v.sanitized);
-                if (!abs.startsWith(cwd))
+                // Anchor containment at a path-separator boundary — an unanchored
+                // `abs.startsWith(cwd)` string-prefix check would let an absolute
+                // path like `${cwd}-staging/x.ts` pass as "inside" `cwd`. Matches
+                // the pattern already used correctly elsewhere in this codebase
+                // (@claude-flow/security's `isWithinPrefix`, hooks/workers, plugins/security).
+                // KNOWN LIMITATION (disclosed 2026-10-20, not fixed here): this
+                // compares the resolved-but-not-realpath'd path, so a symlink
+                // inside cwd pointing outside it still escapes containment
+                // (CWE-59, a distinct/broader gap than the CWE-22 prefix bug this
+                // anchors). Needs fs.realpathSync-based containment as a follow-up.
+                if (abs !== cwd && !abs.startsWith(cwd + sep))
                     return `path escapes project root: ${p}`;
                 out.add(abs);
                 return undefined;
@@ -5169,7 +5179,7 @@ export const hooksCodemod = {
                 }
                 for (const m of matches) {
                     const abs = resolve(cwd, m);
-                    if (abs.startsWith(cwd) && CODEMOD_EXTENSIONS.has(abs.slice(abs.lastIndexOf('.')).toLowerCase())) {
+                    if ((abs === cwd || abs.startsWith(cwd + sep)) && CODEMOD_EXTENSIONS.has(abs.slice(abs.lastIndexOf('.')).toLowerCase())) {
                         out.add(abs);
                     }
                 }