@aiwg/cli 2026.9.5 → 2026.9.7

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

@@ -10,6 +10,7 @@
 import * as ui from '../ui.js';
 import { maybePrintCommunityFooter } from '../../community/footer.js';
 import { listProviderDefinitions } from '../../providers/provider-definitions.js';
+import { getCommandIds } from '../../extensions/commands/definitions.js';
 /**
  * Help command handler
  */
@@ -19,7 +20,12 @@ export const helpHandler = {
     description: 'Show CLI help message',
     category: 'maintenance',
     aliases: ['-h', '-help', '--help'],
-    async execute(_ctx) {
+    async execute(ctx) {
+        if (ctx.args.includes('--json')) {
+            // Canonical IDs only: aliases and example prose are not registry entries.
+            console.log(JSON.stringify({ schema: 'aiwg.command-registry.v1', commandIds: getCommandIds() }));
+            return { exitCode: 0 };
+        }
         displayHelp();
         return { exitCode: 0 };
     },

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

@@ -20,6 +20,10 @@ function display(status, json) {
     console.log(`Release channel:   ${status.identity?.channel ?? '(unrecorded)'}`);
     console.log(`Actual method:     ${status.actualMethod}`);
     console.log(`Actual root:       ${status.actualRoot}`);
+    console.log(`Framework root:    ${status.frameworkRoot}`);
+    if (status.launcher) {
+        console.log(`Launcher:          ${status.launcher.method} at ${status.launcher.root} (edge redirect — expected)`);
+    }
     if (status.drift.length > 0) {
         console.log('Drift:');
         for (const item of status.drift)

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

@@ -169,12 +169,15 @@ function hasFlag(args, flag) {
  * dispatch missions with no ceiling while the operator believed one applied
  * (#1770).
  */
-function parseNumberFlag(args, flag, invalidSink) {
-    const raw = parseFlag(args, flag);
-    if (raw === undefined)
+function parseNumberFlag(args, flag, invalidSink, integer = false) {
+    if (!args.some(arg => arg === flag || arg.startsWith(`${flag}=`)))
         return undefined;
-    const value = Number(raw);
-    if (!Number.isFinite(value) || value <= 0) {
+    const raw = parseFlag(args, flag);
+    // Presence and validity are distinct: a trailing flag must not silently
+    // disappear, and counter limits must not accept fractional/unsafe values.
+    const decimal = typeof raw === 'string' && /^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(raw);
+    const value = decimal ? Number(raw) : NaN;
+    if (!Number.isFinite(value) || value <= 0 || (integer && !Number.isSafeInteger(value))) {
         invalidSink?.push(`${flag} (got '${raw}')`);
         return undefined;
     }
@@ -330,23 +333,13 @@ async function mcDispatch(ctx) {
     const completion = parseFlag(ctx.args, '--completion');
     const priority = parseFlag(ctx.args, '--priority') || 'normal';
     const invalidFlags = [];
-    const maxIterationsRaw = parseFlag(ctx.args, '--max-iterations');
-    let maxIterations = 10;
-    if (maxIterationsRaw !== undefined) {
-        const parsedIterations = parseInt(maxIterationsRaw, 10);
-        if (!Number.isFinite(parsedIterations) || parsedIterations <= 0) {
-            invalidFlags.push(`--max-iterations (got '${maxIterationsRaw}')`);
-        }
-        else {
-            maxIterations = parsedIterations;
-        }
-    }
-    const maxTotalTokens = parseNumberFlag(ctx.args, '--max-total-tokens', invalidFlags);
-    const maxOutputTokens = parseNumberFlag(ctx.args, '--max-output-tokens', invalidFlags);
-    const maxToolCalls = parseNumberFlag(ctx.args, '--max-tool-calls', invalidFlags);
+    const maxIterations = parseNumberFlag(ctx.args, '--max-iterations', invalidFlags, true) ?? 10;
+    const maxTotalTokens = parseNumberFlag(ctx.args, '--max-total-tokens', invalidFlags, true);
+    const maxOutputTokens = parseNumberFlag(ctx.args, '--max-output-tokens', invalidFlags, true);
+    const maxToolCalls = parseNumberFlag(ctx.args, '--max-tool-calls', invalidFlags, true);
     const maxTotalCost = parseNumberFlag(ctx.args, '--max-total-cost', invalidFlags);
     const maxWallClockMinutes = parseNumberFlag(ctx.args, '--max-wall-clock-minutes', invalidFlags);
-    const explorationQuota = parseNumberFlag(ctx.args, '--exploration-quota', invalidFlags);
+    const explorationQuota = parseNumberFlag(ctx.args, '--exploration-quota', invalidFlags, true);
     const budgetStopPolicyRaw = parseFlag(ctx.args, '--budget-stop-policy');
     let budgetStopPolicy;
     if (budgetStopPolicyRaw !== undefined) {

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

@@ -13,6 +13,13 @@
 import { createScriptRunner } from './script-runner.js';
 import { launchExternalRalph, getLoopStatuses, abortLoop, resumeLoop, attachToLoopOutput, } from './ralph-launcher.js';
 import { handlerResultFromError } from '../errors.js';
+/** Parse a complete positive decimal value without truncating counter limits. */
+function parsePositiveLimit(raw, integer = false) {
+    if (typeof raw !== 'string' || !/^[+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(raw))
+        return undefined;
+    const value = Number(raw);
+    return Number.isFinite(value) && value > 0 && (!integer || Number.isSafeInteger(value)) ? value : undefined;
+}
 /**
  * Parse Ralph command arguments
  */
@@ -22,8 +29,8 @@ function parseRalphArgs(args) {
     // Present-but-invalid numeric values are a hard usage error: an operator who
     // typed --max-total-cost expects a ceiling to exist (#1770).
     const positiveNumber = (flag, raw, integer = false) => {
-        const value = integer ? parseInt(raw ?? '', 10) : parseFloat(raw ?? '');
-        if (!Number.isFinite(value) || value <= 0) {
+        const value = parsePositiveLimit(raw, integer);
+        if (value === undefined) {
             result.invalidFlags.push(`${flag} (got '${raw ?? ''}')`);
             return undefined;
         }
@@ -431,8 +438,11 @@ export class RalphResumeHandler {
             if (arg === '--loop-id' && ctx.args[i + 1]) {
                 loopId = ctx.args[++i];
             }
-            else if (arg === '--max-iterations' && ctx.args[i + 1]) {
-                maxIterations = parseInt(ctx.args[++i], 10);
+            else if (arg === '--max-iterations') {
+                maxIterations = parsePositiveLimit(ctx.args[++i], true);
+                if (maxIterations === undefined) {
+                    return { exitCode: 1, message: 'Error: --max-iterations requires a positive safe integer. Loop not resumed.' };
+                }
             }
         }
         try {

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

@@ -13,7 +13,10 @@
  * @issue #173, #174, #482, #557, #694
  */
 import { promises as fs } from 'fs';
+import { execFile } from 'node:child_process';
 import path from 'path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
 import { createScriptRunner } from './script-runner.js';
 import { createUseHandler } from './use.js';
 import { getFrameworkRoot } from '../../channel/manager.mjs';
@@ -21,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 { getProviderArtifactPathStrings } from '../../providers/provider-definitions.js';
 import { collectPackagedAgentInventory, normalizeAgentArtifactName, parseManagedArtifactMarker, } from '../../agents/packaged-agent-inventory.js';
 import * as ui from '../ui.js';
 const PROVIDER_AGENT_DIRS = {
@@ -69,12 +73,33 @@ function isOlderManagedVersion(deployedVersion, currentVersion) {
         return true;
     return deployed.prerelease.localeCompare(current.prerelease, undefined, { numeric: true }) < 0;
 }
-export async function pruneStaleManagedAgentFiles(options) {
-    const desired = await currentBundledAgentBasenames(options.frameworkRoot);
-    const currentVersion = options.currentVersion ?? await readFrameworkVersion(options.frameworkRoot);
-    const removals = [];
-    for (const [provider, relDir] of Object.entries(PROVIDER_AGENT_DIRS)) {
-        const dir = path.join(options.projectRoot, relDir);
+const PRUNABLE_ARTIFACT_KINDS = ['agents', 'commands', 'rules'];
+/**
+ * Resolve the on-disk artifact directories for a provider.
+ *
+ * `PROVIDER_AGENT_DIRS` remains the enumeration of providers AIWG can prune;
+ * the command/rule directories come from the provider definitions so the
+ * unit-prune path never drifts from what `aiwg use` actually wrote.
+ */
+function providerArtifactDirs(provider) {
+    const agents = PROVIDER_AGENT_DIRS[provider] ?? null;
+    const declared = getProviderArtifactPathStrings(provider);
+    const usable = (value) => typeof value === 'string' && value.length > 0 && !path.isAbsolute(value) ? value : null;
+    return {
+        agents,
+        commands: usable(declared?.commands),
+        rules: usable(declared?.rules),
+    };
+}
+/** Collect every AIWG-managed (`source: bundled`) artifact in one provider tree. */
+async function collectManagedProviderArtifacts(projectRoot, provider, kinds) {
+    const dirs = providerArtifactDirs(provider);
+    const hits = [];
+    for (const kind of kinds) {
+        const relDir = dirs[kind];
+        if (!relDir)
+            continue;
+        const dir = path.join(projectRoot, relDir);
         let entries;
         try {
             entries = await fs.readdir(dir, { withFileTypes: true });
@@ -85,6 +110,9 @@ export async function pruneStaleManagedAgentFiles(options) {
         for (const entry of entries) {
             if (!entry.isFile() || !entry.name.endsWith('.md'))
                 continue;
+            // Generated indexes are rewritten on every deploy, never orphaned.
+            if (entry.name === 'RULES-INDEX.md' || entry.name === 'RULES-ONDEMAND.md')
+                continue;
             const file = path.join(dir, entry.name);
             let content;
             try {
@@ -96,32 +124,192 @@ export async function pruneStaleManagedAgentFiles(options) {
             const marker = parseManagedArtifactMarker(content);
             if (marker?.source !== 'bundled')
                 continue;
-            const artifactName = normalizeAgentArtifactName(entry.name);
-            const missingFromCurrentPackage = !desired.has(artifactName);
-            // Addons have independent manifest versions. Comparing their managed
-            // marker to the top-level package version makes a successful refresh
-            // delete freshly restored addon agents. Version-based cleanup remains
-            // valid for other provider trees that were not refreshed, while the
-            // active provider removes only artifacts absent from current sources.
-            const fromOlderPackage = provider !== options.provider
-                && currentVersion !== null
-                && isOlderManagedVersion(marker.version, currentVersion);
-            if (!missingFromCurrentPackage && !fromOlderPackage)
+            hits.push({
+                kind,
+                absolutePath: file,
+                relativePath: path.relative(projectRoot, file),
+                version: marker.version,
+                artifactName: normalizeAgentArtifactName(entry.name),
+            });
+        }
+    }
+    return hits;
+}
+export async function detectStaleProviderTrees(options) {
+    const currentVersion = options.currentVersion ?? await readFrameworkVersion(options.frameworkRoot);
+    if (currentVersion === null)
+        return [];
+    const trees = [];
+    for (const provider of Object.keys(PROVIDER_AGENT_DIRS)) {
+        if (provider === options.provider)
+            continue;
+        const hits = (await collectManagedProviderArtifacts(options.projectRoot, provider, PRUNABLE_ARTIFACT_KINDS))
+            .filter((hit) => isOlderManagedVersion(hit.version, currentVersion));
+        if (hits.length === 0)
+            continue;
+        const counts = { agents: 0, commands: 0, rules: 0 };
+        for (const hit of hits)
+            counts[hit.kind] += 1;
+        const oldest = hits
+            .map((hit) => hit.version)
+            .reduce((a, b) => (isOlderManagedVersion(a, b) ? a : b));
+        trees.push({ provider, version: oldest, counts, total: hits.length });
+    }
+    trees.sort((a, b) => a.provider.localeCompare(b.provider));
+    return trees;
+}
+/**
+ * Split project-relative paths into the ones git tracks and the ones it does not (#2509).
+ *
+ * Deleting an ignored, regenerable artifact and deleting a committed file are
+ * not the same act. A project that is not a git repo — or a machine without
+ * git — reports everything as untracked, so the caller behaves as before.
+ */
+export async function partitionTrackedPaths(projectRoot, relativePaths) {
+    if (relativePaths.length === 0)
+        return { tracked: [], untracked: [] };
+    let trackedSet;
+    try {
+        const { stdout } = await execFileAsync('git', ['ls-files', '-z', '--', ...relativePaths], { cwd: projectRoot, maxBuffer: 32 * 1024 * 1024 });
+        trackedSet = new Set(stdout.split('\0').filter(Boolean));
+    }
+    catch {
+        return { tracked: [], untracked: [...relativePaths] };
+    }
+    const tracked = [];
+    const untracked = [];
+    for (const relativePath of relativePaths) {
+        // git reports POSIX separators regardless of platform.
+        (trackedSet.has(relativePath.split(path.sep).join('/')) ? tracked : untracked).push(relativePath);
+    }
+    return { tracked, untracked };
+}
+export async function pruneStaleManagedAgentFiles(options) {
+    const desired = await currentBundledAgentBasenames(options.frameworkRoot);
+    const currentVersion = options.currentVersion ?? await readFrameworkVersion(options.frameworkRoot);
+    const crossProvider = options.crossProvider ?? 'skip';
+    const removals = [];
+    const trackedSkipped = [];
+    const record = (list, provider, relativePath) => {
+        let entry = list.find((item) => item.provider === provider);
+        if (!entry) {
+            entry = { provider, paths: [] };
+            list.push(entry);
+        }
+        entry.paths.push(relativePath);
+    };
+    for (const provider of Object.keys(PROVIDER_AGENT_DIRS)) {
+        const isTargetProvider = provider === options.provider;
+        // Non-target trees are pruned as a unit or not at all; the refreshed
+        // provider only drops agents whose source no longer ships them.
+        if (!isTargetProvider && crossProvider === 'skip')
+            continue;
+        const kinds = isTargetProvider ? ['agents'] : PRUNABLE_ARTIFACT_KINDS;
+        const hits = await collectManagedProviderArtifacts(options.projectRoot, provider, kinds);
+        const eligible = hits.filter((hit) => {
+            if (isTargetProvider) {
+                // Addons have independent manifest versions. Comparing their managed
+                // marker to the top-level package version makes a successful refresh
+                // delete freshly restored addon agents, so the active provider removes
+                // only artifacts absent from current sources.
+                return !desired.has(hit.artifactName);
+            }
+            return currentVersion !== null && isOlderManagedVersion(hit.version, currentVersion);
+        });
+        if (eligible.length === 0)
+            continue;
+        // Only the cross-provider unit prune defers to VCS state.
+        let protectedPaths = new Set();
+        if (!isTargetProvider && !options.allowTrackedDeletes) {
+            const { tracked } = await partitionTrackedPaths(options.projectRoot, eligible.map((hit) => hit.relativePath));
+            protectedPaths = new Set(tracked);
+        }
+        for (const hit of eligible) {
+            if (protectedPaths.has(hit.relativePath)) {
+                record(trackedSkipped, provider, hit.relativePath);
                 continue;
-            const relFile = path.relative(options.projectRoot, file);
+            }
             if (!options.dryRun)
-                await fs.rm(file, { force: true });
-            let providerRemoval = removals.find((item) => item.provider === provider);
-            if (!providerRemoval) {
-                providerRemoval = { provider, paths: [] };
-                removals.push(providerRemoval);
+                await fs.rm(hit.absolutePath, { force: true });
+            record(removals, provider, hit.relativePath);
+        }
+    }
+    for (const list of [removals, trackedSkipped]) {
+        for (const entry of list)
+            entry.paths.sort((a, b) => a.localeCompare(b));
+    }
+    return { removals, trackedSkipped };
+}
+/**
+ * Reconcile `installed.deployedTo` with the artifacts a prune pass left behind (#2506).
+ *
+ * Recorded counts are written by `aiwg use` before the prune runs, so a run
+ * that deletes artifacts otherwise leaves the config permanently claiming
+ * files that are gone. Two cases:
+ *
+ *  - **Unit-pruned provider tree** (a non-refreshed provider removed wholesale):
+ *    every managed agent/command/rule for that provider is gone, so those
+ *    counts drop to zero across all installed bundles. Skills are not part of
+ *    the prune pass and keep their recorded values.
+ *  - **Refreshed provider** (agent orphans only): subtract the removed count
+ *    from the recorded agent totals, largest contributor first, clamped at 0.
+ */
+async function reconcileDeployedToAfterPrune(projectRoot, removals, refreshedProvider) {
+    if (removals.length === 0)
+        return;
+    const config = await readAiwgConfig(projectRoot);
+    if (!config)
+        return;
+    let changed = false;
+    for (const removal of removals) {
+        const unitPruned = removal.provider !== refreshedProvider;
+        const entries = Object.values(config.installed)
+            .filter((entry) => entry.deployedTo?.[removal.provider]);
+        if (entries.length === 0)
+            continue;
+        if (unitPruned) {
+            for (const entry of entries) {
+                const counts = entry.deployedTo[removal.provider];
+                if (counts.agents === 0 && counts.commands === 0 && counts.rules === 0)
+                    continue;
+                counts.agents = 0;
+                counts.commands = 0;
+                counts.rules = 0;
+                changed = true;
             }
-            providerRemoval.paths.push(relFile);
+            continue;
+        }
+        let outstanding = removal.paths.length;
+        const byAgentsDesc = entries
+            .slice()
+            .sort((a, b) => b.deployedTo[removal.provider].agents - a.deployedTo[removal.provider].agents);
+        for (const entry of byAgentsDesc) {
+            if (outstanding <= 0)
+                break;
+            const counts = entry.deployedTo[removal.provider];
+            const deduct = Math.min(counts.agents, outstanding);
+            if (deduct <= 0)
+                continue;
+            counts.agents -= deduct;
+            outstanding -= deduct;
+            changed = true;
         }
     }
-    for (const removal of removals)
-        removal.paths.sort((a, b) => a.localeCompare(b));
-    return removals;
+    if (changed)
+        await writeAiwgConfig(projectRoot, config);
+}
+/**
+ * Whether this run may delete git-tracked artifacts during a cross-provider
+ * prune (#2514).
+ *
+ * Deliberately not derived from `--force`. `--force` governs what gets
+ * *written* — it replaces artifacts AIWG does not currently manage. Deleting
+ * files someone committed, in a provider tree this run was not asked to touch,
+ * is a different decision and gets its own switch, so habitual `--force` use
+ * can never authorise it.
+ */
+export function allowsTrackedDeletes(args) {
+    return args.includes('--prune-tracked');
 }
 /**
  * Parse --flag value pairs from args
@@ -161,6 +349,17 @@ Options:
   --skip-update             Skip the installation update
   --packages-only           Refresh remote packages only
   --provider <name>         Override provider auto-detection
+  --prune-other-providers   Remove stale AIWG-managed trees belonging to
+                            providers this run did not refresh. Off by default:
+                            a provider-scoped refresh never mutates another
+                            provider's deployed surface. Git-tracked files are
+                            always left in place unless --prune-tracked is given.
+  --prune-tracked           Allow --prune-other-providers to delete git-tracked
+                            files. Deleting committed files is a separate
+                            decision from --force, which only governs writes.
+  --force                   Re-write every deployed artifact, replacing files
+                            AIWG does not currently manage. Never authorises
+                            deleting tracked files.
   --channel <name>          Select the update channel (stable or main)
   --frameworks <list>       Re-deploy a comma-separated installed subset
   --model <name>            Override all deployed agent model tiers
@@ -192,6 +391,14 @@ export const refreshHandler = {
         const quiet = hasFlag(ctx.args, '--quiet');
         const skipUpdate = hasFlag(ctx.args, '--skip-update');
         const packagesOnly = hasFlag(ctx.args, '--packages-only');
+        // #2506: cross-provider pruning is opt-in. A provider-scoped refresh must
+        // not silently delete another provider's deployed surface.
+        const pruneOtherProviders = hasFlag(ctx.args, '--prune-other-providers');
+        const forceDeploy = hasFlag(ctx.args, '--force');
+        // #2514: deleting committed files in a tree this run was not asked to touch
+        // is its own decision, not a consequence of asking for a forceful re-write.
+        // `--force` governs what gets written; this governs what gets destroyed.
+        const pruneTracked = allowsTrackedDeletes(ctx.args);
         const provider = parseFlag(ctx.args, '--provider');
         const channel = parseFlag(ctx.args, '--channel');
         const frameworksArg = parseFlag(ctx.args, '--frameworks');
@@ -313,6 +520,9 @@ export const refreshHandler = {
                         '--target', ctx.cwd,
                         '--yes',
                         '--json',
+                        // #2507: give operators a reclaim path for artifacts an older
+                        // AIWG left behind without a managed marker.
+                        ...(forceDeploy ? ['--force'] : []),
                         ...modelDeployArgs,
                     ],
                     rawArgs: ['use', fw],
@@ -364,32 +574,83 @@ export const refreshHandler = {
         catch {
             // Non-fatal — refresh continues
         }
-        // Step 4.5: Stale deployment check (#621, #1460, #1799)
+        // Step 4.5: Stale deployment check (#621, #1460, #1799, #2506)
         if (!quiet)
             ui.info('Checking for stale deployments...');
+        // A modifier with nothing to modify is almost always a mistyped intent.
+        if (pruneTracked && !pruneOtherProviders && !quiet) {
+            ui.warn('--prune-tracked has no effect without --prune-other-providers; nothing was removed.');
+        }
         let staleAgentRemovals = [];
+        let trackedSkipped = [];
         if (!dryRun && deploymentFailures.length === 0) {
             try {
-                staleAgentRemovals = await pruneStaleManagedAgentFiles({
+                const pruneResult = await pruneStaleManagedAgentFiles({
                     projectRoot: ctx.cwd,
                     frameworkRoot,
                     provider: detectedProvider,
+                    crossProvider: pruneOtherProviders ? 'prune' : 'skip',
+                    allowTrackedDeletes: pruneTracked,
                 });
+                staleAgentRemovals = pruneResult.removals;
+                trackedSkipped = pruneResult.trackedSkipped;
+                if (trackedSkipped.length > 0 && !quiet) {
+                    const total = trackedSkipped.reduce((sum, item) => sum + item.paths.length, 0);
+                    ui.warn(`Left ${total} git-tracked AIWG-managed file${total === 1 ? '' : 's'} in place ` +
+                        `across ${trackedSkipped.length} provider${trackedSkipped.length === 1 ? '' : 's'}`);
+                    for (const skipped of trackedSkipped) {
+                        const shown = skipped.paths.slice(0, 3).join(', ');
+                        const remainder = skipped.paths.length - 3;
+                        ui.dim(`    ${skipped.provider}: ${skipped.paths.length} (${shown}${remainder > 0 ? `, ...and ${remainder} more` : ''})`);
+                    }
+                    ui.dim("    These are committed files. Add --prune-tracked to remove them as well.");
+                }
                 if (staleAgentRemovals.length > 0 && !quiet) {
                     const total = staleAgentRemovals.reduce((sum, item) => sum + item.paths.length, 0);
-                    ui.success(`Removed ${total} stale AIWG-managed agent file${total === 1 ? '' : 's'} ` +
+                    ui.warn(`Removed ${total} stale AIWG-managed file${total === 1 ? '' : 's'} ` +
                         `across ${staleAgentRemovals.length} provider${staleAgentRemovals.length === 1 ? '' : 's'}`);
                     for (const removal of staleAgentRemovals) {
                         const shown = removal.paths.slice(0, 3).join(', ');
                         const remainder = removal.paths.length - 3;
                         ui.dim(`    ${removal.provider}: ${removal.paths.length} (${shown}${remainder > 0 ? `, ...and ${remainder} more` : ''})`);
                     }
+                    ui.dim('    Review `git status` before committing — deployed artifacts may be tracked.');
                 }
+                // #2506: keep the recorded deployment state consistent with what the
+                // prune actually left on disk, so a later run does not trust counts
+                // for artifacts that no longer exist.
+                await reconcileDeployedToAfterPrune(ctx.cwd, staleAgentRemovals, pruneOtherProviders ? detectedProvider : null);
             }
             catch {
                 if (!quiet)
                     ui.dim('  Agent orphan cleanup skipped (non-critical)');
             }
+            // #2506: a provider-scoped refresh reports other providers' stale trees
+            // instead of mutating them. Silent cross-provider deletion destroyed
+            // git-tracked artifacts and left half-deployed surfaces behind.
+            if (!pruneOtherProviders) {
+                try {
+                    const staleTrees = await detectStaleProviderTrees({
+                        projectRoot: ctx.cwd,
+                        frameworkRoot,
+                        provider: detectedProvider,
+                    });
+                    for (const tree of staleTrees) {
+                        const breakdown = ['agents', 'commands', 'rules']
+                            .filter((kind) => tree.counts[kind] > 0)
+                            .map((kind) => `${tree.counts[kind]} ${kind}`)
+                            .join(', ');
+                        ui.warn(`Stale ${tree.provider} deployment: ${tree.total} AIWG-managed file(s) from v${tree.version} ` +
+                            `(${breakdown}) — this run refreshed ${detectedProvider ?? 'the active provider'} only`);
+                        ui.dim(`    Refresh it with 'aiwg refresh --provider ${tree.provider}', ` +
+                            `or remove it with 'aiwg refresh --prune-other-providers'`);
+                    }
+                }
+                catch {
+                    if (!quiet)
+                        ui.dim('  Stale provider tree check skipped (non-critical)');
+                }
+            }
             try {
                 const { getFrameworkRoot } = await import('../../channel/manager.mjs');
                 const { join } = await import('path');
@@ -420,6 +681,13 @@ export const refreshHandler = {
                             ui.warn(`Stale deployment: ${name} — run 'aiwg use ${name}' to redeploy`);
                         }
                     }
+                    else if (staleAgentRemovals.length > 0) {
+                        // #2506: a run that deleted artifacts is not an "up to date" run.
+                        const removed = staleAgentRemovals.reduce((sum, item) => sum + item.paths.length, 0);
+                        if (!quiet) {
+                            ui.warn(`Deployments current, but ${removed} stale artifact(s) were removed this run — review the list above`);
+                        }
+                    }
                     else {
                         if (!quiet)
                             ui.success('All deployments up to date');

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

@@ -298,6 +298,9 @@ async function handleRuntimeInfo(args, cwd = process.cwd()) {
             console.log(`\nAIWG Installation:`);
             console.log(`  Canonical: ${installation.identity?.method ?? 'unrecorded'} at ${installation.identity?.root ?? '(unrecorded)'}`);
             console.log(`  Actual:    ${installation.actualMethod} at ${installation.actualRoot}`);
+            if (installation.launcher) {
+                console.log(`  Launcher:  ${installation.launcher.method} at ${installation.launcher.root} (edge redirect)`);
+            }
             console.log(`  Run mode:  ${installation.identity?.runMode ?? '(unrecorded)'}`);
             console.log(`  State:     ${installation.state}`);
             // Scheduler backend detection

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

@@ -16,6 +16,8 @@ import { sandboxRegistry, normalizeSandboxEvent, } from '../../serve/sandbox-reg
 import { routeTask } from '../../serve/agent-router.js';
 import { routeDispatch } from '../../serve/dispatch-router.js';
 import { observeA2ATerminalState } from '../../serve/a2a-terminal-observer.js';
+import { respondToA2AMission } from '../../serve/mission-hitl.js';
+import { A2A_HITL_PROMPT_V1 } from '../../a2a/client.js';
 import { executorRegistry, validateRegisterPayload, validateDispatchPayload, validateEventEnvelope, } from '../../serve/executor-registry.js';
 import { handleWebhook, IdempotencyCache, PushSecretRegistry, } from '../../a2a/webhook.js';
 import { AiwgError, EXIT_CODES } from '../errors.js';
@@ -807,6 +809,7 @@ export async function startServer(opts) {
         const a2aProtocolPolicy = configuredA2AProtocolPolicy;
         try {
             const result = await routeDispatch(executor, payload, {
+                optionalExtensions: [A2A_HITL_PROMPT_V1],
                 a2aProtocolPolicy,
                 allowA2AProtocolFallback: configuredA2AProtocolFallback,
                 allowLegacyExecutorFallback: configuredLegacyExecutorFallback,
@@ -872,7 +875,14 @@ export async function startServer(opts) {
                 ...(a2aFallbackReason ? { fallbackReason: a2aFallbackReason } : {}),
             });
         }
-        executorRegistry.assignMission(missionId, executor.executorId);
+        const existingMission = executorRegistry.getMission(missionId);
+        // An idempotent replay must not discard in-flight/accepted approvals.
+        if (!(dispatchPath === 'v2' && a2aTask && a2aInstanceId
+            && existingMission?.executorId === executor.executorId
+            && existingMission.a2a?.taskId === a2aTask.id
+            && existingMission.a2a.instanceId === a2aInstanceId)) {
+            executorRegistry.assignMission(missionId, executor.executorId);
+        }
         if (dispatchPath === 'v2' && a2aTask && a2aInstanceId) {
             void observeA2ATerminalState(executorRegistry, executor, missionId, a2aInstanceId, a2aTask, {
                 onError: (err) => {
@@ -929,7 +939,7 @@ export async function startServer(opts) {
             error: mission.error,
         });
     });
-    // POST /api/v1/missions/:id/hitl_response → 200; forwards to owning executor over WS
+    // POST /api/v1/missions/:id/hitl_response → owning task's negotiated transport
     app.post('/api/v1/missions/:id/hitl_response', async (c) => {
         const missionId = c.req.param('id');
         const mission = executorRegistry.getMission(missionId);
@@ -944,9 +954,17 @@ export async function startServer(opts) {
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const payload = body;
-        if (!payload.hitl_id || !payload.response) {
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload)
+            || typeof payload.hitl_id !== 'string' || !payload.hitl_id || !Object.hasOwn(payload, 'response')) {
             return c.json({ error: 'hitl_id and response are required' }, 400);
         }
+        if (mission.a2a) {
+            const result = await respondToA2AMission(executorRegistry, missionId, payload.hitl_id, payload.response);
+            return c.json(result.body, result.status);
+        }
+        if (typeof payload.response !== 'string' || !payload.response) {
+            return c.json({ error: 'Legacy HITL response must be a non-empty string' }, 400);
+        }
         // Push hitl_responded event to the executor over WS
         const envelope = {
             event: 'mission.hitl_responded',