paqad-ai 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,2699 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { realpathSync } from "fs";
+import { pathToFileURL } from "url";
+
+// src/cli/program.ts
+import { Command as Command6 } from "commander";
+
+// src/adapters/shared/base-adapter.ts
+import { readFile as readFile2 } from "fs/promises";
+import { basename, join as join2 } from "pathe";
+
+// src/core/runtime-paths.ts
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+function getRuntimeRoot() {
+  return join(PACKAGE_ROOT, "runtime");
+}
+function getRuntimeTemplatesRoot() {
+  return join(getRuntimeRoot(), "templates");
+}
+
+// src/mcp/server-registry.ts
+var MCP_SERVERS = [
+  {
+    name: "laravel-boost",
+    stacks: ["laravel"],
+    capabilities: ["boost"],
+    provides: ["routes", "models", "services", "middleware", "config"],
+    replaces: ["route-scanning", "model-scanning", "service-scanning"]
+  },
+  {
+    name: "dart-mcp",
+    stacks: ["flutter"],
+    capabilities: [],
+    provides: ["widgets", "dependencies", "assets", "platforms"],
+    replaces: ["widget-scanning", "pubspec-parsing"]
+  },
+  {
+    name: "database-inspector",
+    stacks: ["laravel", "flutter"],
+    capabilities: [],
+    provides: ["schema", "indexes", "foreign-keys", "query-plans"],
+    replaces: ["migration-scanning"]
+  },
+  {
+    name: "figma",
+    stacks: ["laravel", "flutter"],
+    capabilities: [],
+    provides: ["design-specs", "components", "layouts"],
+    replaces: ["web-search-design-research"]
+  }
+];
+function getServersForStack(stack, capabilities) {
+  return MCP_SERVERS.filter((server) => {
+    const stackMatch = server.stacks.includes(stack);
+    const capabilityMatch = server.capabilities.length === 0 || server.capabilities.some((capability) => capabilities.includes(capability));
+    return stackMatch && capabilityMatch;
+  });
+}
+var McpServerRegistry = class {
+  list() {
+    return [...MCP_SERVERS];
+  }
+  forProfile(profile) {
+    const enabledNames = new Set(
+      profile.mcp.servers.filter((server) => server.enabled).map((server) => server.name)
+    );
+    return MCP_SERVERS.filter(
+      (server) => isStackSupported(server.stacks, profile.routing.stack) && isCapabilitySatisfied(server.capabilities, profile.routing.capabilities) && (enabledNames.has(server.name) || isDefaultServer(profile.routing.stack, server.name, profile.routing.capabilities))
+    );
+  }
+};
+function isStackSupported(stacks, stack) {
+  return stacks.includes(stack);
+}
+function isCapabilitySatisfied(required, capabilities) {
+  return required.length === 0 || required.every((capability) => capabilities.includes(capability));
+}
+function isDefaultServer(stack, name, capabilities) {
+  if (name === "database-inspector") {
+    return stack === "laravel" || stack === "flutter";
+  }
+  if (name === "laravel-boost") {
+    return stack === "laravel" && capabilities.includes("boost");
+  }
+  if (name === "dart-mcp") {
+    return stack === "flutter";
+  }
+  return false;
+}
+
+// src/mcp/config-manager.ts
+var ADAPTER_OUTPUT_PATHS = {
+  "claude-code": ".claude/settings.mcp.json",
+  "codex-cli": ".codex/mcp.json",
+  "gemini-cli": ".gemini/mcp.json"
+};
+var McpConfigManager = class {
+  registry = new McpServerRegistry();
+  generate(profile, adapter) {
+    const servers = this.registry.forProfile(profile);
+    return {
+      path: ADAPTER_OUTPUT_PATHS[adapter],
+      content: JSON.stringify(
+        {
+          mcpServers: Object.fromEntries(
+            servers.map((server) => [server.name, buildServerConfig(server, profile)])
+          )
+        },
+        null,
+        2
+      )
+    };
+  }
+};
+function buildServerConfig(server, profile) {
+  const fromProfile = profile.mcp.servers.find((entry) => entry.name === server.name)?.config ?? {};
+  return {
+    enabled: true,
+    stack: profile.routing.stack,
+    provides: server.provides,
+    replaces: server.replaces,
+    ...fromProfile
+  };
+}
+
+// src/templates/engine.ts
+import { readFile } from "fs/promises";
+import Handlebars from "handlebars";
+var TemplateEngine = class {
+  handlebars;
+  constructor() {
+    this.handlebars = Handlebars.create();
+    this.registerHelpers();
+  }
+  async render(templatePath, context) {
+    const templateSource = await readFile(templatePath, "utf8");
+    const template = this.handlebars.compile(templateSource);
+    return template(context);
+  }
+  registerHelpers() {
+    this.handlebars.registerHelper(
+      "if_eq",
+      function ifEq(left, right, options) {
+        return left === right ? options.fn(this) : options.inverse(this);
+      }
+    );
+    this.handlebars.registerHelper(
+      "join",
+      (value, separator = ", ") => Array.isArray(value) ? value.join(separator) : ""
+    );
+    this.handlebars.registerHelper("uppercase", (value) => value.toUpperCase());
+    this.handlebars.registerHelper("lowercase", (value) => value.toLowerCase());
+    this.handlebars.registerHelper(
+      "slugify",
+      (value) => value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")
+    );
+    this.handlebars.registerHelper("date", () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10));
+  }
+};
+
+// src/adapters/shared/base-adapter.ts
+var BaseAdapter = class {
+  engine = new TemplateEngine();
+  async generateConfig(context) {
+    return [
+      {
+        path: this.configOutputPath(),
+        content: await this.engine.render(
+          join2(getRuntimeTemplatesRoot(), "agent-configs", this.configTemplateName()),
+          {
+            adapter: this.type,
+            frameworkPath: context.frameworkPath,
+            rulesPath: context.rulesPath
+          }
+        ),
+        autoUpdate: true
+      }
+    ];
+  }
+  async generateSkills(skills) {
+    return Promise.all(
+      skills.map(async (skill) => ({
+        path: join2(this.skillsRoot(), basename(skill.path)),
+        content: await readFile2(skill.path, "utf8"),
+        autoUpdate: true
+      }))
+    );
+  }
+  async generateAgents(agents) {
+    return Promise.all(
+      agents.map(async (agent) => ({
+        path: join2(this.agentsRoot(), basename(agent.path)),
+        content: await readFile2(agent.path, "utf8"),
+        autoUpdate: true
+      }))
+    );
+  }
+  async installHooks(hooks) {
+    return [
+      {
+        path: this.hooksOutputPath(),
+        content: JSON.stringify(
+          hooks.map((hook) => ({ source: hook.source, path: hook.path })),
+          null,
+          2
+        ),
+        autoUpdate: true
+      }
+    ];
+  }
+  async installMcp(mcpConfigs, profile) {
+    const config = new McpConfigManager().generate(profile, this.type);
+    return [
+      {
+        path: config.path,
+        content: JSON.stringify(
+          {
+            ...JSON.parse(config.content),
+            resolved_artifacts: mcpConfigs.map((artifact) => artifact.source)
+          },
+          null,
+          2
+        ),
+        autoUpdate: true
+      }
+    ];
+  }
+  async configureCaching(profile) {
+    return [
+      {
+        path: this.cacheOutputPath(),
+        content: JSON.stringify(
+          {
+            enabled: profile.efficiency.skill_caching,
+            differential_refresh: profile.efficiency.differential_refresh
+          },
+          null,
+          2
+        ),
+        autoUpdate: true
+      }
+    ];
+  }
+  async configureMemory(profile) {
+    return [
+      {
+        path: this.memoryOutputPath(),
+        content: JSON.stringify(
+          {
+            context_hit_rate_target: profile.efficiency.context_hit_rate_target,
+            mcp_first: profile.efficiency.mcp_first
+          },
+          null,
+          2
+        ),
+        autoUpdate: true
+      }
+    ];
+  }
+};
+
+// src/adapters/claude/claude-adapter.ts
+var ClaudeCodeAdapter = class extends BaseAdapter {
+  type = "claude-code";
+  configTemplateName() {
+    return "claude.md.hbs";
+  }
+  configOutputPath() {
+    return "CLAUDE.md";
+  }
+  skillsRoot() {
+    return ".claude/skills";
+  }
+  agentsRoot() {
+    return ".claude/agents";
+  }
+  hooksOutputPath() {
+    return ".claude/settings.hooks.json";
+  }
+  mcpOutputPath() {
+    return ".claude/settings.mcp.json";
+  }
+  cacheOutputPath() {
+    return ".claude/cache.json";
+  }
+  memoryOutputPath() {
+    return ".claude/memory.json";
+  }
+};
+
+// src/adapters/codex/codex-adapter.ts
+var CodexCliAdapter = class extends BaseAdapter {
+  type = "codex-cli";
+  configTemplateName() {
+    return "agents.md.hbs";
+  }
+  configOutputPath() {
+    return "AGENTS.md";
+  }
+  skillsRoot() {
+    return ".codex/skills";
+  }
+  agentsRoot() {
+    return ".codex/agents";
+  }
+  hooksOutputPath() {
+    return ".codex/hooks.json";
+  }
+  mcpOutputPath() {
+    return ".codex/mcp.json";
+  }
+  cacheOutputPath() {
+    return ".codex/cache.json";
+  }
+  memoryOutputPath() {
+    return ".codex/memory.json";
+  }
+};
+
+// src/adapters/gemini/gemini-adapter.ts
+var GeminiCliAdapter = class extends BaseAdapter {
+  type = "gemini-cli";
+  configTemplateName() {
+    return "gemini.md.hbs";
+  }
+  configOutputPath() {
+    return "GEMINI.md";
+  }
+  skillsRoot() {
+    return ".gemini/skills";
+  }
+  agentsRoot() {
+    return ".gemini/agents";
+  }
+  hooksOutputPath() {
+    return ".gemini/hooks.json";
+  }
+  mcpOutputPath() {
+    return ".gemini/mcp.json";
+  }
+  cacheOutputPath() {
+    return ".gemini/cache.json";
+  }
+  memoryOutputPath() {
+    return ".gemini/memory.json";
+  }
+};
+
+// src/adapters/factory.ts
+var AdapterFactory = class {
+  static create(type) {
+    switch (type) {
+      case "claude-code":
+        return new ClaudeCodeAdapter();
+      case "codex-cli":
+        return new CodexCliAdapter();
+      case "gemini-cli":
+        return new GeminiCliAdapter();
+    }
+  }
+};
+
+// src/core/constants/paths.ts
+var PATHS = {
+  AGENCY_DIR: ".agency",
+  PROJECT_PROFILE: ".agency/project-profile.yaml",
+  DETECTION_REPORT: ".agency/detection-report.json",
+  ONBOARDING_MANIFEST: ".agency/onboarding-manifest.json",
+  FRAMEWORK_VERSION: ".agency/framework-version.txt",
+  FRAMEWORK_PATH: ".agency/framework-path.txt",
+  GLOSSARY: ".agency/glossary.md",
+  HANDOFF: ".agency/session/handoff.md",
+  CHANGED_FILES: ".agency/session/changed-files.json",
+  CONTEXT_HIT_LOG: ".agency/session/context-hit-log.json",
+  SKILL_CACHE_DIR: ".agency/cache/skill-results",
+  INDEXES_DIR: ".agency/indexes",
+  DOCS_DIR: "docs",
+  RULES_DIR: "docs/rules",
+  ARCHITECTURE_DIR: "docs/architecture",
+  DESIGN_SYSTEM_DIR: "docs/design-system",
+  MODULES_DIR: "docs/modules",
+  BENCHMARKS_DIR: "docs/benchmarks",
+  TECH_DEBT_DIR: "docs/tech-debt",
+  MODULE_DB_DIR: "database",
+  MODULE_API_DIR: "api",
+  MODULE_INTEGRATION_DIR: "integration",
+  MODULE_UI_DIR: "ui",
+  MODULE_FEATURES_DIR: "features",
+  MODULE_USER_FLOWS_DIR: "user-flows",
+  MODULE_RESEARCH_DIR: "research",
+  MODULE_DECISIONS_DIR: "decisions",
+  MODULE_ERROR_CATALOG: "error-catalog.md",
+  CLAUDE_MD: "CLAUDE.md",
+  AGENTS_MD: "AGENTS.md",
+  GEMINI_MD: "GEMINI.md",
+  SCRIPTS_DIR: "scripts"
+};
+var REGISTRIES = [
+  "module-registry.md",
+  "feature-registry.md",
+  "model-registry.md",
+  "api-registry.md",
+  "job-event-registry.md",
+  "component-registry.md",
+  "screen-registry.md",
+  "table-registry.md",
+  "query-registry.md",
+  "test-registry.md",
+  "error-code-registry.md",
+  "integration-registry.md",
+  "reuse-catalog.md"
+];
+
+// src/detection/report.ts
+function buildDetectionReport(input) {
+  return {
+    detected_domain: input.domain,
+    detected_stack: input.stack,
+    detected_capabilities: input.capabilities ?? [],
+    confidence: input.confidence,
+    signals: input.signals,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/detection/signals/flutter.ts
+import { existsSync, readFileSync } from "fs";
+import { join as join3 } from "path";
+import { parse } from "yaml";
+function detectFlutterSignals(projectRoot) {
+  const pubspecPath = join3(projectRoot, "pubspec.yaml");
+  if (!existsSync(pubspecPath)) {
+    return [];
+  }
+  const pubspec = parse(readFileSync(pubspecPath, "utf8"));
+  if (pubspec.dependencies?.flutter === void 0) {
+    return [];
+  }
+  return [
+    {
+      signal: "pubspec.yaml declares flutter dependency",
+      file: "pubspec.yaml",
+      implies: "flutter",
+      confidence: "high"
+    }
+  ];
+}
+
+// src/detection/signals/laravel.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
+function detectLaravelSignals(projectRoot) {
+  const signals = [];
+  const capabilities = /* @__PURE__ */ new Set();
+  const composerPath = join4(projectRoot, "composer.json");
+  const packageJsonPath = join4(projectRoot, "package.json");
+  if (existsSync2(join4(projectRoot, "artisan"))) {
+    signals.push(signal("artisan file exists", "artisan", "laravel", "high"));
+  }
+  if (existsSync2(composerPath)) {
+    const composer = readJsonFile(composerPath);
+    const dependencies = {
+      ...composer.dependencies,
+      ...composer.require
+    };
+    if (dependencies["laravel/framework"] !== void 0) {
+      signals.push(
+        signal("composer dependency laravel/framework", "composer.json", "laravel", "high")
+      );
+    }
+    if (dependencies["inertiajs/inertia-laravel"] !== void 0) {
+      capabilities.add("inertia");
+      signals.push(
+        signal("composer dependency inertiajs/inertia-laravel", "composer.json", "inertia", "high")
+      );
+    }
+    if (dependencies["laravel/boost"] !== void 0) {
+      capabilities.add("boost");
+      signals.push(signal("composer dependency laravel/boost", "composer.json", "boost", "high"));
+    }
+  }
+  if (existsSync2(join4(projectRoot, "app"))) {
+    signals.push(signal("app directory exists", "app", "laravel", "medium"));
+  }
+  if (existsSync2(join4(projectRoot, "routes"))) {
+    signals.push(signal("routes directory exists", "routes", "laravel", "medium"));
+  }
+  if (existsSync2(packageJsonPath)) {
+    const packageJson = readJsonFile(packageJsonPath);
+    const dependencies = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    if (dependencies.react !== void 0) {
+      capabilities.add("react");
+      signals.push(signal("package dependency react", "package.json", "react", "high"));
+    }
+    if (dependencies.vue !== void 0) {
+      capabilities.add("vue");
+      signals.push(signal("package dependency vue", "package.json", "vue", "high"));
+    }
+  }
+  if (existsSync2(join4(projectRoot, "resources", "js", "App.tsx"))) {
+    capabilities.add("react");
+    signals.push(signal("React entrypoint found", "resources/js/App.tsx", "react", "high"));
+  }
+  if (existsSync2(join4(projectRoot, "config", "boost.php"))) {
+    capabilities.add("boost");
+    signals.push(signal("boost config exists", "config/boost.php", "boost", "high"));
+  }
+  return {
+    signals,
+    capabilities: Array.from(capabilities)
+  };
+}
+function readJsonFile(path) {
+  return JSON.parse(readFileSync2(path, "utf8"));
+}
+function signal(description, file, implies, confidence) {
+  return {
+    signal: description,
+    file,
+    implies,
+    confidence
+  };
+}
+
+// src/detection/signals/short-video.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
+import { parse as parse2 } from "yaml";
+function detectShortVideoSignals(projectRoot) {
+  const profilePath = join5(projectRoot, ".agency", "project-profile.yaml");
+  const markerPath = join5(projectRoot, ".short-video-project");
+  const signals = [];
+  if (existsSync3(profilePath)) {
+    const profile = parse2(readFileSync3(profilePath, "utf8"));
+    if (profile.routing?.domain === "content" && profile.routing.stack === "short-video") {
+      signals.push({
+        signal: "project profile declares content/short-video",
+        file: ".agency/project-profile.yaml",
+        implies: "short-video",
+        confidence: "high"
+      });
+    }
+  }
+  if (existsSync3(markerPath)) {
+    signals.push({
+      signal: "short-video marker file exists",
+      file: ".short-video-project",
+      implies: "short-video",
+      confidence: "medium"
+    });
+  }
+  return signals;
+}
+
+// src/detection/detector.ts
+var Detector = class {
+  async detect(projectRoot) {
+    const laravel = detectLaravelSignals(projectRoot);
+    const flutter = detectFlutterSignals(projectRoot);
+    const shortVideo = detectShortVideoSignals(projectRoot);
+    const scoredStacks = [
+      {
+        domain: "coding",
+        stack: "laravel",
+        score: laravel.signals.filter((signal2) => signal2.implies === "laravel").length,
+        capabilities: laravel.capabilities,
+        signals: laravel.signals
+      },
+      {
+        domain: "coding",
+        stack: "flutter",
+        score: flutter.length,
+        capabilities: [],
+        signals: flutter
+      },
+      {
+        domain: "content",
+        stack: "short-video",
+        score: shortVideo.length,
+        capabilities: [],
+        signals: shortVideo
+      }
+    ].filter((candidate) => candidate.score > 0);
+    if (scoredStacks.length === 0) {
+      return buildDetectionReport({
+        domain: null,
+        stack: null,
+        signals: [],
+        confidence: "low"
+      });
+    }
+    const topScore = Math.max(...scoredStacks.map((candidate) => candidate.score));
+    const winners = scoredStacks.filter((candidate) => candidate.score === topScore);
+    if (winners.length > 1) {
+      return buildDetectionReport({
+        domain: null,
+        stack: null,
+        signals: winners.flatMap((winner2) => winner2.signals),
+        confidence: "low"
+      });
+    }
+    const winner = winners[0];
+    const confidence = winner.score >= 3 ? "high" : winner.score >= 2 ? "medium" : "low";
+    return buildDetectionReport({
+      domain: winner.domain,
+      stack: winner.stack,
+      capabilities: winner.capabilities,
+      signals: winner.signals,
+      confidence
+    });
+  }
+};
+
+// src/health/checker.ts
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4, statSync } from "fs";
+import { access } from "fs/promises";
+import { constants as fsConstants } from "fs";
+import { join as join6 } from "path";
+import YAML from "yaml";
+
+// src/validators/validator.ts
+import Ajv from "ajv";
+
+// src/validators/schemas/adversarial-review-report.schema.json
+var adversarial_review_report_schema_default = {
+  $id: "adversarial-review-report",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "point",
+    "tier",
+    "mode",
+    "verdict",
+    "summary",
+    "findings",
+    "dimensions_passed_clean",
+    "dimensions_deferred"
+  ],
+  properties: {
+    point: { type: "string", enum: ["after-spec", "after-implementation"] },
+    tier: { type: "string", enum: ["full", "standard", "spot-check"] },
+    mode: { type: "string", enum: ["fresh", "diff"] },
+    verdict: { type: "string", enum: ["pass", "fail"] },
+    summary: { type: "string" },
+    findings: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "dimension", "severity", "finding", "impact", "required_action"],
+        properties: {
+          id: { type: "string" },
+          dimension: { type: "string" },
+          severity: { type: "string", enum: ["critical", "high", "medium", "low"] },
+          finding: { type: "string" },
+          impact: { type: "string" },
+          required_action: { type: "string" }
+        }
+      }
+    },
+    dimensions_passed_clean: { type: "array", items: { type: "string" } },
+    dimensions_deferred: { type: "array", items: { type: "string" } }
+  }
+};
+
+// src/validators/schemas/api-endpoint-doc.schema.json
+var api_endpoint_doc_schema_default = {
+  $id: "api-endpoint-doc",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "method",
+    "route",
+    "auth",
+    "description",
+    "request_schema_ref",
+    "response_schema_ref"
+  ],
+  properties: {
+    method: { type: "string", enum: ["GET", "POST", "PUT", "PATCH", "DELETE"] },
+    route: { type: "string", pattern: "^/" },
+    auth: { type: "string", enum: ["required", "public"] },
+    permissions: { type: "array", items: { type: "string" } },
+    rate_limit: { type: "string" },
+    description: { type: "string", minLength: 1 },
+    request_schema_ref: { type: "string" },
+    response_schema_ref: { type: "string" },
+    error_codes_ref: { type: "string" },
+    added_in: { type: "string" },
+    last_updated: { type: "string" }
+  }
+};
+
+// src/validators/schemas/context-hit-log.schema.json
+var context_hit_log_schema_default = {
+  $id: "context-hit-log",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "session_id",
+    "phase",
+    "files_loaded",
+    "files_referenced",
+    "hit_rate",
+    "unreferenced_files",
+    "timestamp"
+  ],
+  properties: {
+    session_id: { type: "string" },
+    phase: { type: "string" },
+    story: { type: "string" },
+    files_loaded: { type: "integer", minimum: 0 },
+    files_referenced: { type: "integer", minimum: 0 },
+    hit_rate: { type: "number", minimum: 0, maximum: 1 },
+    unreferenced_files: { type: "array", items: { type: "string" } },
+    timestamp: { type: "string", format: "date-time" }
+  }
+};
+
+// src/validators/schemas/detection-report.schema.json
+var detection_report_schema_default = {
+  $id: "detection-report",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "detected_domain",
+    "detected_stack",
+    "detected_capabilities",
+    "confidence",
+    "signals",
+    "timestamp"
+  ],
+  properties: {
+    detected_domain: { type: ["string", "null"], enum: ["coding", "content", null] },
+    detected_stack: {
+      type: ["string", "null"],
+      enum: ["laravel", "flutter", "short-video", null]
+    },
+    detected_capabilities: {
+      type: "array",
+      items: { type: "string", enum: ["inertia", "vue", "react", "boost"] }
+    },
+    confidence: { type: "string", enum: ["high", "medium", "low"] },
+    signals: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["signal", "file", "implies", "confidence"],
+        properties: {
+          signal: { type: "string" },
+          file: { type: "string" },
+          implies: { type: "string" },
+          confidence: { type: "string", enum: ["high", "medium", "low"] }
+        }
+      }
+    },
+    timestamp: { type: "string" }
+  }
+};
+
+// src/validators/schemas/error-catalog.schema.json
+var error_catalog_schema_default = {
+  $id: "error-catalog",
+  type: "object",
+  additionalProperties: false,
+  required: ["code", "user_message", "trigger", "recovery_path", "retry_safe"],
+  properties: {
+    code: { type: "string", pattern: "^[A-Z]{2,5}-[0-9]{3}$" },
+    http_status: { type: "integer", minimum: 400, maximum: 599 },
+    user_message: { type: "string", minLength: 1 },
+    internal_message: { type: "string" },
+    trigger: { type: "string", minLength: 1 },
+    recovery_path: { type: "string", minLength: 1 },
+    retry_safe: { type: "boolean" },
+    logged: { type: "boolean" },
+    alerted: { type: "boolean" },
+    added_in: { type: "string" },
+    last_updated: { type: "string" }
+  }
+};
+
+// src/validators/schemas/gate-result.schema.json
+var gate_result_schema_default = {
+  $id: "gate-result",
+  type: "object",
+  additionalProperties: false,
+  required: ["gate", "passed", "detail"],
+  properties: {
+    gate: { type: "string" },
+    passed: { type: "boolean" },
+    detail: { type: "string" },
+    remediation: { type: "string" }
+  }
+};
+
+// src/validators/schemas/handoff-artifact.schema.json
+var handoff_artifact_schema_default = {
+  $id: "handoff-artifact",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "framework_version",
+    "current_phase",
+    "current_story",
+    "completed_stories",
+    "key_decisions",
+    "verification_results",
+    "changed_files",
+    "context_hit_rate",
+    "warnings",
+    "unresolved_items",
+    "references"
+  ],
+  properties: {
+    framework_version: { type: "string" },
+    current_phase: { type: "string" },
+    current_story: {
+      anyOf: [
+        { type: "null" },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["id", "title"],
+          properties: { id: { type: "string" }, title: { type: "string" } }
+        }
+      ]
+    },
+    completed_stories: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "title", "verification_status"],
+        properties: {
+          id: { type: "string" },
+          title: { type: "string" },
+          verification_status: { type: "string", enum: ["passed", "failed", "partial"] }
+        }
+      }
+    },
+    key_decisions: { type: "array", items: { type: "string" } },
+    verification_results: { type: "array", items: { $ref: "gate-result" } },
+    changed_files: { type: "array", items: { type: "string" } },
+    context_hit_rate: { type: "number" },
+    warnings: { type: "array", items: { type: "string" } },
+    unresolved_items: { type: "array", items: { type: "string" } },
+    references: {
+      type: "object",
+      additionalProperties: false,
+      required: ["spec", "flow", "review_report"],
+      properties: {
+        spec: { type: "string" },
+        flow: { type: "string" },
+        review_report: { type: "string" }
+      }
+    }
+  }
+};
+
+// src/validators/schemas/integration-doc.schema.json
+var integration_doc_schema_default = {
+  $id: "integration-doc",
+  type: "object",
+  additionalProperties: false,
+  required: ["event_class", "published_by", "subscribers", "async"],
+  properties: {
+    event_class: { type: "string", minLength: 1 },
+    published_by: { type: "string", minLength: 1 },
+    payload_fields: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["name", "type", "description"],
+        properties: {
+          name: { type: "string" },
+          type: { type: "string" },
+          description: { type: "string" }
+        }
+      }
+    },
+    subscribers: { type: "array", items: { type: "string" } },
+    async: { type: "boolean" },
+    added_in: { type: "string" }
+  }
+};
+
+// src/validators/schemas/onboarding-manifest.schema.json
+var onboarding_manifest_schema_default = {
+  $id: "onboarding-manifest",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "framework_version",
+    "adapter",
+    "project_root",
+    "profile",
+    "detected",
+    "generated_at",
+    "generated_artifacts"
+  ],
+  properties: {
+    framework_version: { type: "string" },
+    adapter: { type: "string", enum: ["claude-code", "codex-cli", "gemini-cli"] },
+    project_root: { type: "string" },
+    profile: { $ref: "project-profile" },
+    detected: { anyOf: [{ $ref: "detection-report" }, { type: "null" }] },
+    generated_at: { type: "string" },
+    generated_artifacts: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["path", "auto_update"],
+        properties: {
+          path: { type: "string" },
+          auto_update: { type: "boolean" },
+          executable: { type: "boolean" }
+        }
+      }
+    }
+  }
+};
+
+// src/validators/schemas/project-profile.schema.json
+var project_profile_schema_default = {
+  $id: "project-profile",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "project",
+    "routing",
+    "commands",
+    "strictness",
+    "compliance_packs",
+    "features",
+    "mcp",
+    "model_routing",
+    "research",
+    "efficiency",
+    "escalation",
+    "custom"
+  ],
+  properties: {
+    project: {
+      type: "object",
+      additionalProperties: false,
+      required: ["name", "id", "description"],
+      properties: {
+        name: { type: "string" },
+        id: { type: "string" },
+        description: { type: "string" }
+      }
+    },
+    routing: {
+      type: "object",
+      additionalProperties: false,
+      required: ["domain", "stack", "capabilities"],
+      properties: {
+        domain: { type: "string", enum: ["coding", "content"] },
+        stack: { type: "string", enum: ["laravel", "flutter", "short-video"] },
+        capabilities: {
+          type: "array",
+          items: { type: "string", enum: ["inertia", "vue", "react", "boost"] }
+        }
+      }
+    },
+    commands: {
+      type: "object",
+      additionalProperties: false,
+      required: ["install", "dev", "test", "test_single", "lint", "format", "migrate", "build"],
+      properties: {
+        install: { type: "string" },
+        dev: { type: "string" },
+        test: { type: "string" },
+        test_single: { type: "string" },
+        lint: { type: "string" },
+        format: { type: "string" },
+        migrate: { type: "string" },
+        build: { type: "string" }
+      }
+    },
+    strictness: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "full_lane_default",
+        "require_adversarial_review",
+        "block_on_stale_docs",
+        "require_db_review_for_migrations"
+      ],
+      properties: {
+        full_lane_default: { type: "boolean" },
+        require_adversarial_review: { type: "boolean" },
+        block_on_stale_docs: { type: "boolean" },
+        require_db_review_for_migrations: { type: "boolean" }
+      }
+    },
+    compliance_packs: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["name", "enabled"],
+        properties: {
+          name: { type: "string" },
+          enabled: { type: "boolean" }
+        }
+      }
+    },
+    features: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "spec_only_mode",
+        "market_research",
+        "design_research",
+        "team_agents",
+        "supply_chain_governance",
+        "ai_governance"
+      ],
+      properties: {
+        spec_only_mode: { type: "boolean" },
+        market_research: { type: "boolean" },
+        design_research: { type: "boolean" },
+        team_agents: { type: "boolean" },
+        supply_chain_governance: { type: "boolean" },
+        ai_governance: { type: "boolean" }
+      }
+    },
+    mcp: {
+      type: "object",
+      additionalProperties: false,
+      required: ["servers"],
+      properties: {
+        servers: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["name", "enabled"],
+            properties: {
+              name: { type: "string" },
+              enabled: { type: "boolean" },
+              config: { type: "object" }
+            }
+          }
+        }
+      }
+    },
+    model_routing: {
+      type: "object",
+      additionalProperties: false,
+      required: ["default_model", "reasoning_model", "fast_model"],
+      properties: {
+        default_model: { type: "string" },
+        reasoning_model: { type: "string" },
+        fast_model: { type: "string" }
+      }
+    },
+    research: {
+      type: "object",
+      additionalProperties: false,
+      required: ["depth"],
+      properties: {
+        depth: { type: "string", enum: ["cutting-edge", "standard", "conservative"] }
+      }
+    },
+    efficiency: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        context_hit_rate_target: { type: "number" },
+        skill_caching: { type: "boolean" },
+        differential_refresh: { type: "boolean" },
+        mcp_first: { type: "boolean" }
+      }
+    },
+    escalation: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "destructive_operations",
+        "risky_migrations",
+        "security_findings",
+        "db_row_threshold"
+      ],
+      properties: {
+        destructive_operations: {
+          type: "string",
+          enum: ["block", "require_approval", "warn"]
+        },
+        risky_migrations: { type: "string", enum: ["block", "require_approval", "warn"] },
+        security_findings: { type: "string", enum: ["block", "require_approval", "warn"] },
+        db_row_threshold: { type: "integer" }
+      }
+    },
+    custom: {
+      type: "object",
+      additionalProperties: false,
+      required: ["classification_dimensions", "verification_plugins", "escalation_rules"],
+      properties: {
+        classification_dimensions: { type: "array", items: { type: "object" } },
+        verification_plugins: { type: "array", items: { type: "object" } },
+        escalation_rules: { type: "array", items: { type: "object" } }
+      }
+    }
+  }
+};
+
+// src/validators/schemas/skill-frontmatter.schema.json
+var skill_frontmatter_schema_default = {
+  $id: "skill-frontmatter",
+  type: "object",
+  additionalProperties: false,
+  required: ["name", "description", "model_tier"],
+  properties: {
+    name: { type: "string", minLength: 1 },
+    description: { type: "string", minLength: 1 },
+    model_tier: { type: "string", enum: ["fast", "medium", "deep"] },
+    triggers: { type: "array" },
+    max_lines: { type: "integer", maximum: 300 },
+    cacheable: { type: "boolean" },
+    cache_key_inputs: { type: "array", items: { type: "string" } }
+  }
+};
+
+// src/validators/validator.ts
+var SCHEMAS = [
+  project_profile_schema_default,
+  detection_report_schema_default,
+  onboarding_manifest_schema_default,
+  handoff_artifact_schema_default,
+  adversarial_review_report_schema_default,
+  context_hit_log_schema_default,
+  api_endpoint_doc_schema_default,
+  integration_doc_schema_default,
+  error_catalog_schema_default,
+  skill_frontmatter_schema_default,
+  gate_result_schema_default
+];
+var SchemaValidator = class {
+  ajv;
+  constructor() {
+    this.ajv = new Ajv({ allErrors: true, verbose: true });
+    this.ajv.addFormat(
+      "date-time",
+      /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/
+    );
+    this.registerSchemas();
+  }
+  validate(schemaId, data) {
+    const valid = this.ajv.validate(schemaId, data);
+    return {
+      valid,
+      errors: valid ? [] : this.formatErrors(this.ajv.errors)
+    };
+  }
+  registerSchemas() {
+    for (const schema of SCHEMAS) {
+      this.ajv.addSchema(schema);
+    }
+  }
+  formatErrors(errors) {
+    if (errors === null || errors === void 0) {
+      return [];
+    }
+    return errors.map((error) => ({
+      path: error.instancePath || "/",
+      message: error.message ?? "Validation failed",
+      expected: error.schemaPath,
+      actual: error.data === void 0 ? void 0 : JSON.stringify(error.data)
+    }));
+  }
+};
+
+// src/health/checker.ts
+var STALENESS_WINDOW_MS = 1e3 * 60 * 60 * 24 * 7;
+var HealthChecker = class {
+  validator = new SchemaValidator();
+  async run(projectRoot) {
+    const profile = this.readProfile(projectRoot);
+    const modules = this.detectModules(projectRoot);
+    const checks = [
+      this.checkFrameworkArtifacts(projectRoot),
+      this.checkProfile(profile),
+      this.checkDocsScaffold(projectRoot),
+      this.checkIndexesCurrent(projectRoot),
+      await this.checkScripts(projectRoot),
+      this.checkHooks(projectRoot),
+      this.checkAdapterConfig(projectRoot),
+      this.checkStackCommands(profile),
+      this.checkStableFrameworkPaths(projectRoot),
+      this.checkBrokenScaffold(projectRoot),
+      this.checkUiDocs(projectRoot, modules),
+      this.checkApiDocs(projectRoot, modules),
+      this.checkIntegrationDocs(projectRoot, modules),
+      this.checkErrorCatalog(projectRoot, modules),
+      this.checkMcp(projectRoot, profile),
+      this.checkSkillCache(projectRoot),
+      this.checkContextHitRate(projectRoot, profile)
+    ];
+    const overallStatus = deriveOverallStatus(checks);
+    return {
+      overall_status: overallStatus,
+      checks,
+      efficiency: this.buildEfficiencySummary(projectRoot, profile)
+    };
+  }
+  readProfile(projectRoot) {
+    const path = join6(projectRoot, PATHS.PROJECT_PROFILE);
+    if (!existsSync4(path)) {
+      return null;
+    }
+    try {
+      return YAML.parse(readFileSync4(path, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  detectModules(projectRoot) {
+    const modulesRoot = join6(projectRoot, "docs/modules");
+    if (!existsSync4(modulesRoot)) {
+      return [];
+    }
+    return readdirSync(modulesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  }
+  checkFrameworkArtifacts(projectRoot) {
+    const required = [
+      PATHS.PROJECT_PROFILE,
+      PATHS.FRAMEWORK_VERSION,
+      PATHS.FRAMEWORK_PATH,
+      "scripts",
+      "docs/modules/core"
+    ];
+    const missing = required.filter((relative6) => !existsSync4(join6(projectRoot, relative6)));
+    return missing.length === 0 ? pass("Framework artifacts exist", "Framework artifacts are present") : fail(
+      "Framework artifacts exist",
+      `Missing framework artifacts: ${missing.join(", ")}`,
+      "Re-run onboarding to regenerate the missing framework artifacts."
+    );
+  }
+  checkProfile(profile) {
+    if (profile === null) {
+      return fail(
+        "Profile is valid",
+        "Project profile is missing or unreadable",
+        "Regenerate the project profile."
+      );
+    }
+    const validation = this.validator.validate("project-profile", profile);
+    return validation.valid ? pass("Profile is valid", "Project profile schema is valid") : fail(
+      "Profile is valid",
+      validation.errors.map((error) => error.message).join("; "),
+      "Fix the invalid project profile fields."
+    );
+  }
+  checkDocsScaffold(projectRoot) {
+    const required = [
+      "docs/modules/core/api/endpoints.md",
+      "docs/modules/core/api/schemas.md",
+      "docs/modules/core/api/error-codes.md",
+      "docs/modules/core/integration/events.md",
+      "docs/modules/core/integration/contracts.md",
+      "docs/modules/core/error-catalog.md"
+    ];
+    const missing = required.filter((relative6) => !existsSync4(join6(projectRoot, relative6)));
+    return missing.length === 0 ? pass("Docs scaffold exists", "Documentation scaffold is complete") : fail(
+      "Docs scaffold exists",
+      `Missing scaffold files: ${missing.join(", ")}`,
+      "Regenerate the documentation scaffold."
+    );
+  }
+  checkIndexesCurrent(projectRoot) {
+    const missing = REGISTRIES.filter(
+      (registry) => !existsSync4(join6(projectRoot, "docs", registry))
+    );
+    const statusPath = join6(projectRoot, ".agency/indexes/registry-status.json");
+    if (missing.length > 0 || !existsSync4(statusPath)) {
+      return fail(
+        "Indexes are current",
+        "Registry scaffold is incomplete",
+        "Run the registry refresh scripts."
+      );
+    }
+    const stale = isStale(statSync(statusPath).mtimeMs);
+    return stale ? fail("Indexes are current", "Registries are stale", "Run the registry refresh scripts.") : pass("Indexes are current", "Registries are present and current");
+  }
+  async checkScripts(projectRoot) {
+    const required = ["verify.sh", "refresh-registry-diff.sh", "extract-routes.sh"];
+    const missing = [];
+    const nonExecutable = [];
+    for (const script of required) {
+      const path = join6(projectRoot, "scripts", script);
+      if (!existsSync4(path)) {
+        missing.push(script);
+        continue;
+      }
+      try {
+        await access(path, fsConstants.X_OK);
+      } catch {
+        nonExecutable.push(script);
+      }
+    }
+    return missing.length === 0 && nonExecutable.length === 0 ? pass("Scripts are runnable", "Required scripts exist and are executable") : fail(
+      "Scripts are runnable",
+      `Missing: ${missing.join(", ") || "none"}; non-executable: ${nonExecutable.join(", ") || "none"}`,
+      "Regenerate the scripts and ensure they are executable."
+    );
+  }
+  checkHooks(projectRoot) {
+    const candidates = [".claude/settings.hooks.json", ".codex/hooks.json", ".gemini/hooks.json"];
+    return candidates.some((candidate) => existsSync4(join6(projectRoot, candidate))) ? pass("Hooks are active", "Hook registration files are present") : fail(
+      "Hooks are active",
+      "No hook registration files were found",
+      "Regenerate adapter hook configuration."
+    );
+  }
+  checkAdapterConfig(projectRoot) {
+    const configs = [PATHS.CLAUDE_MD, PATHS.AGENTS_MD, PATHS.GEMINI_MD];
+    const existing = configs.filter((config) => existsSync4(join6(projectRoot, config)));
+    return existing.length > 0 ? pass("Adapter config is present", "Adapter config files are present") : fail(
+      "Adapter config is present",
+      "No adapter config files were found",
+      "Regenerate the adapter configuration."
+    );
+  }
+  checkStackCommands(profile) {
+    if (profile === null) {
+      return fail(
+        "Stack commands configured",
+        "Project profile is missing",
+        "Restore a valid project profile."
+      );
+    }
+    if (!profile.commands || typeof profile.commands !== "object") {
+      return fail(
+        "Stack commands configured",
+        "Project commands are missing from the profile",
+        "Restore the commands block in the project profile."
+      );
+    }
+    const missing = Object.entries(profile.commands).filter(([, value]) => typeof value !== "string" || value.trim() === "").map(([key]) => key);
+    return missing.length === 0 ? pass("Stack commands configured", "Required stack commands are populated") : fail(
+      "Stack commands configured",
+      `Missing command definitions: ${missing.join(", ")}`,
+      "Populate the missing command entries in the project profile."
+    );
+  }
+  checkStableFrameworkPaths(projectRoot) {
+    const frameworkPath = join6(projectRoot, PATHS.FRAMEWORK_PATH);
+    if (!existsSync4(frameworkPath)) {
+      return fail(
+        "Stable framework paths only",
+        "Framework path file is missing",
+        "Re-run onboarding to write the framework path."
+      );
+    }
+    const value = readFileSync4(frameworkPath, "utf8").trim();
+    const unstable = value.includes("npx") || value.includes("npm-global") || value.includes(".npm/_npx");
+    return unstable ? fail(
+      "Stable framework paths only",
+      "Framework path points to an ephemeral install location",
+      "Reinstall the framework to a stable user-level path and re-run onboarding."
+    ) : pass("Stable framework paths only", "Framework path is stable");
+  }
+  checkBrokenScaffold(projectRoot) {
+    const broken = walk(projectRoot).filter(
+      (path) => path.endsWith(".partial") || path.endsWith(".tmp")
+    );
+    return broken.length === 0 ? pass("No broken scaffold state", "No partial scaffold artifacts detected") : fail(
+      "No broken scaffold state",
+      `Partial scaffold artifacts detected: ${broken.join(", ")}`,
+      "Remove the partial files and re-run onboarding or update."
+    );
+  }
+  checkUiDocs(projectRoot, modules) {
+    const missing = modules.filter(
+      (moduleName) => !existsSync4(join6(projectRoot, "docs/modules", moduleName, "ui/screens.md")) || !existsSync4(join6(projectRoot, "docs/modules", moduleName, "ui/components.md")) || !existsSync4(join6(projectRoot, "docs/modules", moduleName, "ui/states.md"))
+    );
+    return missing.length === 0 ? pass("UI docs present", "UI docs are present for all modules with UI docs") : fail(
+      "UI docs present",
+      `Missing UI docs for: ${missing.join(", ")}`,
+      "Add the missing UI documentation files."
+    );
+  }
+  checkApiDocs(projectRoot, modules) {
+    const missing = modules.filter(
+      (moduleName) => !existsSync4(join6(projectRoot, "docs/modules", moduleName, "api/endpoints.md")) || !existsSync4(join6(projectRoot, "docs/modules", moduleName, "api/schemas.md")) || !existsSync4(join6(projectRoot, "docs/modules", moduleName, "api/error-codes.md"))
+    );
+    return missing.length === 0 ? pass("API docs present", "API docs are present for all modules with APIs") : fail(
+      "API docs present",
+      `Missing API docs for: ${missing.join(", ")}`,
+      "Add the missing API documentation files."
+    );
+  }
+  checkIntegrationDocs(projectRoot, modules) {
+    const missing = modules.filter(
+      (moduleName) => !existsSync4(join6(projectRoot, "docs/modules", moduleName, "integration/events.md")) || !existsSync4(join6(projectRoot, "docs/modules", moduleName, "integration/contracts.md"))
+    );
+    return missing.length === 0 ? pass("Integration docs present", "Integration docs are present for all modules") : fail(
+      "Integration docs present",
+      `Missing integration docs for: ${missing.join(", ")}`,
+      "Add the missing integration documentation files."
+    );
+  }
+  checkErrorCatalog(projectRoot, modules) {
+    const missing = modules.filter(
+      (moduleName) => !existsSync4(join6(projectRoot, "docs/modules", moduleName, "error-catalog.md"))
+    );
+    return missing.length === 0 ? pass("Error catalog present", "Error catalogs are present for all modules") : fail(
+      "Error catalog present",
+      `Missing error catalogs for: ${missing.join(", ")}`,
+      "Add the missing module error catalogs."
+    );
+  }
+  checkMcp(projectRoot, profile) {
+    if (profile === null || !profile.routing || !Array.isArray(profile.routing.capabilities)) {
+      return warn(
+        "MCP servers configured",
+        "Project profile is unavailable, MCP expectations could not be derived",
+        "Restore the project profile, then configure stack-appropriate MCP servers."
+      );
+    }
+    const candidates = [".claude/settings.mcp.json", ".codex/mcp.json", ".gemini/mcp.json"];
+    const existing = candidates.filter((candidate) => existsSync4(join6(projectRoot, candidate)));
+    const expectedServers = getServersForStack(profile.routing.stack, profile.routing.capabilities).filter((server) => server.name !== "figma").map((server) => server.name);
+    if (existing.length === 0) {
+      return warn(
+        "MCP servers configured",
+        "No MCP configuration files were found",
+        "Configure MCP servers in project profile for improved efficiency"
+      );
+    }
+    const configured = /* @__PURE__ */ new Set();
+    for (const path of existing) {
+      try {
+        const parsed = JSON.parse(readFileSync4(join6(projectRoot, path), "utf8"));
+        Object.keys(parsed.mcpServers ?? {}).forEach((server) => configured.add(server));
+      } catch {
+        continue;
+      }
+    }
+    const missingExpected = expectedServers.filter((server) => !configured.has(server));
+    return missingExpected.length === 0 ? pass("MCP servers configured", "Stack-appropriate MCP servers are configured") : warn(
+      "MCP servers configured",
+      `Missing recommended MCP servers: ${missingExpected.join(", ")}`,
+      "Configure MCP servers in project profile for improved efficiency"
+    );
+  }
+  checkSkillCache(projectRoot) {
+    const cacheDir = join6(projectRoot, PATHS.SKILL_CACHE_DIR);
+    if (!existsSync4(cacheDir)) {
+      return warn(
+        "Skill cache healthy",
+        "Skill cache directory is missing",
+        "Run skill-cache-manager.sh --clear-all to reset cache"
+      );
+    }
+    const corrupt = readdirSync(cacheDir).filter((entry) => entry.endsWith(".json")).filter((entry) => {
+      try {
+        JSON.parse(readFileSync4(join6(cacheDir, entry), "utf8"));
+        return false;
+      } catch {
+        return true;
+      }
+    });
+    return corrupt.length === 0 ? pass("Skill cache healthy", "Skill cache directory is healthy") : warn(
+      "Skill cache healthy",
+      `Corrupt cache files detected: ${corrupt.join(", ")}`,
+      "Run skill-cache-manager.sh --clear-all to reset cache"
+    );
+  }
+  checkContextHitRate(projectRoot, profile) {
+    const path = join6(projectRoot, PATHS.CONTEXT_HIT_LOG);
+    if (!existsSync4(path) || profile === null) {
+      return pass("Context hit rate acceptable", "No recent context logs yet");
+    }
+    try {
+      const entry = JSON.parse(readFileSync4(path, "utf8"));
+      const hitRate = entry.hit_rate ?? 1;
+      const target = profile.efficiency.context_hit_rate_target ?? 0.7;
+      return hitRate >= target ? pass("Context hit rate acceptable", "Context hit rate meets the configured target") : warn(
+        "Context hit rate acceptable",
+        "Context hit rate is below the configured target",
+        "Reduce unnecessary context loading or improve context selection."
+      );
+    } catch {
+      return warn(
+        "Context hit rate acceptable",
+        "Context hit log is unreadable",
+        "Regenerate the context hit log with the tracking hook."
+      );
+    }
+  }
+  buildEfficiencySummary(projectRoot, profile) {
+    const path = join6(projectRoot, PATHS.CONTEXT_HIT_LOG);
+    let contextHitRate = 1;
+    if (existsSync4(path)) {
+      try {
+        const entry = JSON.parse(readFileSync4(path, "utf8"));
+        contextHitRate = entry.hit_rate ?? 1;
+      } catch {
+        contextHitRate = 0;
+      }
+    }
+    return {
+      context_hit_rate: contextHitRate,
+      skill_cache_hit_rate: existsSync4(join6(projectRoot, PATHS.SKILL_CACHE_DIR)) ? 1 : 0,
+      mcp_usage_rate: profile?.efficiency?.mcp_first ? 1 : 0
+    };
+  }
+};
+function pass(name, detail) {
+  return { name, status: "pass", detail };
+}
+function fail(name, detail, remediation) {
+  return { name, status: "fail", detail, remediation };
+}
+function warn(name, detail, remediation) {
+  return { name, status: "warning", detail, remediation };
+}
+function deriveOverallStatus(checks) {
+  if (checks.some((check) => check.status === "fail")) {
+    return "fail";
+  }
+  if (checks.some((check) => check.status === "warning")) {
+    return "warning";
+  }
+  return "pass";
+}
+function isStale(timestampMs) {
+  return Date.now() - timestampMs > STALENESS_WINDOW_MS;
+}
+function walk(root) {
+  const results = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const path = join6(root, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walk(path));
+      continue;
+    }
+    results.push(path);
+  }
+  return results;
+}
+
+// src/install/bootstrap.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+
+// src/onboarding/manifest-writer.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join as join7 } from "path";
+import YAML2 from "yaml";
+function writeProjectProfile(projectRoot, profile) {
+  const path = join7(projectRoot, PATHS.PROJECT_PROFILE);
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, YAML2.stringify(profile));
+  return path;
+}
+function writeDetectionReport(projectRoot, report) {
+  const path = join7(projectRoot, PATHS.DETECTION_REPORT);
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(report, null, 2));
+  return path;
+}
+function writeFrameworkMetadata(projectRoot, version) {
+  mkdirSync(dirname2(join7(projectRoot, PATHS.FRAMEWORK_VERSION)), {
+    recursive: true
+  });
+  writeFileSync(join7(projectRoot, PATHS.FRAMEWORK_VERSION), `${version}
+`);
+  writeFileSync(join7(projectRoot, PATHS.FRAMEWORK_PATH), `${resolveFrameworkInstallPath()}
+`);
+}
+function writeOnboardingManifest(projectRoot, manifest) {
+  const path = join7(projectRoot, PATHS.ONBOARDING_MANIFEST);
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(manifest, null, 2));
+  return path;
+}
+function resolveFrameworkInstallPath() {
+  return process.env.PAQAD_FRAMEWORK_HOME ?? join7(homedir(), ".paqad-ai/current");
+}
+
+// src/install/bootstrap.ts
+function bootstrapFramework(projectRoot) {
+  const frameworkHome = resolveFrameworkInstallPath();
+  mkdirSync2(frameworkHome, { recursive: true });
+  writeFrameworkMetadata(projectRoot, VERSION);
+  return {
+    framework_home: frameworkHome,
+    project_root: projectRoot,
+    version: VERSION
+  };
+}
+
+// src/onboarding/file-writer.ts
+import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, join as join8 } from "path";
+function writeGeneratedFiles(projectRoot, files) {
+  const written = [];
+  const skipped = [];
+  for (const file of files) {
+    const target = join8(projectRoot, file.path);
+    mkdirSync3(dirname3(target), { recursive: true });
+    if (!file.autoUpdate && existsSync5(target)) {
+      skipped.push(file.path);
+      continue;
+    }
+    writeFileSync2(target, file.content);
+    if (file.executable === true) {
+      chmodSync(target, 493);
+    }
+    written.push(file.path);
+  }
+  return { written, skipped };
+}
+
+// src/resolver/resolver.ts
+import fg from "fast-glob";
+import { basename as basename2, extname, relative as relative2 } from "pathe";
+
+// src/resolver/artifact-types.ts
+var ARTIFACT_TYPES = [
+  "rules",
+  "skills",
+  "agents",
+  "hooks",
+  "templates",
+  "patterns",
+  "anti-patterns",
+  "checklists",
+  "mcp-configs"
+];
+var COLLISION_MAP = {
+  rules: "most-specific-wins",
+  skills: "most-specific-wins",
+  agents: "most-specific-wins",
+  hooks: "most-specific-wins",
+  templates: "most-specific-wins",
+  patterns: "additive-merge",
+  "anti-patterns": "additive-merge",
+  checklists: "additive-merge",
+  "mcp-configs": "additive-merge"
+};
+var ARTIFACT_OUTPUT_KEYS = {
+  rules: "rules",
+  skills: "skills",
+  agents: "agents",
+  hooks: "hooks",
+  templates: "templates",
+  patterns: "patterns",
+  "anti-patterns": "antiPatterns",
+  checklists: "checklists",
+  "mcp-configs": "mcpConfigs"
+};
+
+// src/resolver/inheritance.ts
+import { join as join10, relative } from "pathe";
+
+// src/resolver/capability-resolver.ts
+import { join as join9 } from "pathe";
+function resolveCapabilityDirectories(runtimeRoot, domain, stack, capabilities, artifactType) {
+  const directoryName = resolveCapabilityArtifactDirectory(artifactType);
+  return capabilities.map(
+    (capability) => join9(
+      runtimeRoot,
+      "domains",
+      domain,
+      "stacks",
+      stack,
+      "capabilities",
+      capability,
+      directoryName
+    )
+  );
+}
+function resolveCapabilityArtifactDirectory(artifactType) {
+  switch (artifactType) {
+    case "mcp-configs":
+      return "mcp";
+    case "patterns":
+      return join9("benchmarks", "patterns");
+    case "anti-patterns":
+      return join9("benchmarks", "anti-patterns");
+    default:
+      return artifactType;
+  }
+}
+
+// src/resolver/inheritance.ts
+function getInheritanceDirectories(runtimeRoot, routing, artifactType) {
+  if (artifactType === "hooks") {
+    return [
+      {
+        path: join10(runtimeRoot, "hooks"),
+        level: 0,
+        source: relative(runtimeRoot, join10(runtimeRoot, "hooks"))
+      }
+    ];
+  }
+  if (artifactType === "templates") {
+    return [
+      {
+        path: join10(runtimeRoot, "templates"),
+        level: 0,
+        source: relative(runtimeRoot, join10(runtimeRoot, "templates"))
+      }
+    ];
+  }
+  const basePath = join10(runtimeRoot, "domains");
+  const directoryName = resolveArtifactDirectoryName(artifactType);
+  const directories = [
+    {
+      path: join10(basePath, "_shared", directoryName),
+      level: 0,
+      source: relative(runtimeRoot, join10(basePath, "_shared", directoryName))
+    },
+    {
+      path: join10(basePath, routing.domain, directoryName),
+      level: 1,
+      source: relative(runtimeRoot, join10(basePath, routing.domain, directoryName))
+    },
+    {
+      path: join10(basePath, routing.domain, "stacks", "_shared", directoryName),
+      level: 2,
+      source: relative(
+        runtimeRoot,
+        join10(basePath, routing.domain, "stacks", "_shared", directoryName)
+      )
+    },
+    {
+      path: join10(basePath, routing.domain, "stacks", routing.stack, directoryName),
+      level: 2,
+      source: relative(
+        runtimeRoot,
+        join10(basePath, routing.domain, "stacks", routing.stack, directoryName)
+      )
+    }
+  ];
+  const capabilityDirectories = resolveCapabilityDirectories(
+    runtimeRoot,
+    routing.domain,
+    routing.stack,
+    routing.capabilities,
+    artifactType
+  ).map((path) => ({
+    path,
+    level: 3,
+    source: relative(runtimeRoot, path)
+  }));
+  return [...directories, ...capabilityDirectories];
+}
+function resolveArtifactDirectoryName(artifactType) {
+  switch (artifactType) {
+    case "mcp-configs":
+      return "mcp";
+    case "patterns":
+      return join10("benchmarks", "patterns");
+    case "anti-patterns":
+      return join10("benchmarks", "anti-patterns");
+    default:
+      return artifactType;
+  }
+}
+
+// src/resolver/resolver.ts
+var RULE_SEED_PRIORITY = [
+  "constitution",
+  "security",
+  "testing",
+  "documentation",
+  "performance",
+  "pipeline",
+  "canonical-docs",
+  "architecture",
+  "code-quality",
+  "git",
+  "api-design",
+  "environment",
+  "foundation",
+  "conventions",
+  "inertia",
+  "react",
+  "boost"
+];
+var Resolver = class {
+  runtimeRoot;
+  constructor(options) {
+    this.runtimeRoot = options.runtimeRoot;
+  }
+  async resolve(routing) {
+    const result = {
+      rules: [],
+      skills: [],
+      agents: [],
+      hooks: [],
+      templates: [],
+      patterns: [],
+      antiPatterns: [],
+      checklists: [],
+      mcpConfigs: []
+    };
+    for (const artifactType of ARTIFACT_TYPES) {
+      const outputKey = ARTIFACT_OUTPUT_KEYS[artifactType];
+      result[outputKey] = await this.resolveArtifactType(routing, artifactType);
+    }
+    return result;
+  }
+  async resolveArtifactType(routing, artifactType) {
+    const directories = getInheritanceDirectories(this.runtimeRoot, routing, artifactType);
+    const entries = [];
+    const overrides = /* @__PURE__ */ new Map();
+    for (const directory of directories) {
+      const files = await fg("**/*", {
+        cwd: directory.path,
+        onlyFiles: true,
+        absolute: true,
+        dot: false
+      });
+      for (const file of files.sort()) {
+        const artifact = {
+          path: file,
+          level: directory.level,
+          source: relative2(this.runtimeRoot, file)
+        };
+        if (COLLISION_MAP[artifactType] === "additive-merge") {
+          entries.push(artifact);
+          continue;
+        }
+        overrides.set(relative2(directory.path, file), artifact);
+      }
+    }
+    const resolved = COLLISION_MAP[artifactType] === "additive-merge" ? entries : Array.from(overrides.values());
+    if (artifactType === "rules") {
+      return resolved.sort(compareRuleSeedOrder);
+    }
+    return resolved;
+  }
+};
+function compareRuleSeedOrder(left, right) {
+  const leftPriority = getRulePriority(left.path);
+  const rightPriority = getRulePriority(right.path);
+  if (leftPriority !== rightPriority) {
+    return leftPriority - rightPriority;
+  }
+  return left.source.localeCompare(right.source);
+}
+function getRulePriority(filePath) {
+  const name = basename2(filePath, extname(filePath));
+  const index = RULE_SEED_PRIORITY.indexOf(name);
+  return index === -1 ? RULE_SEED_PRIORITY.length : index;
+}
+
+// src/scripts/generator.ts
+import { chmodSync as chmodSync2 } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname as dirname4, join as join11 } from "path";
+
+// src/templates/context-builders/runner-scripts.ts
+function buildRunnerScriptContext(input) {
+  return input;
+}
+
+// src/templates/registry.ts
+import fg2 from "fast-glob";
+import { basename as basename3, relative as relative3 } from "pathe";
+var TemplateRegistry = class {
+  constructor(templatesRoot) {
+    this.templatesRoot = templatesRoot;
+  }
+  async discover() {
+    const files = await fg2("**/*.hbs", {
+      cwd: this.templatesRoot,
+      absolute: true,
+      onlyFiles: true
+    });
+    return files.sort().map((path) => ({
+      name: basename3(path),
+      path,
+      relativePath: relative3(this.templatesRoot, path)
+    }));
+  }
+};
+
+// src/scripts/generator.ts
+var RunnerScriptGenerator = class {
+  engine = new TemplateEngine();
+  async generate(profile) {
+    const registry = new TemplateRegistry(join11(getRuntimeTemplatesRoot(), "runner-scripts"));
+    const templates = await registry.discover();
+    return Promise.all(
+      templates.map(async (template) => ({
+        path: join11("scripts", template.relativePath.replace(/\.hbs$/, "")),
+        content: await this.engine.render(template.path, buildScriptContext(profile)),
+        autoUpdate: true,
+        executable: true
+      }))
+    );
+  }
+  async write(projectRoot, profile) {
+    const generated = await this.generate(profile);
+    const written = [];
+    for (const file of generated) {
+      const target = join11(projectRoot, file.path);
+      await mkdir(dirname4(target), { recursive: true });
+      await writeFile(target, file.content);
+      chmodSync2(target, 493);
+      written.push(file.path);
+    }
+    return written;
+  }
+};
+function buildScriptContext(profile) {
+  return buildRunnerScriptContext({
+    projectName: profile.project.name,
+    commands: {
+      test: profile.commands.test,
+      lint: profile.commands.lint,
+      format: profile.commands.format
+    },
+    routing: {
+      stack: profile.routing.stack
+    }
+  });
+}
+
+// src/onboarding/prompts.ts
+async function resolveSelections(detection, overrides) {
+  return {
+    domain: overrides?.domain ?? detection.detected_domain ?? "coding",
+    stack: overrides?.stack ?? detection.detected_stack ?? "laravel",
+    capabilities: overrides?.capabilities ?? detection.detected_capabilities
+  };
+}
+
+// src/onboarding/registry-generator.ts
+import { readdir } from "fs/promises";
+import { join as join12 } from "path";
+async function generateInitialRegistries(projectRoot) {
+  const modules = await discoverModules(projectRoot);
+  return [
+    {
+      path: ".agency/indexes/registry-status.json",
+      content: JSON.stringify(
+        {
+          generated: true,
+          modules,
+          generated_at: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        null,
+        2
+      ),
+      autoUpdate: true
+    },
+    {
+      path: ".agency/cache/skill-results/.gitkeep",
+      content: "",
+      autoUpdate: true
+    },
+    {
+      path: PATHS.GLOSSARY,
+      content: "# Glossary\n\n",
+      autoUpdate: true
+    },
+    ...REGISTRIES.map((registry) => ({
+      path: join12("docs", registry),
+      content: registry === "module-registry.md" ? buildModuleRegistry(modules) : `# ${registry}
+
+`,
+      autoUpdate: true
+    }))
+  ];
+}
+async function discoverModules(projectRoot) {
+  const candidates = [
+    join12(projectRoot, "docs/modules"),
+    join12(projectRoot, "app"),
+    join12(projectRoot, "lib")
+  ];
+  const modules = /* @__PURE__ */ new Set(["core"]);
+  for (const root of candidates) {
+    try {
+      const entries = await readdir(root, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) {
+          continue;
+        }
+        const name = entry.name;
+        if (name !== "" && !name.startsWith(".")) {
+          modules.add(name);
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return Array.from(modules).sort();
+}
+function buildModuleRegistry(modules) {
+  return ["# module-registry.md", "", ...modules.map((module) => `- ${module}`), ""].join("\n");
+}
+
+// src/onboarding/reference-generator.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join13, relative as relative4 } from "path";
+import fg3 from "fast-glob";
+async function generateReferenceGuides(runtimeRoot, routing) {
+  const stack = routing.stack;
+  if (routing.domain !== "coding" || stack !== "laravel" && stack !== "flutter") {
+    return [];
+  }
+  const referencesRoot = join13(runtimeRoot, "domains", "coding", "stacks", stack, "references");
+  const entries = await fg3(["tools/*.md", "tools-catalog.md"], {
+    cwd: referencesRoot,
+    onlyFiles: true,
+    absolute: true
+  });
+  return Promise.all(
+    entries.sort().map(async (entry) => ({
+      path: toProjectReferencePath(stack, relative4(referencesRoot, entry)),
+      content: await readFile3(entry, "utf8"),
+      autoUpdate: false
+    }))
+  );
+}
+function toProjectReferencePath(stack, relativePath) {
+  const normalized = relativePath.replaceAll("\\", "/");
+  if (normalized === "tools-catalog.md") {
+    return join13("docs/tools", stack, "README.md");
+  }
+  return join13("docs/tools", stack, normalized.replace(/^tools\//, ""));
+}
+
+// src/onboarding/rule-generator.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join14 } from "path";
+async function generateProjectRules(rules) {
+  return Promise.all(
+    rules.map(async (rule) => ({
+      path: toProjectRulePath(rule.source),
+      content: await readFile4(rule.path, "utf8"),
+      autoUpdate: false
+    }))
+  );
+}
+function toProjectRulePath(source) {
+  const normalized = source.replace(/^domains\//, "");
+  const [prefix, suffix] = normalized.split("/rules/");
+  if (prefix === void 0 || suffix === void 0) {
+    return join14("docs/rules", normalized);
+  }
+  const target = suffix.endsWith("/guide.md") ? suffix.replace("/guide.md", ".md") : suffix;
+  return join14("docs/rules", prefix, target);
+}
+
+// src/onboarding/scaffold-generator.ts
+import { join as join15 } from "path";
+
+// src/templates/context-builders/design-system.ts
+function buildDesignSystemContext(projectName) {
+  return { projectName };
+}
+
+// src/templates/context-builders/module-scaffold.ts
+function buildModuleScaffoldContext(moduleName) {
+  return {
+    moduleName,
+    title: moduleName.replace(/-/g, " ")
+  };
+}
+
+// src/onboarding/scaffold-generator.ts
+var MODULE_TEMPLATE_TARGETS = [
+  ["summary.md.hbs", "index/summary.md"],
+  ["schema.md.hbs", "database/schema.md"],
+  ["indexes.md.hbs", "database/indexes.md"],
+  ["queries.md.hbs", "database/queries.md"],
+  ["data-volumes.md.hbs", "database/data-volumes.md"],
+  ["api-endpoints.md.hbs", "api/endpoints.md"],
+  ["api-schemas.md.hbs", "api/schemas.md"],
+  ["api-error-codes.md.hbs", "api/error-codes.md"],
+  ["integration-events.md.hbs", "integration/events.md"],
+  ["integration-contracts.md.hbs", "integration/contracts.md"],
+  ["error-catalog.md.hbs", "error-catalog.md"],
+  ["screens.md.hbs", "ui/screens.md"],
+  ["components.md.hbs", "ui/components.md"],
+  ["states.md.hbs", "ui/states.md"]
+];
+async function generateDocumentationScaffold(moduleNames = ["core"]) {
+  const files = [];
+  for (const moduleName of Array.from(new Set(moduleNames)).sort()) {
+    files.push(...await generateModuleScaffold(moduleName));
+  }
+  const engine = new TemplateEngine();
+  for (const [templateName, target] of DESIGN_SYSTEM_TEMPLATE_TARGETS) {
+    files.push({
+      path: target,
+      content: await engine.render(
+        join15(getRuntimeTemplatesRoot(), "design-system", templateName),
+        buildDesignSystemContext("Paqad")
+      ),
+      autoUpdate: true
+    });
+  }
+  files.push(
+    {
+      path: join15(PATHS.ARCHITECTURE_DIR, "overview.md"),
+      content: "# Architecture Overview\n\n",
+      autoUpdate: true
+    },
+    {
+      path: join15(PATHS.ARCHITECTURE_DIR, "decisions.md"),
+      content: "# Architecture Decisions\n\n",
+      autoUpdate: true
+    },
+    {
+      path: join15(PATHS.ARCHITECTURE_DIR, "patterns.md"),
+      content: "# Architecture Patterns\n\n",
+      autoUpdate: true
+    },
+    {
+      path: join15(PATHS.BENCHMARKS_DIR, "index.md"),
+      content: "# Benchmarks\n\n",
+      autoUpdate: true
+    },
+    {
+      path: join15(PATHS.TECH_DEBT_DIR, "index.md"),
+      content: "# Technical Debt\n\n",
+      autoUpdate: true
+    }
+  );
+  for (const registry of REGISTRIES) {
+    files.push({
+      path: `docs/${registry}`,
+      content: `# ${registry}
+`,
+      autoUpdate: true
+    });
+  }
+  return files;
+}
+async function generateModuleScaffold(moduleName) {
+  const engine = new TemplateEngine();
+  const context = buildModuleScaffoldContext(moduleName);
+  const files = [];
+  for (const [templateName, relativeTarget] of MODULE_TEMPLATE_TARGETS) {
+    files.push({
+      path: join15(PATHS.MODULES_DIR, moduleName, relativeTarget),
+      content: await engine.render(
+        join15(getRuntimeTemplatesRoot(), "module-scaffold", templateName),
+        context
+      ),
+      autoUpdate: false
+    });
+  }
+  return files;
+}
+var DESIGN_SYSTEM_TEMPLATE_TARGETS = [
+  ["tokens.md.hbs", "docs/design-system/tokens.md"],
+  ["components.md.hbs", "docs/design-system/components.md"],
+  ["motion.md.hbs", "docs/design-system/motion.md"],
+  ["accessibility.md.hbs", "docs/design-system/accessibility.md"],
+  ["responsive.md.hbs", "docs/design-system/responsive.md"],
+  ["patterns.md.hbs", "docs/design-system/patterns.md"]
+];
+
+// src/onboarding/orchestrator.ts
+var OnboardingOrchestrator = class {
+  async run(options) {
+    const detector = new Detector();
+    const detection = await detector.detect(options.projectRoot);
+    const selections = await resolveSelections(detection, options.selections);
+    const runtimeRoot = options.runtimeRoot ?? getRuntimeRoot();
+    const resolver = new Resolver({ runtimeRoot });
+    const resolved = await resolver.resolve(selections);
+    const adapters = options.adapters ?? ["claude-code", "codex-cli", "gemini-cli"];
+    const profile = buildProjectProfile(selections, options.profileOverrides);
+    const validator = new SchemaValidator();
+    const validation = validator.validate("project-profile", profile);
+    const modules = await discoverModules(options.projectRoot);
+    if (!validation.valid) {
+      throw new Error(validation.errors.map((error) => error.message).join("; "));
+    }
+    const generatedFiles = [];
+    for (const adapterType of adapters) {
+      const adapter = AdapterFactory.create(adapterType);
+      generatedFiles.push(
+        ...await adapter.generateConfig({
+          frameworkPath: ".agency/framework-path.txt",
+          rulesPath: "docs/rules",
+          projectRoot: options.projectRoot
+        }),
+        ...await adapter.generateSkills(resolved.skills),
+        ...await adapter.generateAgents(resolved.agents),
+        ...await adapter.installHooks(resolved.hooks),
+        ...await adapter.installMcp(resolved.mcpConfigs, profile),
+        ...await adapter.configureCaching(profile),
+        ...await adapter.configureMemory(profile)
+      );
+    }
+    generatedFiles.push(...await generateProjectRules(resolved.rules));
+    generatedFiles.push(...await generateReferenceGuides(runtimeRoot, selections));
+    generatedFiles.push(...await generateDocumentationScaffold(modules));
+    generatedFiles.push(...await generateInitialRegistries(options.projectRoot));
+    generatedFiles.push(...await new RunnerScriptGenerator().generate(profile));
+    const writeResult = writeGeneratedFiles(options.projectRoot, generatedFiles);
+    writeProjectProfile(options.projectRoot, profile);
+    writeDetectionReport(options.projectRoot, detection);
+    writeFrameworkMetadata(options.projectRoot, VERSION);
+    const manifestPath = writeOnboardingManifest(options.projectRoot, {
+      framework_version: VERSION,
+      adapter: adapters[0],
+      project_root: options.projectRoot,
+      profile,
+      detected: detection,
+      generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      generated_artifacts: generatedFiles.map((file) => ({
+        path: file.path,
+        auto_update: file.autoUpdate,
+        executable: file.executable
+      }))
+    });
+    return {
+      adapter: adapters[0],
+      generated_files: writeResult.written,
+      detected_modules: modules,
+      runtime_root: runtimeRoot,
+      manifest_path: manifestPath,
+      warnings: writeResult.skipped
+    };
+  }
+};
+function buildProjectProfile(selections, overrides) {
+  return {
+    project: {
+      name: overrides?.project?.name ?? "paqad project",
+      id: overrides?.project?.id ?? "paqad-project",
+      description: overrides?.project?.description ?? "Generated by paqad-ai"
+    },
+    routing: selections,
+    commands: overrides?.commands ?? {
+      install: "pnpm install",
+      dev: "pnpm dev",
+      test: "pnpm test",
+      test_single: "pnpm test -- <pattern>",
+      lint: "pnpm lint",
+      format: "pnpm format",
+      migrate: 'echo "configure migrate command"',
+      build: "pnpm build"
+    },
+    strictness: overrides?.strictness ?? {
+      full_lane_default: false,
+      require_adversarial_review: true,
+      block_on_stale_docs: true,
+      require_db_review_for_migrations: true
+    },
+    compliance_packs: overrides?.compliance_packs ?? [],
+    features: overrides?.features ?? {
+      spec_only_mode: false,
+      market_research: false,
+      design_research: false,
+      team_agents: true,
+      supply_chain_governance: false,
+      ai_governance: false
+    },
+    mcp: overrides?.mcp ?? { servers: [] },
+    model_routing: overrides?.model_routing ?? {
+      default_model: "gpt-5",
+      reasoning_model: "gpt-5",
+      fast_model: "gpt-5-mini"
+    },
+    research: overrides?.research ?? { depth: "standard" },
+    efficiency: overrides?.efficiency ?? {
+      context_hit_rate_target: 0.7,
+      skill_caching: true,
+      differential_refresh: true,
+      mcp_first: true
+    },
+    escalation: overrides?.escalation ?? {
+      destructive_operations: "block",
+      risky_migrations: "warn",
+      security_findings: "block",
+      db_row_threshold: 1e4
+    },
+    custom: overrides?.custom ?? {
+      classification_dimensions: [],
+      verification_plugins: [],
+      escalation_rules: []
+    }
+  };
+}
+
+// src/pipeline/lane-runner.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname5, join as join16 } from "path";
+
+// src/pipeline/phases/shared.ts
+function createPassResult(phase, summary, context) {
+  return {
+    phase,
+    status: "pass",
+    summary,
+    artifacts: [`handoff:${context.phases.length + 1}`]
+  };
+}
+
+// src/pipeline/phases/classify.ts
+var ClassifyPhase = class {
+  phase = "request-classification";
+  async execute(context) {
+    return createPassResult(this.phase, "Classification confirmed", context);
+  }
+};
+
+// src/pipeline/phases/analysis.ts
+var AnalysisPhase = class {
+  phase = "analysis";
+  async execute(context) {
+    return createPassResult(this.phase, "Analysis roles completed", context);
+  }
+};
+
+// src/pipeline/phases/doc-update.ts
+var DocumentationUpdatePhase = class {
+  phase = "documentation-update";
+  async execute(context) {
+    return createPassResult(this.phase, "Canonical docs updated", context);
+  }
+};
+
+// src/pipeline/phases/flow-writing.ts
+var FlowWritingPhase = class {
+  phase = "user-flow";
+  async execute(context) {
+    return createPassResult(this.phase, "User flows documented", context);
+  }
+};
+
+// src/pipeline/phases/impl-review.ts
+function selectReviewTier(_classification, lane) {
+  if (lane === "fast") {
+    return "spot-check";
+  }
+  if (lane === "graduated") {
+    return "standard";
+  }
+  return "full";
+}
+function selectReviewMode(isReReview, changePercentage) {
+  if (!isReReview) {
+    return "fresh";
+  }
+  if (changePercentage > 0.6) {
+    return "fresh";
+  }
+  return "diff";
+}
+var ImplementationReviewPhase = class {
+  phase = "implementation-review";
+  async execute(context) {
+    const tier = selectReviewTier(context.classification, context.lane);
+    const mode = selectReviewMode(false, 0);
+    return createPassResult(this.phase, `Implementation review passed (${tier}, ${mode})`, context);
+  }
+};
+
+// src/pipeline/phases/implementation.ts
+var ImplementationPhase = class {
+  phase = "implementation";
+  async execute(context) {
+    return createPassResult(this.phase, "Implementation completed", context);
+  }
+};
+
+// src/pipeline/phases/load-docs.ts
+var LoadDocsPhase = class {
+  phase = "docs-first-load";
+  async execute(context) {
+    return createPassResult(this.phase, "Docs-first context prepared", context);
+  }
+};
+
+// src/pipeline/phases/spec-review.ts
+function selectReviewTier2(_classification, lane) {
+  if (lane === "fast") {
+    return "spot-check";
+  }
+  if (lane === "graduated") {
+    return "standard";
+  }
+  return "full";
+}
+function selectReviewMode2(isReReview, changePercentage) {
+  if (!isReReview) {
+    return "fresh";
+  }
+  if (changePercentage > 0.6) {
+    return "fresh";
+  }
+  return "diff";
+}
+var SpecReviewPhase = class {
+  phase = "spec-review";
+  async execute(context) {
+    const tier = selectReviewTier2(context.classification, context.lane);
+    const mode = selectReviewMode2(false, 0);
+    return createPassResult(this.phase, `Spec review passed (${tier}, ${mode})`, context);
+  }
+};
+
+// src/pipeline/phases/spec-writing.ts
+var SpecWritingPhase = class {
+  phase = "specification";
+  async execute(context) {
+    return createPassResult(this.phase, "Specification written", context);
+  }
+};
+
+// src/pipeline/phases/story-planning.ts
+var StoryPlanningPhase = class {
+  phase = "sequence-planning";
+  async execute(context) {
+    return createPassResult(this.phase, "Story sequence planned", context);
+  }
+};
+
+// src/pipeline/phases/verification.ts
+var VerificationPhase = class {
+  phase = "verification-gates";
+  async execute(context) {
+    return createPassResult(this.phase, "Verification gates passed", context);
+  }
+};
+
+// src/pipeline/lane-runner.ts
+var DEFAULT_PHASES = {
+  "request-classification": new ClassifyPhase(),
+  "docs-first-load": new LoadDocsPhase(),
+  analysis: new AnalysisPhase(),
+  "sequence-planning": new StoryPlanningPhase(),
+  specification: new SpecWritingPhase(),
+  "user-flow": new FlowWritingPhase(),
+  "spec-review": new SpecReviewPhase(),
+  implementation: new ImplementationPhase(),
+  "implementation-review": new ImplementationReviewPhase(),
+  "verification-gates": new VerificationPhase(),
+  "documentation-update": new DocumentationUpdatePhase()
+};
+
+// src/skills/cache-manager.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir3, readFile as readFile5, readdir as readdir2, rm, stat, writeFile as writeFile3 } from "fs/promises";
+import { join as join17 } from "path";
+import fg4 from "fast-glob";
+
+// src/skills/frontmatter-parser.ts
+import YAML3 from "yaml";
+
+// src/skills/loader.ts
+import { readFile as readFile6 } from "fs/promises";
+
+// src/update/updater.ts
+import { chmodSync as chmodSync3, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { mkdtemp, readdir as readdir3, readFile as readFile7, rm as rm2 } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname6, join as join18, relative as relative5 } from "path";
+import YAML4 from "yaml";
+var FrameworkUpdater = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async run(projectRoot) {
+    const previousVersion = readText(join18(projectRoot, PATHS.FRAMEWORK_VERSION));
+    const manifest = readManifest(projectRoot);
+    const artifactPolicy = new Map(
+      manifest?.generated_artifacts.map((artifact) => [artifact.path, artifact.auto_update]) ?? []
+    );
+    const candidates = await this.getCandidates(projectRoot);
+    const regenerated = [];
+    const skipped = [];
+    const newScripts = [];
+    for (const candidate of candidates) {
+      const target = join18(projectRoot, candidate.path);
+      const existed = existsSync6(target);
+      const autoUpdate = artifactPolicy.get(candidate.path) ?? candidate.autoUpdate;
+      if (existed && autoUpdate === false) {
+        skipped.push({
+          path: candidate.path,
+          before: readFileSync5(target, "utf8"),
+          after: candidate.content
+        });
+        continue;
+      }
+      mkdirSync4(dirname6(target), { recursive: true });
+      writeFileSync3(target, candidate.content);
+      if (candidate.executable === true) {
+        chmodSync3(target, 493);
+      }
+      regenerated.push(candidate.path);
+      if (!existed && candidate.path.startsWith("scripts/")) {
+        newScripts.push(candidate.path);
+      }
+    }
+    mkdirSync4(dirname6(join18(projectRoot, PATHS.FRAMEWORK_VERSION)), { recursive: true });
+    writeFileSync3(join18(projectRoot, PATHS.FRAMEWORK_VERSION), `${VERSION}
+`);
+    return {
+      previous_version: previousVersion,
+      target_version: VERSION,
+      regenerated,
+      skipped,
+      deprecated: [],
+      new_mcp_servers: [],
+      new_scripts: newScripts.sort()
+    };
+  }
+  async getCandidates(projectRoot) {
+    if (this.options.generateCandidates) {
+      return this.options.generateCandidates(projectRoot);
+    }
+    const profile = readProfile(projectRoot);
+    if (profile === null) {
+      throw new Error("Cannot update framework-managed artifacts without a project profile");
+    }
+    const tempRoot = await mkdtemp(join18(tmpdir(), "paqad-ai-update-"));
+    try {
+      const result = await new OnboardingOrchestrator().run({
+        projectRoot: tempRoot,
+        selections: profile.routing,
+        profileOverrides: profile
+      });
+      const files = await collectFiles(tempRoot, result.generated_files);
+      return files;
+    } finally {
+      await rm2(tempRoot, { recursive: true, force: true });
+    }
+  }
+};
+function readManifest(projectRoot) {
+  const path = join18(projectRoot, PATHS.ONBOARDING_MANIFEST);
+  if (!existsSync6(path)) {
+    return null;
+  }
+  return JSON.parse(readFileSync5(path, "utf8"));
+}
+function readProfile(projectRoot) {
+  const path = join18(projectRoot, PATHS.PROJECT_PROFILE);
+  if (!existsSync6(path)) {
+    return null;
+  }
+  return YAML4.parse(readFileSync5(path, "utf8"));
+}
+function readText(path) {
+  if (!existsSync6(path)) {
+    return null;
+  }
+  return readFileSync5(path, "utf8").trim();
+}
+async function collectFiles(root, generated) {
+  const paths = generated.length > 0 ? generated : await walk2(root);
+  return Promise.all(
+    paths.map(async (file) => ({
+      path: file,
+      content: await readFile7(join18(root, file), "utf8"),
+      autoUpdate: true,
+      executable: file.startsWith("scripts/")
+    }))
+  );
+}
+async function walk2(root, current = root) {
+  const entries = await readdir3(current, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const absolute = join18(current, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walk2(root, absolute));
+      continue;
+    }
+    files.push(relative5(root, absolute));
+  }
+  return files.sort();
+}
+
+// src/verification/gates/documentation-freshness.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join19 } from "path";
+var STALENESS_WINDOW_MS2 = 1e3 * 60 * 60 * 24 * 7;
+
+// src/index.ts
+var VERSION = "0.0.1";
+
+// src/cli/commands/doctor.ts
+import { Command } from "commander";
+function createDoctorCommand() {
+  return new Command("doctor").description("Check framework health and suggest fixes").option("--project-root <path>", "Project root", process.cwd()).action(async (options) => {
+    const report = await new HealthChecker().run(options.projectRoot);
+    console.log(JSON.stringify(report, null, 2));
+    process.exitCode = report.overall_status === "fail" ? 1 : 0;
+  });
+}
+
+// src/cli/commands/install.ts
+import { Command as Command2 } from "commander";
+function createInstallCommand() {
+  return new Command2("install").description("Bootstrap the framework into the current project").option("--project-root <path>", "Project root", process.cwd()).action((options) => {
+    const result = bootstrapFramework(options.projectRoot);
+    console.log(JSON.stringify(result, null, 2));
+  });
+}
+
+// src/cli/commands/onboard.ts
+import { Command as Command3 } from "commander";
+function createOnboardCommand() {
+  return new Command3("onboard").description("Full project onboarding").option("--project-root <path>", "Project root", process.cwd()).option("--domain <domain>", "Force the target domain").option("--stack <stack>", "Force the target stack").option("--capability <capability...>", "Add one or more capabilities").action(
+    async (options) => {
+      const orchestrator = new OnboardingOrchestrator();
+      await orchestrator.run({
+        projectRoot: options.projectRoot,
+        selections: options.domain || options.stack || options.capability ? {
+          domain: options.domain,
+          stack: options.stack,
+          capabilities: options.capability
+        } : void 0
+      });
+    }
+  );
+}
+
+// src/cli/commands/refresh.ts
+import { Command as Command4 } from "commander";
+function createRefreshCommand() {
+  return new Command4("refresh").description("Refresh indexes and registries").action(() => {
+  });
+}
+
+// src/cli/commands/update.ts
+import { Command as Command5 } from "commander";
+function createUpdateCommand() {
+  return new Command5("update").description("Update framework-managed artifacts").option("--project-root <path>", "Project root", process.cwd()).action(async (options) => {
+    const report = await new FrameworkUpdater().run(options.projectRoot);
+    console.log(JSON.stringify(report, null, 2));
+  });
+}
+
+// src/cli/program.ts
+function createProgram() {
+  const program = new Command6();
+  program.name("paqad-ai").description("AI Agency Framework for software agencies").version(VERSION).showSuggestionAfterError(true);
+  program.addCommand(createInstallCommand());
+  program.addCommand(createDoctorCommand());
+  program.addCommand(createOnboardCommand());
+  program.addCommand(createRefreshCommand());
+  program.addCommand(createUpdateCommand());
+  return program;
+}
+
+// src/cli/index.ts
+function getCliBanner() {
+  return "paqad-ai";
+}
+async function runCli(argv = process.argv) {
+  const program = createProgram();
+  await program.parseAsync(argv);
+}
+function shouldRunFromCommandLine(importMetaUrl, argvEntry) {
+  const entrypoint = argvToEntrypoint(argvEntry);
+  return entrypoint !== void 0 && importMetaUrl === entrypoint;
+}
+if (shouldRunFromCommandLine(import.meta.url, process.argv[1])) {
+  await runCli();
+}
+function argvToEntrypoint(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  try {
+    return pathToFileURL(realpathSync(value)).href;
+  } catch {
+    return pathToFileURL(value).href;
+  }
+}
+export {
+  argvToEntrypoint,
+  getCliBanner,
+  runCli,
+  shouldRunFromCommandLine
+};
+//# sourceMappingURL=index.js.map