@aiwg/cli 2026.9.0 → 2026.9.1

package/agentic/code/providers/capability-matrix.yaml

@@ -470,6 +470,47 @@ providers:
     deploy_target: mixed
     aggregated_output: true
 
+  pi:
+    display_name: Pi Coding Agent
+    aliases:
+      - pi-coding-agent
+    status: experimental
+    daemon_tier: unsupported
+    daemon_pty_adapter: false
+    artifact_paths:
+      agents: .agents/skills/
+      commands: .pi/prompts/
+      skills: .pi/skills/
+      skills_cross_agent: .agents/skills/
+      rules: AGENTS.md
+      behaviors: .pi/extensions/
+    native_features:
+      cron: false
+      agent_teams: false
+      tasks: false
+      mcp: false
+      behaviors: false
+      mission_control: false
+      daemon: false
+    emulation:
+      cron: external-trigger
+      agent_teams: aiwg-mc
+      tasks: aiwg-mc
+      mcp: null
+      behaviors: null
+      mission_control: aiwg-mc
+      daemon: null
+    hook_wiring:
+      at_link_support: false
+      fallback: full-inject
+      context_file: AGENTS.md
+    interaction:
+      structured_questions: none
+      fallback: markdown
+      notes: Pi does not expose a built-in structured question tool.
+    deploy_target: project
+    aggregated_output: false
+
 # Feature definitions — documents what each feature key means and
 # what emulation strategies are available when native support is absent.
 features:

package/bin/aiwg.mjs

@@ -128,6 +128,7 @@ const FAST_HELP_TEXT = `
   DISPATCH
     run skill <name>             Execute a script-bearing skill
     run <script-name>            Run a user-defined script from .aiwg/aiwg.config
+    output-mode <action>         Configure composable output language and presentation
 
   FEATURES
     features                     Show optional feature install status
@@ -183,7 +184,7 @@ const FAST_HELP_TEXT = `
     --use-stable                 Switch back to stable npm package
 ────────────────────────────────────────────────────────
 
-  Providers: claude (default), copilot, factory, codex, cursor, opencode, warp, windsurf
+  Providers: 12 — claude (default), codex, copilot, cursor, factory, hermes, opencode, openclaw, openhuman, pi, warp, windsurf (alias: devin)
 
   Examples:
     aiwg use sdlc                   Install SDLC framework
@@ -233,6 +234,12 @@ function maybeWarnUnbuiltDist() {
 }
 maybeWarnUnbuiltDist();
 
+// Propagate the strict no-write contract through helpers that may resolve
+// installation/channel state before the command context exists.
+if (process.argv.slice(2).includes('--dry-run')) {
+  process.env['AIWG_CLI_DRY_RUN'] = '1';
+}
+
 // Display a cached notice and schedule its refresh before every eligible CLI
 // path, including fast help/version, channel recovery, and later preflight
 // failures. This local-only bootstrap never waits on the registry and failures
@@ -299,7 +306,7 @@ trace('bin:entry');
  */
 async function resolveRouterPath() {
   const { loadConfig } = await import('../dist/src/channel/manager.mjs');
-  const config = await loadConfig();
+  const config = await loadConfig({ createIfMissing: !process.argv.slice(2).includes('--dry-run') });
   if (config.devMode && config.edgePath && config.edgePath !== packageRoot) {
     const devRouter = path.join(config.edgePath, 'dist', 'src', 'cli', 'router.js');
     if (!existsSync(devRouter)) {
@@ -414,7 +421,12 @@ async function main() {
       process.exit(1);
     }
     const { assertCanonicalInstallation } = await import(pathToFileURL(identityPath).href);
-    assertCanonicalInstallation({ actualRoot: activePackageRoot });
+    const readOnlyPreview = args.includes('--dry-run');
+    assertCanonicalInstallation({
+      actualRoot: activePackageRoot,
+      createIfMissing: !readOnlyPreview,
+      allowUnrecorded: readOnlyPreview,
+    });
   }
 
   // Wire up the logger level from -v/-vv/--quiet/AIWG_LOG_LEVEL before any

package/dist/src/api/index.d.ts

@@ -19,5 +19,8 @@ export * from '../marketplace/artifact-attestation.js';
 export * from '../uhp/index.js';
 export * from '../mission-protocol/index.js';
 export * from '../governance/index.js';
+export * from '../output-modes/index.js';
+export * from '../schema/index.js';
+export * from '../dataset/index.js';
 export { ARTIFACT_TRUST_ROOT_MEDIA_TYPE, ARTIFACT_TRUST_ROOT_SCHEMA_VERSION, ARTIFACT_TRUST_STATE_SCHEMA_VERSION, bootstrapTrustRoot, parseTrustRoot, parseTrustState, readTrustState, validateTrustRoot, validateTrustState, verifyRootTransition, writeTrustState, channelStateKey, canonicalJson, dssePae, publicKeyFingerprint, sha256, type ArtifactTrustRoot, type ArtifactTrustState, type RootBootstrapResult, type RootTransitionResult, type ArtifactTrustPolicySettings, type TrustedChannelState, } from '../security/artifact-trust.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/api/index.js

@@ -19,5 +19,8 @@ export * from '../marketplace/artifact-attestation.js';
 export * from '../uhp/index.js';
 export * from '../mission-protocol/index.js';
 export * from '../governance/index.js';
+export * from '../output-modes/index.js';
+export * from '../schema/index.js';
+export * from '../dataset/index.js';
 export { ARTIFACT_TRUST_ROOT_MEDIA_TYPE, ARTIFACT_TRUST_ROOT_SCHEMA_VERSION, ARTIFACT_TRUST_STATE_SCHEMA_VERSION, bootstrapTrustRoot, parseTrustRoot, parseTrustState, readTrustState, validateTrustRoot, validateTrustState, verifyRootTransition, writeTrustState, channelStateKey, canonicalJson, dssePae, publicKeyFingerprint, sha256, } from '../security/artifact-trust.js';
 //# sourceMappingURL=index.js.map

package/dist/src/channel/manager.mjs

@@ -213,8 +213,8 @@ export async function getChannel() {
  * Get the framework root path based on current channel
  * @returns {Promise<string>} Path to framework root
  */
-export async function getFrameworkRoot() {
-  const config = await loadConfig();
+export async function getFrameworkRoot(options = {}) {
+  const config = await loadConfig(options);
 
   if (config.channel === 'edge') {
     // Check if edge installation exists

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

@@ -0,0 +1,186 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { createBuiltinAdapterRegistry } from "../../dataset/adapters.js";
+import { FileDatasetOrchestrationRepository } from "../../dataset/file-orchestration-repository.js";
+import { LocalDatasetExecutionBackend } from "../../dataset/local-execution-backend.js";
+import { DatasetOrchestrationService } from "../../dataset/orchestration-service.js";
+import { presentDatasetResult } from "../../dataset/presentation.js";
+export const DATASET_ACTIONS = [
+    "source",
+    "check",
+    "preview",
+    "plan",
+    "ingest",
+    "status",
+    "show",
+    "verify",
+    "query",
+    "lineage",
+    "export",
+    "cancel",
+    "retry",
+];
+function option(args, name) {
+    const i = args.indexOf(name);
+    return i < 0 ? undefined : args[i + 1];
+}
+function positions(args) {
+    const values = new Set([
+        "--file",
+        "--count",
+        "--digest",
+        "--idempotency-key",
+        "--approve",
+        "--reconciliation-digest",
+        "--reconciliation-threshold",
+    ]);
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        if (values.has(args[i])) {
+            i++;
+            continue;
+        }
+        if (!args[i].startsWith("-"))
+            out.push(args[i]);
+    }
+    return out;
+}
+function input(ctx) {
+    const file = option(ctx.args, "--file");
+    if (!file)
+        throw new Error("DATASET_INPUT_REQUIRED: --file <json> is required");
+    return JSON.parse(readFileSync(resolve(ctx.cwd, file), "utf8"));
+}
+function service(ctx) {
+    const registry = createBuiltinAdapterRegistry();
+    return new DatasetOrchestrationService(new FileDatasetOrchestrationRepository(ctx.cwd), {
+        adapter: (id, version) => {
+            const adapter = registry.adapters.find((candidate) => {
+                const manifest = candidate.describe();
+                return manifest.id === id && manifest.version === version;
+            });
+            if (!adapter)
+                throw new Error(`ADAPTER_NOT_REGISTERED: ${id}@${version}`);
+            return adapter;
+        },
+        localBackend: new LocalDatasetExecutionBackend(),
+    });
+}
+export async function executeDatasetCommand(ctx, providedService) {
+    const [action, ...ids] = positions(ctx.args);
+    if (!DATASET_ACTIONS.includes(action))
+        return {
+            exitCode: 1,
+            message: `Unknown dataset action '${action ?? ""}'.`,
+        };
+    const s = providedService ?? service(ctx);
+    let result;
+    switch (action) {
+        case "source":
+            result = await s.source(input(ctx));
+            break;
+        case "check":
+            result = await s.check(ids[0], ctx.args.includes("--offline"));
+            break;
+        case "preview":
+            result = await s.preview(ids[0], Number(option(ctx.args, "--count") ?? 10), ctx.args.includes("--offline"), ctx.signal);
+            break;
+        case "plan":
+            result = await s.plan(input(ctx));
+            break;
+        case "ingest":
+            result = await s.ingest({
+                planId: ids[0],
+                planDigest: option(ctx.args, "--digest") ?? "",
+                idempotencyKey: option(ctx.args, "--idempotency-key") ?? "",
+                approvalIds: (option(ctx.args, "--approve") ?? "")
+                    .split(",")
+                    .filter(Boolean),
+                ...(option(ctx.args, "--reconciliation-digest")
+                    ? {
+                        reconciliationApproval: {
+                            previewDigest: option(ctx.args, "--reconciliation-digest"),
+                            threshold: Number(option(ctx.args, "--reconciliation-threshold")),
+                        },
+                    }
+                    : {}),
+                signal: ctx.signal,
+            });
+            break;
+        case "status":
+            result = await s.status(ids[0]);
+            break;
+        case "show":
+            result = await s.show(ids[0]);
+            break;
+        case "verify":
+            result = await s.verify(ids[0]);
+            break;
+        case "query":
+            result = await s.query(ids[0]);
+            break;
+        case "lineage":
+            result = await s.lineage(ids[0]);
+            break;
+        case "export":
+            result = await s.export(ids[0]);
+            break;
+        case "cancel":
+            result = await s.cancel(ids[0]);
+            break;
+        case "retry":
+            result = await s.retry(ids[0], ctx.signal);
+            break;
+    }
+    return {
+        exitCode: result.ok ? 0 : 1,
+        rawOutput: true,
+        message: presentDatasetResult(result, ctx.args.includes("--json")),
+    };
+}
+export const datasetHandler = {
+    id: "dataset",
+    name: "Dataset intelligence",
+    description: "Register, preview, plan, ingest, verify, query, and trace datasets",
+    category: "index",
+    aliases: ["datasets"],
+    async help() {
+        return {
+            exitCode: 0,
+            rawOutput: true,
+            message: [
+                "Usage: aiwg dataset <action> [id] [options]",
+                "",
+                "Actions: source, check, preview, plan, ingest, status, show, verify, query, lineage, export, cancel, retry",
+                "source/plan: --file <json>",
+                "preview: <source-id> [--count N] [--offline]",
+                "ingest: <plan-id> --digest <sha256> --idempotency-key <key> [--approve id,id]",
+                "All actions: --json for the canonical aiwg.dataset-orchestration/v1 envelope.",
+            ].join("\n"),
+        };
+    },
+    async execute(ctx) {
+        try {
+            return await executeDatasetCommand(ctx);
+        }
+        catch (e) {
+            return {
+                exitCode: 1,
+                rawOutput: true,
+                message: JSON.stringify({
+                    schema: "aiwg.dataset-orchestration/v1",
+                    ok: false,
+                    diagnostics: [
+                        {
+                            code: "DATASET_CLI_INVALID",
+                            message: e instanceof Error ? e.message : String(e),
+                            boundary: "input",
+                            retryable: false,
+                        },
+                    ],
+                }, null, 2) + "\n",
+            };
+        }
+    },
+};
+//# sourceMappingURL=dataset.js.map

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

@@ -90,6 +90,7 @@ function displayHelp() {
     helpGroup('DISPATCH', [
         ['run skill <name>', 'Execute a script-bearing skill'],
         ['run <script-name>', 'Run a user-defined script from .aiwg/aiwg.config'],
+        ['output-mode <action>', 'Configure composable output language and presentation'],
     ]);
     helpGroup('FEATURES', [
         ['features', 'Show optional feature install status'],
@@ -143,7 +144,7 @@ function displayHelp() {
     ]);
     ui.rule();
     ui.blank();
-    console.log(`  ${ui.dimText('Providers:')} claude (default), copilot, factory, codex, cursor, opencode, warp, windsurf`);
+    console.log(`  ${ui.dimText('Providers:')} 12 — claude (default), codex, copilot, cursor, factory, hermes, opencode, openclaw, openhuman, pi, warp, windsurf (alias: devin)`);
     ui.blank();
     console.log(`  ${ui.dimText('Examples:')}`);
     console.log(`    aiwg use sdlc                   ${ui.dimText('Install SDLC framework')}`);

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

@@ -66,12 +66,14 @@ import { artifactVerifyHandler } from './artifact-verify.js';
 import { outputModeHandler } from './output-mode.js';
 import { installationHandler } from './installation.js';
 import { uhpHandler } from './uhp.js';
+import { schemaHandler } from './schema.js';
+import { datasetHandler } from './dataset.js';
 // Re-export individual handlers
 export { 
 // Maintenance
 helpHandler, versionHandler, authHandler, doctorHandler, contextFirewallHandler, updateHandler, refreshHandler, regenerateHandler, workspaceContextHandler, 
 // Framework management
-useHandler, listHandler, removeHandler, promoteHandler, installHandler, packagesHandler, marketplaceHandler, initHandler, setupHandler, setupGenerateHandler, setupRunHandler, setupValidateHandler, issueHandler, issueAuditHandler, runHandler, jobHandler, costReportHandler, evidenceHandler, artifactVerifyHandler, outputModeHandler, installationHandler, 
+useHandler, listHandler, removeHandler, promoteHandler, installHandler, packagesHandler, marketplaceHandler, initHandler, setupHandler, setupGenerateHandler, setupRunHandler, setupValidateHandler, issueHandler, issueAuditHandler, runHandler, jobHandler, costReportHandler, evidenceHandler, artifactVerifyHandler, outputModeHandler, schemaHandler, datasetHandler, installationHandler, 
 // Project
 newBundleHandler, quickrefHandler, newProjectHandler, sessionHandler, sessionsHandler, 
 // Workspace
@@ -156,6 +158,8 @@ export const allHandlers = [
     evidenceHandler,
     artifactVerifyHandler,
     outputModeHandler,
+    schemaHandler,
+    datasetHandler,
     // Workspace management
     ...workspaceHandlers,
     // Subcommand handlers (MCP, catalog, index, skills)

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

@@ -30,6 +30,7 @@ const PROVIDER_LABELS = {
     codex: 'OpenAI Codex      ~/.codex/',
     openclaw: 'OpenClaw          ~/.openclaw/',
     hermes: 'Hermes (MCP)      aiwg mcp',
+    pi: 'Pi Coding Agent   .pi/ + .agents/skills/',
 };
 // Local aliases for the shared prompt utilities. These preserve existing
 // call sites (askYesNo/askString) while routing through a single timeout

package/dist/src/cli/handlers/output-mode.js

@@ -53,12 +53,29 @@ async function execute(ctx) {
             return { exitCode: 1, message: `Unknown output mode '${id}'.` };
         modes = action === 'enable' ? [...new Set([...modes, id])] : modes.filter(value => value !== id);
     }
-    await resolveOutputModes(ctx.cwd, ctx.frameworkRoot, scope === 'session' ? modes : []);
+    await resolveOutputModes(ctx.cwd, ctx.frameworkRoot, [], { [scope]: modes });
     const path = await writeOutputModeState(ctx.cwd, scope, modes);
     return { exitCode: 0, message: `${action === 'clear' ? 'Cleared' : `${action}d`} ${scope} output modes (${modes.join(', ') || 'unaltered'}) at ${path}` };
 }
 export const outputModeHandler = {
     id: 'output-mode', name: 'Output Modes', description: 'List, inspect, and select composable output modes', category: 'project', aliases: ['output-modes'],
+    async help() {
+        return {
+            exitCode: 0,
+            rawOutput: true,
+            message: [
+                'Usage:',
+                '  aiwg output-mode list',
+                '  aiwg output-mode show <id>',
+                '  aiwg output-mode enable <id> --scope invocation|session|project',
+                '  aiwg output-mode disable <id> --scope session|project',
+                '  aiwg output-mode clear --scope session|project',
+                '  aiwg output-mode status [--output-mode <id>]...',
+                '',
+                'Use repeated --output-mode flags with aiwg run for a one-command stack.',
+            ].join('\n'),
+        };
+    },
     async execute(ctx) { try {
         return await execute(ctx);
     }

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

@@ -17,11 +17,16 @@ import { readAiwgConfig, getProjectDir } from '../../config/aiwg-config.js';
 import { handlerResultFromError } from '../errors.js';
 import * as ui from '../ui.js';
 import { resolveOutputModes } from '../../output-modes/registry.js';
-function extractOutputModes(args) {
+export function extractOutputModes(args) {
     const cleaned = [];
     const modes = [];
+    let forwarding = false;
     for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--output-mode') {
+        if (args[i] === '--') {
+            forwarding = true;
+            cleaned.push(args[i]);
+        }
+        else if (!forwarding && args[i] === '--output-mode') {
             const id = args[i + 1];
             if (!id || id.startsWith('-'))
                 throw new Error('--output-mode requires a mode ID');
@@ -67,7 +72,10 @@ export const runHandler = {
         }
         const scriptName = parsed.args[0];
         const projectDir = getProjectDir(ctx, ctx.args);
-        let outputModeEnv = {};
+        let outputModeEnv = {
+            AIWG_OUTPUT_MODES: '',
+            AIWG_OUTPUT_MODES_JSON: '[]',
+        };
         try {
             const resolved = await resolveOutputModes(projectDir, ctx.frameworkRoot, parsed.modes);
             if (resolved.modes.length > 0) {

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

@@ -0,0 +1,221 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { parse as parseYaml } from 'yaml';
+import { analyzeBackwardCompatibility, loadSchemaCatalog, SchemaResolver, SchemaValidator } from '../../schema/index.js';
+const ACTIONS = ['list', 'show', 'graph', 'policy', 'validate', 'lint', 'check-refs', 'diff', 'compatibility', 'generate', 'verify-projections'];
+function value(args, flag) {
+    const index = args.indexOf(flag);
+    return index < 0 ? undefined : args[index + 1];
+}
+function positional(args) {
+    const flagsWithValues = new Set(['--catalog', '--domain', '--lifecycle', '--format', '--direction', '--schema', '--against']);
+    const result = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg)
+            continue;
+        if (flagsWithValues.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith('-'))
+            result.push(arg);
+    }
+    return result;
+}
+function jsonResult(payload, exitCode = 0) {
+    return { exitCode, rawOutput: true, message: `${JSON.stringify(payload, null, 2)}\n` };
+}
+function digest(bytes) {
+    return `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+}
+function readData(path) {
+    const source = readFileSync(path, 'utf8');
+    return ['.yaml', '.yml'].includes(extname(path).toLowerCase()) ? parseYaml(source) : JSON.parse(source);
+}
+function diagnostic(code, message, entry, path) {
+    return { code, severity: 'error', message, ...(entry ? { artifactId: entry.artifact.id } : {}), ...(path ? { path } : {}) };
+}
+function load(ctx) {
+    const catalogPath = value(ctx.args, '--catalog');
+    const result = loadSchemaCatalog({ rootDir: ctx.cwd, ...(catalogPath ? { catalogPath } : {}) });
+    return {
+        ...(result.catalog ? { resolver: new SchemaResolver(result.catalog, { rootDir: ctx.cwd }) } : {}),
+        diagnostics: result.diagnostics,
+    };
+}
+function authorityPath(ctx, entry) {
+    const path = entry.artifact.authority.path;
+    if (!path)
+        throw new Error(`${entry.artifact.id} has no local canonical authority`);
+    return resolve(ctx.cwd, path);
+}
+function schemaRefs(node, refs = []) {
+    if (Array.isArray(node))
+        for (const child of node)
+            schemaRefs(child, refs);
+    else if (typeof node === 'object' && node !== null) {
+        for (const [key, child] of Object.entries(node)) {
+            if (key === '$ref' && typeof child === 'string')
+                refs.push(child);
+            else
+                schemaRefs(child, refs);
+        }
+    }
+    return refs;
+}
+function resolveBaseline(ctx, resolver, query) {
+    const entry = resolver.resolve(query);
+    return readData(entry ? authorityPath(ctx, entry) : resolve(ctx.cwd, query));
+}
+async function execute(ctx) {
+    const [action = 'list', ...terms] = positional(ctx.args);
+    if (!ACTIONS.includes(action))
+        return { exitCode: 1, message: `Unknown schema action '${action}'.` };
+    const loaded = load(ctx);
+    if (!loaded.resolver)
+        return jsonResult({ schema: 'aiwg.schema.diagnostics.v1', valid: false, diagnostics: loaded.diagnostics }, 1);
+    const resolver = loaded.resolver;
+    const query = terms[0];
+    if (action === 'list') {
+        const entries = resolver.list({ domain: value(ctx.args, '--domain'), lifecycle: value(ctx.args, '--lifecycle'), format: value(ctx.args, '--format') });
+        return jsonResult({ schema: 'aiwg.schema.list.v1', entries: entries.map(({ artifact, domain, digest: hash }) => ({ id: artifact.id, logicalName: artifact.logicalName, version: artifact.version, domain, format: artifact.format, lifecycle: artifact.lifecycle, digest: hash })) });
+    }
+    if (action === 'show') {
+        if (!query)
+            return { exitCode: 1, message: 'Usage: aiwg schema show <id|name@version|path>' };
+        const entry = resolver.require(query);
+        return jsonResult({ schema: 'aiwg.schema.show.v1', ...entry });
+    }
+    if (action === 'graph') {
+        const direction = value(ctx.args, '--direction');
+        if (direction && !['dependencies', 'dependents', 'both'].includes(direction))
+            throw new Error(`Invalid graph direction '${direction}'`);
+        return jsonResult({ schema: 'aiwg.schema.graph.v1', ...resolver.graph(query, { direction: direction }) });
+    }
+    if (action === 'policy') {
+        const effective = ctx.args.includes('--effective');
+        if (!effective || !query)
+            return { exitCode: 1, message: 'Usage: aiwg schema policy --effective <id>' };
+        return jsonResult({ schema: 'aiwg.schema.policy.v1', id: resolver.require(query).artifact.id, effective: resolver.policy(query) });
+    }
+    if (action === 'validate') {
+        const schemaQuery = value(ctx.args, '--schema');
+        const instance = schemaQuery ? query : terms[1];
+        const selected = schemaQuery ?? query;
+        if (!selected || !instance)
+            return { exitCode: 1, message: 'Usage: aiwg schema validate --schema <id> <instance>' };
+        const entry = resolver.require(selected);
+        if (entry.artifact.format !== 'json-schema')
+            throw new Error(`Validation currently requires a JSON Schema artifact; got ${entry.artifact.format}`);
+        const data = readData(resolve(ctx.cwd, instance));
+        const result = new SchemaValidator(resolver, { rootDir: ctx.cwd }).validate(entry.artifact.id, data);
+        return jsonResult({ schema: 'aiwg.schema.validation.v1', ...result, instance }, result.valid ? 0 : 1);
+    }
+    if (action === 'lint') {
+        const diagnostics = [...loaded.diagnostics];
+        const entries = resolver.list();
+        for (const entry of entries) {
+            if (entry.artifact.format !== 'json-schema')
+                continue;
+            try {
+                new SchemaValidator(resolver, { rootDir: ctx.cwd }).compile(entry.artifact.id);
+            }
+            catch (error) {
+                diagnostics.push(diagnostic('SCHEMA_COMPILE_FAILED', error instanceof Error ? error.message : String(error), entry, entry.artifact.authority.path));
+            }
+        }
+        const valid = !diagnostics.some(item => item.severity === 'error');
+        return jsonResult({ schema: 'aiwg.schema.diagnostics.v1', valid, diagnostics }, valid ? 0 : 1);
+    }
+    if (action === 'check-refs') {
+        const diagnostics = [];
+        for (const entry of resolver.list()) {
+            for (const dependency of entry.artifact.dependencies ?? [])
+                if (!resolver.resolve(dependency.id) && !dependency.optional)
+                    diagnostics.push(diagnostic('SCHEMA_DEPENDENCY_UNRESOLVED', `Unresolved dependency ${dependency.id}`, entry));
+            if (entry.artifact.format !== 'json-schema' || !entry.artifact.authority.path)
+                continue;
+            for (const ref of schemaRefs(readData(authorityPath(ctx, entry)))) {
+                if (ref.startsWith('#'))
+                    continue;
+                const base = ref.split('#')[0];
+                if (!base)
+                    continue;
+                const local = resolve(dirname(authorityPath(ctx, entry)), base);
+                if (!resolver.resolve(base) && !resolver.resolve(ref) && !existsSync(local))
+                    diagnostics.push(diagnostic('SCHEMA_REFERENCE_UNRESOLVED', `Unresolved $ref ${ref}`, entry, entry.artifact.authority.path));
+            }
+        }
+        return jsonResult({ schema: 'aiwg.schema.references.v1', valid: diagnostics.length === 0, diagnostics }, diagnostics.length ? 1 : 0);
+    }
+    if (action === 'diff' || action === 'compatibility') {
+        const against = value(ctx.args, '--against');
+        if (!query || !against)
+            return { exitCode: 1, message: `Usage: aiwg schema ${action} <id|path> --against <id|path>` };
+        const current = resolveBaseline(ctx, resolver, query);
+        const baseline = resolveBaseline(ctx, resolver, against);
+        const result = analyzeBackwardCompatibility(baseline, current);
+        return jsonResult({ schema: action === 'diff' ? 'aiwg.schema.diff.v1' : 'aiwg.schema.compatibility.v1', current: query, baseline: against, ...result }, result.status === 'breaking' ? 1 : 0);
+    }
+    if (action === 'verify-projections') {
+        const entries = query ? [resolver.require(query)] : resolver.list();
+        const diagnostics = [];
+        for (const entry of entries)
+            for (const projection of entry.artifact.projections ?? []) {
+                const path = resolve(ctx.cwd, projection.path);
+                if (!existsSync(path)) {
+                    diagnostics.push(diagnostic('SCHEMA_PROJECTION_MISSING', `Projection does not exist: ${projection.path}`, entry, projection.path));
+                    continue;
+                }
+                const actual = digest(readFileSync(path));
+                if (projection.digest && projection.digest !== actual)
+                    diagnostics.push(diagnostic('SCHEMA_PROJECTION_DRIFT', `Projection digest does not match: ${projection.path}`, entry, projection.path));
+                if (projection.kind === 'mirror' && readFileSync(path).compare(readFileSync(authorityPath(ctx, entry))) !== 0)
+                    diagnostics.push(diagnostic('SCHEMA_PROJECTION_DRIFT', `Mirror differs from canonical authority: ${projection.path}`, entry, projection.path));
+            }
+        return jsonResult({ schema: 'aiwg.schema.projections.v1', valid: diagnostics.length === 0, diagnostics }, diagnostics.length ? 1 : 0);
+    }
+    const entries = query ? [resolver.require(query)] : resolver.list();
+    const projections = entries.flatMap(entry => (entry.artifact.projections ?? []).map(projection => ({ artifactId: entry.artifact.id, source: entry.artifact.authority.path, ...projection })));
+    if (ctx.args.includes('--write'))
+        for (const item of projections) {
+            if (item.kind !== 'mirror' || !item.source)
+                continue;
+            const target = resolve(ctx.cwd, item.path);
+            mkdirSync(dirname(target), { recursive: true });
+            writeFileSync(target, readFileSync(resolve(ctx.cwd, item.source)));
+        }
+    return jsonResult({ schema: 'aiwg.schema.generation-plan.v1', write: ctx.args.includes('--write'), projections });
+}
+export const schemaHandler = {
+    id: 'schema',
+    name: 'Schema Control Plane',
+    description: 'Discover, validate, compare, and verify governed schema artifacts',
+    category: 'utility',
+    aliases: ['schemas'],
+    async help() {
+        return { exitCode: 0, rawOutput: true, message: [
+                'Usage: aiwg schema <action> [options]',
+                '',
+                'Discovery: list, show <id>, graph [id], policy --effective <id>',
+                'Quality: lint, check-refs, validate --schema <id> <instance>',
+                'Evolution: diff <id|path> --against <id|path>, compatibility <id|path> --against <id|path>',
+                'Projections: generate [id] [--write], verify-projections [id]',
+                '',
+                'Common options: --catalog <path>, --domain <id>, --lifecycle <state>, --format <format>',
+                'All command results use stable versioned JSON envelopes.',
+            ].join('\n') };
+    },
+    async execute(ctx) {
+        try {
+            return await execute(ctx);
+        }
+        catch (error) {
+            return jsonResult({ schema: 'aiwg.schema.error.v1', error: error instanceof Error ? error.message : String(error) }, 1);
+        }
+    },
+};
+//# sourceMappingURL=schema.js.map