@aiwg/cli 2026.10.4 → 2026.10.6

package/dist/src/writing/writing-receipt.js

@@ -2,12 +2,13 @@ import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { z } from 'zod';
+import { integer, dateTime } from '../schema/zod-validation.mjs';
 import { redactStructured } from '../governance/redaction.js';
 import { resolveProjectAiwgDirForWrite } from '../config/project-artifacts.js';
 const sha = z.string().regex(/^[a-f0-9]{64}$/);
 const id = z.string().min(1).max(120).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/);
 const stableId = z.string().min(1).max(120).regex(/^[a-z0-9][a-z0-9.-]*$/).refine(value => !value.includes('..'));
-const isoDate = z.string().datetime();
+const isoDate = dateTime();
 const hash = (text) => createHash('sha256').update(text, 'utf8').digest('hex');
 function canonicalize(value) {
     if (Array.isArray(value))
@@ -28,105 +29,105 @@ function rejectSensitiveReceipt(value) {
     if (redacted.sensitivity !== 'none')
         throw new Error('Writing receipt contains a known secret or credential field');
 }
-const budgetSchema = z.object({
-    limit: z.number().int().nonnegative(),
-    used: z.number().int().nonnegative(),
+const budgetSchema = z.strictObject({
+    limit: integer().nonnegative(),
+    used: integer().nonnegative(),
     unit: z.enum(['tokens', 'utf8-bytes', 'characters']),
     measurement: z.enum(['exact', 'upper-bound', 'estimated']),
     tokenizerId: z.string().min(1).max(120),
     tokenizerVersion: z.string().min(1).max(120),
-}).strict().refine(value => value.used <= value.limit, 'Budget use cannot exceed limit');
-const operationConfigSchema = z.object({
+}).refine(value => value.used <= value.limit, 'Budget use cannot exceed limit');
+const operationConfigSchema = z.strictObject({
     action: z.enum(['plan', 'proofread', 'draft', 'edit', 'continue']),
-    correctionIds: z.array(id).default([]),
+    correctionIds: z.array(id).prefault([]),
     channel: z.enum(['article', 'social', 'email', 'engineering', 'conversation']).optional(),
     configSha256: sha.optional(),
-}).strict();
-const receiptInputBaseSchema = z.object({
+});
+const receiptInputBaseSchema = z.strictObject({
     schemaVersion: z.literal('aiwg.writing-receipt.v1').default('aiwg.writing-receipt.v1'),
     id: stableId.optional(),
     createdAt: isoDate.default(() => new Date().toISOString()),
     operation: z.enum(['draft-from-notes', 'edit-existing', 'proofread-only', 'continue-author-text']),
-    profile: z.object({
+    profile: z.strictObject({
         id: stableId,
         version: z.string().regex(/^\d+\.\d+\.\d+$/),
-        revision: z.number().int().positive(),
-        cacheEpoch: z.number().int().nonnegative(),
+        revision: integer().positive(),
+        cacheEpoch: integer().nonnegative(),
         compiledModeSha256: sha.optional(),
         fallback: z.boolean(),
-    }).strict(),
-    examples: z.object({
+    }),
+    examples: z.strictObject({
         receiptSha256: sha.optional(),
         cacheKey: sha.optional(),
-        selections: z.array(z.object({ sampleId: id, sha256: sha }).strict()).default([]),
+        selections: z.array(z.strictObject({ sampleId: id, sha256: sha })).prefault([]),
         budget: budgetSchema.optional(),
         fallback: z.boolean().default(false),
-    }).strict().optional(),
-    modes: z.array(z.object({
+    }).optional(),
+    modes: z.array(z.strictObject({
         id: stableId,
         version: z.string().min(1).max(120),
         profileSha256: sha.optional(),
-    }).strict()).default([]),
-    state: z.object({
-        selected: z.array(stableId).default([]),
-        delivered: z.array(stableId).default([]),
-        applied: z.array(stableId).default([]),
-        validated: z.array(stableId).default([]),
+    })).prefault([]),
+    state: z.strictObject({
+        selected: z.array(stableId).prefault([]),
+        delivered: z.array(stableId).prefault([]),
+        applied: z.array(stableId).prefault([]),
+        validated: z.array(stableId).prefault([]),
         deliveredTo: z.enum(['local-transform-callback', 'none']),
         fallback: z.enum(['none', 'unaltered']),
-    }).strict().optional(),
-    modelPrompt: z.object({
+    }).optional(),
+    modelPrompt: z.strictObject({
         execution: z.enum(['none', 'local-callback', 'hosted']).default('none'),
         provider: z.string().min(1).max(120).optional(),
         model: z.string().min(1).max(120).optional(),
         promptSha256: sha,
         templateSha256: sha.optional(),
-        decoding: z.object({
+        decoding: z.strictObject({
             temperature: z.number().finite().min(0).max(2).optional(),
             topP: z.number().finite().min(0).max(1).optional(),
-            maxOutputTokens: z.number().int().positive().optional(),
-            seed: z.number().int().optional(),
+            maxOutputTokens: integer().positive().optional(),
+            seed: integer().optional(),
             stopSha256: sha.optional(),
-        }).strict().optional(),
+        }).optional(),
         promptConfigSha256: sha.optional(),
-        hostedVersion: z.object({
+        hostedVersion: z.strictObject({
             attested: z.literal(false),
             reason: z.literal('Hosted provider prompt/version cannot be attested from this local receipt.'),
-        }).strict().optional(),
-    }).strict(),
-    inputs: z.array(z.object({
+        }).optional(),
+    }),
+    inputs: z.array(z.strictObject({
         id,
         role: z.enum(['source', 'author-notes', 'existing-draft', 'brief', 'configuration']),
         sha256: sha,
-    }).strict()).min(1),
+    })).min(1),
     operationConfig: operationConfigSchema.optional(),
-    output: z.object({
+    output: z.strictObject({
         sha256: sha,
         path: z.string().min(1).max(2000).optional(),
-    }).strict().optional(),
+    }).optional(),
     budget: budgetSchema,
-    fallback: z.object({
+    fallback: z.strictObject({
         applied: z.boolean(),
         reason: z.string().min(1).max(400).optional(),
-    }).strict(),
-    validators: z.array(z.object({
+    }),
+    validators: z.array(z.strictObject({
         id,
         version: z.string().min(1).max(120),
         sha256: sha.optional(),
         outcome: z.enum(['pass', 'fail', 'uncertain', 'not-run']),
-    }).strict()).default([]),
-    evaluation: z.array(z.object({
+    })).prefault([]),
+    evaluation: z.array(z.strictObject({
         id,
         method: z.string().min(1).max(120),
         sha256: sha,
         outcome: z.enum(['pass', 'fail', 'uncertain', 'not-established']),
-    }).strict()).default([]),
-    authorAcceptance: z.object({
+    })).prefault([]),
+    authorAcceptance: z.strictObject({
         status: z.enum(['accepted', 'pending', 'rejected', 'not-required']),
         acceptedAt: isoDate.optional(),
         acceptedBy: z.string().min(1).max(120).optional(),
-    }).strict(),
-}).strict();
+    }),
+});
 const enforceReceiptRules = (value, ctx) => {
     if (new Set(value.inputs.map(input => input.id)).size !== value.inputs.length) {
         ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Input IDs must be unique' });
@@ -176,7 +177,7 @@ const enforceReceiptRules = (value, ctx) => {
     }
 };
 const receiptInputSchema = receiptInputBaseSchema.superRefine(enforceReceiptRules);
-export const writingReceiptSchema = receiptInputBaseSchema.extend({ id: stableId, operationConfig: operationConfigSchema, receiptSha256: sha }).strict().superRefine(enforceReceiptRules);
+export const writingReceiptSchema = receiptInputBaseSchema.extend({ id: stableId, operationConfig: operationConfigSchema, receiptSha256: sha }).superRefine(enforceReceiptRules);
 export function createWritingReceipt(input) {
     const parsed = receiptInputSchema.parse(input);
     const defaultAction = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.10.4",
+  "version": "2026.10.6",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",
@@ -27,6 +27,9 @@
     "THIRD_PARTY_NOTICES.md",
     "bin/",
     "agentic/code/providers/",
+    "agentic/code/addons/composition-engine/lib/runtime.mjs",
+    "agentic/code/addons/composition-engine/lib/validator.mjs",
+    "agentic/code/addons/composition-engine/schemas/flow-graph.schema.json",
     "schemas/security/",
     "schemas/decision/",
     "schemas/dataset/",
@@ -115,7 +118,7 @@
     "semver": "^7.8.5",
     "toml-eslint-parser": "0.10.0",
     "yaml": "^2.9.0",
-    "zod": "^3.25.0"
+    "zod": "^4.6.6"
   },
   "optionalDependencies": {
     "@hono/node-server": "2.0.11",

package/schemas/decision/DecisionReview.schema.json

@@ -17,12 +17,89 @@
     "lifecycle": { "type": "object", "additionalProperties": false, "required": ["legalHold"], "properties": { "legalHold": { "type": "boolean" }, "tombstonedAtEpochMs": { "type": "integer", "minimum": 0 }, "tombstoneReason": { "type": "string" } } }
   },
   "$defs": {
+    "evaluation": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Observed evaluator provenance and evidence. Agreement does not establish independent errors or proof.",
+      "properties": {
+        "evaluatorModel": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 8192,
+          "pattern": "\\S"
+        },
+        "evaluatorVendor": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 8192,
+          "pattern": "\\S"
+        },
+        "evaluatorFamily": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 8192,
+          "pattern": "\\S",
+          "description": "Observed model family; unknown remains unknown. CLI names are not model families."
+        },
+        "acceptanceCriteriaRef": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 8192,
+          "pattern": "\\S"
+        },
+        "reReviewOf": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 8192,
+          "pattern": "\\S",
+          "description": "Reference to the previous review/decision, recorded on a re-review after material fixes."
+        },
+        "disagreements": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "claimRef",
+              "generatorPosition",
+              "evaluatorPosition"
+            ],
+            "properties": {
+              "claimRef": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 8192,
+                "pattern": "\\S"
+              },
+              "generatorPosition": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 8192,
+                "pattern": "\\S"
+              },
+              "evaluatorPosition": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 8192,
+                "pattern": "\\S"
+              },
+              "resolutionRef": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 8192,
+                "pattern": "\\S"
+              }
+            }
+          }
+        }
+      }
+    },
     "digest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
     "actor": { "type": "object", "additionalProperties": false, "required": ["id", "roles", "authorityContext"], "properties": { "id": { "type": "string", "minLength": 1 }, "roles": { "type": "array", "items": { "type": "string" } }, "authorityContext": { "type": "string" } } },
     "pin": { "type": "object", "additionalProperties": false, "required": ["id", "version", "digest"], "properties": { "id": { "type": "string" }, "version": { "type": "string" }, "digest": { "$ref": "#/$defs/digest" } } },
     "sourceReceipt": { "type": "object", "additionalProperties": false, "required": ["id", "digest"], "properties": { "id": { "type": "string" }, "digest": { "$ref": "#/$defs/digest" } } },
     "proposal": { "type": "object", "additionalProperties": false, "required": ["version", "action", "actionDigest", "createdAtEpochMs", "editor", "rationale"], "properties": { "version": { "type": "integer", "minimum": 1 }, "action": {}, "actionDigest": { "$ref": "#/$defs/digest" }, "createdAtEpochMs": { "type": "integer" }, "editor": { "$ref": "#/$defs/actor" }, "rationale": { "type": "string" } } },
-    "decision": { "type": "object", "additionalProperties": false, "required": ["reviewer", "proposalVersion", "decision", "rationale", "atEpochMs"], "properties": { "reviewer": { "$ref": "#/$defs/actor" }, "proposalVersion": { "type": "integer" }, "decision": { "enum": ["approve", "reject"] }, "rationale": { "type": "string" }, "atEpochMs": { "type": "integer" } } },
+    "decision": { "type": "object", "additionalProperties": false, "required": ["reviewer", "proposalVersion", "decision", "rationale", "atEpochMs"], "properties": { "reviewer": { "$ref": "#/$defs/actor" }, "proposalVersion": { "type": "integer" }, "decision": { "enum": ["approve", "reject"] }, "rationale": { "type": "string" }, "atEpochMs": { "type": "integer" }, "evaluation": { "$ref": "#/$defs/evaluation" } } },
     "event": { "type": "object", "additionalProperties": false, "required": ["sequence", "type", "atEpochMs", "actor", "proposalVersion", "rationale"], "properties": { "sequence": { "type": "integer" }, "type": { "enum": ["created", "claimed", "approved", "rejected", "edited", "expired", "escalated", "canceled", "resumed", "execution-completed", "execution-failed", "legal-hold-placed", "legal-hold-released", "tombstoned", "authorization-denied", "sensitive-view-accessed"] }, "atEpochMs": { "type": "integer" }, "actor": { "$ref": "#/$defs/actor" }, "proposalVersion": { "type": "integer" }, "rationale": { "type": "string" }, "operatorDecisionEventId": { "type": "string", "minLength": 1 }, "data": { "type": "object" } } },
     "effect": { "type": "object", "additionalProperties": false, "required": ["effectId", "continuationId", "proposalVersion", "completedAtEpochMs", "result"], "properties": { "effectId": { "type": "string" }, "continuationId": { "type": "string" }, "proposalVersion": { "type": "integer" }, "completedAtEpochMs": { "type": "integer" }, "result": {} } }
   }

package/schemas/mission-v1.schema.json

@@ -1643,6 +1643,9 @@
       "type": "object",
       "additionalProperties": false,
       "properties": {
+        "isolation": {
+          "enum": ["systemd-unit", "native-sandbox"]
+        },
         "version": {
           "const": 1
         },

package/tools/agents/deploy-agents.mjs

@@ -32,6 +32,7 @@
  *   --model-tier <tier>      Override all artifacts with economy|standard|premium
  *   --as-agents-md               Aggregate to single AGENTS.md (OpenAI/Codex)
  *   --create-agents-md           Create/update AGENTS.md template
+  --no-context-files           Preserve WORKSPACE.md, AIWG.md and AGENTS.md (including managed blocks)
  *   --skip-commands-migration    Skip deleting the commands directory (warns about duplicate TUI entries) (Factory/Codex/OpenCode/Cursor)
  *   --deploy-source <name>       Managed-marker source for deployed artifacts (default: bundled)
  *   --deploy-version <version>   Managed-marker version for deployed artifacts (default: source package.json)
@@ -75,6 +76,8 @@ const staticModelCatalog = _require('../../agentic/code/providers/model-catalog.
 let fs;
 try { const gfs = _require('graceful-fs'); gfs.gracefulify(realFs); fs = realFs; } catch { fs = realFs; }
 import path from 'path';
+import { importImpl } from '../_resolve-impl.mjs';
+const { resolveDeployVersion } = await importImpl(import.meta.url, 'providers/deploy-version.mjs');
 import os from 'os';
 import readline from 'readline';
 import { fileURLToPath } from 'url';
@@ -96,20 +99,6 @@ import {
   resolveAiwgRoot,
   updateSidecarManifest,
 } from './providers/base.mjs';
-const modelCatalog = loadRuntimeModelCatalog(staticModelCatalog);
-
-/**
- * Read version from package.json at the source root.
- * Falls back to 'unknown' if unavailable.
- */
-function getDeployVersion(srcRoot) {
-  try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(srcRoot, 'package.json'), 'utf8'));
-    return pkg.version || 'unknown';
-  } catch {
-    return 'unknown';
-  }
-}
 
 // ============================================================================
 // Provider Registry
@@ -421,10 +410,8 @@ function pruneStaleAiwgArtifacts(provider, target, srcRoot, opts, explicitSource
   }
 
   if (opts.kernelOnly) {
-    // A kernel-only run deploys skills and nothing else (deployCommands /
-    // deployRules / deployBehaviors are all forced false above), so it has no
-    // basis for judging any flat artifact stale. The empty desired set below
-    // exists for one narrow migration: clearing agents/commands/rules left by
+    // Kernel-only delivers skills and rules. The empty desired set below
+    // applies only to bulk agents/commands left by
     // the pre-#152 bulk default, when the bulk install is the only thing this
     // project ever deployed.
     //
@@ -438,7 +425,7 @@ function pruneStaleAiwgArtifacts(provider, target, srcRoot, opts, explicitSource
       }
       return;
     }
-    for (const type of ['agents', 'commands', 'rules']) {
+    for (const type of ['agents', 'commands']) {
       const relPath = provider.paths?.[type];
       if (!relPath || relPath.endsWith('.md')) continue;
       const destDir = path.isAbsolute(relPath) ? relPath : path.join(target, relPath);
@@ -499,6 +486,8 @@ export function parseArgs(args = process.argv.slice(2)) {
     efficiencyModel: null,
     asAgentsMd: false,
     createAgentsMd: false,
+    contextFiles: true,
+    projectScope: false,
     deployCommands: false,
     deploySkills: false,
     deployRules: false,
@@ -509,6 +498,8 @@ export function parseArgs(args = process.argv.slice(2)) {
     strict: false,
     reportOnly: true,
     kernelOnly: false,
+    deferRuleProjection: false,
+    additionalSources: [],
     filter: null,           // Glob pattern for agent names
     filterRole: null,       // Filter by role: reasoning|coding|efficiency
     save: false,            // Save model config to project models.json
@@ -532,6 +523,11 @@ export function parseArgs(args = process.argv.slice(2)) {
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a === '--source' && args[i + 1]) cfg.source = path.resolve(args[++i]);
+    else if (a === '--additional-source') {
+      const source = args[++i];
+      if (!source || source.startsWith('--')) throw new Error('--additional-source requires a source directory');
+      cfg.additionalSources.push(path.resolve(source));
+    }
     else if (a === '--target' && args[i + 1]) cfg.target = path.resolve(args[++i]);
     else if (a === '--mode' && args[i + 1]) cfg.mode = String(args[++i]).toLowerCase();
     else if (a === '--scope') {
@@ -540,6 +536,7 @@ export function parseArgs(args = process.argv.slice(2)) {
         throw new Error(`--scope expected 'user' or 'project', got '${scope ?? '(missing)'}'`);
       }
       cfg.userScope = scope === 'user';
+      cfg.projectScope = scope === 'project';
     }
     else if (a === '--user') cfg.userScope = true;
     else if (a === '--dry-run') cfg.dryRun = true;
@@ -563,6 +560,8 @@ export function parseArgs(args = process.argv.slice(2)) {
     else if (a === '--allow-over-budget') cfg.allowOverBudget = true;
     else if (a === '--report-only') cfg.reportOnly = true;
     else if (a === '--kernel-only') cfg.kernelOnly = true;
+    // Internal use orchestration: the final source owns rule presentation.
+    else if (a === '--defer-rule-projection') cfg.deferRuleProjection = true;
     else if (a === '--deploy-behaviors') cfg.deployBehaviors = true;
     else if (a === '--filter' && args[i + 1]) cfg.filter = args[++i];
     else if (a === '--filter-role' && args[i + 1]) cfg.filterRole = args[++i];
@@ -579,12 +578,12 @@ export function parseArgs(args = process.argv.slice(2)) {
     // managed-hooks opt-out (default on, mirroring the Claude autoInstall policy).
     else if (a === '--mcp') cfg.mcp = true;
     else if (a === '--no-hooks') cfg.hooks = false;
+    else if (a === '--no-context-files') cfg.contextFiles = false;
     else if (a === '--deploy-source' && args[i + 1]) cfg.deploySource = String(args[++i]);
     else if (a === '--listing-budget') cfg.listingBudget = true;
     else if (a === '--deploy-version' && args[i + 1]) cfg.deployVersion = String(args[++i]);
     else if (a === '--help' || a === '-h') {
-      printHelp();
-      process.exit(0);
+      cfg.help = true;
     }
   }
   return cfg;
@@ -610,7 +609,7 @@ Options:
   --commands-only          Deploy only commands (skip agents)
   --skills-only            Deploy only skills (skip agents)
   --rules-only             Deploy only rules (skip agents)
-  --kernel-only            Deploy kernel skills only and prune managed bulk artifacts
+  --kernel-only            Deploy kernel skills and rules; prune managed bulk agents/commands
   --dry-run                Show what would be deployed without writing
   --force                  Overwrite existing files
   --provider <name>        Target provider (see below)
@@ -630,6 +629,7 @@ Options:
                            (.muse/hooks.json; installed by default)
   --as-agents-md               Aggregate to single AGENTS.md (Codex)
   --create-agents-md           Create/update AGENTS.md template
+  --no-context-files           Preserve WORKSPACE.md, AIWG.md and AGENTS.md (including managed blocks)
   --skip-commands-migration    Skip deleting the commands directory before skills deployment
   --listing-budget             Honor the provider startup-listing cap even with --copy-all
   --deploy-source <name>       Managed-marker source stamped into deployed artifacts.
@@ -743,7 +743,7 @@ function resolveProvider(name) {
       console.error('');
       for (const line of UNSUPPORTED_PROVIDER_HINTS[candidate]) console.error(line);
     }
-    process.exit(1);
+    throw new Error(`Unknown provider: ${name}`);
   }
   return resolved;
 }
@@ -753,14 +753,17 @@ function resolveProvider(name) {
  */
 async function loadProvider(providerName) {
   const resolved = resolveProvider(providerName);
-  const providerPath = `./providers/${resolved}.mjs`;
+  // Resolve against this module, not the caller's cwd: in-process callers
+  // (including module runners such as Vitest) cannot resolve a bare relative
+  // specifier held in a variable.
+  const providerUrl = new URL(`./providers/${resolved}.mjs`, import.meta.url).href;
 
   try {
-    const provider = await import(providerPath);
+    const provider = await import(providerUrl);
     return provider.default || provider;
   } catch (err) {
     console.error(`Failed to load provider '${resolved}':`, err.message);
-    process.exit(1);
+    throw err;
   }
 }
 
@@ -896,7 +899,7 @@ function deepMerge(target, source) {
  * @param {string} targetDir - Resolved target directory
  * @returns {Promise<boolean>} true = proceed with migration, false = skip
  */
-async function promptCommandsMigration(cfg, provider, targetDir) {
+async function promptCommandsMigration(cfg, provider, targetDir, interactive = process.stdout.isTTY) {
   // Home-directory providers share commands across projects — do not delete.
   if (provider.capabilities?.homeDirectoryDeploy) return false;
   // Some providers intentionally expose both surfaces with different runtime
@@ -914,7 +917,7 @@ async function promptCommandsMigration(cfg, provider, targetDir) {
   if (entries.length === 0) return false;
 
   // Non-interactive context: migrate silently.
-  if (cfg.quiet || !process.stdout.isTTY) return true;
+  if (cfg.quiet || !interactive) return true;
 
   const rel = path.relative(process.cwd(), commandsDir);
   console.log(`\n⚠  Commands → Skills Migration`);
@@ -948,6 +951,8 @@ async function promptCommandsMigration(cfg, provider, targetDir) {
 
 export async function main(args = process.argv.slice(2), internal = {}) {
   const cfg = parseArgs(args);
+  if (cfg.help) { printHelp(); return 0; }
+  const modelCatalog = loadRuntimeModelCatalog(staticModelCatalog);
 
   // Resolve source directory (default to repo root relative to this script)
   const __filename = fileURLToPath(import.meta.url);
@@ -956,8 +961,7 @@ export async function main(args = process.argv.slice(2), internal = {}) {
 
   // Validate source directory
   if (!fs.existsSync(srcRoot)) {
-    console.error(`Source directory not found: ${srcRoot}`);
-    process.exit(1);
+    throw new Error(`Source directory not found: ${srcRoot}`);
   }
 
   // Validate target directory
@@ -1020,6 +1024,10 @@ export async function main(args = process.argv.slice(2), internal = {}) {
 
   // Load provider module
   const provider = await loadProvider(cfg.provider);
+  if (cfg.additionalSources.length && provider.name !== 'omp') throw new Error('--additional-source requires the OMP provider');
+  for (const source of cfg.additionalSources) {
+    if (!fs.statSync(source).isDirectory()) throw new Error(`Additional source is not a directory: ${source}`);
+  }
   if (!cfg.quiet) console.log(`\nLoaded provider: ${provider.name}`);
 
   // Build options for provider
@@ -1038,11 +1046,15 @@ export async function main(args = process.argv.slice(2), internal = {}) {
     codingModel: cfg.codingModel,
     efficiencyModel: cfg.efficiencyModel,
     modelsConfig,
+    modelCatalog,
+    // Warnings belong to this pass, just as they do in an isolated CLI run.
+    warnedCommandsDirs: new Set(),
     asAgentsMd: cfg.asAgentsMd,
-    createAgentsMd: cfg.createAgentsMd,
+    createAgentsMd: cfg.contextFiles && cfg.createAgentsMd,
+    contextFiles: cfg.contextFiles,
     deployCommands: cfg.kernelOnly ? false : cfg.deployCommands,
     deploySkills: cfg.kernelOnly ? true : cfg.deploySkills,
-    deployRules: cfg.kernelOnly ? false : cfg.deployRules,
+    deployRules: !cfg.deferRuleProjection && (cfg.kernelOnly || cfg.deployRules),
     deployBehaviors: cfg.kernelOnly ? false : cfg.deployBehaviors,
     commandsOnly: cfg.commandsOnly,
     skillsOnly: cfg.skillsOnly || cfg.kernelOnly,
@@ -1051,6 +1063,8 @@ export async function main(args = process.argv.slice(2), internal = {}) {
     reportOnly: cfg.reportOnly,
     allowOverBudget: cfg.allowOverBudget === true,
     kernelOnly: cfg.kernelOnly,
+    deferRuleProjection: cfg.deferRuleProjection,
+    additionalSources: cfg.additionalSources,
     filter: cfg.filter,
     filterRole: cfg.filterRole,
     save: cfg.save,
@@ -1070,17 +1084,23 @@ export async function main(args = process.argv.slice(2), internal = {}) {
     mcp: cfg.mcp === true,
     hooks: cfg.hooks !== false,
     listingBudget: cfg.listingBudget === true,
-    deployVersion: cfg.deployVersion || getDeployVersion(srcRoot),
+    deployVersion: resolveDeployVersion(resolveAiwgRoot(srcRoot) || srcRoot, cfg.deployVersion),
     deploySource: cfg.deploySource || 'bundled',
   };
-  const { isRuleDeploymentPreparationActive } = await import('./providers/rule-delivery.mjs');
-  const preparationActive = isRuleDeploymentPreparationActive();
+  if (provider.name === 'hermes' && cfg.projectScope && !cfg.userScope) {
+    throw new Error('Hermes does not support --scope project: skills are discovered only under HERMES_HOME/skills (default ~/.hermes/skills). Use --scope user or an isolated HERMES_HOME profile shared with Hermes.');
+  }
+  // Deferred kernel source passes must not load the projection dependency
+  // graph. Preparation still owns their staged deployment when a hook is active.
+  const preparationActive = cfg.kernelOnly && cfg.deferRuleProjection
+    ? Boolean(globalThis[Symbol.for('aiwg.provider-preparation-hook.v1')])
+    : (await import('./providers/rule-delivery.mjs')).isRuleDeploymentPreparationActive();
 
   // Commands → Skills migration: prompt then delete the commands directory
   // so stale command files don't create duplicates in the provider TUI.
   if (!preparationActive && !internal.finalizeOnly) {
     if (!cfg.dryRun && !cfg.skipCommandsMigration) {
-      const doMigrate = await promptCommandsMigration(cfg, provider, cfg.target);
+      const doMigrate = await promptCommandsMigration(cfg, provider, cfg.target, internal.capture ? false : process.stdout.isTTY);
       if (doMigrate) {
         const commandsRelPath = provider.paths?.commands;
         if (commandsRelPath) {
@@ -1106,7 +1126,13 @@ export async function main(args = process.argv.slice(2), internal = {}) {
 
   // Delegate to provider
   try {
-    if (!internal.finalizeOnly) await provider.deploy(opts);
+    if (!internal.finalizeOnly) {
+      if (cfg.kernelOnly && (!cfg.deferRuleProjection || preparationActive)
+        && !['claude', 'codex', 'cursor', 'hermes', 'warp', 'openclaw', 'pi', 'copilot', 'factory', 'opencode', 'windsurf', 'antigravity', 'muse', 'omp', 'grok-build'].includes(provider.name)) {
+        const { deployWithRuleDelivery } = await import('./providers/rule-delivery.mjs');
+        await deployWithRuleDelivery(opts, provider, staged => provider.deploy(staged));
+      } else await provider.deploy(opts);
+    }
     if (preparationActive) return;
 
     const mirroredCommandCount = mirrorSkillsAsCommands(provider, cfg.target, srcRoot, opts);
@@ -1138,11 +1164,13 @@ export async function main(args = process.argv.slice(2), internal = {}) {
     if (cfg.dryRun) {
       console.error('(dry-run mode - no files were modified)');
     }
-    process.exit(1);
+    return 1;
   }
+  return 0;
 }
 
 const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : null;
 if (invokedPath === fileURLToPath(import.meta.url)) {
-  await main();
+  try { process.exitCode = (await main()) ?? 0; }
+  catch (error) { console.error(error.message); process.exitCode = 1; }
 }

package/tools/agents/providers/antigravity.mjs

@@ -2,6 +2,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import {
+  withRuleDeployment,
   collectFrameworkArtifacts,
   createAgentsMdFromTemplate,
   deployFiles,
@@ -96,7 +97,7 @@ export async function postDeploy(target, opts) {
     throw new Error('Antigravity global skill deployment is disabled: official 1.1.26 path documentation conflicts');
   }
   if (opts.createAgentsMd || (!opts.commandsOnly && !opts.skillsOnly && !opts.rulesOnly)) {
-    createAgentsMd(target, opts.srcRoot, opts.dryRun);
+    if (opts.contextFiles !== false) createAgentsMd(target, opts.srcRoot, opts.dryRun);
   }
   if (!opts.quiet) {
     console.log('Antigravity resources are project scoped. Restart agy after resource changes; authenticate with the provider separately.');
@@ -106,6 +107,10 @@ export async function postDeploy(target, opts) {
 export function getFileExtension() { return '.md'; }
 
 export async function deploy(opts) {
+  return withRuleDeployment(opts, { name, paths, kernelSkillsPath }, deploySelected);
+}
+
+async function deploySelected(opts) {
   if (opts.global || opts.user || opts.scope === 'user') {
     throw new Error('Antigravity global skill deployment is disabled: official 1.1.26 path documentation conflicts');
   }