@ludecker/aaac 1.1.0 → 1.1.2

package/src/run-engine/gate-write.mjs

@@ -53,10 +53,22 @@ process.stdin.on("end", () => {
   if (!conversationId) allow();
 
   const active = loadActiveRun(conversationId);
-  if (!active?.run_id || active.status === "completed") allow();
+  if (
+    !active?.run_id ||
+    active.status === "completed" ||
+    active.status === "cancelled"
+  ) {
+    allow();
+  }
 
   const manifest = loadRunManifest(active.run_id);
-  if (!manifest || manifest.status === "completed") allow();
+  if (
+    !manifest ||
+    manifest.status === "completed" ||
+    manifest.status === "cancelled"
+  ) {
+    allow();
+  }
   if (manifest.conversation_id && manifest.conversation_id !== conversationId) allow();
 
   const enforcement = loadEnforcement();

package/src/run-engine/init-run.mjs

@@ -11,10 +11,20 @@ import {
   phaseKind,
   writeJson,
   saveActiveRun,
+  loadActiveRun,
+  loadRunManifest,
+  clearActiveRun,
+  cancelRunManifest,
+  isUserStopIntent,
   conversationIdFromHook,
   promptFromHook,
 } from "./lib.mjs";
 import { recordLog, recordDecision } from "./log.mjs";
+import {
+  resolveCapabilitiesWithRuntime,
+  evaluateCapabilityRuntimePolicy,
+  loadObjectMaturity,
+} from "./capability-evidence.mjs";
 
 async function readStdin() {
   return new Promise((resolve) => {
@@ -36,6 +46,42 @@ try {
 
 const prompt = process.argv[2] ?? promptFromHook(hook);
 const conversationId = conversationIdFromHook(hook);
+
+if (isUserStopIntent(prompt) && conversationId) {
+  const active = loadActiveRun(conversationId);
+  let cancelledRunId = null;
+  if (active?.run_id) {
+    const existing = loadRunManifest(active.run_id);
+    if (
+      existing &&
+      existing.status !== "completed" &&
+      existing.status !== "cancelled"
+    ) {
+      cancelRunManifest(existing, prompt.trim());
+      recordLog(existing, {
+        event: "run_cancelled",
+        phase: existing.phase,
+        phase_kind: existing.phase_kind,
+        detail: `user stop: ${prompt.trim()}`,
+        level: "info",
+      });
+      recordDecision(existing, {
+        phase: existing.phase ?? "dispatch",
+        decision: "user_stop",
+        reason: "User requested stop",
+        evidence: prompt.trim(),
+      });
+      writeJson(`${runDir(active.run_id)}/run.json`, existing);
+      cancelledRunId = active.run_id;
+    }
+    clearActiveRun(conversationId);
+  }
+  console.log(
+    JSON.stringify({ ok: true, aaac: false, cancelled: cancelledRunId }),
+  );
+  process.exit(0);
+}
+
 const parsed = parseAaacPrompt(prompt);
 
 if (!parsed) {
@@ -64,6 +110,14 @@ const runId = `run_${date}_${slugify(parsed.command + (parsed.domain ? `-${parse
 const entry = registry.commands[parsed.command];
 fs.mkdirSync(runDir(runId), { recursive: true });
 
+const runObject = entry.object ?? null;
+const runVerb = entry.verb ?? parsed.command.split("-")[0];
+const objectMaturity = loadObjectMaturity(runObject);
+const capabilitiesResolved = resolveCapabilitiesWithRuntime(runObject, runVerb);
+const capabilityRuntimePolicy = evaluateCapabilityRuntimePolicy(capabilitiesResolved, {
+  object_maturity: objectMaturity,
+});
+
 const manifest = {
   run_id: runId,
   conversation_id: conversationId,
@@ -84,7 +138,9 @@ const manifest = {
   artifacts: {},
   checkpoints: [],
   log: [],
-  capabilities_resolved: {},
+  capabilities_resolved: capabilitiesResolved,
+  capability_runtime: capabilityRuntimePolicy,
+  capability_runtime_approved: false,
   confidence: { architecture: null, requirements: null, scope: null },
   gates: { stack: entry.gate_stack ?? null, results: {} },
   swarm: { task_launches_this_phase: 0, phase: pending[0] },
@@ -131,6 +187,41 @@ recordDecision(manifest, {
   evidence: parsed.raw,
 });
 
+for (const [capabilityId, resolution] of Object.entries(manifest.capabilities_resolved)) {
+  recordLog(manifest, {
+    event: "capability_resolved",
+    phase: "dispatch",
+    phase_kind: "work",
+    detail: `${capabilityId}:${(resolution.providers ?? []).map((p) => p.id).join(",")} state=${resolution.runtime?.state ?? "experimental"}`,
+    level: "debug",
+  });
+}
+
+recordLog(manifest, {
+  event: "capability_runtime_evaluated",
+  phase: "dispatch",
+  phase_kind: "work",
+  detail: `action=${capabilityRuntimePolicy.action} maturity=${objectMaturity}`,
+  level: "info",
+});
+
+if (capabilityRuntimePolicy.action === "warn") {
+  recordLog(manifest, {
+    event: "capability_runtime_warn",
+    phase: "dispatch",
+    phase_kind: "work",
+    detail: capabilityRuntimePolicy.reasons.join("; "),
+    level: "warn",
+  });
+}
+
+recordDecision(manifest, {
+  phase: "dispatch",
+  decision: "capability_runtime",
+  reason: capabilityRuntimePolicy.action,
+  evidence: capabilityRuntimePolicy.reasons.join("; ") || "allow",
+});
+
 recordLog(manifest, {
   event: "phase_start",
   phase: pending[0],

package/src/run-engine/lib.mjs

@@ -5,6 +5,7 @@ import { fileURLToPath } from "url";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export const CURSOR_ROOT = path.resolve(__dirname, "../../..");
+export const REPO_ROOT = path.resolve(CURSOR_ROOT, "..");
 export const AAAC_ROOT = path.join(CURSOR_ROOT, "aaac");
 export const STATE_ROOT = path.join(AAAC_ROOT, "state");
 export const RUNS_ROOT = path.join(STATE_ROOT, "runs");
@@ -12,6 +13,10 @@ export const ACTIVE_RUN_PATH = path.join(STATE_ROOT, "active-run.json");
 export const ACTIVE_RUNS_DIR = path.join(STATE_ROOT, "active-runs");
 export const REGISTRY_PATH = path.join(AAAC_ROOT, "runtime-registry.json");
 export const ENFORCEMENT_PATH = path.join(AAAC_ROOT, "enforcement.json");
+export const ONTOLOGY_PATH = path.join(AAAC_ROOT, "ontology.json");
+export const CAPABILITY_REGISTRY_PATH = path.join(AAAC_ROOT, "capabilities", "registry.json");
+export const PROMOTION_RULES_PATH = path.join(AAAC_ROOT, "capabilities", "promotion-rules.json");
+export const CAPABILITY_STATS_PATH = path.join(STATE_ROOT, "capability-stats.json");
 
 export function readJson(filePath, fallback = null) {
   try {
@@ -134,3 +139,36 @@ export function phaseKind(phase, registry) {
 export function promptFromHook(hook) {
   return hook?.prompt ?? hook?.text ?? hook?.content ?? "";
 }
+
+/** User explicitly asked to halt the current Run (short prompts only). */
+export function isUserStopIntent(text) {
+  if (!text || typeof text !== "string") return false;
+  const trimmed = text.trim();
+  if (trimmed.length > 60) return false;
+  return (
+    /^(stop|cancel|abort)([.!?]*)$/i.test(trimmed) ||
+    /^(please\s+)?(stop|cancel|abort)([.!?]*)$/i.test(trimmed) ||
+    /^(stop|cancel|abort)\s+(the\s+)?run([.!?]*)$/i.test(trimmed)
+  );
+}
+
+export function cancelRunManifest(manifest, evidence = "user_stop") {
+  manifest.status = "cancelled";
+  manifest.awaiting_approval = false;
+  manifest.blocked_reason = null;
+  manifest.updated_at = isoNow();
+  if (manifest.enforcement) {
+    manifest.enforcement.edit_allowed = true;
+  }
+  return manifest;
+}
+
+export function clearActiveRun(conversationId) {
+  if (!conversationId) return;
+  const filePath = activeRunPath(conversationId);
+  try {
+    fs.unlinkSync(filePath);
+  } catch {
+    // already cleared
+  }
+}

package/src/run-engine/record-task.mjs

@@ -34,7 +34,13 @@ process.stdin.on("end", () => {
   if (!active?.run_id) allow();
 
   const manifest = loadRunManifest(active.run_id);
-  if (!manifest || manifest.status === "completed") allow();
+  if (
+    !manifest ||
+    manifest.status === "completed" ||
+    manifest.status === "cancelled"
+  ) {
+    allow();
+  }
   if (manifest.conversation_id && manifest.conversation_id !== conversationId) allow();
 
   manifest.swarm = manifest.swarm ?? {};

package/src/run-engine/stop-check.mjs

@@ -28,7 +28,13 @@ process.stdin.on("end", () => {
   if (!active?.run_id) process.exit(0);
 
   const manifest = loadRunManifest(active.run_id);
-  if (!manifest || manifest.status === "completed") process.exit(0);
+  if (
+    !manifest ||
+    manifest.status === "completed" ||
+    manifest.status === "cancelled"
+  ) {
+    process.exit(0);
+  }
 
   const remaining = [manifest.phase, ...(manifest.pending ?? [])].filter(Boolean);
 

package/src/run-engine/verify-website-build.mjs

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/**
+ * Verify app static assets + production build (project overlay).
+ * Skips when `.cursor/aaac/project.config.json` has `verify.enabled: false`.
+ *
+ * Usage:
+ *   node verify-website-build.mjs [--run-id <run_id>] [--skip-build]
+ */
+import fs from "fs";
+import path from "path";
+import { spawnSync } from "child_process";
+import { runDir, isoNow, writeJson, readJson } from "./lib.mjs";
+
+const PROJECT_ROOT = process.cwd();
+
+const args = process.argv.slice(2);
+const runIdIdx = args.indexOf("--run-id");
+const runId = runIdIdx >= 0 ? args[runIdIdx + 1] : null;
+const skipBuild = args.includes("--skip-build");
+
+function loadVerifyConfig() {
+  const configPath = path.join(PROJECT_ROOT, ".cursor/aaac/project.config.json");
+  const config = readJson(configPath, { verify: { enabled: false } });
+  const verify = config.verify ?? { enabled: false };
+  if (!verify.enabled) {
+    return { enabled: false };
+  }
+  const appRootRel = verify.app_root ?? "apps/website";
+  const indexRel =
+    verify.index_html ?? path.join(appRootRel, "index.html").replace(/\\/g, "/");
+  const appRoot = path.join(PROJECT_ROOT, appRootRel);
+  const indexHtml = path.join(PROJECT_ROOT, indexRel);
+  const build = verify.build ?? { command: "pnpm", args: ["run", "build"] };
+  return { enabled: true, appRoot, indexHtml, build, appRootRel };
+}
+
+const verifyConfig = loadVerifyConfig();
+
+const results = {
+  status: "pass",
+  checked_at: isoNow(),
+  static_assets: { status: "pass", missing: [] },
+  build: {
+    status: skipBuild ? "skipped" : "pending",
+    command: null,
+  },
+  verify_config: verifyConfig.enabled ? "enabled" : "disabled",
+};
+
+function fail(section, detail) {
+  results.status = "fail";
+  if (section === "static_assets") {
+    results.static_assets.status = "fail";
+    results.static_assets.missing.push(detail);
+  } else if (section === "build") {
+    results.build.status = "fail";
+    results.build.detail = detail;
+  }
+  console.error(`[verify-website-build] FAIL ${section}: ${detail}`);
+}
+
+function resolveRootAsset(assetPath, websiteRoot, appRootRel) {
+  const rel = assetPath.replace(/^\//, "");
+  const candidates = [
+    path.join(websiteRoot, "public", rel),
+    path.join(websiteRoot, rel),
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function checkStaticAssets(indexHtml, websiteRoot, appRootRel) {
+  if (!fs.existsSync(indexHtml)) {
+    fail("static_assets", `missing index.html at ${indexHtml}`);
+    return;
+  }
+
+  const html = fs.readFileSync(indexHtml, "utf8");
+  const rootRefs = [
+    ...html.matchAll(/\b(?:href|src)="(\/[^"#?]+)"/g),
+  ].map((match) => match[1]);
+
+  const seen = new Set();
+  for (const ref of rootRefs) {
+    if (seen.has(ref) || ref.startsWith("//")) continue;
+    seen.add(ref);
+
+    const resolved = resolveRootAsset(ref, websiteRoot, appRootRel);
+    if (!resolved) {
+      fail(
+        "static_assets",
+        `${ref} not found under ${appRootRel}/public/ or ${appRootRel}/`,
+      );
+    }
+  }
+}
+
+function runBuild(build) {
+  if (skipBuild) return;
+
+  const command = build.command ?? "pnpm";
+  const buildArgs = build.args ?? ["run", "build"];
+  results.build.command = [command, ...buildArgs].join(" ");
+
+  const proc = spawnSync(command, buildArgs, {
+    cwd: build.cwd ? path.join(PROJECT_ROOT, build.cwd) : PROJECT_ROOT,
+    encoding: "utf8",
+    env: { ...process.env, CI: "1" },
+  });
+
+  if (proc.status !== 0) {
+    const detail = [proc.stderr, proc.stdout].filter(Boolean).join("\n").trim();
+    results.build.status = "fail";
+    results.build.exit_code = proc.status ?? 1;
+    fail("build", detail || `exit ${proc.status}`);
+    return;
+  }
+
+  results.build.status = "pass";
+  results.build.exit_code = 0;
+}
+
+function writeArtifact() {
+  if (!runId) return;
+
+  const artifactDir = path.join(runDir(runId), "artifacts");
+  fs.mkdirSync(artifactDir, { recursive: true });
+
+  const yaml = [
+    `status: ${results.status}`,
+    `checked_at: ${results.checked_at}`,
+    `verify_config: ${results.verify_config}`,
+    "static_assets:",
+    `  status: ${results.static_assets.status}`,
+    `  missing: ${JSON.stringify(results.static_assets.missing)}`,
+    "build:",
+    `  status: ${results.build.status}`,
+    results.build.command ? `  command: ${JSON.stringify(results.build.command)}` : null,
+    results.build.exit_code != null ? `  exit_code: ${results.build.exit_code}` : null,
+    results.build.detail ? `  detail: ${JSON.stringify(results.build.detail)}` : null,
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  fs.writeFileSync(path.join(artifactDir, "verify.yaml"), `${yaml}\n`);
+
+  const manifestPath = path.join(runDir(runId), "run.json");
+  try {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    manifest.artifacts = manifest.artifacts ?? {};
+    manifest.artifacts.verify = results;
+    manifest.updated_at = isoNow();
+    writeJson(manifestPath, manifest);
+  } catch {
+    // run.json may not exist in standalone invocations
+  }
+}
+
+if (!verifyConfig.enabled) {
+  results.static_assets.status = "skipped";
+  results.build.status = "skipped";
+  results.build.command = null;
+  writeArtifact();
+  console.log(JSON.stringify({ ok: true, skipped: true, reason: "verify.disabled", ...results }));
+  process.exit(0);
+}
+
+results.build.command = skipBuild
+  ? null
+  : [verifyConfig.build.command, ...(verifyConfig.build.args ?? [])].join(" ");
+
+checkStaticAssets(
+  verifyConfig.indexHtml,
+  verifyConfig.appRoot,
+  verifyConfig.appRootRel,
+);
+runBuild(verifyConfig.build);
+writeArtifact();
+
+console.log(JSON.stringify({ ok: results.status === "pass", ...results }));
+process.exit(results.status === "pass" ? 0 : 1);

package/templates/cursor/aaac/capabilities/promotion-rules.json

@@ -0,0 +1,64 @@
+{
+  "version": 1,
+  "description": "Evidence-driven capability lifecycle promotion thresholds. State belongs to capability, not provider.",
+  "states": ["experimental", "validated", "trusted", "canonical", "deprecated"],
+  "default_state": "experimental",
+  "thresholds": {
+    "validated": {
+      "min_invocations": 10
+    },
+    "trusted": {
+      "min_invocations": 25,
+      "min_success_rate": 0.8,
+      "max_rollback_rate": 0.05,
+      "max_gate_failure_rate": 0.2
+    },
+    "canonical": {
+      "min_invocations": 100,
+      "min_success_rate": 0.95,
+      "max_rollback_rate": 0.01,
+      "max_gate_failure_rate": 0.1,
+      "manual_approval": true
+    }
+  },
+  "demotion": {
+    "from_trusted": {
+      "min_invocations": 20,
+      "min_success_rate_below": 0.7
+    },
+    "to_deprecated": {
+      "manual_only": true
+    }
+  },
+  "fitness_scoring": {
+    "pass": 100,
+    "warning": 75,
+    "fail": 0
+  },
+  "runtime": {
+    "by_state": {
+      "experimental": {
+        "warn": true,
+        "require_approval_on": ["critical", "protected"]
+      },
+      "validated": {},
+      "trusted": {},
+      "canonical": {},
+      "deprecated": {
+        "block_execute": true
+      }
+    },
+    "evidence_triggers": [
+      {
+        "min_invocations": 5,
+        "min_success_rate_below": 0.5,
+        "action": "require_approval"
+      },
+      {
+        "min_invocations": 10,
+        "min_avg_fitness_below": 60,
+        "action": "require_approval"
+      }
+    ]
+  }
+}

package/templates/cursor/aaac/capabilities/registry.json

@@ -2,15 +2,15 @@
   "version": 2,
   "capabilities": {
     "ui-design": {
-      "description": "Design tokens, component CSS, presentational UI",
+      "description": "Presentational components, token-based styling",
       "providers": [
         { "id": "component", "type": "skill", "path": "skills/shared/component" }
       ]
     },
     "ux-design": {
-      "description": "User flows, readability, navigation clarity",
+      "description": "Editorial readability, navigation clarity",
       "providers": [
-        { "id": "workflow", "type": "skill", "path": "skills/shared/workflow" }
+        { "id": "documentation", "type": "skill", "path": "skills/shared/documentation" }
       ]
     },
     "api-design": {
@@ -20,22 +20,21 @@
       ]
     },
     "database-design": {
-      "description": "Schema, migrations, persistence contracts",
+      "description": "Schema, migrations, persistence boundaries",
       "providers": [
-        { "id": "schema", "type": "skill", "path": "skills/shared/schema" },
-        { "id": "migration", "type": "skill", "path": "skills/shared/migration" }
+        { "id": "schema", "type": "skill", "path": "skills/shared/schema" }
       ]
     },
     "security": {
-      "description": "Auth, secrets, access control — extend with project skills",
+      "description": "Auth, secrets, access control at boundaries",
       "providers": [
         { "id": "architecture", "type": "skill", "path": "skills/shared/architecture" }
       ]
     },
     "infrastructure": {
-      "description": "Deploy, hosting, environment",
+      "description": "Deploy, hosting, environment configuration",
       "providers": [
-        { "id": "platform-release", "type": "skill", "path": "skills/shared/platform-release" }
+        { "id": "integration", "type": "skill", "path": "skills/shared/integration" }
       ]
     },
     "layer-boundaries": {
@@ -75,7 +74,7 @@
       ]
     },
     "integration-model": {
-      "description": "API routes, webhooks, MCP adapters",
+      "description": "API routes, webhooks, external adapters",
       "providers": [
         { "id": "integration", "type": "skill", "path": "skills/shared/integration" }
       ]
@@ -101,6 +100,7 @@
   },
   "resolution": {
     "graph_skill_keys": "providers where type=skill → id maps to graph skills key",
-    "run_record": "all providers including type=mcp recorded on Run.capabilities_resolved and decisions"
+    "run_record": "all providers including type=mcp recorded on Run.capabilities_resolved and decisions",
+    "lifecycle": "cross-run state in state/capability-stats.json; promotion thresholds in promotion-rules.json; updated by capability-evidence.mjs after each completed Run"
   }
 }

package/templates/cursor/aaac/dispatch.md

@@ -51,7 +51,7 @@ Read [graph.yaml](graph.yaml) and [ontology.json](ontology.json).
 - **Lifecycle (work):** [lifecycle/lifecycle.json](lifecycle/lifecycle.json) `verbs.*.work_phases`
 - **Gates (approval):** [governance/gates.json](governance/gates.json) — composed into runtime per `verb_runtime` in graph
 - **Maturity:** read `object_maturity.<object>` and apply `maturity_rules.<level>` (may require extra gate phases)
-- **Capabilities:** resolve `object_capabilities.<object>` via [capabilities/registry.json](capabilities/registry.json) — record all providers (skill + mcp) on Run
+- **Capabilities:** resolve `object_capabilities.<object>` via [capabilities/registry.json](capabilities/registry.json) — `init-run.mjs` records providers on `Run.capabilities_resolved`; on completion `capability-evidence.mjs` aggregates evidence into [state/capability-stats.json](state/capability-stats.json) and evaluates [capabilities/promotion-rules.json](capabilities/promotion-rules.json)
 - **Dependencies:** [dependencies.yaml](dependencies.yaml)
 - **Fitness:** [fitness-functions.yaml](fitness-functions.yaml) — includes `minimal_complexity` for create/update/fix
 - **Complexity:** [complexity.yaml](complexity.yaml) + [minimal-complexity.md](../policies/minimal-complexity.md) for create/update/fix
@@ -144,7 +144,7 @@ Do **not** proceed until user approves in chat. On approval: log decision, set `
 1. **discover** — 4–6 parallel Task agents per [discovery/SKILL.md](../skills/shared/discovery/SKILL.md)
 2. **investigate_swarm** — 7 parallel Task agents per investigation Mode A — **one message**
 3. **root_cause** — artifact required; confidence ≥ 0.7 before plan
-4. **verify** — fix verify swarm (3 parallel) per [testing/SKILL.md](../skills/shared/testing/SKILL.md); fail if `repro_status: not_fixed`
+4. **verify** — fix verify swarm (3 parallel) per [testing/SKILL.md](../skills/shared/testing/SKILL.md); **website build gate** (`verify-website-build.mjs`) must pass for create/update/fix; fail if `repro_status: not_fixed`
 
 Skipping swarms because the issue "looks simple" is a **contract violation** for `fix-module` / `fix-bug` / `fix_mode`.
 

package/templates/cursor/aaac/enforcement.json

@@ -1,8 +1,9 @@
 {
-  "version": 1,
+  "version": 2,
   "description": "AAAC runtime enforcement — SSOT for hooks and run engine",
   "edit_phases": ["execute", "sync_inventory", "persist", "write"],
-  "artifact_write_phases": ["plan", "report"],
+  "artifact_write_phases": ["plan", "report", "verify"],
+  "verify_verbs": ["create", "update", "fix"],
   "swarm_min_agents": {
     "discover": 4,
     "investigate_swarm": 7,
@@ -13,10 +14,12 @@
     "investigate_swarm": ["artifacts/investigation.md"],
     "root_cause": ["artifacts/root_cause.yaml"],
     "plan": ["artifacts/plan.yaml"],
+    "verify": ["artifacts/verify.yaml"],
     "report": ["artifacts/report.md"]
   },
   "allowed_path_prefixes": {
-    "run_artifacts": [".cursor/aaac/state/runs/", "aaac/state/runs/"]
+    "run_artifacts": [".cursor/aaac/state/runs/", "aaac/state/runs/"],
+    "write_article": [".cursor/write-article-runs/"]
   },
   "fix_commands": ["fix-module", "fix-bug", "module-fix", "bug-fix"]
 }

package/templates/cursor/aaac/governance/gates.json

@@ -29,7 +29,9 @@
         "plan missing requirement_map or unjustified create",
         "impact proceed false",
         "rollback unverified",
-        "user intent contains requires approval"
+        "user intent contains requires approval",
+        "capability runtime require_approval",
+        "capability state deprecated"
       ],
       "run_fields": {
         "status": "blocked",