@aiwg/cli 2026.10.3 → 2026.10.5

package/tools/agents/providers/warp.mjs

@@ -29,10 +29,12 @@ import path from 'path';
 import { spawn } from 'child_process';
 import { classifyModelRole, modelForRole } from './model-role.mjs';
 import {
+  withRuleDeployment,
   ensureDir,
   listMdFiles,
   listSkillDirs,
   deploySkillDir,
+  deployFiles,
   deploySkillsWithKernelRouting,
   isKernelSkill,
   pruneStaleAiwgSkills,
@@ -197,33 +199,15 @@ export function deploySkills(skillDirs, targetDir, opts) {
  * This generates the aggregated WARP.md file
  */
 export async function deployWarp(targetDir, srcRoot, opts) {
-  const scriptPath = path.join(srcRoot, 'tools', 'warp', 'setup-warp.mjs');
+  const { generateAIWGContent, mergeWarpMd } = await import('../../warp/warp-content.mjs');
+  const dest = path.join(targetDir, 'WARP.md');
+  const existing = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8') : '';
+  const content = generateAIWGContent(srcRoot, opts.mode, opts);
+  // Preserve operator sections even for a forced artifact refresh.
+  const output = mergeWarpMd(existing, content, false);
+  ensureDir(targetDir, opts.dryRun);
+  if (!opts.dryRun) fs.writeFileSync(dest, output);
 
-  if (!fs.existsSync(scriptPath)) {
-    console.warn(`Warp setup script not found at ${scriptPath}`);
-    return;
-  }
-
-  console.log('\nGenerating aggregated WARP.md...');
-
-  return new Promise((resolve, reject) => {
-    const args = ['--target', targetDir, '--source', srcRoot];
-    if (opts.dryRun) args.push('--dry-run');
-    if (opts.force) args.push('--force');
-    if (opts.mode) args.push('--mode', opts.mode);
-
-    const child = spawn('node', [scriptPath, ...args], {
-      stdio: 'inherit',
-      cwd: srcRoot
-    });
-
-    child.on('close', (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`setup-warp.mjs exited with code ${code}`));
-    });
-
-    child.on('error', reject);
-  });
 }
 
 // ============================================================================
@@ -259,6 +243,10 @@ export function getFileExtension(type) {
  * Deploys discrete files for all artifact types, then generates aggregated WARP.md
  */
 export async function deploy(opts) {
+  return withRuleDeployment(opts, { name, paths, kernelSkillsPath }, deploySelected);
+}
+
+async function deploySelected(opts) {
   const {
     srcRoot,
     target,
@@ -380,6 +368,12 @@ export async function deploy(opts) {
     console.log(`\nSkipping discrete rule deployment (Warp uses WARP.md)`);
   }
 
+  // Bound definitions must live outside the startup routing table.
+  ensureDir(path.join(target, paths.agents));
+  ensureDir(path.join(target, paths.commands));
+  deployFiles(agentFiles, path.join(target, paths.agents), opts, transformAgent);
+  deployFiles(commandFiles, path.join(target, paths.commands), opts, transformCommand);
+
   // Generate aggregated WARP.md (existing behavior)
   console.log('\n--- Generating aggregated output ---');
   await deployWarp(target, srcRoot, opts);

package/tools/cli/decision-offload-report.mjs

@@ -0,0 +1,40 @@
+import { fileURLToPath } from 'node:url';
+import { importImpl } from '../_resolve-impl.mjs';
+
+/** Offline inspection only: never probes a service or records an opportunity. */
+export async function collectDecisionOffloadReport(projectRoot) {
+  try {
+    const { buildDecisionOffloadSnapshot } = await importImpl(import.meta.url, 'decision/offload.js');
+    return await buildDecisionOffloadSnapshot({ projectRoot, frameworkRoot: fileURLToPath(new URL('../../', import.meta.url)) });
+  } catch {
+    // An unavailable reader must not be interpreted as healthy adoption, nor
+    // leak exception details that can include private paths or stored values.
+    return { status: 'unknown', observation: 'unknown', reason: 'report-unavailable', advisory: true };
+  }
+}
+
+export function formatDecisionOffloadReport(snapshot) {
+  const lines = ['Decision offload (offline, advisory):'];
+  if (snapshot.status === 'unknown' && snapshot.reason === 'report-unavailable') {
+    lines.push('  Observation: unknown (report unavailable).');
+    return lines;
+  }
+  const calls = snapshot.calls?.organic;
+  const opportunities = snapshot.opportunities?.organic;
+  lines.push(`  Scope: ${snapshot.scope?.mode ?? 'unknown'}${snapshot.scope?.sessionId ? ` (${snapshot.scope.sessionId})` : ''}`);
+  lines.push(`  Ask: ${snapshot.readiness?.ask?.state ?? 'unknown'}; evaluate: ${snapshot.readiness?.evaluate?.state ?? 'unknown'} (no probe)`);
+  lines.push(`  Completed calls: ${calls?.completed ?? 'unknown'}; answered: ${calls?.answered ?? 'unknown'}; fallback: ${calls?.fallback ?? 'unknown'}`);
+  if (calls) {
+    lines.push(`  Estimated LLM tokens avoided: ${calls.llmTokensAvoided}; Jev tokens: ${calls.jevTokens}`);
+    for (const [reason, count] of Object.entries(calls.fallbackReasons ?? {}).sort(([a], [b]) => a.localeCompare(b))) {
+      lines.push(`  Fallback ${reason}: ${count}`);
+    }
+  }
+  if (opportunities) lines.push(`  Observed checkpoints: ${opportunities.observed}; eligible: ${opportunities.eligible}; attempted: ${opportunities.attempted}; skipped: ${opportunities.skipped}; unknown: ${opportunities.unknown}`);
+  lines.push(`  Activation: rule=${snapshot.activation?.ruleDelivery ?? 'unknown'}, anchor=${snapshot.activation?.startupAnchor ?? 'unknown'}, native=${snapshot.activation?.nativeActivation ?? 'unknown'}`);
+  lines.push(`  Drift: ${snapshot.drift?.status ?? 'unknown'}${snapshot.drift?.reasons?.length ? ` (${snapshot.drift.reasons.join(', ')})` : ''}`);
+  if (snapshot.activityHint?.status === 'advisory') lines.push(`  Activity hint (low confidence): ${snapshot.activityHint.reason}; eligible count unknown.`);
+  if (snapshot.drift?.note) lines.push(`  ${snapshot.drift.note}`);
+  lines.push('  Diagnostic/setup/benchmark calls are excluded from organic adoption.');
+  return lines;
+}