paqad-ai 0.3.1 → 0.3.3

package/dist/cli/index.js

@@ -73,6 +73,10 @@ var init_paths = __esm({
       // Feature 2 - Predictive Cache
       TRANSITION_LOG: ".paqad/cache/transition-log.json",
       CACHE_METRICS: ".paqad/cache/metrics.json",
+      PLANNING_SPECS_DIR: ".paqad/specs",
+      PLANNING_MODULE_HEALTH_DIR: ".paqad/module-health",
+      COMPILED_RULES: ".paqad/compiled-rules.json",
+      PLANNING_COSTS: ".paqad/cache/planning-costs.json",
       // Feature 3 - Context Budget Optimizer
       CONTEXT_BUDGET_STATE: ".paqad/session/context-budget.json",
       CONTEXT_SAVINGS: ".paqad/session/context-savings.json",
@@ -283,7 +287,7 @@ var init_domain = __esm({
       "node-service",
       "short-video"
     ];
-    ACTIVE_CAPABILITIES = ["content", "coding", "security"];
+    ACTIVE_CAPABILITIES = ["content", "coding", "planning", "security"];
     DOMAIN_STACK_MAP = {
       coding: [
         "laravel",
@@ -1163,6 +1167,19 @@ var init_onboarding_manifest_schema = __esm({
               executable: { type: "boolean" }
             }
           }
+        },
+        planning_artifacts: {
+          type: "object",
+          additionalProperties: false,
+          required: ["compiled_rules_path", "module_health_initialized"],
+          properties: {
+            compiled_rules_path: { type: "string" },
+            classifier_config_path: { type: "string" },
+            module_health_initialized: {
+              type: "array",
+              items: { type: "string" }
+            }
+          }
         }
       }
     };
@@ -4261,20 +4278,20 @@ async function readIgnoreRules(projectRoot, config) {
   }
   return rules;
 }
-function isEligibleByLayer1(basename9, extAllowlist, basenameIncludes) {
-  const lowerBasename = basename9.toLowerCase();
+function isEligibleByLayer1(basename12, extAllowlist, basenameIncludes) {
+  const lowerBasename = basename12.toLowerCase();
   for (const extension of extAllowlist) {
     if (lowerBasename.endsWith(extension.toLowerCase())) {
       return true;
     }
   }
-  if (basenameIncludes.has(basename9)) {
+  if (basenameIncludes.has(basename12)) {
     return true;
   }
-  const stem = basename9.split(".")[0];
+  const stem = basename12.split(".")[0];
   return stem.length > 0 && basenameIncludes.has(stem);
 }
-function isExcludedByLayer2(absolutePath, basename9, projectRoot, hardExclusions, adapterFiles) {
+function isExcludedByLayer2(absolutePath, basename12, projectRoot, hardExclusions, adapterFiles) {
   const relativePath = toProjectRelativePath(projectRoot, absolutePath);
   const segments = splitSegments(relativePath);
   if (relativePath.startsWith(".paqad/") || segments.includes(".paqad")) {
@@ -4284,8 +4301,8 @@ function isExcludedByLayer2(absolutePath, basename9, projectRoot, hardExclusions
   if (aiToolDir) {
     return `ai-tool-directory:${aiToolDir}`;
   }
-  if (hardExclusions.has(basename9)) {
-    return adapterFiles.has(basename9) ? `adapter-file:${basename9}` : `hard-file:${basename9}`;
+  if (hardExclusions.has(basename12)) {
+    return adapterFiles.has(basename12) ? `adapter-file:${basename12}` : `hard-file:${basename12}`;
   }
   return void 0;
 }
@@ -4304,8 +4321,8 @@ function findMatchingDirectory(relativePath, directories) {
     return relativeDir === normalized || relativeDir.startsWith(`${normalized}/`) || relativeDir.includes(`/${normalized}/`) || relativeDir.endsWith(`/${normalized}`);
   });
 }
-function isSoftEnvExcluded(basename9) {
-  return basename9 === ".env" || basename9.startsWith(".env.");
+function isSoftEnvExcluded(basename12) {
+  return basename12 === ".env" || basename12.startsWith(".env.");
 }
 function resolveIgnorePattern(baseDir, pattern) {
   const normalizedBase = trimSlashes(toPosixPath(baseDir));
@@ -4635,9 +4652,9 @@ var init_file_filter = __esm({
         return this.discoverFiles();
       }
       async evaluateFile(absolutePath, layer3IgnoreRules) {
-        const basename9 = basenameOf(absolutePath);
+        const basename12 = basenameOf(absolutePath);
         const relativePath = toProjectRelativePath(this.options.projectRoot, absolutePath);
-        if (!isEligibleByLayer1(basename9, this.extensionAllowlist, this.namedBasenameIncludes)) {
+        if (!isEligibleByLayer1(basename12, this.extensionAllowlist, this.namedBasenameIncludes)) {
           return {
             path: absolutePath,
             excluded: true,
@@ -4647,7 +4664,7 @@ var init_file_filter = __esm({
         }
         const layer2 = isExcludedByLayer2(
           absolutePath,
-          basename9,
+          basename12,
           this.options.projectRoot,
           this.hardNamedFileExclusionSet,
           this.adapterFileExclusionSet
@@ -4660,7 +4677,7 @@ var init_file_filter = __esm({
             rule: layer2
           };
         }
-        const layer3 = this.evaluateLayer3(relativePath, basename9, layer3IgnoreRules);
+        const layer3 = this.evaluateLayer3(relativePath, basename12, layer3IgnoreRules);
         if (layer3) {
           return {
             path: absolutePath,
@@ -4683,7 +4700,7 @@ var init_file_filter = __esm({
           excluded: false
         };
       }
-      evaluateLayer3(relativePath, basename9, ignoreRules) {
+      evaluateLayer3(relativePath, basename12, ignoreRules) {
         const includedByConfig = this.ragConfig.include.some(
           (pattern) => matchesProjectGlob(relativePath, pattern)
         );
@@ -4708,7 +4725,7 @@ var init_file_filter = __esm({
         if (configExclude && !includedByConfig) {
           return `config-exclude:${configExclude}`;
         }
-        if (isSoftEnvExcluded(basename9) && !includedByConfig) {
+        if (isSoftEnvExcluded(basename12) && !includedByConfig) {
           return "soft-env-exclusion";
         }
         return void 0;
@@ -8211,6 +8228,15 @@ init_esm_shims();
 // src/core/constants/index.ts
 init_paths();
 
+// src/core/constants/planning.ts
+init_esm_shims();
+var HEALTH_TIERS = {
+  STABLE: "stable",
+  MODERATE: "moderate",
+  FRAGILE: "fragile",
+  UNKNOWN: "unknown"
+};
+
 // src/core/errors/index.ts
 init_esm_shims();
 
@@ -8391,6 +8417,15 @@ init_esm_shims();
 // src/core/types/pentest.ts
 init_esm_shims();
 
+// src/core/types/planning.ts
+init_esm_shims();
+
+// src/core/types/post-classification.ts
+init_esm_shims();
+
+// src/core/types/pre-classification.ts
+init_esm_shims();
+
 // src/core/types/project-profile.ts
 init_esm_shims();
 
@@ -10594,6 +10629,7 @@ var HealthChecker = class {
       this.checkMcp(projectRoot, profile),
       this.checkSkillCache(projectRoot),
       this.checkContextHitRate(projectRoot, profile),
+      this.checkClassificationOverrideRate(projectRoot),
       ...await this.checkRag(projectRoot, profile)
     ];
     const overallStatus = deriveOverallStatus(checks);
@@ -10615,7 +10651,7 @@ var HealthChecker = class {
   }
   checkFrameworkArtifacts(projectRoot) {
     const required = [PATHS.PROJECT_PROFILE, PATHS.FRAMEWORK_VERSION, PATHS.FRAMEWORK_PATH];
-    const missing = required.filter((relative12) => !existsSync17(join35(projectRoot, relative12)));
+    const missing = required.filter((relative17) => !existsSync17(join35(projectRoot, relative17)));
     return missing.length === 0 ? pass("Framework artifacts exist", "Framework artifacts are present") : fail(
       "Framework artifacts exist",
       `Missing framework artifacts: ${missing.join(", ")}`,
@@ -10960,6 +10996,34 @@ var HealthChecker = class {
       mcp_usage_rate: 0
     };
   }
+  checkClassificationOverrideRate(projectRoot) {
+    const path11 = join35(projectRoot, PATHS.AGENCY_CACHE_DIR, "classification-history.json");
+    if (!existsSync17(path11)) {
+      return pass(
+        "Classification override rate acceptable",
+        "No classification history recorded yet"
+      );
+    }
+    try {
+      const entries = JSON.parse(readFileSync14(path11, "utf8"));
+      const sample = entries.slice(-50);
+      const ratio = sample.length === 0 ? 0 : sample.filter((entry) => entry.high_override_rate).length / sample.length;
+      return ratio > 0.3 ? warn(
+        "Classification override rate acceptable",
+        `High override rate detected across recent classifications (${Math.round(ratio * 100)}%)`,
+        "Review pre-classification signals and reduce deterministic/LLM disagreement."
+      ) : pass(
+        "Classification override rate acceptable",
+        "Classification override rate is within acceptable bounds"
+      );
+    } catch {
+      return warn(
+        "Classification override rate acceptable",
+        "Classification history is unreadable",
+        "Regenerate classification history by re-running recent classification flows."
+      );
+    }
+  }
   documentationHasRun(projectRoot) {
     return existsSync17(join35(projectRoot, PATHS.DOC_PROGRESS));
   }
@@ -11163,14 +11227,14 @@ init_paths();
 init_project_profile();
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname15, join as join36 } from "path";
+import { dirname as dirname15, join as join36, relative as relative2, sep as sep2 } from "path";
 function writeProjectProfile2(projectRoot, profile) {
   return writeProjectProfile(projectRoot, profile);
 }
 function writeDetectionReport(projectRoot, report) {
   const path11 = join36(projectRoot, PATHS.DETECTION_REPORT);
   mkdirSync5(dirname15(path11), { recursive: true });
-  writeFileSync4(path11, JSON.stringify(report, null, 2));
+  writeFileSync4(path11, JSON.stringify(sanitizeDetectionReport(projectRoot, report), null, 2));
   return path11;
 }
 function writeFrameworkMetadata(projectRoot, version) {
@@ -11181,18 +11245,76 @@ function writeFrameworkMetadata(projectRoot, version) {
 updated_at=${(/* @__PURE__ */ new Date()).toISOString()}
 `;
   writeFileSync4(join36(projectRoot, PATHS.FRAMEWORK_VERSION), content);
-  writeFileSync4(join36(projectRoot, PATHS.FRAMEWORK_PATH), `${resolveFrameworkInstallPath()}
+  writeFileSync4(join36(projectRoot, PATHS.FRAMEWORK_PATH), `${resolveFrameworkInstallReference()}
 `);
 }
 function writeOnboardingManifest(projectRoot, manifest) {
   const path11 = join36(projectRoot, PATHS.ONBOARDING_MANIFEST);
   mkdirSync5(dirname15(path11), { recursive: true });
-  writeFileSync4(path11, JSON.stringify(manifest, null, 2));
+  writeFileSync4(path11, JSON.stringify(sanitizeOnboardingManifest(projectRoot, manifest), null, 2));
   return path11;
 }
 function resolveFrameworkInstallPath() {
   return process.env.PAQAD_FRAMEWORK_HOME ?? join36(homedir7(), ".paqad-ai/current");
 }
+function resolveFrameworkInstallReference() {
+  return process.env.PAQAD_FRAMEWORK_HOME ? "$PAQAD_FRAMEWORK_HOME" : "~/.paqad-ai/current";
+}
+function sanitizeDetectionReport(projectRoot, report) {
+  return {
+    ...report,
+    repository: report.repository ? sanitizeRepositoryContext(projectRoot, report.repository) : void 0
+  };
+}
+function sanitizeOnboardingManifest(projectRoot, manifest) {
+  return {
+    ...manifest,
+    project_root: typeof manifest.project_root === "string" ? sanitizePersistedPath(projectRoot, manifest.project_root) : manifest.project_root,
+    detected: manifest.detected ? sanitizeDetectionReport(projectRoot, manifest.detected) : null,
+    repository: manifest.repository ? sanitizeRepositoryContext(projectRoot, manifest.repository) : void 0
+  };
+}
+function sanitizeRepositoryContext(projectRoot, repository) {
+  return {
+    ...repository,
+    selected_root: sanitizePersistedPath(projectRoot, repository.selected_root),
+    ignored_paths: repository.ignored_paths.map((path11) => sanitizePersistedPath(projectRoot, path11)),
+    projects: repository.projects.map((project) => sanitizeRepositoryProject(projectRoot, project)),
+    applications: repository.applications.map(
+      (application) => sanitizeRepositoryApplication(projectRoot, application)
+    ),
+    primary_project_root: repository.primary_project_root === null ? null : sanitizePersistedPath(projectRoot, repository.primary_project_root)
+  };
+}
+function sanitizeRepositoryProject(projectRoot, project) {
+  return {
+    ...project,
+    root: sanitizePersistedPath(projectRoot, project.root),
+    parent_root: project.parent_root === null ? null : sanitizePersistedPath(projectRoot, project.parent_root)
+  };
+}
+function sanitizeRepositoryApplication(projectRoot, application) {
+  return {
+    ...application,
+    root: sanitizePersistedPath(projectRoot, application.root),
+    component_roots: application.component_roots.map(
+      (root) => sanitizePersistedPath(projectRoot, root)
+    )
+  };
+}
+function sanitizePersistedPath(projectRoot, value) {
+  if (value === ".") {
+    return value;
+  }
+  const relativePath = relative2(projectRoot, value);
+  if (relativePath === "") {
+    return ".";
+  }
+  if (relativePath !== ".." && !relativePath.startsWith(`..${sep2}`) && relativePath !== "") {
+    return relativePath.replaceAll("\\", "/");
+  }
+  return value;
+}
 
 // src/install/bootstrap.ts
 function bootstrapFramework(projectRoot) {
@@ -11268,7 +11390,7 @@ init_esm_shims();
 init_paths();
 init_project_profile();
 import { mkdir as mkdir20, readFile as readFile25, readdir as readdir6, writeFile as writeFile20 } from "fs/promises";
-import { dirname as dirname18, join as join41, relative as relative2 } from "path";
+import { dirname as dirname18, join as join41, relative as relative3 } from "path";
 
 // src/onboarding/registry-generator.ts
 init_esm_shims();
@@ -12098,7 +12220,7 @@ async function gatherSourceFiles(projectRoot, stack, repository) {
   for (const root of roots) {
     try {
       for (const file of await walk3(join41(projectRoot, root))) {
-        results.add(relative2(projectRoot, file));
+        results.add(relative3(projectRoot, file));
       }
     } catch {
       if (!root.includes(".")) {
@@ -12685,8 +12807,8 @@ function generateFeatureDevelopmentPolicy(domain) {
 
 // src/onboarding/orchestrator.ts
 init_esm_shims();
-import { readFileSync as readFileSync16 } from "fs";
-import { join as join48 } from "path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync7 } from "fs";
+import { join as join59 } from "path";
 init_paths();
 init_project_intelligence();
 init_runtime_paths();
@@ -12694,7 +12816,7 @@ init_runtime_paths();
 // src/resolver/resolver.ts
 init_esm_shims();
 import fg6 from "fast-glob";
-import { basename as basename4, extname as extname2, relative as relative4 } from "pathe";
+import { basename as basename4, extname as extname2, relative as relative5 } from "pathe";
 
 // src/resolver/artifact-types.ts
 init_esm_shims();
@@ -12734,7 +12856,7 @@ var ARTIFACT_OUTPUT_KEYS = {
 
 // src/resolver/inheritance.ts
 init_esm_shims();
-import { join as join44, relative as relative3 } from "pathe";
+import { join as join44, relative as relative4 } from "pathe";
 
 // src/resolver/capability-resolver.ts
 init_esm_shims();
@@ -12774,7 +12896,7 @@ function getInheritanceDirectories(runtimeRoot, routing, artifactType) {
       {
         path: join44(runtimeRoot, "hooks"),
         level: 0,
-        source: relative3(runtimeRoot, join44(runtimeRoot, "hooks"))
+        source: relative4(runtimeRoot, join44(runtimeRoot, "hooks"))
       }
     ];
   }
@@ -12783,7 +12905,7 @@ function getInheritanceDirectories(runtimeRoot, routing, artifactType) {
       {
         path: join44(runtimeRoot, "templates"),
         level: 0,
-        source: relative3(runtimeRoot, join44(runtimeRoot, "templates"))
+        source: relative4(runtimeRoot, join44(runtimeRoot, "templates"))
       }
     ];
   }
@@ -12795,12 +12917,12 @@ function getInheritanceDirectories(runtimeRoot, routing, artifactType) {
     {
       path: join44(runtimeRoot, "base", directoryName),
       level: 0,
-      source: relative3(runtimeRoot, join44(runtimeRoot, "base", directoryName))
+      source: relative4(runtimeRoot, join44(runtimeRoot, "base", directoryName))
     },
     {
       path: join44(runtimeRoot, "capabilities", "content", directoryName),
       level: 1,
-      source: relative3(runtimeRoot, join44(runtimeRoot, "capabilities", "content", directoryName))
+      source: relative4(runtimeRoot, join44(runtimeRoot, "capabilities", "content", directoryName))
     }
   ];
   if (activeCapabilities.includes("coding")) {
@@ -12808,12 +12930,12 @@ function getInheritanceDirectories(runtimeRoot, routing, artifactType) {
       {
         path: join44(runtimeRoot, "capabilities", "coding", directoryName),
         level: 2,
-        source: relative3(runtimeRoot, join44(runtimeRoot, "capabilities", "coding", directoryName))
+        source: relative4(runtimeRoot, join44(runtimeRoot, "capabilities", "coding", directoryName))
       },
       {
         path: join44(runtimeRoot, "capabilities", "coding", "stacks", "_shared", directoryName),
         level: 3,
-        source: relative3(
+        source: relative4(
           runtimeRoot,
           join44(runtimeRoot, "capabilities", "coding", "stacks", "_shared", directoryName)
         )
@@ -12821,7 +12943,7 @@ function getInheritanceDirectories(runtimeRoot, routing, artifactType) {
       ...matchedPacks.map((pack, index) => ({
         path: join44(runtimeRoot, "capabilities", "coding", "stacks", pack, directoryName),
         level: 4 + Math.min(index, 1),
-        source: relative3(
+        source: relative4(
           runtimeRoot,
           join44(runtimeRoot, "capabilities", "coding", "stacks", pack, directoryName)
         )
@@ -12830,7 +12952,7 @@ function getInheritanceDirectories(runtimeRoot, routing, artifactType) {
         (pack) => resolveCapabilityDirectories(runtimeRoot, pack, traits, artifactType).map((path11) => ({
           path: path11,
           level: 5,
-          source: relative3(runtimeRoot, path11)
+          source: relative4(runtimeRoot, path11)
         }))
       )
     );
@@ -12839,7 +12961,7 @@ function getInheritanceDirectories(runtimeRoot, routing, artifactType) {
     directories.push({
       path: join44(runtimeRoot, "capabilities", "security", directoryName),
       level: 6,
-      source: relative3(runtimeRoot, join44(runtimeRoot, "capabilities", "security", directoryName))
+      source: relative4(runtimeRoot, join44(runtimeRoot, "capabilities", "security", directoryName))
     });
   }
   return directories;
@@ -12961,13 +13083,13 @@ var Resolver = class {
         const artifact = {
           path: file,
           level: directory.level,
-          source: relative4(this.runtimeRoot, file)
+          source: relative5(this.runtimeRoot, file)
         };
         if (COLLISION_MAP[artifactType] === "additive-merge") {
           entries.push(artifact);
           continue;
         }
-        overrides.set(relative4(directory.path, file), artifact);
+        overrides.set(relative5(directory.path, file), artifact);
       }
     }
     const resolved = COLLISION_MAP[artifactType] === "additive-merge" ? entries : Array.from(overrides.values());
@@ -12994,13 +13116,252 @@ function getRulePriority(filePath) {
 // src/onboarding/orchestrator.ts
 init_validator();
 
+// src/planning/index.ts
+init_esm_shims();
+
+// src/planning/contract-boundary.ts
+init_esm_shims();
+import { readFile as readFile26 } from "fs/promises";
+import { basename as basename5, extname as extname3, join as join45, relative as relative6 } from "path";
+import fg7 from "fast-glob";
+
+// src/planning/cost-predictor.ts
+init_esm_shims();
+init_paths();
+import { mkdir as mkdir21, readFile as readFile27, writeFile as writeFile21 } from "fs/promises";
+import { join as join46 } from "path";
+
+// src/planning/coverage-overlay.ts
+init_esm_shims();
+import { readFile as readFile28 } from "fs/promises";
+import { join as join47 } from "path";
+import fg8 from "fast-glob";
+
+// src/planning/defect-advisory.ts
+init_esm_shims();
+
+// src/planning/delta-merger.ts
+init_esm_shims();
+
+// src/planning/doc-target-resolver.ts
+init_esm_shims();
+import { access as access2 } from "fs/promises";
+import { join as join48 } from "path";
+
+// src/planning/intelligence-assembler.ts
+init_esm_shims();
+import { readFile as readFile31 } from "fs/promises";
+import { join as join51 } from "path";
+import fg11 from "fast-glob";
+
+// src/planning/module-health.ts
+init_esm_shims();
+import { mkdir as mkdir22, readFile as readFile29, writeFile as writeFile22 } from "fs/promises";
+import { join as join49 } from "path";
+import fg9 from "fast-glob";
+init_paths();
+function deriveHealthTier(metrics) {
+  const coverage = metrics.coverage_pct ?? null;
+  const defectFrequency = metrics.defect_frequency ?? null;
+  const contractStability = metrics.contract_stability ?? null;
+  if (coverage === null && defectFrequency === null && contractStability === null) {
+    return HEALTH_TIERS.UNKNOWN;
+  }
+  if (coverage !== null && coverage >= 80 && defectFrequency !== null && defectFrequency <= 2 && contractStability !== null && contractStability >= 0.85) {
+    return HEALTH_TIERS.STABLE;
+  }
+  if (coverage !== null && coverage >= 50 && defectFrequency !== null && defectFrequency <= 5) {
+    return HEALTH_TIERS.MODERATE;
+  }
+  return HEALTH_TIERS.FRAGILE;
+}
+async function readModuleHealth(root, moduleName) {
+  try {
+    const raw = await readFile29(moduleHealthPath(root, moduleName), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeModuleHealth(root, moduleName, metrics) {
+  const profile = {
+    module: moduleName,
+    tier: deriveHealthTier(metrics),
+    metrics,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await mkdir22(join49(root, PATHS.PLANNING_MODULE_HEALTH_DIR), { recursive: true });
+  await writeFile22(
+    moduleHealthPath(root, moduleName),
+    JSON.stringify(profile, null, 2) + "\n",
+    "utf8"
+  );
+  return profile;
+}
+async function initializeModuleHealth(root, moduleName) {
+  const existing = await readModuleHealth(root, moduleName);
+  if (existing) {
+    return existing;
+  }
+  return writeModuleHealth(root, moduleName, {
+    coverage_pct: null,
+    defect_frequency: null,
+    contract_stability: null,
+    change_velocity: null
+  });
+}
+function moduleHealthPath(root, moduleName) {
+  return join49(root, PATHS.PLANNING_MODULE_HEALTH_DIR, `${moduleName}.json`);
+}
+
+// src/planning/rule-compiler.ts
+init_esm_shims();
+init_paths();
+import { mkdir as mkdir23, readFile as readFile30, writeFile as writeFile23 } from "fs/promises";
+import { createHash as createHash9 } from "crypto";
+import { join as join50, relative as relative7 } from "path";
+import fg10 from "fast-glob";
+var RULE_SCHEMA_VERSION = 1;
+async function compileRules(root) {
+  const files = await fg10("**/*.md", {
+    cwd: join50(root, PATHS.RULES_DIR),
+    onlyFiles: true
+  });
+  const rules = await Promise.all(
+    files.map(async (file, index) => compileRuleFile(root, file, index + 1))
+  );
+  return {
+    schema_version: RULE_SCHEMA_VERSION,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    source_hash: await computeSourceHash(root),
+    rules
+  };
+}
+async function writeCompiledRules(root, store) {
+  const outputPath = join50(root, PATHS.COMPILED_RULES);
+  await mkdir23(join50(root, ".paqad"), { recursive: true });
+  await writeFile23(outputPath, JSON.stringify(store, null, 2) + "\n", "utf8");
+  return outputPath;
+}
+async function readCompiledRules(root) {
+  try {
+    const raw = await readFile30(join50(root, PATHS.COMPILED_RULES), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function isCompiledRulesStale(root) {
+  const store = await readCompiledRules(root);
+  if (!store) {
+    return true;
+  }
+  return store.source_hash !== await computeSourceHash(root);
+}
+async function computeSourceHash(root) {
+  const files = await fg10("**/*.md", {
+    cwd: join50(root, PATHS.RULES_DIR),
+    onlyFiles: true
+  });
+  const hash = createHash9("sha256");
+  for (const file of files.sort()) {
+    const content = await readFile30(join50(root, PATHS.RULES_DIR, file), "utf8");
+    hash.update(file);
+    hash.update("\0");
+    hash.update(content);
+    hash.update("\0");
+  }
+  return `sha256:${hash.digest("hex")}`;
+}
+async function compileRuleFile(root, file, ordinal) {
+  const absolutePath = join50(root, PATHS.RULES_DIR, file);
+  const raw = await readFile30(absolutePath, "utf8");
+  const headingMatch = raw.match(/^#\s+(.+)$/m);
+  const title = headingMatch?.[1]?.trim() || relative7(root, absolutePath);
+  const summary = raw.split("\n").map((line) => line.trim()).find((line) => line && !line.startsWith("#") && !line.startsWith("```"));
+  const triggerPatterns = extractTriggerPatterns(raw);
+  if (summary === void 0) {
+    return {
+      rule_id: `RULE-${ordinal}`,
+      title,
+      source_path: join50(PATHS.RULES_DIR, file),
+      trigger_patterns: ["**"],
+      severity: "must",
+      summary: "Unparseable rule content; preserve raw text for planning context.",
+      raw_text: raw
+    };
+  }
+  return {
+    rule_id: `RULE-${ordinal}`,
+    title,
+    source_path: join50(PATHS.RULES_DIR, file),
+    trigger_patterns: triggerPatterns.length > 0 ? triggerPatterns : ["**"],
+    severity: inferSeverity(raw),
+    summary,
+    raw_text: raw
+  };
+}
+function extractTriggerPatterns(raw) {
+  const explicitDirective = raw.match(/<!--\s*trigger:\s*([^>]+)\s*-->/i)?.[1];
+  const candidates = explicitDirective ? explicitDirective.split(",").map((value) => value.trim()) : Array.from(raw.matchAll(/`([^`]+)`/g), (match) => match[1].trim());
+  return [...new Set(candidates.filter(Boolean))];
+}
+function inferSeverity(raw) {
+  const normalized = raw.toLowerCase();
+  if (/\bmust\b|\brequired\b|\bnever\b/.test(normalized)) {
+    return "must";
+  }
+  if (/\bshould\b|\brecommended\b/.test(normalized)) {
+    return "should";
+  }
+  return "could";
+}
+
+// src/planning/manifest-parser.ts
+init_esm_shims();
+init_paths();
+import { access as access3, readFile as readFile32, readdir as readdir7 } from "fs/promises";
+import { createHash as createHash10 } from "crypto";
+import { join as join52 } from "path";
+import YAML9 from "yaml";
+
+// src/planning/manifest-types.ts
+init_esm_shims();
+
+// src/planning/manifest-validator.ts
+init_esm_shims();
+
+// src/planning/plan-vs-actual.ts
+init_esm_shims();
+init_paths();
+import { mkdir as mkdir24, writeFile as writeFile24 } from "fs/promises";
+import { join as join53 } from "path";
+
+// src/planning/regression-detector.ts
+init_esm_shims();
+import { readFile as readFile33 } from "fs/promises";
+import { basename as basename6, extname as extname4, join as join54 } from "path";
+import fg12 from "fast-glob";
+
+// src/planning/rule-injection.ts
+init_esm_shims();
+
+// src/planning/skeleton-emitter.ts
+init_esm_shims();
+import { mkdir as mkdir25, writeFile as writeFile25 } from "fs/promises";
+import { dirname as dirname20, join as join55 } from "path";
+
+// src/planning/slug-utils.ts
+init_esm_shims();
+
 // src/onboarding/gitignore-writer.ts
 init_esm_shims();
 import { existsSync as existsSync20, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "fs";
-import { join as join45 } from "path";
+import { join as join56 } from "path";
 var PAQAD_MARKER = "# paqad-ai";
 var PAQAD_GITIGNORE_ENTRIES = [
   PAQAD_MARKER,
+  ".paqad/framework-path.txt",
   ".paqad/cache/",
   ".paqad/session/",
   ".paqad/context/",
@@ -13012,7 +13373,7 @@ var PAQAD_GITIGNORE_ENTRIES = [
   ".paqad/theme/"
 ].join("\n");
 function writeGitignore(projectRoot) {
-  const gitignorePath = join45(projectRoot, ".gitignore");
+  const gitignorePath = join56(projectRoot, ".gitignore");
   const existing = existsSync20(gitignorePath) ? readFileSync15(gitignorePath, "utf8") : "";
   if (existing.includes(PAQAD_MARKER)) {
     return;
@@ -13706,9 +14067,9 @@ async function enableRagDuringOnboarding(projectRoot, ragSelection) {
 init_esm_shims();
 init_paths();
 import { existsSync as existsSync21 } from "fs";
-import { readFile as readFile26 } from "fs/promises";
-import { join as join46, relative as relative5 } from "path";
-import fg7 from "fast-glob";
+import { readFile as readFile34 } from "fs/promises";
+import { join as join57, relative as relative8 } from "path";
+import fg13 from "fast-glob";
 async function generateReferenceGuides(runtimeRoot, context) {
   if (context.domain !== "coding") {
     return [];
@@ -13718,11 +14079,11 @@ async function generateReferenceGuides(runtimeRoot, context) {
     routing: { domain: context.domain },
     stack_profile: context.stack_profile
   });
-  const referencesRoot = join46(runtimeRoot, "capabilities", "coding", "stacks", stack, "references");
+  const referencesRoot = join57(runtimeRoot, "capabilities", "coding", "stacks", stack, "references");
   if (!existsSync21(referencesRoot)) {
     return [buildFallbackReferenceGuide(stack)];
   }
-  const entries = await fg7(["tools/*.md", "tools-catalog.md"], {
+  const entries = await fg13(["tools/*.md", "tools-catalog.md"], {
     cwd: referencesRoot,
     onlyFiles: true,
     absolute: true
@@ -13732,8 +14093,8 @@ async function generateReferenceGuides(runtimeRoot, context) {
   }
   return Promise.all(
     entries.sort().map(async (entry) => ({
-      path: toProjectReferencePath(stack, relative5(referencesRoot, entry)),
-      content: await readFile26(entry, "utf8"),
+      path: toProjectReferencePath(stack, relative8(referencesRoot, entry)),
+      content: await readFile34(entry, "utf8"),
       autoUpdate: false
     }))
   );
@@ -13741,14 +14102,14 @@ async function generateReferenceGuides(runtimeRoot, context) {
 function toProjectReferencePath(stack, relativePath) {
   const normalized = relativePath.replaceAll("\\", "/");
   if (normalized === "tools-catalog.md") {
-    return join46(PATHS.TOOLS_DIR, stack, "README.md");
+    return join57(PATHS.TOOLS_DIR, stack, "README.md");
   }
-  return join46(PATHS.TOOLS_DIR, stack, normalized.replace(/^tools\//, ""));
+  return join57(PATHS.TOOLS_DIR, stack, normalized.replace(/^tools\//, ""));
 }
 function buildFallbackReferenceGuide(stack) {
   const title = stack.split("-").map((segment) => segment.slice(0, 1).toUpperCase() + segment.slice(1)).join(" ");
   return {
-    path: join46(PATHS.TOOLS_DIR, stack, "README.md"),
+    path: join57(PATHS.TOOLS_DIR, stack, "README.md"),
     autoUpdate: false,
     content: [
       `# ${title} Tool References`,
@@ -13767,13 +14128,13 @@ function buildFallbackReferenceGuide(stack) {
 // src/onboarding/rule-generator.ts
 init_esm_shims();
 init_paths();
-import { readFile as readFile27 } from "fs/promises";
-import { join as join47 } from "path";
+import { readFile as readFile35 } from "fs/promises";
+import { join as join58 } from "path";
 async function generateProjectRules(rules) {
   return Promise.all(
     rules.map(async (rule) => ({
       path: toProjectRulePath(rule.source),
-      content: await readFile27(rule.path, "utf8"),
+      content: await readFile35(rule.path, "utf8"),
       autoUpdate: false
     }))
   );
@@ -13781,22 +14142,22 @@ async function generateProjectRules(rules) {
 function toProjectRulePath(source) {
   const normalized = source.replaceAll("\\", "/");
   if (normalized.startsWith("base/rules/")) {
-    return join47(PATHS.RULES_DIR, "_shared", normalized.replace(/^base\/rules\//, ""));
+    return join58(PATHS.RULES_DIR, "_shared", normalized.replace(/^base\/rules\//, ""));
   }
   if (normalized.startsWith("capabilities/")) {
     const capabilityNormalized = normalized.replace(/^capabilities\//, "");
     const [prefix2, suffix2] = capabilityNormalized.split("/rules/");
     if (prefix2 !== void 0 && suffix2 !== void 0) {
       const target2 = suffix2.endsWith("/guide.md") ? suffix2.replace("/guide.md", ".md") : suffix2;
-      return join47(PATHS.RULES_DIR, prefix2, target2);
+      return join58(PATHS.RULES_DIR, prefix2, target2);
     }
   }
   const [prefix, suffix] = normalized.split("/rules/");
   if (prefix === void 0 || suffix === void 0) {
-    return join47(PATHS.RULES_DIR, normalized);
+    return join58(PATHS.RULES_DIR, normalized);
   }
   const target = suffix.endsWith("/guide.md") ? suffix.replace("/guide.md", ".md") : suffix;
-  return join47(PATHS.RULES_DIR, prefix, target);
+  return join58(PATHS.RULES_DIR, prefix, target);
 }
 
 // src/onboarding/orchestrator.ts
@@ -13852,7 +14213,7 @@ var OnboardingOrchestrator = class {
         stack_profile: selections.stack_profile
       })
     );
-    const silentUpdateSrc = join48(runtimeRoot, "hooks", "silent-update.sh");
+    const silentUpdateSrc = join59(runtimeRoot, "hooks", "silent-update.sh");
     try {
       const hookContent = readFileSync16(silentUpdateSrc, "utf8");
       generatedFiles.push({
@@ -13887,6 +14248,81 @@ var OnboardingOrchestrator = class {
     writeDetectionReport(options.projectRoot, detection);
     writeFrameworkMetadata(options.projectRoot, VERSION);
     bootstrapFramework(options.projectRoot);
+    let compiledRulesPath = join59(options.projectRoot, PATHS.COMPILED_RULES);
+    let initializedModules = [];
+    try {
+      if (await isCompiledRulesStale(options.projectRoot)) {
+        const compiledRules = await compileRules(options.projectRoot);
+        compiledRulesPath = await writeCompiledRules(options.projectRoot, compiledRules);
+      }
+    } catch (error) {
+      onboardingWarnings.push(
+        `Planning rule compilation failed during onboarding: ${error instanceof Error ? error.message : "unknown error"}.`
+      );
+    }
+    try {
+      initializedModules = await Promise.all(
+        modules.map(async (moduleName) => {
+          await initializeModuleHealth(options.projectRoot, moduleName);
+          return moduleName;
+        })
+      );
+    } catch (error) {
+      onboardingWarnings.push(
+        `Planning module health initialization failed during onboarding: ${error instanceof Error ? error.message : "unknown error"}.`
+      );
+    }
+    try {
+      await ensureStoreDir(join59(options.projectRoot, ".paqad", "defect-patterns"));
+    } catch (error) {
+      onboardingWarnings.push(
+        `Defect pattern store initialization failed during onboarding: ${error instanceof Error ? error.message : "unknown error"}.`
+      );
+    }
+    try {
+      const classifierConfigPath = join59(options.projectRoot, ".paqad", "classifier-config.json");
+      writeFileSync7(
+        classifierConfigPath,
+        JSON.stringify(
+          {
+            schema_version: 1,
+            workflow_patterns: [
+              {
+                workflow: "pentest-retest",
+                priority: 250,
+                patterns: ["pentest retest", "pentest-retest"]
+              },
+              {
+                workflow: "pentest",
+                priority: 240,
+                patterns: ["run a pentest", "penetration test", "security audit"]
+              },
+              { workflow: "root-cause-analysis", priority: 230, patterns: ["root cause", "rca"] },
+              {
+                workflow: "documentation-update",
+                priority: 200,
+                patterns: ["documentation", "docs", "documenation"]
+              },
+              { workflow: "research", priority: 180, patterns: ["research", "investigate"] },
+              { workflow: "cleanup", priority: 170, patterns: ["cleanup", "clean up"] },
+              { workflow: "bug-fix", priority: 160, patterns: ["fix", "bug"] },
+              {
+                workflow: "feature-development",
+                priority: 140,
+                patterns: ["implement", "build", "add", "feature", "develop"]
+              }
+            ]
+          },
+          null,
+          2
+        ) + "\n"
+      );
+      writeResult.written.push(".paqad/classifier-config.json");
+    } catch (error) {
+      onboardingWarnings.push(
+        `Classifier config initialization failed during onboarding: ${error instanceof Error ? error.message : "unknown error"}.`
+      );
+    }
     const manifestPath = writeOnboardingManifest(options.projectRoot, {
       framework_version: VERSION,
       adapter: adapters[0],
@@ -13899,7 +14335,12 @@ var OnboardingOrchestrator = class {
         path: file.path,
         auto_update: file.autoUpdate,
         executable: file.executable
-      }))
+      })),
+      planning_artifacts: {
+        compiled_rules_path: compiledRulesPath,
+        module_health_initialized: initializedModules,
+        classifier_config_path: ".paqad/classifier-config.json"
+      }
     });
     return {
       adapter: adapters[0],
@@ -14164,7 +14605,7 @@ function buildRustCommands(usingCompose) {
 init_esm_shims();
 init_paths();
 init_runtime_paths();
-import { join as join49 } from "path";
+import { join as join60 } from "path";
 
 // src/templates/index.ts
 init_esm_shims();
@@ -14195,13 +14636,13 @@ init_esm_shims();
 
 // src/templates/registry.ts
 init_esm_shims();
-import fg8 from "fast-glob";
-import { basename as basename5, relative as relative6 } from "pathe";
+import fg14 from "fast-glob";
+import { basename as basename7, relative as relative9 } from "pathe";
 
 // src/onboarding/scaffold-generator.ts
 var FEATURE_TEMPLATE_TARGETS = [
-  ["business.md.hbs", join49(PATHS.MODULE_FEATURES_DIR, "core", "business.md")],
-  ["technical.md.hbs", join49(PATHS.MODULE_FEATURES_DIR, "core", "technical.md")]
+  ["business.md.hbs", join60(PATHS.MODULE_FEATURES_DIR, "core", "business.md")],
+  ["technical.md.hbs", join60(PATHS.MODULE_FEATURES_DIR, "core", "technical.md")]
 ];
 
 // src/packs/index.ts
@@ -14275,19 +14716,19 @@ async function queryOsv(packages) {
 init_esm_shims();
 init_paths();
 import { existsSync as existsSync23 } from "fs";
-import { mkdir as mkdir22, readdir as readdir8, readFile as readFile29, writeFile as writeFile22 } from "fs/promises";
-import { dirname as dirname21, join as join51 } from "path";
+import { mkdir as mkdir27, readdir as readdir9, readFile as readFile37, writeFile as writeFile27 } from "fs/promises";
+import { dirname as dirname22, join as join62 } from "path";
 init_validator();
 
 // src/pentest/shared.ts
 init_esm_shims();
 init_paths();
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { existsSync as existsSync22 } from "fs";
-import { mkdir as mkdir21, readFile as readFile28, readdir as readdir7, writeFile as writeFile21 } from "fs/promises";
-import { basename as basename6, dirname as dirname20, join as join50, relative as relative7 } from "path";
+import { mkdir as mkdir26, readFile as readFile36, readdir as readdir8, writeFile as writeFile26 } from "fs/promises";
+import { basename as basename8, dirname as dirname21, join as join61, relative as relative10 } from "path";
 import { execa as execa2 } from "execa";
-import fg9 from "fast-glob";
+import fg15 from "fast-glob";
 function toLocalTimestamp(date) {
   const year = date.getFullYear();
   const month = String(date.getMonth() + 1).padStart(2, "0");
@@ -14298,18 +14739,18 @@ function toLocalTimestamp(date) {
   return `${year}-${month}-${day}-${hours}-${minutes}-${seconds}`;
 }
 async function writeJson(target, data) {
-  await mkdir21(dirname20(target), { recursive: true });
-  await writeFile21(target, `${JSON.stringify(data, null, 2)}
+  await mkdir26(dirname21(target), { recursive: true });
+  await writeFile26(target, `${JSON.stringify(data, null, 2)}
 `);
 }
 async function readJsonIfExists(target) {
   if (!existsSync22(target)) {
     return null;
   }
-  return JSON.parse(await readFile28(target, "utf8"));
+  return JSON.parse(await readFile36(target, "utf8"));
 }
 async function hashRelevantInputs(projectRoot, workflow, extra = {}) {
-  const files = (await fg9(
+  const files = (await fg15(
     [
       "docs/modules/**/*.md",
       "tests/**/*",
@@ -14334,11 +14775,11 @@ async function hashRelevantInputs(projectRoot, workflow, extra = {}) {
       dot: true
     }
   )).sort();
-  const hash = createHash9("sha256");
+  const hash = createHash11("sha256");
   hash.update(workflow);
   for (const file of files) {
-    hash.update(relative7(projectRoot, file));
-    hash.update(await readFile28(file));
+    hash.update(relative10(projectRoot, file));
+    hash.update(await readFile36(file));
   }
   hash.update(JSON.stringify(extra));
   return hash.digest("hex");
@@ -14349,11 +14790,11 @@ async function discoverTargetUrl(projectRoot, stack, explicit) {
   }
   const envFiles = [".env", ".env.local", ".env.example"];
   for (const envFile of envFiles) {
-    const path11 = join50(projectRoot, envFile);
+    const path11 = join61(projectRoot, envFile);
     if (!existsSync22(path11)) {
       continue;
     }
-    const content = await readFile28(path11, "utf8");
+    const content = await readFile36(path11, "utf8");
     const match = content.match(/(?:^|\n)\s*APP_URL\s*=\s*["']?([^\n"']+)["']?/i) ?? content.match(/(?:^|\n)\s*VITE_APP_URL\s*=\s*["']?([^\n"']+)["']?/i) ?? content.match(/(?:^|\n)\s*VITE_BASE_URL\s*=\s*["']?([^\n"']+)["']?/i);
     if (match?.[1]) {
       return match[1].trim();
@@ -14371,18 +14812,18 @@ async function discoverTargetUrl(projectRoot, stack, explicit) {
   return null;
 }
 async function runProjectScript(projectRoot, scriptName, env, logDir) {
-  const scriptPath = join50(projectRoot, PATHS.SCRIPTS_DIR, scriptName);
-  const stdoutPath = join50(logDir, `${scriptName}.stdout.log`);
-  const stderrPath = join50(logDir, `${scriptName}.stderr.log`);
-  await mkdir21(logDir, { recursive: true });
+  const scriptPath = join61(projectRoot, PATHS.SCRIPTS_DIR, scriptName);
+  const stdoutPath = join61(logDir, `${scriptName}.stdout.log`);
+  const stderrPath = join61(logDir, `${scriptName}.stderr.log`);
+  await mkdir26(logDir, { recursive: true });
   if (!existsSync22(scriptPath)) {
-    await writeFile21(stdoutPath, "");
-    await writeFile21(stderrPath, `Missing script: ${relative7(projectRoot, scriptPath)}
+    await writeFile26(stdoutPath, "");
+    await writeFile26(stderrPath, `Missing script: ${relative10(projectRoot, scriptPath)}
 `);
     return {
       script: scriptName,
       status: "blocked",
-      artifact_paths: [relative7(projectRoot, stdoutPath), relative7(projectRoot, stderrPath)],
+      artifact_paths: [relative10(projectRoot, stdoutPath), relative10(projectRoot, stderrPath)],
       exit_code: null,
       summary: `Missing project script ${scriptName}`
     };
@@ -14392,25 +14833,25 @@ async function runProjectScript(projectRoot, scriptName, env, logDir) {
     env,
     reject: false
   });
-  await writeFile21(stdoutPath, result.stdout);
-  await writeFile21(stderrPath, result.stderr);
+  await writeFile26(stdoutPath, result.stdout);
+  await writeFile26(stderrPath, result.stderr);
   return {
     script: scriptName,
     status: result.exitCode === 0 ? "completed" : "failed",
-    artifact_paths: [relative7(projectRoot, stdoutPath), relative7(projectRoot, stderrPath)],
+    artifact_paths: [relative10(projectRoot, stdoutPath), relative10(projectRoot, stderrPath)],
     exit_code: result.exitCode ?? null,
     summary: result.exitCode === 0 ? `${scriptName} completed` : `${scriptName} failed with exit code ${result.exitCode}`
   };
 }
 async function loadModuleDocs(projectRoot, focusModules = []) {
-  const moduleRoot = join50(projectRoot, PATHS.MODULES_DIR);
+  const moduleRoot = join61(projectRoot, PATHS.MODULES_DIR);
   if (!existsSync22(moduleRoot)) {
     return [];
   }
-  const dirs = (await readdir7(moduleRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((moduleName) => focusModules.length === 0 || focusModules.includes(moduleName)).sort();
+  const dirs = (await readdir8(moduleRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((moduleName) => focusModules.length === 0 || focusModules.includes(moduleName)).sort();
   return Promise.all(
     dirs.map(async (moduleName) => {
-      const paths = (await fg9(
+      const paths = (await fg15(
         [
           `${moduleName}/business.md`,
           `${moduleName}/technical.md`,
@@ -14428,17 +14869,17 @@ async function loadModuleDocs(projectRoot, focusModules = []) {
           absolute: true
         }
       )).sort();
-      const content = (await Promise.all(paths.map((path11) => readFile28(path11, "utf8").catch(() => "")))).join("\n");
+      const content = (await Promise.all(paths.map((path11) => readFile36(path11, "utf8").catch(() => "")))).join("\n");
       return {
         module: moduleName,
-        paths: paths.map((path11) => relative7(projectRoot, path11)),
+        paths: paths.map((path11) => relative10(projectRoot, path11)),
         content
       };
     })
   );
 }
 async function loadTests(projectRoot, focusModules = []) {
-  const files = (await fg9(["tests/**/*.{ts,tsx,js,jsx,php,dart}", "src/**/*.{test,spec}.{ts,tsx,js,jsx}"], {
+  const files = (await fg15(["tests/**/*.{ts,tsx,js,jsx,php,dart}", "src/**/*.{test,spec}.{ts,tsx,js,jsx}"], {
     cwd: projectRoot,
     onlyFiles: true,
     absolute: true
@@ -14449,8 +14890,8 @@ async function loadTests(projectRoot, focusModules = []) {
   ) : files;
   return Promise.all(
     filtered.map(async (path11) => ({
-      path: relative7(projectRoot, path11),
-      content: await readFile28(path11, "utf8").catch(() => "")
+      path: relative10(projectRoot, path11),
+      content: await readFile36(path11, "utf8").catch(() => "")
     }))
   );
 }
@@ -14472,7 +14913,7 @@ function inferSourceArtifacts(baseDir, scriptResults) {
   return [
     ...new Set(
       artifacts.map(
-        (artifact) => artifact.startsWith(".") ? artifact : relative7(dirname20(baseDir), join50(dirname20(baseDir), artifact))
+        (artifact) => artifact.startsWith(".") ? artifact : relative10(dirname21(baseDir), join61(dirname21(baseDir), artifact))
       )
     )
   ];
@@ -14546,11 +14987,11 @@ var PentestProgressTracker = class {
     };
   }
   async load(projectRoot, runId) {
-    const target = join51(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "progress.json");
+    const target = join62(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "progress.json");
     if (!existsSync23(target)) {
       return null;
     }
-    const parsed = JSON.parse(await readFile29(target, "utf8"));
+    const parsed = JSON.parse(await readFile37(target, "utf8"));
     const validation = this.validator.validate("pentest-progress", parsed);
     if (!validation.valid) {
       throw new Error(validation.errors.map((error) => error.message).join("; "));
@@ -14558,10 +14999,10 @@ var PentestProgressTracker = class {
     return parsed;
   }
   async save(projectRoot, progress) {
-    const target = join51(projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "progress.json");
+    const target = join62(projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "progress.json");
     progress.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir22(dirname21(target), { recursive: true });
-    await writeFile22(target, `${JSON.stringify(progress, null, 2)}
+    await mkdir27(dirname22(target), { recursive: true });
+    await writeFile27(target, `${JSON.stringify(progress, null, 2)}
 `);
   }
   markStepRunning(progress, stepId, inputHash) {
@@ -14617,11 +15058,11 @@ var PentestProgressTracker = class {
     return step.status === "completed" && step.input_hash === inputHash;
   }
   async findIncompleteRun(projectRoot, workflow, sourceReportPath) {
-    const runsDir = join51(projectRoot, PATHS.PENTEST_RUNS_DIR);
+    const runsDir = join62(projectRoot, PATHS.PENTEST_RUNS_DIR);
     if (!existsSync23(runsDir)) {
       return null;
     }
-    const entries = (await readdir8(runsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().reverse();
+    const entries = (await readdir9(runsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().reverse();
     for (const runId of entries) {
       const progress = await this.load(projectRoot, runId);
       if (progress === null) {
@@ -14660,10 +15101,10 @@ var PentestProgressTracker = class {
   }
 };
 function runArtifactsDir(projectRoot, runId) {
-  return join51(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "artifacts");
+  return join62(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "artifacts");
 }
 function runLogsDir(projectRoot, runId) {
-  return join51(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "logs");
+  return join62(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "logs");
 }
 
 // src/pipeline/index.ts
@@ -14672,21 +15113,61 @@ init_esm_shims();
 // src/pipeline/classifier.ts
 init_esm_shims();
 
+// src/pipeline/confidence-scorer.ts
+init_esm_shims();
+
+// src/pipeline/post-classifier.ts
+init_esm_shims();
+import { mkdir as mkdir28, readFile as readFile38, readdir as readdir10, writeFile as writeFile28 } from "fs/promises";
+import { join as join63 } from "path";
+init_paths();
+
+// src/pipeline/pre-classifier.ts
+init_esm_shims();
+
+// src/pipeline/context-budget-estimator.ts
+init_esm_shims();
+
+// src/pipeline/delta-detector.ts
+init_esm_shims();
+
+// src/pipeline/impact-resolver.ts
+init_esm_shims();
+
+// src/pipeline/module-resolver.ts
+init_esm_shims();
+init_chunk_index();
+init_service();
+import { existsSync as existsSync24 } from "fs";
+import { readdir as readdir11 } from "fs/promises";
+import { basename as basename9, join as join64, relative as relative11 } from "path";
+
+// src/pipeline/rule-trigger-matcher.ts
+init_esm_shims();
+
+// src/pipeline/scope-resolver.ts
+init_esm_shims();
+import { readFile as readFile39 } from "fs/promises";
+import { join as join65, relative as relative12 } from "path";
+
+// src/pipeline/llm-skip-evaluator.ts
+init_esm_shims();
+
 // src/pipeline/lane-runner.ts
 init_esm_shims();
 init_paths();
 init_runtime_paths();
-import { existsSync as existsSync27 } from "fs";
-import { mkdir as mkdir28, readFile as readFile37, rename as rename3, writeFile as writeFile28 } from "fs/promises";
-import { dirname as dirname26, join as join63 } from "path";
-import { basename as basename7, dirname as pathDirname } from "pathe";
-import fg12 from "fast-glob";
+import { existsSync as existsSync28 } from "fs";
+import { mkdir as mkdir34, readFile as readFile47, rename as rename3, writeFile as writeFile34 } from "fs/promises";
+import { dirname as dirname27, join as join77 } from "path";
+import { basename as basename10, dirname as pathDirname } from "pathe";
+import fg18 from "fast-glob";
 init_project_profile();
 
 // src/workflows/engine.ts
 init_esm_shims();
-import { readFile as readFile30, writeFile as writeFile23, mkdir as mkdir23 } from "fs/promises";
-import { join as join52, dirname as dirname22 } from "path";
+import { readFile as readFile40, writeFile as writeFile29, mkdir as mkdir29 } from "fs/promises";
+import { join as join66, dirname as dirname23 } from "path";
 import { randomUUID } from "crypto";
 
 // src/workflows/template-validator.ts
@@ -14727,7 +15208,30 @@ function createFailResult(phase, summary, context) {
 var ClassifyPhase = class {
   phase = "request-classification";
   async execute(context) {
-    return createPassResult(this.phase, "Classification confirmed", context);
+    const confidence = context.classification.classification_confidence;
+    const resolutionMap = context.classification.resolution_map;
+    if (confidence === void 0) {
+      return createPassResult(
+        this.phase,
+        "Classification confirmed (legacy result without confidence metadata)",
+        context
+      );
+    }
+    if (confidence < 0.5) {
+      return createPassResult(
+        this.phase,
+        "Classification confidence below 0.5; treat downstream planning as tentative",
+        context
+      );
+    }
+    const guessedCount = Object.values(resolutionMap ?? {}).filter(
+      (source) => source === "llm-guessed"
+    ).length;
+    return createPassResult(
+      this.phase,
+      guessedCount > 0 ? `Classification confirmed with ${guessedCount} tentative dimension(s)` : "Classification confirmed",
+      context
+    );
   }
 };
 
@@ -14860,16 +15364,16 @@ init_esm_shims();
 
 // src/workflows/pentest.ts
 init_esm_shims();
-import { mkdir as mkdir24, writeFile as writeFile24 } from "fs/promises";
-import { join as join55, relative as relative8 } from "path";
+import { mkdir as mkdir30, writeFile as writeFile30 } from "fs/promises";
+import { join as join69, relative as relative13 } from "path";
 init_paths();
 
 // src/pentest/findings.ts
 init_esm_shims();
-import { existsSync as existsSync24 } from "fs";
-import { readFile as readFile31 } from "fs/promises";
-import { join as join53 } from "path";
-import { createHash as createHash10 } from "crypto";
+import { existsSync as existsSync25 } from "fs";
+import { readFile as readFile41 } from "fs/promises";
+import { join as join67 } from "path";
+import { createHash as createHash12 } from "crypto";
 function createFinding(input3) {
   return {
     id: "",
@@ -15296,11 +15800,11 @@ function buildModuleFindings(docs, tests) {
   return findings;
 }
 async function buildSecretFindings(artifactDir) {
-  const path11 = join53(artifactDir, "secrets", "matches.txt");
-  if (!existsSync24(path11)) {
+  const path11 = join67(artifactDir, "secrets", "matches.txt");
+  if (!existsSync25(path11)) {
     return [];
   }
-  const matches = parseSecretMatches(await readFile31(path11, "utf8"));
+  const matches = parseSecretMatches(await readFile41(path11, "utf8"));
   return matches.map(
     (match, index) => createFinding({
       title: `Potential secret exposure match ${index + 1}`,
@@ -15433,12 +15937,12 @@ function findingFingerprint(finding) {
     runtime_required: finding.runtime_required,
     manual_follow_up: finding.manual_follow_up
   });
-  return createHash10("sha1").update(payload).digest("hex").slice(0, 8).toUpperCase();
+  return createHash12("sha1").update(payload).digest("hex").slice(0, 8).toUpperCase();
 }
 async function readNativeAuditFindings(artifactDir) {
   const findings = [];
-  const dependencyDir = join53(artifactDir, "dependencies");
-  const npmAudit = await readJsonMaybe(join53(dependencyDir, "npm-audit.json"));
+  const dependencyDir = join67(artifactDir, "dependencies");
+  const npmAudit = await readJsonMaybe(join67(dependencyDir, "npm-audit.json"));
   for (const [name, vulnerability] of Object.entries(npmAudit?.vulnerabilities ?? {})) {
     const via = (vulnerability.via ?? []).find((entry) => typeof entry === "object");
     findings.push({
@@ -15450,7 +15954,7 @@ async function readNativeAuditFindings(artifactDir) {
       details: via?.url ?? ""
     });
   }
-  const pnpmAudit = await readJsonMaybe(join53(dependencyDir, "pnpm-audit.json"));
+  const pnpmAudit = await readJsonMaybe(join67(dependencyDir, "pnpm-audit.json"));
   for (const advisory of Object.values(pnpmAudit?.advisories ?? {})) {
     findings.push({
       package_name: advisory.module_name ?? "unknown",
@@ -15461,7 +15965,7 @@ async function readNativeAuditFindings(artifactDir) {
       details: advisory.overview ?? ""
     });
   }
-  const composerAudit = await readJsonMaybe(join53(dependencyDir, "composer-audit.json"));
+  const composerAudit = await readJsonMaybe(join67(dependencyDir, "composer-audit.json"));
   if (Array.isArray(composerAudit?.advisories)) {
     for (const advisory of composerAudit.advisories) {
       findings.push({
@@ -15498,11 +16002,11 @@ async function readNativeAuditFindings(artifactDir) {
   });
 }
 async function readJsonMaybe(path11) {
-  if (!existsSync24(path11)) {
+  if (!existsSync25(path11)) {
     return null;
   }
   try {
-    return JSON.parse(await readFile31(path11, "utf8"));
+    return JSON.parse(await readFile41(path11, "utf8"));
   } catch {
     return null;
   }
@@ -15599,9 +16103,9 @@ var FileCheckMapper = class {
 
 // src/pentest/incremental-scanner.ts
 init_esm_shims();
-import { readFile as readFile32 } from "fs/promises";
-import { join as join54 } from "path";
-import { createHash as createHash11 } from "crypto";
+import { readFile as readFile42 } from "fs/promises";
+import { join as join68 } from "path";
+import { createHash as createHash13 } from "crypto";
 import { execa as execa3 } from "execa";
 var IncrementalScanner = class {
   constructor(mapper) {
@@ -15638,10 +16142,10 @@ var IncrementalScanner = class {
     }
   }
   async gitDiff(projectRoot, lastRunId) {
-    const progressPath = join54(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
+    const progressPath = join68(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
     let baseCommit;
     try {
-      const raw = await readFile32(progressPath, "utf8");
+      const raw = await readFile42(progressPath, "utf8");
       const progress = JSON.parse(raw);
       baseCommit = progress.git_commit;
     } catch {
@@ -15655,10 +16159,10 @@ var IncrementalScanner = class {
     return result.stdout.split("\n").map((f) => f.trim()).filter(Boolean);
   }
   async hashDiff(projectRoot, lastRunId) {
-    const manifestPath = join54(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
+    const manifestPath = join68(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
     let fileManifest = {};
     try {
-      const raw = await readFile32(manifestPath, "utf8");
+      const raw = await readFile42(manifestPath, "utf8");
       const progress = JSON.parse(raw);
       fileManifest = progress.file_hashes ?? {};
     } catch {
@@ -15667,8 +16171,8 @@ var IncrementalScanner = class {
     const changed = [];
     for (const [filePath, storedHash] of Object.entries(fileManifest)) {
       try {
-        const content = await readFile32(join54(projectRoot, filePath), "utf8");
-        const currentHash = createHash11("sha256").update(content).digest("hex");
+        const content = await readFile42(join68(projectRoot, filePath), "utf8");
+        const currentHash = createHash13("sha256").update(content).digest("hex");
         if (currentHash !== storedHash) {
           changed.push(filePath);
         }
@@ -15680,13 +16184,13 @@ var IncrementalScanner = class {
   }
   async warnIfFullScanStale(projectRoot, thresholdDays) {
     try {
-      const runsDir = join54(projectRoot, ".paqad", "pentest", "runs");
-      const { readdir: readdir10 } = await import("fs/promises");
-      const runs = await readdir10(runsDir).catch(() => []);
+      const runsDir = join68(projectRoot, ".paqad", "pentest", "runs");
+      const { readdir: readdir13 } = await import("fs/promises");
+      const runs = await readdir13(runsDir).catch(() => []);
       for (const run of runs.sort().reverse()) {
-        const progressPath = join54(runsDir, run, "progress.json");
+        const progressPath = join68(runsDir, run, "progress.json");
         try {
-          const raw = await readFile32(progressPath, "utf8");
+          const raw = await readFile42(progressPath, "utf8");
           const progress = JSON.parse(raw);
           if (!progress.incremental_type || progress.incremental_type === "full") {
             const startedAt = new Date(progress.started_at ?? 0);
@@ -15872,8 +16376,8 @@ var PentestWorkflow = class {
     await this.tracker.save(options.projectRoot, progress);
     const artifactsDir = runArtifactsDir(options.projectRoot, progress.run_id);
     const logsDir = runLogsDir(options.projectRoot, progress.run_id);
-    await mkdir24(artifactsDir, { recursive: true });
-    await mkdir24(logsDir, { recursive: true });
+    await mkdir30(artifactsDir, { recursive: true });
+    await mkdir30(logsDir, { recursive: true });
     const blockedChecks = [];
     const contextHash = await hashRelevantInputs(options.projectRoot, "pentest", {
       focus_modules: focusModules
@@ -15883,8 +16387,8 @@ var PentestWorkflow = class {
       await this.tracker.save(options.projectRoot, progress);
       const docs = await loadModuleDocs(options.projectRoot, focusModules);
       const tests = await loadTests(options.projectRoot, focusModules);
-      const docsPath = join55(artifactsDir, "docs-summary.json");
-      const testsPath = join55(artifactsDir, "tests-summary.json");
+      const docsPath = join69(artifactsDir, "docs-summary.json");
+      const testsPath = join69(artifactsDir, "tests-summary.json");
       await writeJson(docsPath, docs);
       await writeJson(
         testsPath,
@@ -15896,7 +16400,7 @@ var PentestWorkflow = class {
       this.tracker.markStepCompleted(
         progress,
         "collect-context",
-        [relative8(options.projectRoot, docsPath), relative8(options.projectRoot, testsPath)],
+        [relative13(options.projectRoot, docsPath), relative13(options.projectRoot, testsPath)],
         [...PENTEST_SKILLS.context].map(skillPath)
       );
       await this.tracker.save(options.projectRoot, progress);
@@ -15985,7 +16489,7 @@ var PentestWorkflow = class {
         progressRunId: progress.run_id,
         reportTimestamp: new Date(progress.started_at)
       });
-      const findingIndexPath = join55(
+      const findingIndexPath = join69(
         options.projectRoot,
         PATHS.PENTEST_RUNS_DIR,
         progress.run_id,
@@ -15995,14 +16499,14 @@ var PentestWorkflow = class {
       this.tracker.markStepCompleted(
         progress,
         "synthesize-findings",
-        [relative8(options.projectRoot, findingIndexPath), ...report.raw_evidence_paths],
+        [relative13(options.projectRoot, findingIndexPath), ...report.raw_evidence_paths],
         [...PENTEST_SKILLS.normalize].map(skillPath)
       );
       await this.tracker.save(options.projectRoot, progress);
     }
     if (report === null) {
       const existingSidecar = progress.sidecar_path ? await readJsonIfExists(
-        join55(options.projectRoot, progress.sidecar_path)
+        join69(options.projectRoot, progress.sidecar_path)
       ) : null;
       report = existingSidecar;
     }
@@ -16017,18 +16521,18 @@ var PentestWorkflow = class {
       this.tracker.markStepRunning(progress, "write-report", writeHash);
       await this.tracker.save(options.projectRoot, progress);
       await writeJson(
-        join55(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "report-preview.json"),
+        join69(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "report-preview.json"),
         { report_id: report.report_id, findings: report.findings.length }
       );
-      await writeJson(join55(options.projectRoot, report.sidecar_path), report);
+      await writeJson(join69(options.projectRoot, report.sidecar_path), report);
       await writeJson(
-        join55(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "blocked-checks.json"),
+        join69(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "blocked-checks.json"),
         report.blocked_checks
       );
-      await mkdir24(join55(options.projectRoot, PATHS.PENTEST_DIR), { recursive: true });
+      await mkdir30(join69(options.projectRoot, PATHS.PENTEST_DIR), { recursive: true });
       const markdown = buildPentestMarkdown(report);
-      await writeJson(join55(options.projectRoot, report.sidecar_path), report);
-      await writeFile24(join55(options.projectRoot, report.report_path), markdown);
+      await writeJson(join69(options.projectRoot, report.sidecar_path), report);
+      await writeFile30(join69(options.projectRoot, report.report_path), markdown);
       this.tracker.markStepCompleted(
         progress,
         "write-report",
@@ -16055,7 +16559,7 @@ async function buildCurrentPentestReport(input3) {
   const docs = await loadModuleDocs(input3.projectRoot, input3.focusModules);
   const tests = await loadTests(input3.projectRoot, input3.focusModules);
   const osvFindings = await queryOsv(input3.snapshot.packages);
-  const osvPath = join55(input3.artifactsDir, "dependencies", "osv-results.json");
+  const osvPath = join69(input3.artifactsDir, "dependencies", "osv-results.json");
   await writeJson(osvPath, osvFindings);
   const dependencyFindings = await buildDependencyFindings(
     input3.snapshot,
@@ -16064,7 +16568,7 @@ async function buildCurrentPentestReport(input3) {
   );
   const moduleFindings = buildModuleFindings(docs, tests);
   const secretFindings = await buildSecretFindings(input3.artifactsDir);
-  const runtimePayload = await readJsonIfExists(join55(input3.artifactsDir, "runtime", "runtime-checks.json"));
+  const runtimePayload = await readJsonIfExists(join69(input3.artifactsDir, "runtime", "runtime-checks.json"));
   const runtimeStatus = input3.targetUrl ? runtimePayload?.reachable ? {
     target_url: input3.targetUrl,
     status: "reachable",
@@ -16090,8 +16594,8 @@ async function buildCurrentPentestReport(input3) {
     ...runtimeFindings
   ]);
   const timestamp = toLocalTimestamp(input3.reportTimestamp);
-  const reportPath = join55(PATHS.PENTEST_DIR, `${timestamp}.md`);
-  const sidecarPath = join55(PATHS.PENTEST_DIR, `${timestamp}.json`);
+  const reportPath = join69(PATHS.PENTEST_DIR, `${timestamp}.md`);
+  const sidecarPath = join69(PATHS.PENTEST_DIR, `${timestamp}.json`);
   const stack = getPrimaryStack({
     routing: { domain: "coding" },
     stack_profile: input3.snapshot.profile
@@ -16142,11 +16646,11 @@ async function buildCurrentPentestReport(input3) {
     ],
     next_remediation_priorities: remediationPriorities(findings),
     raw_evidence_paths: [
-      relative8(input3.projectRoot, osvPath),
+      relative13(input3.projectRoot, osvPath),
       ...[
-        join55(PATHS.PENTEST_RUNS_DIR, input3.progressRunId, "finding-index.json"),
-        join55(PATHS.PENTEST_RUNS_DIR, input3.progressRunId, "artifacts", "docs-summary.json"),
-        join55(PATHS.PENTEST_RUNS_DIR, input3.progressRunId, "artifacts", "tests-summary.json")
+        join69(PATHS.PENTEST_RUNS_DIR, input3.progressRunId, "finding-index.json"),
+        join69(PATHS.PENTEST_RUNS_DIR, input3.progressRunId, "artifacts", "docs-summary.json"),
+        join69(PATHS.PENTEST_RUNS_DIR, input3.progressRunId, "artifacts", "tests-summary.json")
       ]
     ]
   };
@@ -16190,8 +16694,8 @@ init_esm_shims();
 // src/workflows/pentest-retest.ts
 init_esm_shims();
 init_paths();
-import { mkdir as mkdir25, writeFile as writeFile25 } from "fs/promises";
-import { dirname as dirname23, join as join56 } from "path";
+import { mkdir as mkdir31, writeFile as writeFile31 } from "fs/promises";
+import { dirname as dirname24, join as join70 } from "path";
 var RETEST_STEPS = [
   { id: "load-source-report", title: "Load source pentest report" },
   { id: "rerun-evidence", title: "Collect fresh evidence for source findings" },
@@ -16212,7 +16716,7 @@ var PentestRetestWorkflow = class {
     }
     const normalizedSourcePath = normalizeSidecarPath(sourceReportPath);
     const sourceSidecar = await readJsonIfExists(
-      join56(options.projectRoot, normalizedSourcePath)
+      join70(options.projectRoot, normalizedSourcePath)
     );
     if (sourceSidecar === null) {
       throw new Error(`Source pentest sidecar not found at ${normalizedSourcePath}`);
@@ -16237,12 +16741,12 @@ var PentestRetestWorkflow = class {
     if (!this.tracker.shouldSkipStep(progress, "load-source-report", sourceHash)) {
       this.tracker.markStepRunning(progress, "load-source-report", sourceHash);
       await this.tracker.save(options.projectRoot, progress);
-      const sourceCopy = join56(artifactsDir, "source-report.json");
+      const sourceCopy = join70(artifactsDir, "source-report.json");
       await writeJson(sourceCopy, sourceSidecar);
       this.tracker.markStepCompleted(
         progress,
         "load-source-report",
-        [join56(PATHS.PENTEST_RUNS_DIR, progress.run_id, "artifacts", "source-report.json")],
+        [join70(PATHS.PENTEST_RUNS_DIR, progress.run_id, "artifacts", "source-report.json")],
         [...RETEST_SKILLS.source].map(skillPath)
       );
       await this.tracker.save(options.projectRoot, progress);
@@ -16259,7 +16763,7 @@ var PentestRetestWorkflow = class {
         PENTEST_RUN_ID: progress.run_id,
         PENTEST_ARTIFACT_DIR: artifactsDir,
         PENTEST_TARGET_URL: targetUrl ?? "",
-        PENTEST_SOURCE_REPORT: join56(options.projectRoot, normalizedSourcePath),
+        PENTEST_SOURCE_REPORT: join70(options.projectRoot, normalizedSourcePath),
         PENTEST_DB_CONNECTION_NAME: options.dbConnectionName ?? ""
       };
       const scriptResults = await Promise.all([
@@ -16308,8 +16812,8 @@ var PentestRetestWorkflow = class {
         ...currentReport,
         report_id: toReportId("RETEST", new Date(progress.started_at)),
         workflow: "pentest-retest",
-        report_path: join56(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.md`),
-        sidecar_path: join56(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.json`),
+        report_path: join70(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.md`),
+        sidecar_path: join70(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.json`),
         source_report_path: normalizedSourcePath,
         source_report_id: sourceSidecar.report_id,
         findings: retestFindings,
@@ -16322,7 +16826,7 @@ var PentestRetestWorkflow = class {
           ...[...RETEST_SKILLS.source, ...RETEST_SKILLS.evaluate].map(skillPath)
         ]
       };
-      const findingIndexPath = join56(
+      const findingIndexPath = join70(
         options.projectRoot,
         PATHS.PENTEST_RUNS_DIR,
         progress.run_id,
@@ -16332,14 +16836,14 @@ var PentestRetestWorkflow = class {
       this.tracker.markStepCompleted(
         progress,
         "evaluate-source-findings",
-        [join56(PATHS.PENTEST_RUNS_DIR, progress.run_id, "finding-index.json")],
+        [join70(PATHS.PENTEST_RUNS_DIR, progress.run_id, "finding-index.json")],
         [...RETEST_SKILLS.evaluate].map(skillPath)
       );
       await this.tracker.save(options.projectRoot, progress);
     }
     if (retestReport === null) {
       const existing = progress.sidecar_path ? await readJsonIfExists(
-        join56(options.projectRoot, progress.sidecar_path)
+        join70(options.projectRoot, progress.sidecar_path)
       ) : null;
       retestReport = existing;
     }
@@ -16353,12 +16857,12 @@ var PentestRetestWorkflow = class {
     if (!this.tracker.shouldSkipStep(progress, "write-report", writeHash)) {
       this.tracker.markStepRunning(progress, "write-report", writeHash);
       await this.tracker.save(options.projectRoot, progress);
-      await writeJson(join56(options.projectRoot, retestReport.sidecar_path), retestReport);
-      await mkdir25(dirname23(join56(options.projectRoot, retestReport.report_path)), {
+      await writeJson(join70(options.projectRoot, retestReport.sidecar_path), retestReport);
+      await mkdir31(dirname24(join70(options.projectRoot, retestReport.report_path)), {
         recursive: true
       });
-      await writeFile25(
-        join56(options.projectRoot, retestReport.report_path),
+      await writeFile31(
+        join70(options.projectRoot, retestReport.report_path),
         buildPentestMarkdown(retestReport)
       );
       this.tracker.markStepCompleted(
@@ -16421,8 +16925,8 @@ var PentestRetestPhase = class {
 
 // src/pipeline/phases/question-answering.ts
 init_esm_shims();
-import { mkdir as mkdir26, rename as rename2, writeFile as writeFile26 } from "fs/promises";
-import { dirname as dirname24, join as join59 } from "path";
+import { mkdir as mkdir32, rename as rename2, writeFile as writeFile32 } from "fs/promises";
+import { dirname as dirname25, join as join73 } from "path";
 init_paths();
 
 // src/project-knowledge/index.ts
@@ -16434,9 +16938,9 @@ init_esm_shims();
 // src/project-knowledge/evidence-retriever.ts
 init_esm_shims();
 init_service();
-import { readFile as readFile33 } from "fs/promises";
-import { join as join57 } from "path";
-import fg10 from "fast-glob";
+import { readFile as readFile43 } from "fs/promises";
+import { join as join71 } from "path";
+import fg16 from "fast-glob";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "a",
   "an",
@@ -16598,17 +17102,17 @@ var EvidenceRetriever = class {
   async retrieveLexicalEvidence(query, keywords) {
     const candidates = [];
     for (const { pattern, source_class } of EVIDENCE_PATTERNS) {
-      const paths = await fg10(pattern, {
+      const paths = await fg16(pattern, {
         cwd: query.project_root,
         absolute: false,
         dot: true
       });
       for (const relativePath of paths) {
-        const absolutePath = join57(query.project_root, relativePath);
+        const absolutePath = join71(query.project_root, relativePath);
         let excerpt = "";
         let score = 0;
         try {
-          const content = await readFile33(absolutePath, "utf8");
+          const content = await readFile43(absolutePath, "utf8");
           score = scoreFile(relativePath, content, keywords);
           if (score <= 0) {
             continue;
@@ -16628,18 +17132,18 @@ var EvidenceRetriever = class {
 
 // src/project-knowledge/freshness-checker.ts
 init_esm_shims();
-import { readFile as readFile34, stat as stat6 } from "fs/promises";
-import { join as join58 } from "path";
+import { readFile as readFile44, stat as stat6 } from "fs/promises";
+import { join as join72 } from "path";
 var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
 var UNKNOWN_NOTE = "Documentation freshness unknown \u2014 run paqad-ai onboard to establish baseline";
 var FreshnessChecker = class {
   async check(projectRoot, evidencePaths) {
-    const docProgressPath = join58(projectRoot, ".paqad", "doc-progress.json");
-    const stackDriftPath = join58(projectRoot, ".paqad", "stack-drift.json");
+    const docProgressPath = join72(projectRoot, ".paqad", "doc-progress.json");
+    const stackDriftPath = join72(projectRoot, ".paqad", "stack-drift.json");
     let generatedAt;
     let note;
     try {
-      const raw = await readFile34(docProgressPath, "utf8");
+      const raw = await readFile44(docProgressPath, "utf8");
       const parsed = JSON.parse(raw);
       generatedAt = parsed.generated_at;
     } catch {
@@ -16647,7 +17151,7 @@ var FreshnessChecker = class {
     }
     let driftDetected = false;
     try {
-      const raw = await readFile34(stackDriftPath, "utf8");
+      const raw = await readFile44(stackDriftPath, "utf8");
       const parsed = JSON.parse(raw);
       driftDetected = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && Object.keys(parsed).length > 0;
     } catch {
@@ -16656,7 +17160,7 @@ var FreshnessChecker = class {
     if (generatedAt) {
       const baseTime = new Date(generatedAt).getTime();
       for (const relativePath of evidencePaths) {
-        const absolutePath = join58(projectRoot, relativePath);
+        const absolutePath = join72(projectRoot, relativePath);
         try {
           const info = await stat6(absolutePath);
           const ageDiff = info.mtimeMs - baseTime;
@@ -16878,10 +17382,10 @@ var ProjectQuestionPhase = class {
       project_root: context.project_root
     });
     const answerArtifactPath = PATHS.PROJECT_QUESTION_ANSWER;
-    const target = join59(context.project_root, answerArtifactPath);
-    await mkdir26(dirname24(target), { recursive: true });
+    const target = join73(context.project_root, answerArtifactPath);
+    await mkdir32(dirname25(target), { recursive: true });
     const tmp = `${target}.tmp`;
-    await writeFile26(tmp, `${JSON.stringify(answer, null, 2)}
+    await writeFile32(tmp, `${JSON.stringify(answer, null, 2)}
 `, "utf8");
     await rename2(tmp, target);
     return createPassResult(
@@ -16899,8 +17403,8 @@ init_esm_shims();
 // src/workflows/root-cause-analysis.ts
 init_esm_shims();
 init_paths();
-import { mkdir as mkdir27, writeFile as writeFile27 } from "fs/promises";
-import { dirname as dirname25, join as join60 } from "path";
+import { mkdir as mkdir33, writeFile as writeFile33 } from "fs/promises";
+import { dirname as dirname26, join as join74 } from "path";
 var DEFAULT_TITLE_SLUG = "root-cause-analysis";
 var RCA_SECTIONS = [
   "Summary",
@@ -16919,10 +17423,10 @@ var RootCauseAnalysisWorkflow = class {
   async run(options) {
     const title = deriveTitle(options.classification.request_text);
     const filename = `${toLocalTimestamp2(/* @__PURE__ */ new Date())}-${slugify2(title) || DEFAULT_TITLE_SLUG}.md`;
-    const relativePath = join60(PATHS.RCA_DIR, filename);
-    const outputPath = join60(options.projectRoot, relativePath);
-    await mkdir27(dirname25(outputPath), { recursive: true });
-    await writeFile27(outputPath, buildRcaDocument(title, options.classification));
+    const relativePath = join74(PATHS.RCA_DIR, filename);
+    const outputPath = join74(options.projectRoot, relativePath);
+    await mkdir33(dirname26(outputPath), { recursive: true });
+    await writeFile33(outputPath, buildRcaDocument(title, options.classification));
     return {
       output_path: relativePath,
       title
@@ -17736,9 +18240,9 @@ var DatabaseQualityGate = class {
 
 // src/verification/gates/documentation-freshness.ts
 init_esm_shims();
-import { existsSync as existsSync25 } from "fs";
-import { readFile as readFile35 } from "fs/promises";
-import { join as join61 } from "path";
+import { existsSync as existsSync26 } from "fs";
+import { readFile as readFile45 } from "fs/promises";
+import { join as join75 } from "path";
 
 // src/validators/index.ts
 init_esm_shims();
@@ -17865,7 +18369,7 @@ var DocumentationFreshnessGate = class {
 async function collectApiDocFailures(projectRoot, modules) {
   const failures = [];
   for (const moduleName of modules) {
-    const modulePath = join61(projectRoot, "docs", "modules", moduleName);
+    const modulePath = join75(projectRoot, "docs", "modules", moduleName);
     const result = await checkApiDocs(modulePath);
     if (!result.passed) {
       failures.push(result.detail);
@@ -17876,7 +18380,7 @@ async function collectApiDocFailures(projectRoot, modules) {
 async function collectIntegrationDocFailures(projectRoot, modules) {
   const failures = [];
   for (const moduleName of modules) {
-    const modulePath = join61(projectRoot, "docs", "modules", moduleName);
+    const modulePath = join75(projectRoot, "docs", "modules", moduleName);
     const result = await checkIntegrationDocs(modulePath);
     if (!result.passed) {
       failures.push(result.detail);
@@ -17887,7 +18391,7 @@ async function collectIntegrationDocFailures(projectRoot, modules) {
 async function collectErrorCatalogFailures(projectRoot, modules) {
   const failures = [];
   for (const moduleName of modules) {
-    const modulePath = join61(projectRoot, "docs", "modules", moduleName);
+    const modulePath = join75(projectRoot, "docs", "modules", moduleName);
     const result = await checkErrorCatalog(modulePath);
     if (!result.passed) {
       failures.push(result.detail);
@@ -17896,10 +18400,10 @@ async function collectErrorCatalogFailures(projectRoot, modules) {
   return failures;
 }
 async function checkApiDocs(modulePath) {
-  const endpointsPath = join61(modulePath, "api", "endpoints.md");
-  const endpointsExists = existsSync25(endpointsPath);
-  const schemasExists = existsSync25(join61(modulePath, "api", "schemas.md"));
-  const errorCodesExists = existsSync25(join61(modulePath, "api", "error-codes.md"));
+  const endpointsPath = join75(modulePath, "api", "endpoints.md");
+  const endpointsExists = existsSync26(endpointsPath);
+  const schemasExists = existsSync26(join75(modulePath, "api", "schemas.md"));
+  const errorCodesExists = existsSync26(join75(modulePath, "api", "error-codes.md"));
   if (!endpointsExists || !schemasExists || !errorCodesExists) {
     return {
       passed: false,
@@ -17910,7 +18414,7 @@ async function checkApiDocs(modulePath) {
       ].filter(Boolean).join(", ")}`
     };
   }
-  const endpointsValidation = validateApiDoc(await readFile35(endpointsPath, "utf8"));
+  const endpointsValidation = validateApiDoc(await readFile45(endpointsPath, "utf8"));
   if (!endpointsValidation.valid) {
     return {
       passed: false,
@@ -17920,8 +18424,8 @@ async function checkApiDocs(modulePath) {
   return { passed: true, detail: "API docs present" };
 }
 async function checkIntegrationDocs(modulePath) {
-  const eventsExists = existsSync25(join61(modulePath, "integration", "events.md"));
-  const contractsExists = existsSync25(join61(modulePath, "integration", "contracts.md"));
+  const eventsExists = existsSync26(join75(modulePath, "integration", "events.md"));
+  const contractsExists = existsSync26(join75(modulePath, "integration", "contracts.md"));
   if (!eventsExists || !contractsExists) {
     return {
       passed: false,
@@ -17934,15 +18438,15 @@ async function checkIntegrationDocs(modulePath) {
   return { passed: true, detail: "Integration docs present" };
 }
 async function checkErrorCatalog(modulePath) {
-  const catalogPath = join61(modulePath, "error-catalog.md");
-  const catalogExists = existsSync25(catalogPath);
+  const catalogPath = join75(modulePath, "error-catalog.md");
+  const catalogExists = existsSync26(catalogPath);
   if (!catalogExists) {
     return {
       passed: false,
       detail: `Missing error-catalog.md in ${modulePath}`
     };
   }
-  const validation = validateErrorCatalogMarkdown(await readFile35(catalogPath, "utf8"));
+  const validation = validateErrorCatalogMarkdown(await readFile45(catalogPath, "utf8"));
   if (!validation.valid) {
     return {
       passed: false,
@@ -17954,8 +18458,8 @@ async function checkErrorCatalog(modulePath) {
 function collectMissingDocs(projectRoot, modules, segments) {
   return modules.map((moduleName) => ({
     moduleName,
-    path: join61(projectRoot, "docs", "modules", moduleName, ...segments)
-  })).filter((entry) => !existsSync25(entry.path)).map((entry) => `${entry.moduleName}:${segments.join("/")}`);
+    path: join75(projectRoot, "docs", "modules", moduleName, ...segments)
+  })).filter((entry) => !existsSync26(entry.path)).map((entry) => `${entry.moduleName}:${segments.join("/")}`);
 }
 function isStale2(input3) {
   const parsed = Date.parse(input3);
@@ -18130,10 +18634,10 @@ init_esm_shims();
 // src/pipeline/workflow-router.ts
 init_esm_shims();
 init_runtime_paths();
-import { readFile as readFile36 } from "fs/promises";
-import { existsSync as existsSync26 } from "fs";
-import { join as join62, relative as relative9 } from "path";
-import fg11 from "fast-glob";
+import { readFile as readFile46 } from "fs/promises";
+import { existsSync as existsSync27 } from "fs";
+import { join as join76, relative as relative14 } from "path";
+import fg17 from "fast-glob";
 init_project_profile();
 
 // src/pipeline/lane-runner.ts
@@ -18160,17 +18664,17 @@ init_esm_shims();
 
 // src/pipeline/stream-truncator.ts
 init_esm_shims();
-import { appendFile, mkdir as mkdir29 } from "fs/promises";
-import { join as join64, dirname as dirname27 } from "path";
+import { appendFile, mkdir as mkdir35 } from "fs/promises";
+import { join as join78, dirname as dirname28 } from "path";
 
 // src/resolver/index.ts
 init_esm_shims();
 
 // src/resolver/deduplicator.ts
 init_esm_shims();
-import { createHash as createHash12 } from "crypto";
-import { readFile as readFile38, writeFile as writeFile29, mkdir as mkdir30 } from "fs/promises";
-import { join as join65, dirname as dirname28 } from "path";
+import { createHash as createHash14 } from "crypto";
+import { readFile as readFile48, writeFile as writeFile35, mkdir as mkdir36 } from "fs/promises";
+import { join as join79, dirname as dirname29 } from "path";
 
 // src/rag/index.ts
 init_esm_shims();
@@ -18269,8 +18773,8 @@ init_esm_shims();
 // src/scripts/generator.ts
 init_esm_shims();
 import { chmodSync as chmodSync3 } from "fs";
-import { mkdir as mkdir31, writeFile as writeFile30 } from "fs/promises";
-import { dirname as dirname29, join as join66 } from "path";
+import { mkdir as mkdir37, writeFile as writeFile36 } from "fs/promises";
+import { dirname as dirname30, join as join80 } from "path";
 init_runtime_paths();
 
 // src/skills/index.ts
@@ -18279,14 +18783,14 @@ init_esm_shims();
 // src/skills/index-generator.ts
 init_esm_shims();
 init_paths();
-import { mkdir as mkdir32, readFile as readFile39, writeFile as writeFile31 } from "fs/promises";
-import { dirname as dirname30, join as join67, relative as relative10 } from "path";
-import fg13 from "fast-glob";
+import { mkdir as mkdir38, readFile as readFile49, writeFile as writeFile37 } from "fs/promises";
+import { dirname as dirname31, join as join81, relative as relative15 } from "path";
+import fg19 from "fast-glob";
 
 // src/skills/loader.ts
 init_esm_shims();
-import { readFile as readFile40 } from "fs/promises";
-import { basename as basename8 } from "pathe";
+import { readFile as readFile50 } from "fs/promises";
+import { basename as basename11 } from "pathe";
 
 // src/skills/trigger-evaluator.ts
 init_esm_shims();
@@ -18296,8 +18800,8 @@ init_esm_shims();
 
 // src/test-output/service.ts
 init_esm_shims();
-import { readFile as readFile41 } from "fs/promises";
-import fg14 from "fast-glob";
+import { readFile as readFile51 } from "fs/promises";
+import fg20 from "fast-glob";
 
 // src/update/index.ts
 init_esm_shims();
@@ -18306,23 +18810,23 @@ init_esm_shims();
 init_esm_shims();
 init_paths();
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8 } from "fs";
-import { dirname as dirname31, join as join68 } from "path";
+import { dirname as dirname32, join as join82 } from "path";
 function auditPath(projectRoot) {
-  return join68(projectRoot, PATHS.AUDIT_LOG);
+  return join82(projectRoot, PATHS.AUDIT_LOG);
 }
 function ts() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function appendAuditLog2(projectRoot, previous, updated) {
   const path11 = auditPath(projectRoot);
-  mkdirSync8(dirname31(path11), { recursive: true });
+  mkdirSync8(dirname32(path11), { recursive: true });
   const line = `[${ts()}] INFO silent-update previous=${previous ?? "unknown"} updated=${updated}
 `;
   appendFileSync2(path11, line);
 }
 function appendAuditLogFailure(projectRoot, previous, target, error) {
   const path11 = auditPath(projectRoot);
-  mkdirSync8(dirname31(path11), { recursive: true });
+  mkdirSync8(dirname32(path11), { recursive: true });
   const sanitized = error.replace(/"/g, "'");
   const line = `[${ts()}] WARN silent-update-failed previous=${previous ?? "unknown"} target=${target} error="${sanitized}"
 `;
@@ -18333,16 +18837,16 @@ function appendAuditLogFailure(projectRoot, previous, target, error) {
 init_esm_shims();
 init_paths();
 init_project_profile();
-import { chmodSync as chmodSync4, existsSync as existsSync28, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync7 } from "fs";
-import { mkdtemp, readdir as readdir9, readFile as readFile42, rm as rm5 } from "fs/promises";
+import { chmodSync as chmodSync4, existsSync as existsSync29, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "fs";
+import { mkdtemp, readdir as readdir12, readFile as readFile52, rm as rm5 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname32, join as join69, relative as relative11 } from "path";
+import { dirname as dirname33, join as join83, relative as relative16 } from "path";
 var FrameworkUpdater = class {
   constructor(options = {}) {
     this.options = options;
   }
   async run(projectRoot) {
-    const previousVersion = readText(join69(projectRoot, PATHS.FRAMEWORK_VERSION));
+    const previousVersion = readText(join83(projectRoot, PATHS.FRAMEWORK_VERSION));
     const manifest = readManifest(projectRoot);
     const artifactPolicy = new Map(
       manifest?.generated_artifacts.map((artifact) => [artifact.path, artifact.auto_update]) ?? []
@@ -18352,8 +18856,8 @@ var FrameworkUpdater = class {
     const skipped = [];
     const newScripts = [];
     for (const candidate of candidates) {
-      const target = join69(projectRoot, candidate.path);
-      const existed = existsSync28(target);
+      const target = join83(projectRoot, candidate.path);
+      const existed = existsSync29(target);
       const autoUpdate = artifactPolicy.get(candidate.path) ?? candidate.autoUpdate;
       if (existed && autoUpdate === false) {
         skipped.push({
@@ -18363,8 +18867,8 @@ var FrameworkUpdater = class {
         });
         continue;
       }
-      mkdirSync9(dirname32(target), { recursive: true });
-      writeFileSync7(target, candidate.content);
+      mkdirSync9(dirname33(target), { recursive: true });
+      writeFileSync8(target, candidate.content);
       if (candidate.executable === true) {
         chmodSync4(target, 493);
       }
@@ -18373,9 +18877,9 @@ var FrameworkUpdater = class {
         newScripts.push(candidate.path);
       }
     }
-    mkdirSync9(dirname32(join69(projectRoot, PATHS.FRAMEWORK_VERSION)), { recursive: true });
-    writeFileSync7(
-      join69(projectRoot, PATHS.FRAMEWORK_VERSION),
+    mkdirSync9(dirname33(join83(projectRoot, PATHS.FRAMEWORK_VERSION)), { recursive: true });
+    writeFileSync8(
+      join83(projectRoot, PATHS.FRAMEWORK_VERSION),
       `version=${VERSION}
 updated_at=${(/* @__PURE__ */ new Date()).toISOString()}
 `
@@ -18398,7 +18902,7 @@ updated_at=${(/* @__PURE__ */ new Date()).toISOString()}
     if (profile === null) {
       throw new Error("Cannot update framework-managed artifacts without a project profile");
     }
-    const tempRoot = await mkdtemp(join69(tmpdir(), "paqad-ai-update-"));
+    const tempRoot = await mkdtemp(join83(tmpdir(), "paqad-ai-update-"));
     try {
       const result = await new OnboardingOrchestrator().run({
         projectRoot: tempRoot,
@@ -18419,8 +18923,8 @@ updated_at=${(/* @__PURE__ */ new Date()).toISOString()}
   }
 };
 function readManifest(projectRoot) {
-  const path11 = join69(projectRoot, PATHS.ONBOARDING_MANIFEST);
-  if (!existsSync28(path11)) {
+  const path11 = join83(projectRoot, PATHS.ONBOARDING_MANIFEST);
+  if (!existsSync29(path11)) {
     return null;
   }
   return JSON.parse(readFileSync18(path11, "utf8"));
@@ -18429,7 +18933,7 @@ function readProfile(projectRoot) {
   return readProjectProfile(projectRoot);
 }
 function readText(path11) {
-  if (!existsSync28(path11)) {
+  if (!existsSync29(path11)) {
     return null;
   }
   const raw = readFileSync18(path11, "utf8");
@@ -18444,22 +18948,22 @@ async function collectFiles(root, generated, manifest) {
   return Promise.all(
     paths.map(async (file) => ({
       path: file,
-      content: await readFile42(join69(root, file), "utf8"),
+      content: await readFile52(join83(root, file), "utf8"),
       autoUpdate: artifactPolicy.get(file)?.auto_update ?? true,
       executable: artifactPolicy.get(file)?.executable ?? file.startsWith("scripts/")
     }))
   );
 }
 async function walk4(root, current = root) {
-  const entries = await readdir9(current, { withFileTypes: true });
+  const entries = await readdir12(current, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const absolute = join69(current, entry.name);
+    const absolute = join83(current, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walk4(root, absolute));
       continue;
     }
-    files.push(relative11(root, absolute));
+    files.push(relative16(root, absolute));
   }
   return files.sort();
 }
@@ -18489,7 +18993,7 @@ init_pattern_suggester();
 
 // src/patterns/pattern-cli.ts
 init_esm_shims();
-import { writeFile as writeFile32 } from "fs/promises";
+import { writeFile as writeFile38 } from "fs/promises";
 var STALENESS_THRESHOLD_DAYS2 = 180;
 var PatternCli = class {
   constructor(store) {
@@ -18523,7 +19027,7 @@ var PatternCli = class {
   async exportPatterns(outputPath, format) {
     const patterns = await this.store.list();
     if (format === "json") {
-      await writeFile32(outputPath, JSON.stringify(patterns, null, 2), "utf8");
+      await writeFile38(outputPath, JSON.stringify(patterns, null, 2), "utf8");
     } else {
       const lines = ["# Pattern Library Export\n"];
       for (const p of patterns) {
@@ -18540,7 +19044,7 @@ ${p.solution}
 `);
         lines.push("---\n");
       }
-      await writeFile32(outputPath, lines.join("\n"), "utf8");
+      await writeFile38(outputPath, lines.join("\n"), "utf8");
     }
     console.log(`Exported ${patterns.length} pattern(s) to ${outputPath}`);
   }
@@ -18553,7 +19057,7 @@ init_esm_shims();
 init_esm_shims();
 
 // src/index.ts
-var VERSION = "0.3.1";
+var VERSION = "0.3.3";
 
 // src/cli/commands/capabilities.ts
 init_esm_shims();
@@ -18592,7 +19096,7 @@ function requireProfile(projectRoot) {
 
 // src/cli/commands/compliance.ts
 init_esm_shims();
-import { readFile as readFile43, stat as stat7 } from "fs/promises";
+import { readFile as readFile53, stat as stat7 } from "fs/promises";
 import path10 from "path";
 import { Command as Command2 } from "commander";
 function resolveIndexPath2(explicitPath, spec) {
@@ -18634,7 +19138,7 @@ function createComplianceCommand() {
     const indexPath = resolveIndexPath2(options.indexPath, options.spec);
     const specPath = path10.resolve(options.projectRoot, options.spec);
     const relativeSpec = path10.relative(options.projectRoot, specPath);
-    const specMarkdown = await readFile43(specPath, "utf8");
+    const specMarkdown = await readFile53(specPath, "utf8");
     const review = await loadSpecReviewReport({
       project_root: options.projectRoot,
       spec_file: relativeSpec
@@ -18655,7 +19159,7 @@ function createComplianceCommand() {
   command.command("review <specFile>").description("Run deterministic spec-quality review and persist the review report").option("--project-root <path>", "Project root", process.cwd()).option("--json", "Print JSON instead of a human-readable summary").action(async (specFile, options) => {
     const specPath = path10.resolve(options.projectRoot, specFile);
     const relativeSpec = path10.relative(options.projectRoot, specPath);
-    const specMarkdown = await readFile43(specPath, "utf8");
+    const specMarkdown = await readFile53(specPath, "utf8");
     const previousReport = await loadSpecReviewReport({
       project_root: options.projectRoot,
       spec_file: relativeSpec
@@ -19003,8 +19507,8 @@ function createInstallCommand() {
 
 // src/cli/commands/onboard.ts
 init_esm_shims();
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync8 } from "fs";
-import { join as join70 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
+import { join as join84 } from "path";
 import { Command as Command5 } from "commander";
 
 // src/cli/ui/banner.ts
@@ -19087,10 +19591,10 @@ function createOnboardCommand() {
   );
 }
 function writeNextStepsFile(projectRoot) {
-  const paqadDir = join70(projectRoot, ".paqad");
+  const paqadDir = join84(projectRoot, ".paqad");
   mkdirSync10(paqadDir, { recursive: true });
-  writeFileSync8(
-    join70(paqadDir, "next-steps.md"),
+  writeFileSync9(
+    join84(paqadDir, "next-steps.md"),
     [
       "# Next Steps",
       "",
@@ -19695,8 +20199,8 @@ function createRagCommand() {
 // src/cli/commands/refresh.ts
 init_esm_shims();
 import { Command as Command9 } from "commander";
-import { existsSync as existsSync29, readFileSync as readFileSync20, writeFileSync as writeFileSync9 } from "fs";
-import { join as join71 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync20, writeFileSync as writeFileSync10 } from "fs";
+import { join as join85 } from "path";
 init_paths();
 init_domain();
 init_project_profile();
@@ -19765,9 +20269,9 @@ function resolveRefreshStack(value) {
   return value !== void 0 && STACKS.includes(value) ? value : null;
 }
 function writeRefreshDrift(projectRoot, refreshDrift) {
-  const path11 = join71(projectRoot, PATHS.STACK_DRIFT);
+  const path11 = join85(projectRoot, PATHS.STACK_DRIFT);
   const current = readExistingJson(path11);
-  writeFileSync9(path11, `${JSON.stringify({ ...current ?? {}, ...refreshDrift }, null, 2)}
+  writeFileSync10(path11, `${JSON.stringify({ ...current ?? {}, ...refreshDrift }, null, 2)}
 `);
 }
 function readExistingJson(path11) {
@@ -19781,8 +20285,8 @@ function resolveChangedFiles(projectRoot, contextChangedFiles) {
   if (contextChangedFiles.length > 0) {
     return [...new Set(contextChangedFiles)].sort();
   }
-  const trackedPath = join71(projectRoot, PATHS.CHANGED_FILES);
-  if (!existsSync29(trackedPath)) {
+  const trackedPath = join85(projectRoot, PATHS.CHANGED_FILES);
+  if (!existsSync30(trackedPath)) {
     return [];
   }
   try {