@aiwg/cli 2026.10.1 → 2026.10.3

package/dist/src/cli/handlers/init.js

@@ -4,9 +4,21 @@
  * Implements `aiwg init` — the first-run wizard that creates
  * `.aiwg/aiwg.config` for the current project.
  *
- * Prompts:
- *   1. Which AI provider toolchains does this project target?
- *   2. Would you like to add any scripts? (optional)
+ * Prompts, and the argument that answers each one directly (#3062):
+ *   1. Which AI provider toolchains does this project target? → `--providers <list>`
+ *   2. Would you like to add default scripts (deploy/doctor/sync)? → `--default-scripts true|false`
+ *   3. Add a custom script (name + command)? → `--script <name>=<command>` (repeatable;
+ *      implies yes) or `--custom-scripts true|false` (answers the question directly
+ *      without supplying a script; `false` declines it outright)
+ *   4. Enable direct worker dispatch? → `--worker-dispatch enable|decline`
+ *
+ * With a terminal attached, any of these given directly skips that
+ * question — only genuinely missing values are still asked. Without one,
+ * omitted inputs fall back to their documented defaults (`claude`, default
+ * scripts on) rather than erroring, since those defaults are always safe to
+ * apply headless. `--non-interactive`/`--yes` force the non-interactive
+ * path even with a terminal attached. `--dry-run` never writes anything,
+ * including the baseline config itself.
  *
  * Runs automatically on first `aiwg use` when no config exists.
  * Can also be run explicitly to reconfigure.
@@ -16,10 +28,14 @@
 import readline from 'readline';
 import { readAiwgConfig, writeAiwgConfig, emptyConfig, populateDeployedTo, VALID_PROVIDERS, getConfigPath, } from '../../config/aiwg-config.js';
 import * as ui from '../ui.js';
-import { askString as sharedAskString, askYesNo as sharedAskYesNo } from '../prompt-utils.js';
+import { askString as sharedAskString, askYesNo as sharedAskYesNo, askConsent } from '../prompt-utils.js';
 import { normalizeProviderDefinitionId } from '../../providers/provider-definitions.js';
 import { writeNormalizedAiwgMd } from '../../smiths/context-pipeline/finalization.js';
 import { ensureWorkspaceContext } from '../../smiths/context-pipeline/workspace-context.js';
+import { detectInstalledWorkerClis, evaluateWorkerDispatchOffer, workerDispatchOfferQuestion, workerDispatchOfferHintWithArg, parseWorkerDispatchArg, } from '../../models/worker-dispatch-offer.js';
+import { EXIT_CODES } from '../errors.js';
+import { isInteractive } from '../env.js';
+import { requireFlagValue, collectFlagValues, parseBooleanFlagValue, parseListFlagValue, parseKeyValueEntry, MissingFlagValueError, } from '../flag-parsing.js';
 const PROVIDER_LABELS = {
     antigravity: 'Google Antigravity .agents/',
     claude: 'Claude Code       .claude/',
@@ -76,6 +92,89 @@ async function askProviders(rl, signal) {
     }
     return selected.length > 0 ? selected : ['claude'];
 }
+/**
+ * Non-interactive / --yes / no-TTY runs never prompt and never touch the
+ * config (#3050 item 2) — they only print one line naming the enable
+ * command, when two or more worker CLIs are detected and dispatch is not
+ * already on or declined. The hint also names `--worker-dispatch` (#3062):
+ * that argument answers the same question headlessly.
+ */
+function renderWorkerDispatchHintIfApplicable(parallelism, setup) {
+    const offer = evaluateWorkerDispatchOffer(parallelism, setup, detectInstalledWorkerClis());
+    if (offer.shouldOffer)
+        ui.dim(`  ${workerDispatchOfferHintWithArg(offer.detected)}`);
+}
+function parseInitArgInputs(args) {
+    // #3062 second review, finding 4: `precedence: 'first'` matches this
+    // command's pre-existing (and, for `--providers`/`--default-scripts`/
+    // `--script`/`--custom-scripts`, only) convention — see
+    // `parseInitArgInputs`'s module-level callers for why `--worker-dispatch`
+    // specifically needs `rejectEmpty` (an explicit empty choice is never
+    // meaningful and must not silently fall through to "not given").
+    const workerDispatchArg = parseWorkerDispatchArg(requireFlagValue(args, { rejectEmpty: true }, '--worker-dispatch'));
+    const rawProviders = parseListFlagValue(requireFlagValue(args, {}, '--providers'));
+    const providersArg = rawProviders?.map((entry) => {
+        const canonical = normalizeProviderDefinitionId(entry);
+        if (!canonical || canonical === 'generic' || !VALID_PROVIDERS.includes(canonical)) {
+            throw new Error(`--providers: unknown provider '${entry}' (valid: ${VALID_PROVIDERS.join(', ')})`);
+        }
+        return canonical;
+    });
+    if (providersArg && providersArg.length === 0) {
+        throw new Error('--providers requires at least one provider name');
+    }
+    const defaultScriptsArg = parseBooleanFlagValue(requireFlagValue(args, {}, '--default-scripts'), '--default-scripts');
+    const customScriptsArg = parseBooleanFlagValue(requireFlagValue(args, {}, '--custom-scripts'), '--custom-scripts');
+    const scriptPairs = {};
+    for (const entry of collectFlagValues(args, {}, '--script')) {
+        const [name, command] = parseKeyValueEntry(entry, '--script');
+        scriptPairs[name] = command;
+    }
+    return { workerDispatchArg, providersArg, defaultScriptsArg, customScriptsArg, scriptPairs };
+}
+/** One-line description of what an explicit `--worker-dispatch` choice would write. */
+function describeWorkerDispatchWrite(arg) {
+    return arg === 'enable'
+        ? 'enable parallelism.worker_dispatch'
+        : 'record a worker-dispatch decline (setup.worker_dispatch_offer)';
+}
+/**
+ * Resolve an explicit `--worker-dispatch` choice into a decision to apply to
+ * a brand-new config (#3062). Under `--dry-run`, writes nothing — reports
+ * what would be written instead and returns `undefined` so the caller never
+ * applies it to the config it builds.
+ */
+function resolveWorkerDispatchDecisionForNewConfig(arg, dryRun) {
+    if (dryRun) {
+        ui.dim(`  Would ${describeWorkerDispatchWrite(arg)} (--dry-run writes nothing).`);
+        return undefined;
+    }
+    return { kind: arg };
+}
+/**
+ * Interactive-only: asks the one consent question (default/unanswered is
+ * no, strict `y`/`yes` parsing only) when two or more worker CLIs are
+ * detected and dispatch is not already on or declined. Returns the
+ * decision to apply, or `undefined` when there is nothing to offer, or
+ * when the prompt timed out / stdin closed without an answer — only an
+ * actually-answered "no" is recorded as a persistent decline (#3050
+ * review item 4).
+ */
+async function askWorkerDispatchOffer(rl, parallelism, setup, signal) {
+    const offer = evaluateWorkerDispatchOffer(parallelism, setup, detectInstalledWorkerClis());
+    if (!offer.shouldOffer)
+        return undefined;
+    console.log('');
+    const outcome = await askConsent(rl, workerDispatchOfferQuestion(offer.detected), undefined, signal);
+    if (outcome.kind !== 'answered')
+        return undefined;
+    if (outcome.value) {
+        ui.success('  Will enable parallelism.worker_dispatch.');
+        return { kind: 'enable' };
+    }
+    ui.dim('  Noted — enable later with `aiwg config set --project parallelism.worker_dispatch true`.');
+    return { kind: 'decline' };
+}
 export const initHandler = {
     id: 'init',
     name: 'Init',
@@ -84,16 +183,34 @@ export const initHandler = {
     aliases: [],
     async execute(ctx) {
         const force = ctx.args.includes('--force');
-        // Treat a missing stdin TTY as non-interactive so piped/backgrounded
-        // invocations never attempt to create a readline interface. This is a
-        // single authoritative check — downstream code MUST NOT re-derive
+        // `--non-interactive`/`--yes` are this command's own explicit flags for
+        // the one shared interactive decision (#3062 review item 12) — honored
+        // ahead of (and regardless of) the environment-only checks `isInteractive`
+        // otherwise applies (TTY, TERM, CI). Downstream code MUST NOT re-derive
         // interactive-ness from process.stdin.isTTY again.
-        const nonInteractive = ctx.args.includes('--non-interactive') ||
-            ctx.args.includes('--yes') ||
-            !process.stdin.isTTY ||
-            !process.stdout.isTTY ||
-            process.env['CI'] === 'true';
+        const explicitNonInteractive = ctx.args.includes('--non-interactive') || ctx.args.includes('--yes');
+        const nonInteractive = !isInteractive(explicitNonInteractive);
         const projectDir = ctx.cwd;
+        // `--worker-dispatch enable|decline` answers the worker-dispatch offer
+        // directly (#3062), with or without a terminal, and is honored even when
+        // fewer than two worker CLIs are detected — an explicit choice overrides
+        // the presence-only detection gate. `--providers`/`--default-scripts`/
+        // `--script` answer the remaining wizard inputs the same way (review
+        // item 10). Every flag is parsed strictly (review item 11): present
+        // without a usable value is a usage error, raised here before any
+        // preflight check, read, or write.
+        let workerDispatchArg;
+        let providersArg;
+        let defaultScriptsArg;
+        let customScriptsArg;
+        let scriptPairs;
+        try {
+            ({ workerDispatchArg, providersArg, defaultScriptsArg, customScriptsArg, scriptPairs } = parseInitArgInputs(ctx.args));
+        }
+        catch (err) {
+            const message = err instanceof MissingFlagValueError ? `${err.message}.` : err instanceof Error ? err.message : String(err);
+            return { exitCode: EXIT_CODES.USAGE, message };
+        }
         ui.blank();
         console.log(`  ${ui.brandMark()} ${ui.bold('AIWG Baseline Config')}`);
         ui.rule();
@@ -101,7 +218,10 @@ export const initHandler = {
         const existing = await readAiwgConfig(projectDir);
         if (existing && !force) {
             ui.info(`Config already exists: ${getConfigPath(projectDir)}`);
-            await writeNormalizedAiwgMd(projectDir);
+            // #3062 review item 18: `--dry-run` must write nothing at all, not
+            // just skip the worker-dispatch increment below.
+            if (!ctx.dryRun)
+                await writeNormalizedAiwgMd(projectDir);
             console.log(`  Providers: ${existing.providers.join(', ')}`);
             const scriptCount = Object.keys(existing.scripts).length;
             if (scriptCount > 0) {
@@ -111,22 +231,71 @@ export const initHandler = {
             ui.dim('  Ask your AIWG agent to review repo, tracker, delivery, signing, and provider policy.');
             ui.dim('  Agents may use `aiwg setup project --dry-run` as the CLI helper for that review.');
             ui.dim('  Run `aiwg init --force` only when you need to recreate the baseline config.');
+            // #3050: guide users to direct worker dispatch from the setup step they
+            // already run, instead of leaving it undiscoverable. `--dry-run` must
+            // never prompt and never write (review item 1) — it degrades to the
+            // same hint-only behavior as non-interactive runs.
+            // #3062: an explicit `--worker-dispatch` argument always answers the
+            // question directly (bypassing the ask/hint entirely) except under
+            // `--dry-run`, which still writes nothing — it reports what would be
+            // written instead.
+            if (workerDispatchArg) {
+                if (ctx.dryRun) {
+                    ui.dim(`  Would ${describeWorkerDispatchWrite(workerDispatchArg)} (--dry-run writes nothing).`);
+                }
+                else if (workerDispatchArg === 'enable') {
+                    await writeAiwgConfig(projectDir, { ...existing, parallelism: { ...existing.parallelism, worker_dispatch: true } });
+                    ui.success('  Enabled parallelism.worker_dispatch.');
+                }
+                else {
+                    await writeAiwgConfig(projectDir, { ...existing, setup: { ...existing.setup, worker_dispatch_offer: 'declined' } });
+                    ui.success('  Recorded worker-dispatch decline (setup.worker_dispatch_offer).');
+                }
+            }
+            else if (nonInteractive || ctx.dryRun) {
+                renderWorkerDispatchHintIfApplicable(existing.parallelism, existing.setup);
+            }
+            else {
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                try {
+                    const decision = await askWorkerDispatchOffer(rl, existing.parallelism, existing.setup, ctx.signal);
+                    if (decision?.kind === 'enable') {
+                        await writeAiwgConfig(projectDir, { ...existing, parallelism: { ...existing.parallelism, worker_dispatch: true } });
+                    }
+                    else if (decision?.kind === 'decline') {
+                        await writeAiwgConfig(projectDir, { ...existing, setup: { ...existing.setup, worker_dispatch_offer: 'declined' } });
+                    }
+                }
+                finally {
+                    rl.close();
+                }
+            }
             ui.blank();
             return { exitCode: 0 };
         }
         let providers;
         let scripts = {};
+        let workerDispatchDecision;
+        const DEFAULT_SCRIPTS = { deploy: 'aiwg use all', doctor: 'aiwg doctor', sync: 'aiwg sync' };
         if (nonInteractive) {
-            // Non-interactive: use defaults
-            providers = ['claude'];
-            scripts = {
-                deploy: 'aiwg use all',
-                doctor: 'aiwg doctor',
-                sync: 'aiwg sync',
-            };
+            // Non-interactive: an explicit `--providers`/`--default-scripts`
+            // answers the corresponding wizard input directly (review item 10);
+            // anything not supplied keeps its prior default.
+            providers = providersArg ?? ['claude'];
+            const includeDefaultScripts = defaultScriptsArg ?? true;
+            scripts = { ...(includeDefaultScripts ? DEFAULT_SCRIPTS : {}), ...scriptPairs };
+            if (workerDispatchArg) {
+                workerDispatchDecision = resolveWorkerDispatchDecisionForNewConfig(workerDispatchArg, ctx.dryRun);
+            }
+            else {
+                renderWorkerDispatchHintIfApplicable(undefined, undefined);
+            }
         }
         else {
-            // Interactive wizard
+            // Interactive wizard — skip a prompt whenever its argument already
+            // answered it (review item 10/12: "with a terminal we can skip steps
+            // for any params provided and only provide interaction when we are
+            // missing a value").
             const rl = readline.createInterface({
                 input: process.stdin,
                 output: process.stdout,
@@ -134,16 +303,29 @@ export const initHandler = {
             try {
                 // Thread ctx.signal through every prompt so Ctrl-C during the wizard
                 // cancels cleanly instead of being absorbed by readline (POC #926).
-                providers = await askProviders(rl, ctx.signal);
+                providers = providersArg ?? await askProviders(rl, ctx.signal);
                 console.log('');
-                const addScripts = await askYesNo(rl, '  Add default scripts (deploy, doctor, sync)? [Y/n]: ', true, ctx.signal);
-                if (addScripts) {
-                    scripts = {
-                        deploy: 'aiwg use all',
-                        doctor: 'aiwg doctor',
-                        sync: 'aiwg sync',
-                    };
-                    const addCustom = await askYesNo(rl, '  Add a custom script? [y/N]: ', false, ctx.signal);
+                const includeDefaultScripts = defaultScriptsArg !== undefined
+                    ? defaultScriptsArg
+                    : await askYesNo(rl, '  Add default scripts (deploy, doctor, sync)? [Y/n]: ', true, ctx.signal);
+                scripts = includeDefaultScripts ? { ...DEFAULT_SCRIPTS } : {};
+                if (Object.keys(scriptPairs).length > 0) {
+                    // `--script` already answered "add a custom script?" (implicit
+                    // yes) and its name/command sub-prompts — never ask any of the
+                    // three (#3062 second review, finding 5a).
+                    scripts = { ...scripts, ...scriptPairs };
+                }
+                else {
+                    // `--custom-scripts true|false` answers "add a custom script?"
+                    // directly when `--script` itself was not given — an explicit
+                    // decline (`false`) skips the question entirely, same as every
+                    // other already-supplied input; `true` still asks for the
+                    // name/command, since those were not supplied either.
+                    const addCustom = customScriptsArg !== undefined
+                        ? customScriptsArg
+                        : includeDefaultScripts
+                            ? await askYesNo(rl, '  Add a custom script? [y/N]: ', false, ctx.signal)
+                            : false;
                     if (addCustom) {
                         const name = await askString(rl, '  Script name: ', '', ctx.signal);
                         const cmd = await askString(rl, '  Command: ', '', ctx.signal);
@@ -152,6 +334,21 @@ export const initHandler = {
                         }
                     }
                 }
+                // #3050: offer direct worker dispatch inside the same wizard — but
+                // `--dry-run` must never prompt or write anything from the offer
+                // (review item 1), so it degrades to the hint instead. An explicit
+                // `--worker-dispatch` argument (#3062) always answers the question
+                // directly instead of asking or hinting, still subject to `--dry-run`
+                // writing nothing.
+                if (workerDispatchArg) {
+                    workerDispatchDecision = resolveWorkerDispatchDecisionForNewConfig(workerDispatchArg, ctx.dryRun);
+                }
+                else if (ctx.dryRun) {
+                    renderWorkerDispatchHintIfApplicable(undefined, undefined);
+                }
+                else {
+                    workerDispatchDecision = await askWorkerDispatchOffer(rl, undefined, undefined, ctx.signal);
+                }
             }
             finally {
                 rl.close();
@@ -160,6 +357,24 @@ export const initHandler = {
         // Build config
         let config = emptyConfig(providers);
         config.scripts = scripts;
+        if (workerDispatchDecision?.kind === 'enable') {
+            config.parallelism = { ...config.parallelism, worker_dispatch: true };
+        }
+        else if (workerDispatchDecision?.kind === 'decline') {
+            config.setup = { ...config.setup, worker_dispatch_offer: 'declined' };
+        }
+        // #3062 review item 18: `--dry-run` writes nothing at all — not even
+        // the baseline config — rather than only skipping the worker-dispatch
+        // increment. Report what would be written instead.
+        if (ctx.dryRun) {
+            ui.blank();
+            ui.dim(`  Would create ${getConfigPath(projectDir)} (--dry-run writes nothing).`);
+            ui.dim(`  Providers: ${providers.join(', ')}`);
+            if (Object.keys(scripts).length > 0)
+                ui.dim(`  Scripts: ${Object.keys(scripts).join(', ')}`);
+            ui.blank();
+            return { exitCode: 0 };
+        }
         // Populate deployedTo from disk for entries with empty deployedTo (#721)
         config = await populateDeployedTo(config, projectDir);
         // Write

package/dist/src/cli/handlers/mc.js

@@ -15,6 +15,7 @@ import * as ui from '../ui.js';
 import { promises as fs } from 'node:fs';
 import { join } from 'node:path';
 import { createHash, randomBytes } from 'node:crypto';
+import { assertMissionWorkerHandoff } from '../../mission-protocol/codecs.js';
 // ── Constants ────────────────────────────────────────────────
 const MC_ROOT = '.aiwg/ralph-external/mc';
 const SESSIONS_DIR = join(MC_ROOT, 'sessions');
@@ -378,6 +379,18 @@ async function mcDispatch(ctx) {
         ui.error(sessionId ? `Session not found: ${sessionId}` : 'No active session. Run `aiwg mc start` first.');
         return { exitCode: 1 };
     }
+    // mission-dispatch accepts only the frozen objective envelope. Worker
+    // bindings can arrive through its existing session, so inspect that payload.
+    try {
+        assertMissionWorkerHandoff(selected, 'mc-cli');
+        for (const mission of selected.missions)
+            assertMissionWorkerHandoff(mission, 'mc-cli');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ui.error(message);
+        return { exitCode: 1, message };
+    }
     // #1361: Check project-level parallelism cap. Active missions = running or
     // queued; if at cap, warn but still queue (FIFO behavior — the mission goes
     // into the session as 'queued' and will run when a slot frees up).
@@ -560,6 +573,16 @@ async function mcRun(ctx) {
         return { exitCode: 1 };
     }
     const queued = session.missions.filter((m) => m.status === 'queued');
+    try {
+        assertMissionWorkerHandoff(session, 'mc-cli');
+        for (const mission of queued)
+            assertMissionWorkerHandoff(mission, 'mc-cli');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ui.error(message);
+        return { exitCode: 1, message };
+    }
     if (queued.length === 0) {
         ui.info(`No queued missions in session ${session.id}. Run \`aiwg mc dispatch ${session.id} "<objective>"\` to add one.`);
         return { exitCode: 0 };

package/dist/src/cli/handlers/models.js

@@ -7,13 +7,63 @@ import os from 'node:os';
 import path from 'node:path';
 import { glob } from 'glob';
 import { load as loadYaml } from 'js-yaml';
-import { compileModelPolicy, validateCanonicalModelPolicy, validateUserProjectModelConfig, } from '../../models/provider-policy.js';
+import { compileModelPolicy, validateCanonicalModelPolicy, validateUserProjectModelConfig, loadProviderModelCapabilities, WorkerPolicyError, } from '../../models/provider-policy.js';
 import { resolveGrokBuildRoleModel } from '../../models/grok-build-models.js';
+import { readAiwgConfig, emptyConfig } from '../../config/aiwg-config.js';
+import { ConfigLoader } from '../../models/config-loader.js';
+import { loadRecordedWorkerInstallations } from '../../models/worker-installation.mjs';
+import { parseWorkerCommandArgs, resolveWorkerInvocation, workerInvocationDiagnostic } from '../../serve/worker-invocation.js';
+/**
+ * #2892: exported so the MCP worker-invoke bridge can resolve a direct worker
+ * plan in-process (same snapshot/driver construction as `aiwg models resolve`),
+ * without shelling out to the CLI. No new loader is introduced; this is the
+ * CLI's own existing default `ModelsWorkerServices.load`.
+ */
+export async function loadWorkerInputs(ctx) {
+    const config = await readAiwgConfig(ctx.cwd) ?? emptyConfig();
+    const loader = new ConfigLoader(ctx.cwd);
+    const models = await loader.load(config.parallelism);
+    const catalog = await effectiveCatalog(ctx, ctx.cwd, false, parseArgs(['resolve']));
+    const registry = loadProviderModelCapabilities();
+    // Let the resolver explain the dispatch gate before requiring host qualification (#3070).
+    if (!config.parallelism?.worker_dispatch) {
+        return { snapshot: { config, models, modelDigests: loader.getInputDigests(), catalog,
+                registry, installations: {} }, drivers: {} };
+    }
+    const { registry: qualifiedRegistry, installations, drivers } = await loadRecordedWorkerInstallations({
+        registry, cwd: ctx.cwd, policy: models.defaults.workerSelection,
+    });
+    return { snapshot: { config, models, modelDigests: loader.getInputDigests(), catalog,
+            registry: qualifiedRegistry, installations }, drivers };
+}
+async function resolveDirect(ctx, services) {
+    let shell = false;
+    try {
+        const request = parseWorkerCommandArgs(ctx.args.slice(1));
+        shell = request.format === 'shell';
+        const { snapshot, drivers } = await services.load(ctx);
+        const plan = await resolveWorkerInvocation(snapshot, request, drivers, services.now?.());
+        const runnable = plan.invocation?.readiness === 'launchable';
+        if (shell && !runnable)
+            console.error(JSON.stringify({ status: 'blocked', diagnostics: plan.diagnostics }, null, 2));
+        else if (shell && plan.invocation?.transport === 'shell')
+            print(plan.invocation.shellCommand, false);
+        else
+            print(plan, true);
+        return { exitCode: runnable ? 0 : 2 };
+    }
+    catch (error) {
+        const diagnostic = { status: 'blocked', diagnostics: [workerInvocationDiagnostic(error, error instanceof WorkerPolicyError
+                    && error.code === 'OG_ADAPTER_UNQUALIFIED' ? '/parallelism/clis' : '/request')] };
+        if (shell)
+            console.error(JSON.stringify(diagnostic, null, 2));
+        else
+            print(diagnostic, true);
+        return { exitCode: 2 };
+    }
+}
 const TIERS = new Set(['economy', 'standard', 'premium', 'max-quality']);
-const PROVIDERS = new Set([
-    'antigravity', 'claude', 'codex', 'copilot', 'cursor', 'deepseek-harness', 'factory', 'grok-build', 'grokbot', 'hermes',
-    'opencode', 'openclaw', 'openhuman', 'omp', 'pi', 'warp', 'windsurf',
-]);
+const PROVIDERS = new Set(Object.keys(loadProviderModelCapabilities().providers));
 function parseArgs(args) {
     const [subcommand = 'help', ...rest] = args;
     const flags = new Map();
@@ -222,8 +272,18 @@ function replaceFrontmatter(raw, item, tier) {
     }
     return `---\n${frontmatter}\n---\n${match[2]}`;
 }
-async function execute(ctx) {
+async function execute(ctx, services = { load: loadWorkerInputs }) {
+    // Preserve artifact/native resolve when direct-only flags are absent.
+    if (ctx.args[0] === 'resolve' && ctx.args.slice(1).some(arg => /^--(?:task|group|brief|workdir|final-output|transport|format)(?:=|$)/.test(arg))) {
+        return resolveDirect(ctx, services);
+    }
     const parsed = parseArgs(ctx.args);
+    if (parsed.subcommand === 'resolve') {
+        const supported = new Set(['agent', 'skill', 'glob', 'role', 'tier', 'framework', 'all', 'target', 'provider', 'model', 'json', 'help', 'dry-run']);
+        for (const key of parsed.flags.keys())
+            if (!supported.has(key))
+                return { exitCode: 2, message: `Unsupported models resolve flag: --${key}` };
+    }
     const json = parsed.flags.has('json');
     const dryRun = parsed.flags.has('dry-run') || ctx.dryRun === true;
     const target = path.resolve(flagString(parsed, 'target') ?? ctx.cwd);
@@ -380,4 +440,7 @@ export const modelsHandler = {
     aliases: [],
     execute,
 };
+export function createModelsHandler(services) {
+    return { ...modelsHandler, execute: ctx => execute(ctx, services) };
+}
 //# sourceMappingURL=models.js.map

package/dist/src/cli/handlers/ralph.js

@@ -336,6 +336,9 @@ export class RalphStatusHandler {
     category = 'ralph';
     aliases = ['agent-loop-status', 'ralph-status'];
     async execute(ctx) {
+        if (ctx.args.includes('--workers')) {
+            return createScriptRunner(ctx.frameworkRoot).run('tools/ralph-external/index.mjs', ['--status', ...ctx.args]);
+        }
         const showAll = ctx.args.includes('--all') || ctx.args.includes('-a');
         const statuses = getLoopStatuses(process.cwd());
         if (statuses.length === 0) {

package/dist/src/cli/handlers/refresh.js

@@ -24,6 +24,7 @@ import { refreshAllPackages } from '../../packages/registry.js';
 import { resolveActiveProvider } from '../provider-resolution.js';
 import { readAiwgConfig, writeAiwgConfig, hashManifest, getProviderParallelismDefaults, } from '../../config/aiwg-config.js';
 import { discoverProjectLocalBundles } from '../../extensions/project-local-discovery.js';
+import { detectInstalledWorkerClis, evaluateWorkerDispatchOffer, workerDispatchOfferHint } from '../../models/worker-dispatch-offer.js';
 import { getProviderArtifactPathStrings } from '../../providers/provider-definitions.js';
 import { collectPackagedAgentInventory, normalizeAgentArtifactName, parseManagedArtifactMarker, } from '../../agents/packaged-agent-inventory.js';
 import * as ui from '../ui.js';
@@ -786,6 +787,21 @@ export const refreshHandler = {
                 // Non-fatal — refresh continues even if migration fails
             }
         }
+        // Step 4.65: Direct worker dispatch opt-in hint (#3050). Refresh never
+        // prompts; this only names the enable command when dispatch is off and
+        // two or more worker CLIs are detected (presence-only PATH scan, no
+        // spawn). Silent otherwise, including after a previous decline.
+        if (!quiet) {
+            try {
+                const config = await readAiwgConfig(process.cwd());
+                const offer = evaluateWorkerDispatchOffer(config?.parallelism, config?.setup, detectInstalledWorkerClis());
+                if (offer.shouldOffer)
+                    ui.info(workerDispatchOfferHint(offer.detected));
+            }
+            catch {
+                // Non-fatal — refresh continues even if the hint check fails
+            }
+        }
         // Step 5: Health check
         if (!quiet)
             ui.info(dryRun ? 'Would run health check...' : 'Running health check...');

package/dist/src/cli/handlers/regenerate.js

@@ -150,6 +150,20 @@ async function handleRegenerate(args, cwd) {
     console.log(`  Selected: ${selection.explicit ? 'explicit' : 'inferred'} — ${selection.reason}`);
     if (selection.evidence.length > 0)
         console.log(`  Evidence: ${selection.evidence.join(', ')}`);
+    // #3050: regenerate never prompts. Point at direct worker dispatch when
+    // it is off and two or more worker CLIs are detected (presence-only PATH
+    // scan, no spawn); silent otherwise, including after a decline.
+    try {
+        const { readAiwgConfig } = await import('../../config/aiwg-config.js');
+        const { detectInstalledWorkerClis, evaluateWorkerDispatchOffer, workerDispatchOfferHint } = await import('../../models/worker-dispatch-offer.js');
+        const dispatchConfig = await readAiwgConfig(target);
+        const offer = evaluateWorkerDispatchOffer(dispatchConfig?.parallelism, dispatchConfig?.setup, detectInstalledWorkerClis());
+        if (offer.shouldOffer)
+            console.log(`  ${workerDispatchOfferHint(offer.detected)}`);
+    }
+    catch {
+        // Non-fatal — this is an informational nudge, never a regenerate gate.
+    }
     if (existingProject) {
         const preflight = await migrateWorkspaceContext(target, {
             dryRun: true,

package/dist/src/cli/handlers/runtime-info.js

@@ -12,6 +12,7 @@ import path from 'path';
 import { AiwgError, EXIT_CODES, handlerResultFromError } from '../errors.js';
 import { getPackageRoot } from '../../channel/manager.mjs';
 import { inspectInstallation } from '../../installation/manager.mjs';
+import { isSessionProviderResolution, resolveActiveProvider } from '../provider-resolution.js';
 function isMissingRuntimeCatalogError(error) {
     return error instanceof Error && error.message.includes('No catalog found');
 }
@@ -304,21 +305,35 @@ async function handleRuntimeInfo(args, cwd = process.cwd()) {
             console.log(`  Run mode:  ${installation.identity?.runMode ?? '(unrecorded)'}`);
             console.log(`  State:     ${installation.state}`);
             // Scheduler backend detection
-            const { execSync } = await import('child_process');
+            const { boundedExecFileSync } = await import('../../process/bounded-child-process.mjs');
             let schedulerBackend = 'external trigger required (system cron/systemd/CI)';
             let chronyInstalled = false;
-            try {
-                execSync('which chronyc 2>/dev/null || which chronyd 2>/dev/null', { stdio: 'pipe' });
-                chronyInstalled = true;
-            }
-            catch {
-                // chrony not found
+            for (const tool of ['chronyc', 'chronyd']) {
+                try {
+                    boundedExecFileSync('which', [tool], 'quick', { stdio: ['pipe', 'pipe', 'ignore'] });
+                    chronyInstalled = true;
+                    break;
+                }
+                catch {
+                    // Try the next chrony binary.
+                }
             }
             // Native CronCreate is only available when running inside a Claude Code agent context.
             // The CLI itself cannot call agent tools, so we report based on platform heuristics.
             // When invoked from within an agent, the schedule skill performs live detection.
-            const isClaudeCodeContext = process.env.CLAUDE_CODE_VERSION !== undefined ||
-                process.env.ANTHROPIC_API_KEY !== undefined;
+            //
+            // Resolved through the same shared provider-resolution path `steward
+            // capabilities` uses (`resolveActiveProvider` -> the `claude` provider's
+            // `detection.env` markers in provider-definitions.ts) so the two never
+            // disagree about which provider the current session is running under
+            // (#2623, #2627). The ad-hoc `CLAUDE_CODE_VERSION`/`ANTHROPIC_API_KEY`
+            // check this replaced was stale (neither is set by current Claude Code)
+            // and `ANTHROPIC_API_KEY` was a false positive for any non-Claude
+            // session with that key set.
+            const activeProviderResolution = await resolveActiveProvider({ cwd });
+            // Only a session signal counts: a project merely configured or deployed
+            // for Claude is not a Claude Code agent context.
+            const isClaudeCodeContext = activeProviderResolution.provider === 'claude' && isSessionProviderResolution(activeProviderResolution);
             if (isClaudeCodeContext) {
                 schedulerBackend = 'native-cron (CronCreate); external trigger outside agent sessions';
             }