@aiwg/cli 2026.8.19 → 2026.8.25

package/dist/src/artifacts/types.js

@@ -195,6 +195,11 @@ export const BUILTIN_GRAPH_CONFIGS = {
  * @implements #426
  */
 export const GRAPH_CONFIGS = { ...BUILTIN_GRAPH_CONFIGS };
+let projectGraphBackend;
+/** Resolve backend precedence: graph override, project default, then JSON. */
+export function resolveGraphBackendType(graph) {
+    return (graph ? GRAPH_CONFIGS[graph]?.graphBackend : undefined) ?? projectGraphBackend ?? 'json';
+}
 function freshBuiltinGraphConfig(name) {
     const config = BUILTIN_GRAPH_CONFIGS[name];
     return {
@@ -459,6 +464,7 @@ export function loadUserGraphConfigs(cwd, diagnostics) {
     // Reset on every project load so a prior cwd cannot leak its override or
     // detected Python package roots into a later build in the same process.
     GRAPH_CONFIGS.codebase = detectPythonCodebaseConfig(cwd, freshBuiltinGraphConfig('codebase'));
+    projectGraphBackend = undefined;
     // Load module-declared graphs first (frameworks/addons)
     const moduleLoaded = loadModuleGraphConfigs(cwd, diagnostics);
     const loaded = [...moduleLoaded];
@@ -469,12 +475,16 @@ export function loadUserGraphConfigs(cwd, diagnostics) {
     let graphs;
     let graphOverrides;
     let fromDeprecatedYaml = false;
+    let canonicalIndexPresent = false;
     // (a) Canonical: .aiwg/aiwg.config (JSON).
     try {
         const aiwgConfigPath = projectControlPath(cwd, 'aiwg.config');
         if (fs.existsSync(aiwgConfigPath)) {
             const parsed = JSON.parse(fs.readFileSync(aiwgConfigPath, 'utf-8'));
             const idx = parsed.index;
+            canonicalIndexPresent = idx !== undefined;
+            if (idx?.graphBackend === 'json' || idx?.graphBackend === 'graphology' || idx?.graphBackend === 'sqlite')
+                projectGraphBackend = idx.graphBackend;
             const g = idx?.graphs;
             if (g && typeof g === 'object')
                 graphs = g;
@@ -493,12 +503,14 @@ export function loadUserGraphConfigs(cwd, diagnostics) {
         });
     }
     // (b) Fallback: legacy .aiwg/config.yaml.
-    if (!graphs && !graphOverrides) {
+    if (!canonicalIndexPresent && !graphs && !graphOverrides) {
         try {
             const configPath = projectAiwgPath(cwd, 'config.yaml');
             if (fs.existsSync(configPath)) {
                 const config = loadYaml(fs.readFileSync(configPath, 'utf-8'));
                 const idx = config?.index;
+                if (idx?.graphBackend === 'json' || idx?.graphBackend === 'graphology' || idx?.graphBackend === 'sqlite')
+                    projectGraphBackend = idx.graphBackend;
                 const g = idx?.graphs;
                 if (g && typeof g === 'object') {
                     graphs = g;

package/dist/src/cli/handlers/artifact-verify.js

@@ -102,6 +102,9 @@ export const artifactVerifyHandler = {
     description: 'Verify cross-asset DSSE provenance and manage trust roots',
     category: 'utility',
     aliases: [],
+    async help() {
+        return { exitCode: 0, message: usage() };
+    },
     async execute(ctx) {
         if (ctx.args.includes('--help') || ctx.args.includes('-h') || ctx.args.length === 0)
             return { exitCode: 0, message: usage() };

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

@@ -71,6 +71,8 @@ function displayHelp() {
         ['runtime-info', 'Show runtime environment summary'],
         ['runtime-info --discover', 'Full tool discovery and catalog generation'],
         ['runtime-info --check <tool>', 'Check specific tool availability'],
+        ['runtime-info --transports', 'Show configured transport capabilities separately from providers'],
+        ['uhp <operation> --profile <name>', 'Inspect or smoke-test an explicit experimental UHP endpoint profile'],
     ]);
     helpGroup('CATALOG', [
         ['catalog list', 'List all models in catalog'],

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

@@ -32,6 +32,7 @@ import { regenerateHandler, regenerateHandlers } from './regenerate.js';
 import { workspaceContextHandler, workspaceContextHandlers } from './workspace-context.js';
 import { artifactsHandler, artifactsHandlers } from './artifacts.js';
 import { mcHandler, mcHandlers } from './mc.js';
+import { missionHandlers } from './mission.js';
 import { sdlcAccelerateHandler } from './sdlc-accelerate.js';
 import { teamHandler, teamHandlers } from './team.js';
 import { installHandler } from './install.js';
@@ -64,6 +65,7 @@ import { evidenceHandler } from './evidence.js';
 import { artifactVerifyHandler } from './artifact-verify.js';
 import { outputModeHandler } from './output-mode.js';
 import { installationHandler } from './installation.js';
+import { uhpHandler } from './uhp.js';
 // Re-export individual handlers
 export { 
 // Maintenance
@@ -75,7 +77,7 @@ newBundleHandler, quickrefHandler, newProjectHandler, sessionHandler, sessionsHa
 // Workspace
 statusHandler, wizardHandler, migrateWorkspaceHandler, rollbackWorkspaceHandler, 
 // Subcommands
-mcpHandler, catalogHandler, modelsHandler, versionsHandler, indexHandler, artifactsHandler, corpusHandler, discoverHandler, showHandler, featuresHandler, skillsHandler, configHandler, opsHandler, storageHandler, activityLogHandler, commandLogHandler, skillUsageHandler, kbHandler, memoryHandler, reflectionsHandler, provenanceHandler, researchStoreHandler, researchQueryHandler, runtimeInfoHandler, agentcardHandler, 
+mcpHandler, catalogHandler, modelsHandler, versionsHandler, indexHandler, artifactsHandler, corpusHandler, discoverHandler, showHandler, featuresHandler, skillsHandler, configHandler, opsHandler, storageHandler, activityLogHandler, commandLogHandler, skillUsageHandler, kbHandler, memoryHandler, reflectionsHandler, provenanceHandler, researchStoreHandler, researchQueryHandler, runtimeInfoHandler, agentcardHandler, uhpHandler, 
 // Agentic Tools (RLM)
 chunkHandler, fanoutHandler, rlmPrepHandler, rlmSearchHandler, rlmStatusCliHandler, rlmCacheHandler, 
 // Utilities
@@ -111,7 +113,7 @@ repoAccessHandler,
 // Lint
 lintHandler, };
 // Re-export handler arrays
-export { workspaceHandlers, utilityHandlers, scaffoldingHandlers, ralphHandlers, subcommandHandlers, mcHandlers, teamHandlers, stewardHandlers, regenerateHandlers, workspaceContextHandlers, artifactsHandlers, daemonHandlers, sandboxHandlers, repoAccessHandlers, };
+export { workspaceHandlers, utilityHandlers, scaffoldingHandlers, ralphHandlers, subcommandHandlers, mcHandlers, missionHandlers, teamHandlers, stewardHandlers, regenerateHandlers, workspaceContextHandlers, artifactsHandlers, daemonHandlers, sandboxHandlers, repoAccessHandlers, };
 /**
  * All registered command handlers
  *
@@ -170,6 +172,7 @@ export const allHandlers = [
     skillsHandler,
     runtimeInfoHandler,
     agentcardHandler,
+    uhpHandler,
     // Utilities
     prefillCardsHandler,
     contributeStartHandler,
@@ -188,6 +191,7 @@ export const allHandlers = [
     ...ralphHandlers,
     // Mission Control
     ...mcHandlers,
+    ...missionHandlers,
     // Agent Teams
     ...teamHandlers,
     // Steward (capability awareness)

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

@@ -0,0 +1,27 @@
+const usage = `Usage: aiwg mission migrate [--dry-run] [--root <workspace>]
+       aiwg mission migrate --apply --target mission.aiwg.io/v1 [--id <id>]
+       aiwg mission migrate --verify <id> | --resume <id> | --rollback <id>
+
+Preview is the default. Apply is backup-first and requires an explicit target.`;
+export const missionHandler = {
+    id: 'mission',
+    name: 'Mission Protocol',
+    description: 'Preview, apply, verify, resume, or roll back Mission Protocol migrations',
+    category: 'orchestration',
+    aliases: [],
+    async execute(ctx) {
+        if (ctx.args[0] !== 'migrate' || ctx.args.includes('--help') || ctx.args.includes('-h')) {
+            return { exitCode: ctx.args[0] === 'migrate' ? 0 : 2, message: usage, rawOutput: true };
+        }
+        const { spawn } = await import('node:child_process');
+        const path = await import('node:path');
+        const script = path.join(ctx.frameworkRoot, 'tools/mission-protocol/migrate.mjs');
+        return await new Promise(resolve => {
+            const child = spawn(process.execPath, [script, ...ctx.args.slice(1), '--root', ctx.cwd], { stdio: 'inherit', signal: ctx.signal });
+            child.once('error', error => resolve({ exitCode: 1, error, message: error.message }));
+            child.once('exit', code => resolve({ exitCode: code ?? 1 }));
+        });
+    },
+};
+export const missionHandlers = [missionHandler];
+//# sourceMappingURL=mission.js.map

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

@@ -10,7 +10,7 @@
  *
  * @implements @agentic/code/frameworks/sdlc-complete/rules/self-maintenance.md
  * @source @src/cli/router.ts
- * @issue #482, #557, #694
+ * @issue #173, #174, #482, #557, #694
  */
 import { promises as fs } from 'fs';
 import path from 'path';
@@ -151,6 +151,30 @@ export function collectModelDeployArgs(args) {
     }
     return forwarded;
 }
+const REFRESH_HELP = `Usage: aiwg refresh [options]
+
+Update AIWG, re-deploy installed frameworks, and run health verification.
+
+Options:
+  --dry-run                 Preview changes without updating or deploying
+  --quiet                   Suppress progress output
+  --skip-update             Skip the installation update
+  --packages-only           Refresh remote packages only
+  --provider <name>         Override provider auto-detection
+  --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
+  --reasoning-model <name>  Override the reasoning model tier
+  --coding-model <name>     Override the coding model tier
+  --efficiency-model <name> Override the efficiency model tier
+  --filter <pattern>        Limit model deployment by agent name
+  --filter-role <role>      Limit model deployment by role
+  --model-tier <tier>       Limit model deployment by tier
+  --save                    Save model overrides to the project
+  --save-user               Save model overrides to user configuration
+  -h, --help                Show this help without running refresh
+
+Alias: aiwg sync (deprecated)`;
 /**
  * Refresh command handler (formerly sync)
  */
@@ -160,6 +184,9 @@ export const refreshHandler = {
     description: 'Refresh AIWG to latest version and re-deploy installed frameworks',
     category: 'maintenance',
     aliases: ['--refresh', 'sync', '--sync'],
+    async help() {
+        return { exitCode: 0, message: REFRESH_HELP, rawOutput: true };
+    },
     async execute(ctx) {
         const dryRun = hasFlag(ctx.args, '--dry-run');
         const quiet = hasFlag(ctx.args, '--quiet');
@@ -451,6 +478,10 @@ export const refreshHandler = {
             if (dryRun) {
                 ui.info('Dry run complete — no changes made');
             }
+            else if (updateFailure) {
+                ui.warn(`Refresh completed with installation update failure (exit ${updateFailure.exitCode}); ` +
+                    're-deployment continued, but AIWG may still be on the previous version.');
+            }
             else {
                 ui.success('Refresh complete');
             }
@@ -459,7 +490,11 @@ export const refreshHandler = {
         // Quiet mode: JSON output
         if (quiet) {
             const output = JSON.stringify({
-                status: dryRun ? 'dry-run' : 'refreshed',
+                status: dryRun
+                    ? 'dry-run'
+                    : updateFailure
+                        ? 'refreshed-with-update-failure'
+                        : 'refreshed',
                 provider: detectedProvider,
                 frameworks,
                 skipUpdate,

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

@@ -53,8 +53,37 @@ async function handleRuntimeInfo(args, cwd = process.cwd()) {
     const hasCheck = checkIndex >= 0;
     const hasCapabilities = args.includes('--capabilities');
     const hasProviders = args.includes('--providers');
+    const hasTransports = args.includes('--transports');
     const featureIndex = args.indexOf('--feature');
     const hasFeature = featureIndex >= 0;
+    if (hasTransports) {
+        const { readAiwgConfig } = await import('../../config/aiwg-config.js');
+        const config = await readAiwgConfig(cwd);
+        const profiles = Object.entries(config?.uhp?.profiles ?? {}).map(([name, profile]) => ({
+            name,
+            transport: 'uhp',
+            protocolVersion: profile.version,
+            experimental: true,
+            configured: true,
+            enabled: config?.uhp?.enabled === true,
+            endpointOrigin: new URL(profile.endpoint).origin,
+            credentialSource: profile.credential.source,
+            credentialReference: profile.credential.name,
+        }));
+        const output = { providersAreTransports: false, transports: { uhp: { experimental: true, enabled: config?.uhp?.enabled === true, profiles } } };
+        if (hasJson)
+            console.log(JSON.stringify(output, null, 2));
+        else {
+            console.log('\nTransport Inventory');
+            console.log('===================');
+            console.log('UHP is a remote execution transport, not an AIWG provider.');
+            if (!profiles.length)
+                console.log('  UHP: not configured (experimental)');
+            for (const profile of profiles)
+                console.log(`  UHP/${profile.name}: ${profile.enabled ? 'enabled' : 'disabled'}, ${profile.protocolVersion}, ${profile.endpointOrigin}`);
+        }
+        return;
+    }
     // --- Capability matrix queries (no RuntimeDiscovery needed) ---
     if (hasProviders) {
         const { collectProviderInventory } = await import('../../providers/provider-inventory.js');

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

@@ -182,6 +182,7 @@ async function handleSteward(args, ctx) {
     aiwg steward capabilities --feature <name>    Provider support matrix for a feature
     aiwg steward capabilities --all               Full matrix (all providers x features)
     aiwg steward find --capability <name>         Routing advice for your current provider
+    aiwg steward transports                       Report transport capabilities separately from providers
     aiwg steward models [--complex|--high-impact] Model policy/discovery routing advice
     aiwg steward models --route --capability-type <agent|skill|rule|workflow>
       --capability <id> --assignment <text> [--provider <name>] [--json]
@@ -263,6 +264,17 @@ async function handleSteward(args, ctx) {
             exitCode: EXIT_CODES.USAGE,
         });
     }
+    if (subcommand === 'transports') {
+        const projectDir = ctx ? getProjectDir(ctx, args) : process.cwd();
+        const config = await readAiwgConfig(projectDir);
+        const profiles = Object.keys(config?.uhp?.profiles ?? {});
+        console.log('\n  Remote execution transports');
+        console.log('  ───────────────────────────');
+        console.log(`  UHP ${config?.uhp?.enabled ? 'enabled' : 'disabled'} (experimental client transport; not a provider capability)`);
+        console.log(`  Profiles: ${profiles.length ? profiles.join(', ') : 'none'}`);
+        console.log('  Routing: explicit `aiwg uhp <operation> --profile <name>`; no UHP↔A2A fallback.');
+        return;
+    }
     const matrix = loadCapabilityMatrix();
     if (subcommand === 'capabilities') {
         const providerFlag = args.indexOf('--provider');

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

@@ -1139,34 +1139,40 @@ export const pluginStatusHandler = {
  *
  * Delegates to tools/plugin/package-plugins.mjs
  */
+function packagePluginHelp() {
+    return {
+        exitCode: 0,
+        message: [
+            "aiwg package-plugin — package a project-local or built-in marketplace wrapper",
+            "",
+            "Usage:",
+            "  aiwg package-plugin <name> [--source <path>] [--output <path>] [--provider <name>] [--clean] [--dry-run]",
+            "  aiwg package-plugin --plugin <name> [options]  # compatibility form",
+            "",
+            "Options:",
+            "  --source <path>    explicit project-local wrapper source (must stay inside the project)",
+            "  --output <path>    standalone archive output (default: dist/plugins)",
+            "  --provider <name>  claude, codex, or all for standalone wrappers; built-ins retain all formats",
+            "  --clean            clean generated plugin output before packaging",
+            "  --dry-run, -n      preview without writing",
+            "  --help, -h         show this help",
+            "",
+            "Project-local wrappers are discovered under .aiwg/plugins and packaged as deterministic archives.",
+        ].join("\n"),
+    };
+}
 export const packagePluginHandler = {
     id: "package-plugin",
     name: "Package Plugin",
     description: "Package a plugin for distribution",
     category: "plugin",
     aliases: ["-package-plugin", "--package-plugin"],
+    async help() {
+        return packagePluginHelp();
+    },
     async execute(ctx) {
         if (ctx.args.includes("--help") || ctx.args.includes("-h")) {
-            return {
-                exitCode: 0,
-                message: [
-                    "aiwg package-plugin — package a project-local or built-in marketplace wrapper",
-                    "",
-                    "Usage:",
-                    "  aiwg package-plugin <name> [--source <path>] [--output <path>] [--provider <name>] [--clean] [--dry-run]",
-                    "  aiwg package-plugin --plugin <name> [options]  # compatibility form",
-                    "",
-                    "Options:",
-                    "  --source <path>    explicit project-local wrapper source (must stay inside the project)",
-                    "  --output <path>    standalone archive output (default: dist/plugins)",
-                    "  --provider <name>  claude, codex, or all for standalone wrappers; built-ins retain all formats",
-                    "  --clean            clean generated plugin output before packaging",
-                    "  --dry-run, -n      preview without writing",
-                    "  --help, -h         show this help",
-                    "",
-                    "Project-local wrappers are discovered under .aiwg/plugins and packaged as deterministic archives.",
-                ].join("\n"),
-            };
+            return packagePluginHelp();
         }
         const hasExplicitPlugin = ctx.args.includes("--plugin") || ctx.args.includes("-p");
         const positional = ctx.args[0] && !ctx.args[0].startsWith("-")

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

@@ -0,0 +1,88 @@
+import { readAiwgConfig } from '../../config/aiwg-config.js';
+import { resolveUhpProfile } from '../../uhp/config.js';
+import { UhpClient } from '../../uhp/client.js';
+import { projectUhpResponseToCanonicalMission, projectUhpResponseToMission, unknownUhpMissionEvidence } from '../../uhp/mission.js';
+import { UhpError } from '../../uhp/errors.js';
+function valueAfter(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function usage() {
+    return `Usage: aiwg uhp <discover|harnesses|models|run> --profile <name> [options]
+
+Experimental UHP ${'2026-08-11'} client (client support only; no server conformance claim)
+
+  discover                         Inspect unauthenticated capability discovery
+  harnesses                        List configured remote harnesses
+  models [--harness <id>]          List global or per-harness model availability
+  run --input <text> [--harness <id>] [--model <id>] [--stream]
+                                   Run an explicit smoke task
+
+All commands require --profile. Credentials are resolved from the profile's
+secret reference at request time; bearer values are never accepted as CLI arguments.`;
+}
+async function executeUhp(ctx) {
+    const [operation] = ctx.args;
+    if (!operation || operation === 'help' || operation === '--help')
+        return { exitCode: 0, message: usage(), rawOutput: true };
+    const profileName = valueAfter(ctx.args, '--profile');
+    if (!profileName)
+        return { exitCode: 2, message: 'UHP routing requires explicit --profile <name> selection.' };
+    const config = await readAiwgConfig(ctx.cwd);
+    const profile = resolveUhpProfile(config?.uhp, profileName);
+    const client = new UhpClient(profileName, profile);
+    if (operation === 'discover')
+        return { exitCode: 0, message: JSON.stringify(await client.discover(), null, 2), rawOutput: true };
+    if (operation === 'harnesses')
+        return { exitCode: 0, message: JSON.stringify(await client.listHarnesses(), null, 2), rawOutput: true };
+    if (operation === 'models')
+        return { exitCode: 0, message: JSON.stringify(await client.listModels(valueAfter(ctx.args, '--harness')), null, 2), rawOutput: true };
+    if (operation !== 'run')
+        return { exitCode: 2, message: `Unknown UHP operation '${operation}'.\n${usage()}`, rawOutput: true };
+    const input = valueAfter(ctx.args, '--input');
+    if (!input)
+        return { exitCode: 2, message: 'aiwg uhp run requires --input <text>.' };
+    const request = {
+        input,
+        ...(valueAfter(ctx.args, '--model') ? { model: valueAfter(ctx.args, '--model') } : {}),
+        metadata: { ...(valueAfter(ctx.args, '--harness') ? { harness_id: valueAfter(ctx.args, '--harness') } : {}) },
+    };
+    if (ctx.args.includes('--stream')) {
+        const events = [];
+        let terminal;
+        try {
+            for await (const event of client.streamResponse(request, { signal: ctx.signal })) {
+                events.push(event);
+                if (event.response)
+                    terminal = event.response;
+            }
+            const canonical = terminal ? projectUhpResponseToCanonicalMission(profileName, terminal, request, events.at(-1)) : undefined;
+            return { exitCode: 0, message: JSON.stringify({ events, evidence: terminal ? projectUhpResponseToMission(profileName, terminal, request, events.at(-1)) : unknownUhpMissionEvidence(profileName, 'Stream ended without a response'), ...(canonical ? { mission: canonical.value, adapter: { sourceVersion: canonical.sourceVersion, warnings: canonical.warnings, lossReport: canonical.lossReport } } : {}) }, null, 2), rawOutput: true };
+        }
+        catch (error) {
+            if (error instanceof UhpError && error.options.remoteState === 'unknown') {
+                return { exitCode: 1, message: JSON.stringify({ error: { code: error.code, message: error.message }, evidence: unknownUhpMissionEvidence(profileName, error.message, terminal?.id, events.at(-1)?.sequence_number) }, null, 2), rawOutput: true };
+            }
+            throw error;
+        }
+    }
+    const response = await client.createResponse(request, { signal: ctx.signal });
+    const canonical = projectUhpResponseToCanonicalMission(profileName, response, request);
+    return { exitCode: 0, message: JSON.stringify({ response, evidence: projectUhpResponseToMission(profileName, response, request), mission: canonical.value, adapter: { sourceVersion: canonical.sourceVersion, warnings: canonical.warnings, lossReport: canonical.lossReport } }, null, 2), rawOutput: true };
+}
+export const uhpHandler = {
+    id: 'uhp',
+    name: 'Unified Harness Protocol',
+    description: 'Inspect and smoke-test an explicitly selected experimental UHP endpoint profile',
+    category: 'toolsmith',
+    aliases: [],
+    async execute(ctx) {
+        try {
+            return await executeUhp(ctx);
+        }
+        catch (error) {
+            return { exitCode: error instanceof UhpError || error instanceof Error ? 1 : 1, message: error instanceof Error ? error.message : 'UHP operation failed' };
+        }
+    },
+};
+//# sourceMappingURL=uhp.js.map

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

@@ -466,6 +466,9 @@ export const doctorHandler = {
     description: 'Run health diagnostics',
     category: 'maintenance',
     aliases: ['-doctor', '--doctor'],
+    async help() {
+        return { exitCode: 0, message: DOCTOR_HELP, rawOutput: true };
+    },
     async execute(ctx) {
         if (ctx.args.includes('--help') || ctx.args.includes('-h')) {
             return { exitCode: 0, message: DOCTOR_HELP, rawOutput: true };

package/dist/src/cli/router.js

@@ -10,6 +10,7 @@
  * @tests @test/unit/cli/router.test.ts
  * @issue #33
  * @issue #58
+ * @issue #174
  */
 import { loadRegistry } from '../extensions/loader.js';
 import { getFrameworkRoot } from '../channel/manager.mjs';
@@ -134,6 +135,32 @@ export async function run(args, options = {}) {
         ui.error(`No handler found for command: ${commandId}`);
         process.exit(1);
     }
+    // Help must be intercepted before hooks and the normal handler path. Some
+    // commands mutate project or installation state, so passing an unrecognised
+    // help flag through to execute() is unsafe (#174).
+    if (commandArgs.includes('--help') || commandArgs.includes('-h')) {
+        const ctx = await buildContext(commandArgs, args, options);
+        if (handler.help) {
+            const result = await handler.help(ctx);
+            if (result.message) {
+                if (result.rawOutput) {
+                    process.stdout.write(result.message.endsWith('\n') ? result.message : `${result.message}\n`);
+                }
+                else if (result.exitCode !== 0) {
+                    ui.error(result.message);
+                }
+                else {
+                    ui.info(result.message);
+                }
+            }
+            if (result.exitCode !== 0)
+                process.exit(result.exitCode);
+        }
+        else {
+            ui.info(`No detailed help for \`aiwg ${commandId}\`. Run \`aiwg help\` for the command overview.`);
+        }
+        return;
+    }
     // Build context for handler and hooks
     const ctx = await buildContext(commandArgs, args, options);
     // Build hook context

package/dist/src/config/aiwg-config.js

@@ -17,6 +17,7 @@ import { validateAuthorization, } from '../policy/authorization.js';
 import { projectAiwgPath, projectControlPath, resolveProjectAiwgDir, } from './project-artifacts.js';
 import { defaultThreatAssessmentConfig, validateThreatAssessmentConfig, } from '../security/threat-assessment-config.js';
 import { defaultArtifactOutputs, validateArtifactOutputs } from '../artifacts/output-policy.js';
+import { validateUhpConfig } from '../uhp/config.js';
 const CONFIG_FILENAME = 'aiwg.config';
 /**
  * Operations that a workspace may authorize for one member repository.
@@ -159,6 +160,9 @@ export function validateIndexConfig(index) {
         return ['index: must be an object'];
     }
     const indexObject = index;
+    if (indexObject.graphBackend !== undefined && !GRAPH_BACKENDS.includes(indexObject.graphBackend)) {
+        errors.push(`index.graphBackend: must be one of ${GRAPH_BACKENDS.join(' | ')}`);
+    }
     const isStringArray = (v) => Array.isArray(v) && v.every((x) => typeof x === 'string');
     const graphOverrides = indexObject.graphOverrides;
     if (graphOverrides !== undefined) {
@@ -772,6 +776,9 @@ export async function readAiwgConfig(projectDir) {
     const artifactOutputErrors = validateArtifactOutputs(parsed.artifact_outputs);
     if (artifactOutputErrors.length > 0)
         throw new Error(`Invalid .aiwg/aiwg.config:\n${artifactOutputErrors.join('\n')}`);
+    const uhpErrors = validateUhpConfig(parsed.uhp);
+    if (uhpErrors.length > 0)
+        throw new Error(`Invalid .aiwg/aiwg.config:\n${uhpErrors.join('\n')}`);
     return parsed;
 }
 /**
@@ -787,6 +794,9 @@ export async function writeAiwgConfig(projectDir, config) {
     const artifactOutputErrors = validateArtifactOutputs(config.artifact_outputs);
     if (artifactOutputErrors.length > 0)
         throw new Error(`Invalid .aiwg/aiwg.config:\n${artifactOutputErrors.join('\n')}`);
+    const uhpErrors = validateUhpConfig(config.uhp);
+    if (uhpErrors.length > 0)
+        throw new Error(`Invalid .aiwg/aiwg.config:\n${uhpErrors.join('\n')}`);
     const localPath = getConfigPath(projectDir);
     const artifactDir = resolveProjectAiwgDir(projectDir);
     const artifactPath = join(artifactDir, CONFIG_FILENAME);

package/dist/src/extensions/commands/definitions.js

@@ -1663,6 +1663,24 @@ export const agentcardCommand = {
         },
     },
 };
+export const uhpCommand = {
+    id: 'uhp',
+    type: 'command',
+    name: 'Unified Harness Protocol',
+    description: 'Inspect discovery and run smoke tasks through an explicit experimental UHP endpoint profile',
+    version: '1.0.0',
+    capabilities: ['cli', 'uhp', 'remote-harness', 'transport'],
+    keywords: ['uhp', 'unified harness protocol', 'remote harness', 'responses'],
+    category: 'toolsmith',
+    platforms: { claude: 'full', generic: 'full' },
+    deployment: { pathTemplate: '.{platform}/commands/{id}.md', core: true },
+    metadata: {
+        type: 'command',
+        template: 'utility',
+        argumentHint: '<discover|harnesses|models|run> --profile <name> [--harness <id>] [--model <id>] [--input <text>] [--stream]',
+        allowedTools: ['Read', 'Bash'],
+    },
+};
 // Utility Commands
 export const prefillCardsCommand = {
     id: 'prefill-cards',
@@ -2371,6 +2389,24 @@ export const mcCommand = {
         },
     },
 };
+export const missionCommand = {
+    id: 'mission',
+    type: 'command',
+    name: 'Mission Protocol',
+    description: 'Preview, apply, verify, resume, and roll back versioned Mission workspace migrations',
+    version: '1.0.0',
+    capabilities: ['cli', 'orchestration', 'mission-protocol', 'migration', 'rollback'],
+    keywords: ['mission', 'migrate', 'migration', 'preview', 'resume', 'rollback'],
+    category: 'orchestration',
+    platforms: { claude: 'full', generic: 'full' },
+    deployment: { pathTemplate: '.{platform}/commands/{id}.md', core: true },
+    metadata: {
+        type: 'command',
+        template: 'orchestration',
+        allowedTools: ['Bash', 'Read', 'Write'],
+        argumentHint: 'migrate [--dry-run|--apply|--verify|--resume|--rollback]',
+    },
+};
 // Steward Commands
 export const stewardCommand = {
     id: 'steward',
@@ -3631,6 +3667,7 @@ export const commandDefinitions = [
     // Toolsmith (1)
     runtimeInfoCommand,
     agentcardCommand,
+    uhpCommand,
     // Utility (5)
     prefillCardsCommand,
     contributeStartCommand,
@@ -3663,6 +3700,7 @@ export const commandDefinitions = [
     ralphConfigCommand,
     // Mission Control (1)
     mcCommand,
+    missionCommand,
     // Steward (1)
     stewardCommand,
     // Agent Teams (1)

package/dist/src/installation/manager-command.mjs

@@ -21,11 +21,20 @@ export function resolveManagerCommand(file, args, options = {}) {
   return {
     file: commandInterpreter,
     args: ['/d', '/s', '/c', command],
+    // The payload above already contains cmd.exe-native quoting. Instruct
+    // Node not to apply MSVCRT escaping to those embedded quotes (#173).
+    windowsVerbatimArguments: true,
   };
 }
 
 export function executeManagerCommand(file, args, options = {}) {
   const invocation = resolveManagerCommand(file, args, options);
   const execute = options.execute ?? execFileSync;
-  return execute(invocation.file, invocation.args, options.execOptions ?? { stdio: 'inherit' });
+  const execOptions = options.execOptions
+    ? { ...options.execOptions }
+    : { stdio: 'inherit' };
+  if (invocation.windowsVerbatimArguments === true) {
+    execOptions.windowsVerbatimArguments = true;
+  }
+  return execute(invocation.file, invocation.args, execOptions);
 }