archondev 2.19.57 → 3.0.0

package/dist/{chunk-LU4DXW3J.js → chunk-YK5Z6U5A.js}

@@ -1,11 +1,12 @@
 import {
   loadAtom,
   loadRoleOverrides
-} from "./chunk-OHIN6OHU.js";
+} from "./chunk-7RXZTPXY.js";
 import {
+  appendLocalUsageEntry,
   debugLog,
   getDebugLogPath
-} from "./chunk-R664NEAA.js";
+} from "./chunk-I3BBA7MB.js";
 import {
   ArchitectureParser
 } from "./chunk-5EVHUDQX.js";
@@ -21,6 +22,10 @@ import {
 import {
   KeyManager
 } from "./chunk-RDG5BUED.js";
+import {
+  loadConfig,
+  saveConfig
+} from "./chunk-GGRW4NTA.js";
 import {
   __commonJS,
   __require,
@@ -2851,10 +2856,10 @@ var require_js_yaml2 = __commonJS({
 });
 
 // src/cli/execute.ts
-import chalk2 from "chalk";
-import { existsSync as existsSync8 } from "fs";
+import chalk3 from "chalk";
+import { existsSync as existsSync9 } from "fs";
 import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 import { createInterface } from "readline";
 
@@ -4512,6 +4517,208 @@ function getDefaultModelForRole(role, provider) {
   return "claude-sonnet-4-6";
 }
 
+// src/core/risk/scorer.ts
+function computeRiskScore(filesToModify, schema, depCheck) {
+  const factors = [];
+  let score = 0;
+  for (const pp of schema.protectedPaths) {
+    if (pp.level === "HARD") {
+      const matched = filesToModify.filter((f) => matchesPattern(f, pp.pattern));
+      if (matched.length > 0) {
+        const pts = 20 * matched.length;
+        score += pts;
+        factors.push({ label: "HARD protected path", points: pts, detail: pp.pattern });
+      }
+    }
+  }
+  for (const pp of schema.protectedPaths) {
+    if (pp.level === "SOFT") {
+      const matched = filesToModify.filter((f) => matchesPattern(f, pp.pattern));
+      if (matched.length > 0) {
+        const pts = 10 * matched.length;
+        score += pts;
+        factors.push({ label: "SOFT protected path", points: pts, detail: pp.pattern });
+      }
+    }
+  }
+  for (const cp of schema.cautiousPaths ?? []) {
+    const matched = filesToModify.filter((f) => matchesPattern(f, cp.pattern));
+    if (matched.length > 0) {
+      const pts = 10 * matched.length;
+      score += pts;
+      factors.push({ label: "Cautious path", points: pts, detail: cp.pattern });
+    }
+  }
+  for (const comp of schema.components) {
+    if (comp.stability === "STABLE") {
+      const touchesStable = filesToModify.some(
+        (f) => comp.paths.some((p) => matchesPattern(f, p))
+      );
+      if (touchesStable) {
+        score += 5;
+        factors.push({ label: "STABLE component", points: 5, detail: comp.name });
+      }
+    }
+  }
+  if (depCheck) {
+    for (const impact of depCheck.impacts) {
+      const pts = impact.rule.severity === "BLOCKER" ? 3 : impact.rule.severity === "WARNING" ? 2 : 0;
+      if (pts > 0) {
+        score += pts;
+        factors.push({
+          label: `${impact.rule.severity} dependency`,
+          points: pts,
+          detail: impact.rule.id
+        });
+      }
+    }
+  }
+  const fileCount = filesToModify.length;
+  if (fileCount > 5) {
+    const pts = fileCount - 5;
+    score += pts;
+    factors.push({ label: "File complexity", points: pts, detail: `${fileCount} files (>${5})` });
+  }
+  score = Math.min(score, 100);
+  const level = scoreToLevel(score);
+  const summary = buildSummary(fileCount, factors, score, level);
+  return { score, level, factors, fileCount, summary };
+}
+function scoreToLevel(score) {
+  if (score <= 25) return "LOW";
+  if (score <= 50) return "MEDIUM";
+  if (score <= 75) return "HIGH";
+  return "CRITICAL";
+}
+function shouldAskConfirmation(level, approvalPolicy) {
+  if (approvalPolicy === "full_autopilot") return false;
+  if (level === "CRITICAL") return true;
+  if (level === "HIGH" && approvalPolicy !== "always_approve_safe_ops") return true;
+  return false;
+}
+function buildSummary(fileCount, factors, score, level) {
+  const parts = [`${fileCount} file${fileCount !== 1 ? "s" : ""}`];
+  const protectedCount = factors.filter(
+    (f) => f.label.includes("protected") || f.label.includes("Cautious")
+  ).length;
+  if (protectedCount > 0) {
+    parts.push(`${protectedCount} protected path${protectedCount !== 1 ? "s" : ""}`);
+  } else {
+    parts.push("no protected paths");
+  }
+  const depFactors = factors.filter((f) => f.label.includes("dependency"));
+  if (depFactors.length > 0) {
+    parts.push(`${depFactors.length} dep warning${depFactors.length !== 1 ? "s" : ""}`);
+  }
+  return parts.join(", ");
+}
+function matchesPattern(filePath, pattern) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  if (normalizedPattern.includes("*")) {
+    const regex = normalizedPattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+    return new RegExp(`^${regex}`).test(normalized) || new RegExp(regex).test(normalized);
+  }
+  return normalized.startsWith(normalizedPattern) || normalized.includes(`/${normalizedPattern}`);
+}
+
+// src/cli/policy.ts
+import chalk2 from "chalk";
+var DEFAULT_POLICY = {
+  approval: "approve_this_task",
+  sentinel: "plan_batch_only",
+  routing: "balanced"
+};
+async function loadRuntimePolicy() {
+  const config = await loadConfig();
+  return {
+    approval: config.approvalPolicy ?? DEFAULT_POLICY.approval,
+    sentinel: config.sentinelPolicy ?? DEFAULT_POLICY.sentinel,
+    routing: config.routingProfile ?? DEFAULT_POLICY.routing
+  };
+}
+async function setRuntimePolicy(update) {
+  const config = await loadConfig();
+  const next = {
+    approval: update.approval ?? config.approvalPolicy ?? DEFAULT_POLICY.approval,
+    sentinel: update.sentinel ?? config.sentinelPolicy ?? DEFAULT_POLICY.sentinel,
+    routing: update.routing ?? config.routingProfile ?? DEFAULT_POLICY.routing
+  };
+  await saveConfig({
+    ...config,
+    approvalPolicy: next.approval,
+    sentinelPolicy: next.sentinel,
+    routingProfile: next.routing
+  });
+  return next;
+}
+async function showPolicy() {
+  const policy = await loadRuntimePolicy();
+  console.log(chalk2.green("Runtime Policy:"));
+  console.log();
+  console.log(`  ${chalk2.blue("Approval:")} ${policy.approval}`);
+  console.log(`  ${chalk2.blue("Sentinel:")} ${policy.sentinel}`);
+  console.log(`  ${chalk2.blue("Routing:")}  ${policy.routing}`);
+}
+async function setPolicy(scope, value) {
+  if (scope === "approval") {
+    const allowed = [
+      "ask_every_time",
+      "approve_this_task",
+      "approve_this_session",
+      "always_approve_safe_ops",
+      "full_autopilot"
+    ];
+    if (!allowed.includes(value)) {
+      console.error(chalk2.red(`Invalid approval policy: ${value}`));
+      console.log(chalk2.dim(`Valid values: ${allowed.join(", ")}`));
+      process.exit(1);
+    }
+    await setRuntimePolicy({ approval: value });
+    console.log(chalk2.green(`\u2713 approval policy set to ${value}`));
+    return;
+  }
+  if (scope === "sentinel") {
+    const allowed = ["every_atom", "plan_batch_only", "manual_only"];
+    if (!allowed.includes(value)) {
+      console.error(chalk2.red(`Invalid sentinel policy: ${value}`));
+      console.log(chalk2.dim(`Valid values: ${allowed.join(", ")}`));
+      process.exit(1);
+    }
+    await setRuntimePolicy({ sentinel: value });
+    console.log(chalk2.green(`\u2713 sentinel policy set to ${value}`));
+    return;
+  }
+  if (scope === "routing") {
+    const allowed = ["cheap", "balanced", "max_quality"];
+    if (!allowed.includes(value)) {
+      console.error(chalk2.red(`Invalid routing profile: ${value}`));
+      console.log(chalk2.dim(`Valid values: ${allowed.join(", ")}`));
+      process.exit(1);
+    }
+    await setRuntimePolicy({ routing: value });
+    console.log(chalk2.green(`\u2713 routing profile set to ${value}`));
+    return;
+  }
+  console.error(chalk2.red(`Invalid policy scope: ${scope}`));
+  console.log(chalk2.dim("Valid scopes: approval, sentinel, routing"));
+  process.exit(1);
+}
+
+// src/core/code-review/scope-drift.ts
+function detectScopeDrift(plannedFiles, actualFiles) {
+  const plannedSet = new Set(plannedFiles.map((f) => f.replace(/\\/g, "/")));
+  const unexpectedFiles = actualFiles.map((f) => f.replace(/\\/g, "/")).filter((f) => !plannedSet.has(f));
+  if (unexpectedFiles.length === 0) return null;
+  const driftPercentage = actualFiles.length > 0 ? unexpectedFiles.length / actualFiles.length * 100 : 0;
+  return {
+    plannedFiles,
+    actualFiles,
+    unexpectedFiles,
+    driftPercentage
+  };
+}
+
 // src/core/git/rollback.ts
 import { spawnSync } from "child_process";
 function rollbackFiles(cwd, files) {
@@ -4737,6 +4944,111 @@ var EnvironmentValidator = class {
   }
 };
 
+// src/core/skills/registry.ts
+import { existsSync as existsSync8, readdirSync } from "fs";
+import { join as join3, basename } from "path";
+import matter2 from "gray-matter";
+var DEFAULT_SKILL_DIRS = [
+  join3("archondev-lite", "base", "archondev-skills"),
+  join3(".archon", "skills")
+];
+var FRONTEND_FILE_PATTERN = /\.(tsx|jsx|css|scss|sass|html|astro|vue|svelte)$/i;
+var PUBLIC_WEB_FILE_PATTERN = /(?:^|\/)(?:website|web|site|public|pages|src\/pages|src\/app)(?:\/|$)|\.(?:html|astro)$/i;
+var API_AUTH_FILE_PATTERN = /(?:^|\/)(?:api|auth|middleware|routes|server)(?:\/|$)|\.(?:ts|tsx|js|jsx)$/i;
+function loadSkillRegistry(cwd) {
+  const skills = /* @__PURE__ */ new Map();
+  for (const relativeDir of DEFAULT_SKILL_DIRS) {
+    const dir = join3(cwd, relativeDir);
+    if (!existsSync8(dir)) continue;
+    for (const entry of readdirSync(dir)) {
+      if (!entry.endsWith(".md")) continue;
+      const filePath = join3(dir, entry);
+      try {
+        const parsed = matter2.read(filePath);
+        const slug = basename(entry, ".md");
+        skills.set(slug, {
+          slug,
+          name: typeof parsed.data["name"] === "string" ? parsed.data["name"] : slug,
+          description: typeof parsed.data["description"] === "string" ? parsed.data["description"] : "",
+          trigger: typeof parsed.data["trigger"] === "string" ? parsed.data["trigger"] : void 0,
+          category: typeof parsed.data["category"] === "string" ? parsed.data["category"] : void 0,
+          filePath
+        });
+      } catch {
+      }
+    }
+  }
+  return Array.from(skills.values());
+}
+function suggestSkills(context) {
+  const registry = loadSkillRegistry(context.cwd);
+  const changedFiles = context.changedFiles ?? [];
+  const normalizedInput = (context.input ?? "").toLowerCase();
+  const hasFrontendChanges = changedFiles.some((file) => FRONTEND_FILE_PATTERN.test(file));
+  const hasPublicWebChanges = changedFiles.some((file) => PUBLIC_WEB_FILE_PATTERN.test(file));
+  const hasApiOrAuthChanges = changedFiles.some((file) => API_AUTH_FILE_PATTERN.test(file));
+  const wantsColor = /\b(color|colour|palette|theme|branding|design tokens)\b/.test(normalizedInput);
+  const deployIntent = /\b(deploy|ship|publish|launch|go live|release)\b/.test(normalizedInput);
+  const reviewIntent = /\b(review|audit|qa|quality check|code review)\b/.test(normalizedInput);
+  const debugIntent = /\b(debug|bug|broken|fix|crash|error|failing|failure|stack trace|not working)\b/.test(normalizedInput);
+  const seoIntent = /\b(seo|meta tags|open graph|twitter cards|search visibility|google)\b/.test(normalizedInput);
+  const geoIntent = /\b(geo|ai search|ai citations|generative engine optimization|perplexity|ai overviews)\b/.test(normalizedInput);
+  const strategyIntent = /\b(strategy|scope|plan the project|roadmap|direction)\b/.test(normalizedInput);
+  const suggested = /* @__PURE__ */ new Map();
+  const scores = /* @__PURE__ */ new Map();
+  const add = (slug, weight = 1) => {
+    const skill = registry.find((item) => item.slug === slug);
+    if (!skill) return;
+    suggested.set(slug, skill);
+    scores.set(slug, (scores.get(slug) ?? 0) + weight);
+  };
+  if (hasFrontendChanges) {
+    add("design-review", 3);
+    add("accessibility-audit", 2);
+  }
+  if (wantsColor) {
+    add("color-scheme-picker", 5);
+  }
+  if ((deployIntent || hasFrontendChanges) && context.isWebProject) {
+    add("accessibility-audit", 2);
+  }
+  if (reviewIntent) {
+    add("code-review", 5);
+    if (context.isWebProject || hasFrontendChanges) {
+      add("design-review", 2);
+    }
+  }
+  if (debugIntent) {
+    add("systematic-debugging", 6);
+    if (hasApiOrAuthChanges) {
+      add("code-review", 2);
+    }
+  }
+  if (deployIntent) {
+    add("ship-readiness", 8);
+    add("code-review", 3);
+    if (context.isWebProject || hasFrontendChanges || hasPublicWebChanges) {
+      add("accessibility-audit", 3);
+      add("design-review", 2);
+    }
+  }
+  if ((seoIntent || geoIntent) && (context.isWebProject || hasPublicWebChanges)) {
+    add("seo-optimization", 5);
+  }
+  if (geoIntent && (context.isWebProject || hasPublicWebChanges)) {
+    add("geo-optimization", 5);
+  }
+  if (strategyIntent) {
+    add("project-strategy", 5);
+    add("scope-review", 4);
+  }
+  return Array.from(suggested.values()).sort((a, b) => {
+    const scoreDelta = (scores.get(b.slug) ?? 0) - (scores.get(a.slug) ?? 0);
+    if (scoreDelta !== 0) return scoreDelta;
+    return a.name.localeCompare(b.name);
+  });
+}
+
 // src/cli/execute.ts
 var ATOMS_DIR = ".archon/atoms";
 function isGovernanceViolation(errorMessage) {
@@ -4766,7 +5078,7 @@ async function attemptPathScopeAutoRecovery(atom, cwd, parseSchema, options) {
   if (allowedPaths.length === 0) {
     return false;
   }
-  const { listLocalAtoms, plan } = await import("./plan-WBNGP2UE.js");
+  const { listLocalAtoms, plan } = await import("./plan-HBAUG3KD.js");
   const before = await listLocalAtoms();
   const recoveryStartedAt = Date.now();
   const recoverySource = atom.description ?? atom.title;
@@ -4785,7 +5097,7 @@ Hard Constraints:
 - Do not create files outside this base path.
 - If this cannot satisfy the task, return a minimal architecture path update proposal instead of writing out-of-scope files.`;
   const phaseLabel = recoveryDepth === 0 ? "scope-constrained retry" : "forced-base-path retry";
-  console.log(chalk2.dim(`
+  console.log(chalk3.dim(`
 Auto-recovery: re-planning with ${phaseLabel}...
 `));
   await plan(scopedRequest, { conversational: true });
@@ -4805,10 +5117,10 @@ Auto-recovery: re-planning with ${phaseLabel}...
     replacement = after.filter((entry) => entry.status === "READY" && entry.externalId !== atom.externalId).sort(byMostRecent)[0];
   }
   if (!replacement) {
-    console.log(chalk2.yellow("Auto-recovery could not find a replacement READY atom to retry."));
+    console.log(chalk3.yellow("Auto-recovery could not find a replacement READY atom to retry."));
     return false;
   }
-  console.log(chalk2.dim(`Auto-recovery: retrying with ${replacement.externalId}...
+  console.log(chalk3.dim(`Auto-recovery: retrying with ${replacement.externalId}...
 `));
   await execute(replacement.externalId, { ...options, autoRecoverDepth: recoveryDepth + 1, nonTerminating: true });
   return true;
@@ -4834,7 +5146,7 @@ async function execute(atomId, options) {
     process.exit(1);
   };
   if (options.parallel && options.parallel.length > 0) {
-    const { parallelExecute } = await import("./parallel-T37FF7GD.js");
+    const { parallelExecute } = await import("./parallel-4PXJA2QD.js");
     const allAtomIds = [atomId, ...options.parallel];
     await parallelExecute(allAtomIds, { skipGates: options.skipGates === true });
     return;
@@ -4844,50 +5156,50 @@ async function execute(atomId, options) {
   const concise = options.conciseOutput === true;
   const debugPath = getDebugLogPath();
   if (debugPath) {
-    console.log(chalk2.dim(`Debug logging enabled: ${debugPath}`));
+    console.log(chalk3.dim(`Debug logging enabled: ${debugPath}`));
   }
   debugLog("execute", "start", "Execute command started", { atomId, options });
   try {
     if (options.cloud) {
-      console.log(chalk2.yellow("\nCloud execution is disabled in the free/BYOK model."));
-      console.log(chalk2.dim("Run without --cloud to execute locally using your configured provider keys."));
+      console.log(chalk3.yellow("\nCloud execution is disabled in the free/BYOK model."));
+      console.log(chalk3.dim("Run without --cloud to execute locally using your configured provider keys."));
       return;
     }
     if (!concise) {
-      console.log(chalk2.dim(`Loading atom ${atomId}...`));
+      console.log(chalk3.dim(`Loading atom ${atomId}...`));
     }
     let atom = await loadAtom(atomId);
     if (!atom) {
-      console.error(chalk2.red(`Atom ${atomId} not found.`));
-      console.log(chalk2.dim(`Use "archon list" to see available atoms.`));
+      console.error(chalk3.red(`Atom ${atomId} not found.`));
+      console.log(chalk3.dim(`Use "archon list" to see available atoms.`));
       return fail();
     }
     const envLoader = new EnvironmentConfigLoader(cwd);
     const targetEnvName = options.env ?? "development";
     if (!envLoader.isValidEnvironment(targetEnvName)) {
-      console.error(chalk2.red(`Invalid environment: ${targetEnvName}`));
-      console.log(chalk2.dim("Valid environments: development, staging, production"));
+      console.error(chalk3.red(`Invalid environment: ${targetEnvName}`));
+      console.log(chalk3.dim("Valid environments: development, staging, production"));
       return fail();
     }
     const envConfigs = await envLoader.loadConfig();
     const envConfig = envLoader.getEnvironmentConfig(envConfigs, targetEnvName);
     const validator = new EnvironmentValidator(envConfigs);
     if (!concise) {
-      console.log(chalk2.dim(`Environment: ${targetEnvName}`));
+      console.log(chalk3.dim(`Environment: ${targetEnvName}`));
     }
     const envState = await loadAtomEnvironmentState(atomId, cwd);
     const executionCheck = validator.canExecuteInEnvironment(atom, targetEnvName, envState?.lastExecutedEnv);
     if (!executionCheck.allowed) {
-      console.error(chalk2.red(executionCheck.reason ?? "Execution not allowed"));
+      console.error(chalk3.red(executionCheck.reason ?? "Execution not allowed"));
       return fail();
     }
     if (atom.status === "DONE" && targetEnvName === envState?.lastExecutedEnv) {
-      console.log(chalk2.yellow(`Atom ${atomId} has already been executed in ${targetEnvName}.`));
+      console.log(chalk3.yellow(`Atom ${atomId} has already been executed in ${targetEnvName}.`));
       return;
     }
     if (atom.status === "IN_PROGRESS") {
       if (!options.resumeInProgress) {
-        console.log(chalk2.yellow(`Atom ${atomId} is already in progress.`));
+        console.log(chalk3.yellow(`Atom ${atomId} is already in progress.`));
         const answer = await prompt.ask("Continue anyway? (y/N): ");
         if (answer.toLowerCase() !== "y") {
           return;
@@ -4895,39 +5207,77 @@ async function execute(atomId, options) {
       }
     }
     if (atom.status !== "READY" && atom.status !== "IN_PROGRESS" && atom.status !== "DONE") {
-      console.error(chalk2.red(`Atom ${atomId} is not ready for execution.`));
-      console.log(chalk2.dim(`Status: ${atom.status}. Only READY or DONE atoms can be executed.`));
+      console.error(chalk3.red(`Atom ${atomId} is not ready for execution.`));
+      console.log(chalk3.dim(`Status: ${atom.status}. Only READY or DONE atoms can be executed.`));
       return fail();
     }
     if (!atom.plan) {
-      console.error(chalk2.red(`Atom ${atomId} has no plan.`));
-      console.log(chalk2.dim(`Run "archon plan" to create a plan first.`));
+      console.error(chalk3.red(`Atom ${atomId} has no plan.`));
+      console.log(chalk3.dim(`Run "archon plan" to create a plan first.`));
       return fail();
     }
     const atomContext = atom.context;
     const designApproved = atomContext?.["designApproved"] === true;
     if (!designApproved) {
-      console.log(chalk2.yellow("\n[!] This atom does not record explicit design approval metadata."));
+      console.log(chalk3.yellow("\n[!] This atom does not record explicit design approval metadata."));
       const proceed = await prompt.ask("Proceed with execution anyway? (y/N): ");
       if (proceed.trim().toLowerCase() !== "y") {
-        console.log(chalk2.dim("Execution cancelled. Re-run planning and approve design first."));
+        console.log(chalk3.dim("Execution cancelled. Re-run planning and approve design first."));
         return;
       }
     }
-    const archPath = join3(cwd, "ARCHITECTURE.md");
-    if (!existsSync8(archPath)) {
-      console.error(chalk2.red("ARCHITECTURE.md not found."));
+    const archPath = join4(cwd, "ARCHITECTURE.md");
+    if (!existsSync9(archPath)) {
+      console.error(chalk3.red("ARCHITECTURE.md not found."));
       return fail();
     }
     const parser = new ArchitectureParser(archPath);
     const parseResult = await parser.parse();
     if (!parseResult.success || !parseResult.schema) {
-      console.error(chalk2.red("Failed to parse ARCHITECTURE.md."));
+      console.error(chalk3.red("Failed to parse ARCHITECTURE.md."));
       return fail();
     }
+    if (atom.plan?.files_to_modify) {
+      let depCheckResult;
+      try {
+        const depParser = new DependencyParser(cwd);
+        if (depParser.exists()) {
+          depCheckResult = await depParser.checkFiles(atom.plan.files_to_modify);
+        }
+      } catch {
+      }
+      const riskAssessment = computeRiskScore(
+        atom.plan.files_to_modify,
+        parseResult.schema,
+        depCheckResult
+      );
+      const riskColors = {
+        LOW: chalk3.green,
+        MEDIUM: chalk3.yellow,
+        HIGH: chalk3.hex("#FF8C00"),
+        CRITICAL: chalk3.red
+      };
+      const colorFn = riskColors[riskAssessment.level] ?? chalk3.dim;
+      if (!concise) {
+        console.log(colorFn(`Risk: ${riskAssessment.score}/100 (${riskAssessment.level}) \u2014 ${riskAssessment.summary}`));
+      }
+      if (shouldAskConfirmation(riskAssessment.level, "ask_every_time")) {
+        try {
+          const policy = await loadRuntimePolicy();
+          if (shouldAskConfirmation(riskAssessment.level, policy.approval)) {
+            const answer = await prompt.ask("High-risk execution. Proceed? (Y/n): ");
+            if (answer.toLowerCase() === "n") {
+              console.log(chalk3.dim("Execution aborted."));
+              return;
+            }
+          }
+        } catch {
+        }
+      }
+    }
     if (!options.skipConflictCheck) {
       if (!concise) {
-        console.log(chalk2.dim("\nChecking for conflicts..."));
+        console.log(chalk3.dim("\nChecking for conflicts..."));
       }
       const conflictChecker = new ConflictChecker(parseResult.schema);
       const conflictReport = await conflictChecker.checkConflicts(atom.plan, {
@@ -4935,48 +5285,48 @@ async function execute(atomId, options) {
         planCreatedAt: atom.createdAt
       });
       if (conflictReport.hasConflicts) {
-        console.log(chalk2.yellow(`
+        console.log(chalk3.yellow(`
 [!] ${conflictReport.conflicts.length} conflict(s) detected:`));
         for (const conflict of conflictReport.conflicts) {
-          const icon = conflict.severity === "BLOCKER" ? chalk2.red("\u2717") : chalk2.yellow("[!]");
+          const icon = conflict.severity === "BLOCKER" ? chalk3.red("\u2717") : chalk3.yellow("[!]");
           console.log(`  ${icon} [${conflict.type}] ${conflict.message}`);
         }
         if (conflictReport.blockerCount > 0) {
-          console.log(chalk2.red(`
+          console.log(chalk3.red(`
 ${conflictReport.blockerCount} blocking conflict(s) found.`));
           const answer = await prompt.ask("Continue anyway? (y/N): ");
           if (answer.toLowerCase() !== "y") {
-            console.log(chalk2.dim("Execution aborted."));
+            console.log(chalk3.dim("Execution aborted."));
             return;
           }
         } else {
-          console.log(chalk2.dim("\nRecommendations:"));
+          console.log(chalk3.dim("\nRecommendations:"));
           for (const rec of conflictReport.recommendations) {
-            console.log(chalk2.dim(`  - ${rec}`));
+            console.log(chalk3.dim(`  - ${rec}`));
           }
         }
       } else if (!concise) {
-        console.log(chalk2.green("\u2713 No conflicts detected"));
+        console.log(chalk3.green("\u2713 No conflicts detected"));
       }
     }
     try {
       atom = transitionAtom(atom, "IN_PROGRESS");
     } catch (error) {
-      console.error(chalk2.red("Failed to update atom status."));
-      console.error(chalk2.dim(error instanceof Error ? error.message : "Unknown error"));
+      console.error(chalk3.red("Failed to update atom status."));
+      console.error(chalk3.dim(error instanceof Error ? error.message : "Unknown error"));
       return fail();
     }
     await saveAtom(atom);
     if (!concise) {
-      console.log(chalk2.blue("\n\u{1F680} Executing plan..."));
+      console.log(chalk3.blue("\n\u{1F680} Executing plan..."));
     }
     const roleOverrides = await loadRoleOverrides(cwd);
     const keyManager = new KeyManager();
     const apiKeys = await resolveApiKeys(keyManager);
     const hasAnyKey = !!apiKeys.anthropic || !!apiKeys.openai || !!apiKeys.google;
     if (!hasAnyKey) {
-      console.log(chalk2.red("\nNo API key configured for execution."));
-      console.log(chalk2.dim("Add a provider key with: archon keys add"));
+      console.log(chalk3.red("\nNo API key configured for execution."));
+      console.log(chalk3.dim("Add a provider key with: archon keys add"));
       return fail();
     }
     const defaultProvider = pickDefaultProvider(apiKeys, roleOverrides?.executor?.provider);
@@ -4988,8 +5338,8 @@ ${conflictReport.blockerCount} blocking conflict(s) found.`));
     );
     const safeProvider = pickAvailableProvider(apiKeys, executorProvider);
     if (!safeProvider) {
-      console.log(chalk2.red("\nNo valid API key available for execution."));
-      console.log(chalk2.dim("Add a provider key with: archon keys add"));
+      console.log(chalk3.red("\nNo valid API key available for execution."));
+      console.log(chalk3.dim("Add a provider key with: archon keys add"));
       return fail();
     }
     const executorModel = normalizeModelForProvider(roleOverrides?.executor?.model, safeProvider);
@@ -4999,6 +5349,16 @@ ${conflictReport.blockerCount} blocking conflict(s) found.`));
     };
     const executor = new ExecutorAgent(executorConfig, apiKeys);
     const executionResult = await executor.executeAtom(atom, atom.plan, parseResult.schema, cwd);
+    await appendLocalUsageEntry({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      projectPath: cwd,
+      model: executorModel,
+      provider: safeProvider,
+      operation: "EXECUTION",
+      inputTokens: executionResult.usage.inputTokens,
+      outputTokens: executionResult.usage.outputTokens,
+      baseCost: executionResult.usage.baseCost
+    });
     debugLog("execute", "result.received", "Executor returned execution result", {
       success: executionResult.success,
       rollbackPerformed: executionResult.rollbackPerformed,
@@ -5016,27 +5376,27 @@ ${conflictReport.blockerCount} blocking conflict(s) found.`));
           plannedFiles: atom.plan.files_to_modify,
           violations: extractGovernanceViolations(executionResult.errorMessage)
         });
-        console.log(chalk2.yellow("\n\u26A0\uFE0F  Execution paused by governance guidance"));
-        console.log(chalk2.dim("No changes were committed. Update the plan/path scope, then continue."));
+        console.log(chalk3.yellow("\n\u26A0\uFE0F  Execution paused by governance guidance"));
+        console.log(chalk3.dim("No changes were committed. Update the plan/path scope, then continue."));
         const violations = extractGovernanceViolations(executionResult.errorMessage);
         const pathScopeBlocked = violations.some((violation) => violation.toLowerCase().includes("outside the allowed paths"));
         if (violations.length > 0) {
-          console.log(chalk2.yellow("\nGovernance guidance:"));
+          console.log(chalk3.yellow("\nGovernance guidance:"));
           for (const violation of violations) {
-            console.log(chalk2.dim(`  - ${violation}`));
+            console.log(chalk3.dim(`  - ${violation}`));
           }
           if (pathScopeBlocked) {
-            console.log(chalk2.dim('\nTry in chat: "adjust this task to allowed paths", then "continue".'));
+            console.log(chalk3.dim('\nTry in chat: "adjust this task to allowed paths", then "continue".'));
           }
         } else {
-          console.log(chalk2.yellow(executionResult.errorMessage ?? "Architecture constraints were not satisfied."));
+          console.log(chalk3.yellow(executionResult.errorMessage ?? "Architecture constraints were not satisfied."));
         }
       } else {
-        console.log(chalk2.red("\n\u274C Execution failed"));
-        console.log(chalk2.red(executionResult.errorMessage ?? "Unknown error"));
+        console.log(chalk3.red("\n\u274C Execution failed"));
+        console.log(chalk3.red(executionResult.errorMessage ?? "Unknown error"));
       }
       if (executionResult.rollbackPerformed) {
-        console.log(chalk2.yellow("Changes have been rolled back."));
+        console.log(chalk3.yellow("Changes have been rolled back."));
       }
       if (isGovernanceViolation(executionResult.errorMessage)) {
         atom = transitionAtom(atom, "BLOCKED");
@@ -5086,18 +5446,32 @@ ${conflictReport.blockerCount} blocking conflict(s) found.`));
       return fail();
     }
     if (!concise) {
-      console.log(chalk2.green("\u2713 Plan executed successfully"));
-      console.log(chalk2.dim(`Files modified: ${filesChanged.length}`));
+      console.log(chalk3.green("\u2713 Plan executed successfully"));
+      console.log(chalk3.dim(`Files modified: ${filesChanged.length}`));
       for (const file of filesChanged) {
-        console.log(chalk2.dim(`  - ${file}`));
+        console.log(chalk3.dim(`  - ${file}`));
       }
     }
     await printDeliverablePreview(cwd, filesChanged, concise);
+    if (atom.plan?.files_to_modify) {
+      const drift = detectScopeDrift(atom.plan.files_to_modify, filesChanged);
+      if (drift) {
+        console.log(chalk3.yellow(`Scope drift: ${drift.unexpectedFiles.length} file(s) outside plan (${drift.driftPercentage.toFixed(0)}%)`));
+        for (const f of drift.unexpectedFiles.slice(0, 5)) {
+          console.log(chalk3.dim(`  + ${f}`));
+        }
+        if (drift.unexpectedFiles.length > 5) {
+          console.log(chalk3.dim(`  ... and ${drift.unexpectedFiles.length - 5} more`));
+        }
+      } else if (!concise) {
+        console.log(chalk3.green("\u2713 Scope check: clean"));
+      }
+    }
     if (!options.skipGates) {
       if (!concise) {
-        console.log(chalk2.dim(`
+        console.log(chalk3.dim(`
 Running quality gates for ${targetEnvName}...`));
-        console.log(chalk2.dim(`Gates: ${envConfig.qualityGates.join(", ")}`));
+        console.log(chalk3.dim(`Gates: ${envConfig.qualityGates.join(", ")}`));
       }
       const gateRunner = new QualityGateRunner({ cwd, verbose: false });
       const gateResult = await gateRunner.runGates(envConfig.qualityGates);
@@ -5105,14 +5479,14 @@ Running quality gates for ${targetEnvName}...`));
         gateRunner.printResults(gateResult);
       }
       if (!gateResult.allPassed) {
-        console.log(chalk2.red("\n\u274C Quality gates failed"));
-        console.log(chalk2.yellow("Rolling back changes..."));
+        console.log(chalk3.red("\n\u274C Quality gates failed"));
+        console.log(chalk3.yellow("Rolling back changes..."));
         try {
           rollbackFiles(cwd, filesChanged);
-          console.log(chalk2.yellow("Changes rolled back (scoped to atom files)."));
+          console.log(chalk3.yellow("Changes rolled back (scoped to atom files)."));
         } catch (error) {
-          console.log(chalk2.red("Failed to rollback. Please manually revert changes."));
-          console.log(chalk2.dim(error instanceof Error ? error.message : "Unknown rollback error"));
+          console.log(chalk3.red("Failed to rollback. Please manually revert changes."));
+          console.log(chalk3.dim(error instanceof Error ? error.message : "Unknown rollback error"));
         }
         atom = transitionAtom(atom, "FAILED");
         atom.errorMessage = `Quality gate failed: ${gateResult.failedAt}`;
@@ -5133,7 +5507,7 @@ Running quality gates for ${targetEnvName}...`));
       }
     }
     if (!concise) {
-      console.log(chalk2.dim("\nCommitting changes..."));
+      console.log(chalk3.dim("\nCommitting changes..."));
     }
     try {
       const commitMessage = `feat: [${atom.externalId}] - ${atom.title}`;
@@ -5146,10 +5520,10 @@ Running quality gates for ${targetEnvName}...`));
         throw new Error(commitResult.stderr?.toString() || "git commit failed");
       }
       if (!concise) {
-        console.log(chalk2.green(`\u2713 Committed: ${commitMessage}`));
+        console.log(chalk3.green(`\u2713 Committed: ${commitMessage}`));
       }
     } catch (error) {
-      console.log(chalk2.yellow("No changes to commit or git commit failed."));
+      console.log(chalk3.yellow("No changes to commit or git commit failed."));
     }
     atom = transitionAtom(atom, "TESTING");
     atom = transitionAtom(atom, "DONE");
@@ -5159,7 +5533,7 @@ Running quality gates for ${targetEnvName}...`));
       promotedTo: envState?.promotedTo ?? []
     });
     if (!concise) {
-      console.log(chalk2.dim("\nCapturing learnings..."));
+      console.log(chalk3.dim("\nCapturing learnings..."));
     }
     const executionSummary = {
       atomId: atom.id,
@@ -5173,9 +5547,9 @@ Running quality gates for ${targetEnvName}...`));
     const verifyLearning = options.verifyLearning !== false;
     if (verifyLearning && !concise) {
       if (learningResult.success && learningResult.entriesAdded > 0) {
-        console.log(chalk2.green("\u2713 Learning captured to progress.txt"));
+        console.log(chalk3.green("\u2713 Learning captured to progress.txt"));
       } else {
-        console.log(chalk2.yellow("[!] No learnings captured to progress.txt"));
+        console.log(chalk3.yellow("[!] No learnings captured to progress.txt"));
       }
     }
     const agentsMdUpdater = new AgentsMdUpdater(cwd);
@@ -5183,20 +5557,31 @@ Running quality gates for ${targetEnvName}...`));
     if (verifyLearning && !concise) {
       const agentsMdCount = agentsMdResult.filesCreated.length + agentsMdResult.filesUpdated.length;
       if (agentsMdCount === 0) {
-        console.log(chalk2.yellow("[!] No AGENTS.md updates (no reusable patterns found)"));
+        console.log(chalk3.yellow("[!] No AGENTS.md updates (no reusable patterns found)"));
       } else {
-        console.log(chalk2.green(`\u2713 Updated ${agentsMdCount} AGENTS.md file(s)`));
+        console.log(chalk3.green(`\u2713 Updated ${agentsMdCount} AGENTS.md file(s)`));
       }
     } else if (!concise && (agentsMdResult.filesCreated.length > 0 || agentsMdResult.filesUpdated.length > 0)) {
-      console.log(chalk2.dim(`Updated ${agentsMdResult.filesUpdated.length + agentsMdResult.filesCreated.length} AGENTS.md file(s)`));
+      console.log(chalk3.dim(`Updated ${agentsMdResult.filesUpdated.length + agentsMdResult.filesCreated.length} AGENTS.md file(s)`));
+    }
+    const suggestedSkills = suggestSkills({
+      cwd,
+      changedFiles: filesChanged,
+      isWebProject: filesChanged.some((file) => /\.(tsx|jsx|css|scss|sass|html|astro|vue|svelte)$/i.test(file))
+    });
+    if (!concise && suggestedSkills.length > 0) {
+      console.log(chalk3.dim("\nHelpful skills you may want next:"));
+      for (const skill of suggestedSkills.slice(0, 3)) {
+        console.log(chalk3.dim(`  - ${skill.name}: ${skill.description}`));
+      }
     }
     if (concise) {
-      console.log(chalk2.green("\n\u2713 Done."));
+      console.log(chalk3.green("\n\u2713 Done."));
     } else {
-      console.log(chalk2.green("\n\u2705 Atom executed successfully!"));
-      console.log(chalk2.dim(`Atom: ${atom.externalId}`));
-      console.log(chalk2.dim(`Status: ${atom.status}`));
-      console.log(chalk2.dim(`Files changed: ${filesChanged.length}`));
+      console.log(chalk3.green("\n\u2705 Atom executed successfully!"));
+      console.log(chalk3.dim(`Atom: ${atom.externalId}`));
+      console.log(chalk3.dim(`Status: ${atom.status}`));
+      console.log(chalk3.dim(`Files changed: ${filesChanged.length}`));
       printExecuteNextActions(atom.externalId, true);
     }
   } finally {
@@ -5265,27 +5650,27 @@ function normalizeApiKey(value) {
 }
 function printExecuteNextActions(atomExternalId, success, context = "generic") {
   console.log();
-  console.log(chalk2.bold("Next best action:"));
+  console.log(chalk3.bold("Next best action:"));
   if (success) {
-    console.log(chalk2.dim(`  \u2022 Run ${chalk2.cyan("archon list")} to select your next task.`));
+    console.log(chalk3.dim(`  \u2022 Run ${chalk3.cyan("archon list")} to select your next task.`));
   } else {
     if (context === "governance_path") {
-      console.log(chalk2.dim(`  \u2022 In chat, say ${chalk2.cyan('"adjust this task to allowed paths"')} to re-scope automatically.`));
-      console.log(chalk2.dim(`  \u2022 Then say ${chalk2.cyan('"continue"')} to execute the re-scoped task.`));
-      console.log(chalk2.dim(`  \u2022 Run ${chalk2.cyan(`archon show ${atomExternalId}`)} to inspect the blocked task.`));
+      console.log(chalk3.dim(`  \u2022 In chat, say ${chalk3.cyan('"adjust this task to allowed paths"')} to re-scope automatically.`));
+      console.log(chalk3.dim(`  \u2022 Then say ${chalk3.cyan('"continue"')} to execute the re-scoped task.`));
+      console.log(chalk3.dim(`  \u2022 Run ${chalk3.cyan(`archon show ${atomExternalId}`)} to inspect the blocked task.`));
       return;
     }
-    console.log(chalk2.dim(`  \u2022 Run ${chalk2.cyan(`archon show ${atomExternalId}`)} to inspect this task.`));
+    console.log(chalk3.dim(`  \u2022 Run ${chalk3.cyan(`archon show ${atomExternalId}`)} to inspect this task.`));
   }
-  console.log(chalk2.dim(`  \u2022 Run ${chalk2.cyan("archon config ai")} to add/rotate provider keys.`));
-  console.log(chalk2.dim(`  \u2022 Run ${chalk2.cyan("archon preferences")} to tune model routing.`));
+  console.log(chalk3.dim(`  \u2022 Run ${chalk3.cyan("archon config ai")} to add/rotate provider keys.`));
+  console.log(chalk3.dim(`  \u2022 Run ${chalk3.cyan("archon preferences")} to tune model routing.`));
 }
 async function printDeliverablePreview(cwd, filesChanged, concise = false) {
   const previewTarget = filesChanged.find((file) => /\.md$/i.test(file));
   if (!previewTarget) {
     return;
   }
-  const absolutePath = join3(cwd, previewTarget);
+  const absolutePath = join4(cwd, previewTarget);
   try {
     const content = await readFile7(absolutePath, "utf-8");
     const previewLines = content.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim().length > 0).slice(0, 8);
@@ -5293,20 +5678,20 @@ async function printDeliverablePreview(cwd, filesChanged, concise = false) {
       return;
     }
     if (concise) {
-      console.log(chalk2.dim(`Output: ${absolutePath}`));
+      console.log(chalk3.dim(`Output: ${absolutePath}`));
       return;
     }
-    console.log(chalk2.bold("\nDeliverable preview:"));
-    console.log(chalk2.dim(`  Output file: ${absolutePath}`));
+    console.log(chalk3.bold("\nDeliverable preview:"));
+    console.log(chalk3.dim(`  Output file: ${absolutePath}`));
     for (const line of previewLines) {
-      console.log(chalk2.dim(`  ${line}`));
+      console.log(chalk3.dim(`  ${line}`));
     }
   } catch {
   }
 }
 async function saveAtom(atom) {
-  const atomsDir = join3(process.cwd(), ATOMS_DIR);
-  const atomFile = join3(atomsDir, `${atom.externalId}.json`);
+  const atomsDir = join4(process.cwd(), ATOMS_DIR);
+  const atomFile = join4(atomsDir, `${atom.externalId}.json`);
   await writeFile4(atomFile, JSON.stringify(atom, null, 2));
 }
 async function captureLearnings(atom, execution, concise = false) {
@@ -5314,12 +5699,12 @@ async function captureLearnings(atom, execution, concise = false) {
     const learningCapture = new LearningCapture("progress.txt");
     const result = await learningCapture.appendLearning(atom, execution);
     if (result.success && !concise) {
-      console.log(chalk2.dim(`Learnings captured: ${result.entriesAdded} entries, ${result.patternsAdded} patterns`));
+      console.log(chalk3.dim(`Learnings captured: ${result.entriesAdded} entries, ${result.patternsAdded} patterns`));
     }
     return result;
   } catch (error) {
     if (!concise) {
-      console.log(chalk2.dim("Failed to capture learnings (non-critical)."));
+      console.log(chalk3.dim("Failed to capture learnings (non-critical)."));
     }
     return {
       success: false,
@@ -5331,21 +5716,25 @@ async function captureLearnings(atom, execution, concise = false) {
   }
 }
 async function loadAtomEnvironmentState(atomId, cwd) {
-  const stateFile = join3(cwd, ATOMS_DIR, `${atomId}.env.json`);
-  if (!existsSync8(stateFile)) {
+  const stateFile = join4(cwd, ATOMS_DIR, `${atomId}.env.json`);
+  if (!existsSync9(stateFile)) {
     return null;
   }
   const content = await readFile7(stateFile, "utf-8");
   return JSON.parse(content);
 }
 async function saveAtomEnvironmentState(atomId, cwd, state) {
-  const stateFile = join3(cwd, ATOMS_DIR, `${atomId}.env.json`);
+  const stateFile = join4(cwd, ATOMS_DIR, `${atomId}.env.json`);
   await writeFile4(stateFile, JSON.stringify(state, null, 2));
 }
 
 export {
   DependencyParser,
+  loadRuntimePolicy,
+  showPolicy,
+  setPolicy,
   EnvironmentConfigLoader,
   EnvironmentValidator,
+  suggestSkills,
   execute
 };