paqad-ai 0.1.0 → 0.1.2

package/dist/cli/index.js

@@ -4117,7 +4117,8 @@ function walk(root) {
 }
 
 // src/install/bootstrap.ts
-import { mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, rmSync, symlinkSync } from "fs";
+import { dirname as dirname12 } from "path";
 
 // src/onboarding/manifest-writer.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
@@ -4154,7 +4155,12 @@ function resolveFrameworkInstallPath() {
 // src/install/bootstrap.ts
 function bootstrapFramework(projectRoot) {
   const frameworkHome = resolveFrameworkInstallPath();
-  mkdirSync3(frameworkHome, { recursive: true });
+  const runtimeRoot = getRuntimeRoot();
+  mkdirSync3(dirname12(frameworkHome), { recursive: true });
+  if (existsSync11(frameworkHome)) {
+    rmSync(frameworkHome, { recursive: true, force: true });
+  }
+  symlinkSync(runtimeRoot, frameworkHome);
   writeFrameworkMetadata(projectRoot, VERSION);
   return {
     framework_home: frameworkHome,
@@ -4165,7 +4171,7 @@ function bootstrapFramework(projectRoot) {
 
 // src/document/workflow.ts
 import { mkdir as mkdir10, readFile as readFile12, readdir as readdir2, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname13, join as join26, relative } from "path";
+import { dirname as dirname14, join as join26, relative } from "path";
 
 // src/onboarding/registry-generator.ts
 import { readdir } from "fs/promises";
@@ -4399,7 +4405,7 @@ async function readTemplate(packRoot, templatePath) {
 
 // src/document/progress-tracker.ts
 import { mkdir as mkdir9, readFile as readFile10, rm, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname12, join as join24 } from "path";
+import { dirname as dirname13, join as join24 } from "path";
 var DocumentProgressTracker = class {
   constructor(validator = new SchemaValidator()) {
     this.validator = validator;
@@ -4420,7 +4426,7 @@ var DocumentProgressTracker = class {
   }
   async save(projectRoot, progress) {
     const target = join24(projectRoot, PATHS.DOC_PROGRESS);
-    await mkdir9(dirname12(target), { recursive: true });
+    await mkdir9(dirname13(target), { recursive: true });
     await writeFile9(target, `${JSON.stringify(progress, null, 2)}
 `);
   }
@@ -4583,7 +4589,7 @@ var DocumentationWorkflow = class {
         stackSnapshot,
         profile
       });
-      await mkdir10(dirname13(join26(options.projectRoot, contentOutputPath)), { recursive: true });
+      await mkdir10(dirname14(join26(options.projectRoot, contentOutputPath)), { recursive: true });
       await writeFile10(join26(options.projectRoot, contentOutputPath), contentBody);
       generated.push(contentOutputPath);
       steps.push({
@@ -4626,7 +4632,7 @@ var DocumentationWorkflow = class {
     }
     await Promise.all(
       themeArtifacts.map(async (artifact) => {
-        await mkdir10(dirname13(join26(options.projectRoot, artifact.path)), { recursive: true });
+        await mkdir10(dirname14(join26(options.projectRoot, artifact.path)), { recursive: true });
         await writeFile10(join26(options.projectRoot, artifact.path), artifact.content);
         designSystemGenerated.push(artifact.path);
       })
@@ -4913,7 +4919,7 @@ async function processEntry(input) {
   input.entry.state = "generating";
   input.entry.started_at = (/* @__PURE__ */ new Date()).toISOString();
   input.entry.error = null;
-  await mkdir10(dirname13(join26(input.projectRoot, input.entry.output_path)), { recursive: true });
+  await mkdir10(dirname14(join26(input.projectRoot, input.entry.output_path)), { recursive: true });
   await writeFile10(join26(input.projectRoot, input.entry.output_path), input.content);
   input.generated.push(input.entry.output_path);
   input.entry.state = "done";
@@ -5491,15 +5497,15 @@ function basenameWithoutExtension(path) {
 }
 
 // src/onboarding/file-writer.ts
-import { chmodSync, existsSync as existsSync11, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname14, join as join27 } from "path";
+import { chmodSync, existsSync as existsSync12, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname15, join as join27 } from "path";
 function writeGeneratedFiles(projectRoot, files) {
   const written = [];
   const skipped = [];
   for (const file of files) {
     const target = join27(projectRoot, file.path);
-    mkdirSync4(dirname14(target), { recursive: true });
-    if (!file.autoUpdate && existsSync11(target)) {
+    mkdirSync4(dirname15(target), { recursive: true });
+    if (!file.autoUpdate && existsSync12(target)) {
       skipped.push(file.path);
       continue;
     }
@@ -5705,6 +5711,8 @@ function resolveArtifactDirectoryName(artifactType) {
 var RULE_SEED_PRIORITY = [
   "constitution",
   "security",
+  "pentest",
+  "design-system",
   "content-rules",
   "testing",
   "documentation",
@@ -5800,9 +5808,34 @@ function getRulePriority(filePath) {
   return index === -1 ? RULE_SEED_PRIORITY.length : index;
 }
 
+// src/onboarding/gitignore-writer.ts
+import { existsSync as existsSync13, readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "fs";
+import { join as join30 } from "path";
+var PAQAD_MARKER = "# paqad-ai";
+var PAQAD_GITIGNORE_ENTRIES = [
+  PAQAD_MARKER,
+  ".paqad/cache/",
+  ".paqad/session/",
+  ".paqad/context/",
+  ".paqad/workflows/",
+  ".paqad/indexes/",
+  ".paqad/pentest/",
+  ".paqad/theme/"
+].join("\n");
+function writeGitignore(projectRoot) {
+  const gitignorePath = join30(projectRoot, ".gitignore");
+  const existing = existsSync13(gitignorePath) ? readFileSync11(gitignorePath, "utf8") : "";
+  if (existing.includes(PAQAD_MARKER)) {
+    return;
+  }
+  const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  writeFileSync4(gitignorePath, `${existing}${separator}
+${PAQAD_GITIGNORE_ENTRIES}
+`);
+}
+
 // src/onboarding/prompts.ts
 import { checkbox, select } from "@inquirer/prompts";
-var ALL_PROVIDERS = ["codex-cli", "claude-code", "gemini-cli", "junie"];
 function isInteractive() {
   return Boolean(process.stdout.isTTY && process.stdin.isTTY);
 }
@@ -5836,7 +5869,7 @@ function buildFromOverridesAndDetection(detection, snapshot, overrides) {
     snapshot
   ));
   return {
-    providers: overrides?.providers ?? ALL_PROVIDERS,
+    providers: overrides?.providers ?? ["claude-code"],
     domain,
     stack_profile: stackProfile,
     stack: overrides?.stack ?? (snapshot?.profile ? getPrimaryStack({
@@ -6227,9 +6260,9 @@ function inferSelectionDomain(detection, overrides, snapshot) {
 }
 
 // src/onboarding/reference-generator.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { readFile as readFile13 } from "fs/promises";
-import { join as join30, relative as relative4 } from "path";
+import { join as join31, relative as relative4 } from "path";
 import fg3 from "fast-glob";
 async function generateReferenceGuides(runtimeRoot, context) {
   if (context.domain !== "coding") {
@@ -6240,8 +6273,8 @@ async function generateReferenceGuides(runtimeRoot, context) {
     routing: { domain: context.domain },
     stack_profile: context.stack_profile
   });
-  const referencesRoot = join30(runtimeRoot, "capabilities", "coding", "stacks", stack, "references");
-  if (!existsSync12(referencesRoot)) {
+  const referencesRoot = join31(runtimeRoot, "capabilities", "coding", "stacks", stack, "references");
+  if (!existsSync14(referencesRoot)) {
     return [buildFallbackReferenceGuide(stack)];
   }
   const entries = await fg3(["tools/*.md", "tools-catalog.md"], {
@@ -6263,14 +6296,14 @@ async function generateReferenceGuides(runtimeRoot, context) {
 function toProjectReferencePath(stack, relativePath) {
   const normalized = relativePath.replaceAll("\\", "/");
   if (normalized === "tools-catalog.md") {
-    return join30(PATHS.TOOLS_DIR, stack, "README.md");
+    return join31(PATHS.TOOLS_DIR, stack, "README.md");
   }
-  return join30(PATHS.TOOLS_DIR, stack, normalized.replace(/^tools\//, ""));
+  return join31(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: join30(PATHS.TOOLS_DIR, stack, "README.md"),
+    path: join31(PATHS.TOOLS_DIR, stack, "README.md"),
     autoUpdate: false,
     content: [
       `# ${title} Tool References`,
@@ -6288,7 +6321,7 @@ function buildFallbackReferenceGuide(stack) {
 
 // src/onboarding/rule-generator.ts
 import { readFile as readFile14 } from "fs/promises";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 async function generateProjectRules(rules) {
   return Promise.all(
     rules.map(async (rule) => ({
@@ -6301,22 +6334,22 @@ async function generateProjectRules(rules) {
 function toProjectRulePath(source) {
   const normalized = source.replaceAll("\\", "/");
   if (normalized.startsWith("base/rules/")) {
-    return join31(PATHS.RULES_DIR, "_shared", normalized.replace(/^base\/rules\//, ""));
+    return join32(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 join31(PATHS.RULES_DIR, prefix2, target2);
+      return join32(PATHS.RULES_DIR, prefix2, target2);
     }
   }
   const [prefix, suffix] = normalized.split("/rules/");
   if (prefix === void 0 || suffix === void 0) {
-    return join31(PATHS.RULES_DIR, normalized);
+    return join32(PATHS.RULES_DIR, normalized);
   }
   const target = suffix.endsWith("/guide.md") ? suffix.replace("/guide.md", ".md") : suffix;
-  return join31(PATHS.RULES_DIR, prefix, target);
+  return join32(PATHS.RULES_DIR, prefix, target);
 }
 
 // src/onboarding/orchestrator.ts
@@ -6331,7 +6364,7 @@ var OnboardingOrchestrator = class {
     const runtimeRoot = options.runtimeRoot ?? getRuntimeRoot();
     const resolver = new Resolver({ runtimeRoot });
     const resolved = await resolver.resolve(selections);
-    const adapters = options.adapters ?? selections.providers ?? ["claude-code", "codex-cli", "gemini-cli", "junie"];
+    const adapters = options.adapters ?? selections.providers ?? ["claude-code"];
     const profile = buildProjectProfile(selections, liveSnapshot, options.profileOverrides);
     const validator = new SchemaValidator();
     const validation = validator.validate("project-profile", profile);
@@ -6368,8 +6401,9 @@ var OnboardingOrchestrator = class {
       { writeHumanDocs: false }
     );
     writeProjectProfile2(options.projectRoot, profile);
+    writeGitignore(options.projectRoot);
     writeDetectionReport(options.projectRoot, detection);
-    writeFrameworkMetadata(options.projectRoot, VERSION);
+    bootstrapFramework(options.projectRoot);
     const manifestPath = writeOnboardingManifest(options.projectRoot, {
       framework_version: VERSION,
       adapter: adapters[0],
@@ -6642,7 +6676,7 @@ function buildRustCommands(usingCompose) {
 }
 
 // src/onboarding/scaffold-generator.ts
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 
 // src/templates/registry.ts
 import fg4 from "fast-glob";
@@ -6650,29 +6684,29 @@ import { basename as basename4, relative as relative5 } from "pathe";
 
 // src/onboarding/scaffold-generator.ts
 var FEATURE_TEMPLATE_TARGETS = [
-  ["business.md.hbs", join32(PATHS.MODULE_FEATURES_DIR, "core", "business.md")],
-  ["technical.md.hbs", join32(PATHS.MODULE_FEATURES_DIR, "core", "technical.md")]
+  ["business.md.hbs", join33(PATHS.MODULE_FEATURES_DIR, "core", "business.md")],
+  ["technical.md.hbs", join33(PATHS.MODULE_FEATURES_DIR, "core", "technical.md")]
 ];
 
 // src/packs/manager.ts
 import {
   cpSync,
-  existsSync as existsSync13,
+  existsSync as existsSync15,
   mkdirSync as mkdirSync5,
   mkdtempSync,
   readdirSync as readdirSync3,
-  rmSync,
-  writeFileSync as writeFileSync4
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync5
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join33, resolve as resolve2 } from "path";
+import { join as join34, resolve as resolve2 } from "path";
 import { execa } from "execa";
 var SOURCE_ORDER2 = ["built-in", "global", "project"];
 function resolvePackManagerRoots(projectRoot = process.cwd(), overrides = {}) {
   return {
     runtimeRoot: overrides.runtimeRoot ?? getRuntimeRoot(),
-    globalPacksRoot: overrides.globalPacksRoot ?? process.env.PAQAD_GLOBAL_PACKS_ROOT ?? join33(homedir2(), ".paqad", "packs"),
-    projectPacksRoot: overrides.projectPacksRoot ?? join33(projectRoot, ".paqad", "packs"),
+    globalPacksRoot: overrides.globalPacksRoot ?? process.env.PAQAD_GLOBAL_PACKS_ROOT ?? join34(homedir2(), ".paqad", "packs"),
+    projectPacksRoot: overrides.projectPacksRoot ?? join34(projectRoot, ".paqad", "packs"),
     registryUrl: overrides.registryUrl ?? process.env.PAQAD_PACK_REGISTRY_URL
   };
 }
@@ -6720,8 +6754,8 @@ async function installPack(source, options = {}) {
   if (!pack.validation.valid) {
     throw new Error(formatValidationIssues(pack.validation.issues));
   }
-  const destination = join33(installRoot, pack.manifest.name);
-  rmSync(destination, { recursive: true, force: true });
+  const destination = join34(installRoot, pack.manifest.name);
+  rmSync2(destination, { recursive: true, force: true });
   cpSync(candidateRoot, destination, { recursive: true });
   const installed = loader.validatePack(destination, scope === "project" ? "project" : "global");
   if (!installed.validation.valid) {
@@ -6732,13 +6766,13 @@ async function installPack(source, options = {}) {
 function removePack(name, projectRoot = process.cwd(), scope = "global", overrides = {}) {
   const roots = resolvePackManagerRoots(projectRoot, overrides);
   const targetRoot = scope === "project" ? roots.projectPacksRoot : roots.globalPacksRoot;
-  const target = join33(targetRoot, name);
-  if (existsSync13(target)) {
-    rmSync(target, { recursive: true, force: true });
+  const target = join34(targetRoot, name);
+  if (existsSync15(target)) {
+    rmSync2(target, { recursive: true, force: true });
     return;
   }
-  const builtInRoot = join33(roots.runtimeRoot, "capabilities", "coding", "stacks", name);
-  if (existsSync13(builtInRoot)) {
+  const builtInRoot = join34(roots.runtimeRoot, "capabilities", "coding", "stacks", name);
+  if (existsSync15(builtInRoot)) {
     throw new Error(
       `Cannot remove built-in pack "${name}"; remove a global or project override instead`
     );
@@ -6755,14 +6789,14 @@ function validatePackAt(path) {
 function createPack(name, options = {}) {
   const destinationRoot = options.destinationRoot ?? process.cwd();
   const ecosystem = options.ecosystem ?? "node";
-  const packRoot = join33(destinationRoot, name);
-  if (existsSync13(packRoot)) {
+  const packRoot = join34(destinationRoot, name);
+  if (existsSync15(packRoot)) {
     throw new Error(`Pack scaffold already exists at ${packRoot}`);
   }
-  mkdirSync5(join33(packRoot, "rules"), { recursive: true });
-  writeFileSync4(join33(packRoot, "pack.yaml"), renderPackTemplate(name, ecosystem));
-  writeFileSync4(
-    join33(packRoot, "rules", "conventions.md"),
+  mkdirSync5(join34(packRoot, "rules"), { recursive: true });
+  writeFileSync5(join34(packRoot, "pack.yaml"), renderPackTemplate(name, ecosystem));
+  writeFileSync5(
+    join34(packRoot, "rules", "conventions.md"),
     `# ${name}
 
 Document project-specific conventions for the ${name} stack here.
@@ -6772,14 +6806,14 @@ Document project-specific conventions for the ${name} stack here.
 }
 function listPackNamesForSource(source, roots) {
   const sourceRoot = resolveSourceRoot(source, roots);
-  if (!existsSync13(sourceRoot)) {
+  if (!existsSync15(sourceRoot)) {
     return [];
   }
   return readdirSync3(sourceRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
 }
 function resolveSourceRoot(source, roots) {
   if (source === "built-in") {
-    return join33(roots.runtimeRoot, "capabilities", "coding", "stacks");
+    return join34(roots.runtimeRoot, "capabilities", "coding", "stacks");
   }
   return source === "global" ? roots.globalPacksRoot : roots.projectPacksRoot;
 }
@@ -6799,27 +6833,27 @@ async function materializePackSource(source, roots) {
   return clonePackSource(buildRegistryPackUrl(roots.registryUrl, source));
 }
 function looksLikeLocalPath(source) {
-  return source.startsWith(".") || source.startsWith("/") || existsSync13(resolve2(source));
+  return source.startsWith(".") || source.startsWith("/") || existsSync15(resolve2(source));
 }
 function looksLikeGitUrl(source) {
   return source.startsWith("http://") || source.startsWith("https://") || source.startsWith("ssh://") || source.startsWith("git@") || source.startsWith("file://") || source.endsWith(".git");
 }
 async function clonePackSource(source) {
-  const tempRoot = mkdtempSync(join33(homedir2(), ".paqad-pack-clone-"));
+  const tempRoot = mkdtempSync(join34(homedir2(), ".paqad-pack-clone-"));
   try {
     await execa("git", ["clone", "--depth", "1", source, tempRoot]);
   } catch (error) {
-    rmSync(tempRoot, { recursive: true, force: true });
+    rmSync2(tempRoot, { recursive: true, force: true });
     throw error;
   }
   return findPackRoot(tempRoot);
 }
 function findPackRoot(root) {
-  const rootManifest = join33(root, "pack.yaml");
-  if (existsSync13(rootManifest)) {
+  const rootManifest = join34(root, "pack.yaml");
+  if (existsSync15(rootManifest)) {
     return root;
   }
-  const candidates = readdirSync3(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join33(root, entry.name)).filter((candidate) => existsSync13(join33(candidate, "pack.yaml")));
+  const candidates = readdirSync3(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join34(root, entry.name)).filter((candidate) => existsSync15(join34(candidate, "pack.yaml")));
   if (candidates.length === 1) {
     return candidates[0];
   }
@@ -6918,15 +6952,15 @@ async function queryOsv(packages) {
 }
 
 // src/pentest/progress-tracker.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { mkdir as mkdir12, readdir as readdir4, readFile as readFile16, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname16, join as join35 } from "path";
+import { dirname as dirname17, join as join36 } from "path";
 
 // src/pentest/shared.ts
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { mkdir as mkdir11, readFile as readFile15, readdir as readdir3, writeFile as writeFile11 } from "fs/promises";
-import { basename as basename5, dirname as dirname15, join as join34, relative as relative6 } from "path";
+import { basename as basename5, dirname as dirname16, join as join35, relative as relative6 } from "path";
 import { execa as execa2 } from "execa";
 import fg5 from "fast-glob";
 function toLocalTimestamp(date) {
@@ -6939,12 +6973,12 @@ function toLocalTimestamp(date) {
   return `${year}-${month}-${day}-${hours}-${minutes}-${seconds}`;
 }
 async function writeJson(target, data) {
-  await mkdir11(dirname15(target), { recursive: true });
+  await mkdir11(dirname16(target), { recursive: true });
   await writeFile11(target, `${JSON.stringify(data, null, 2)}
 `);
 }
 async function readJsonIfExists(target) {
-  if (!existsSync14(target)) {
+  if (!existsSync16(target)) {
     return null;
   }
   return JSON.parse(await readFile15(target, "utf8"));
@@ -6990,8 +7024,8 @@ async function discoverTargetUrl(projectRoot, stack, explicit) {
   }
   const envFiles = [".env", ".env.local", ".env.example"];
   for (const envFile of envFiles) {
-    const path = join34(projectRoot, envFile);
-    if (!existsSync14(path)) {
+    const path = join35(projectRoot, envFile);
+    if (!existsSync16(path)) {
       continue;
     }
     const content = await readFile15(path, "utf8");
@@ -7012,11 +7046,11 @@ async function discoverTargetUrl(projectRoot, stack, explicit) {
   return null;
 }
 async function runProjectScript(projectRoot, scriptName, env, logDir) {
-  const scriptPath = join34(projectRoot, PATHS.SCRIPTS_DIR, scriptName);
-  const stdoutPath = join34(logDir, `${scriptName}.stdout.log`);
-  const stderrPath = join34(logDir, `${scriptName}.stderr.log`);
+  const scriptPath = join35(projectRoot, PATHS.SCRIPTS_DIR, scriptName);
+  const stdoutPath = join35(logDir, `${scriptName}.stdout.log`);
+  const stderrPath = join35(logDir, `${scriptName}.stderr.log`);
   await mkdir11(logDir, { recursive: true });
-  if (!existsSync14(scriptPath)) {
+  if (!existsSync16(scriptPath)) {
     await writeFile11(stdoutPath, "");
     await writeFile11(stderrPath, `Missing script: ${relative6(projectRoot, scriptPath)}
 `);
@@ -7044,8 +7078,8 @@ async function runProjectScript(projectRoot, scriptName, env, logDir) {
   };
 }
 async function loadModuleDocs(projectRoot, focusModules = []) {
-  const moduleRoot = join34(projectRoot, PATHS.MODULES_DIR);
-  if (!existsSync14(moduleRoot)) {
+  const moduleRoot = join35(projectRoot, PATHS.MODULES_DIR);
+  if (!existsSync16(moduleRoot)) {
     return [];
   }
   const dirs = (await readdir3(moduleRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((moduleName) => focusModules.length === 0 || focusModules.includes(moduleName)).sort();
@@ -7113,7 +7147,7 @@ function inferSourceArtifacts(baseDir, scriptResults) {
   return [
     ...new Set(
       artifacts.map(
-        (artifact) => artifact.startsWith(".") ? artifact : relative6(dirname15(baseDir), join34(dirname15(baseDir), artifact))
+        (artifact) => artifact.startsWith(".") ? artifact : relative6(dirname16(baseDir), join35(dirname16(baseDir), artifact))
       )
     )
   ];
@@ -7187,8 +7221,8 @@ var PentestProgressTracker = class {
     };
   }
   async load(projectRoot, runId) {
-    const target = join35(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "progress.json");
-    if (!existsSync15(target)) {
+    const target = join36(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "progress.json");
+    if (!existsSync17(target)) {
       return null;
     }
     const parsed = JSON.parse(await readFile16(target, "utf8"));
@@ -7199,9 +7233,9 @@ var PentestProgressTracker = class {
     return parsed;
   }
   async save(projectRoot, progress) {
-    const target = join35(projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "progress.json");
+    const target = join36(projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "progress.json");
     progress.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir12(dirname16(target), { recursive: true });
+    await mkdir12(dirname17(target), { recursive: true });
     await writeFile12(target, `${JSON.stringify(progress, null, 2)}
 `);
   }
@@ -7258,8 +7292,8 @@ var PentestProgressTracker = class {
     return step.status === "completed" && step.input_hash === inputHash;
   }
   async findIncompleteRun(projectRoot, workflow, sourceReportPath) {
-    const runsDir = join35(projectRoot, PATHS.PENTEST_RUNS_DIR);
-    if (!existsSync15(runsDir)) {
+    const runsDir = join36(projectRoot, PATHS.PENTEST_RUNS_DIR);
+    if (!existsSync17(runsDir)) {
       return null;
     }
     const entries = (await readdir4(runsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().reverse();
@@ -7301,15 +7335,15 @@ var PentestProgressTracker = class {
   }
 };
 function runArtifactsDir(projectRoot, runId) {
-  return join35(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "artifacts");
+  return join36(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "artifacts");
 }
 function runLogsDir(projectRoot, runId) {
-  return join35(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "logs");
+  return join36(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "logs");
 }
 
 // src/pipeline/lane-runner.ts
 import { mkdir as mkdir16, writeFile as writeFile16 } from "fs/promises";
-import { dirname as dirname19, join as join41 } from "path";
+import { dirname as dirname20, join as join42 } from "path";
 
 // src/pipeline/phases/shared.ts
 function createPassResult(phase, summary, context, artifacts = [`handoff:${context.phases.length + 1}`]) {
@@ -7429,12 +7463,12 @@ var LoadDocsPhase = class {
 
 // src/workflows/pentest.ts
 import { mkdir as mkdir13, writeFile as writeFile13 } from "fs/promises";
-import { join as join38, relative as relative7 } from "path";
+import { join as join39, relative as relative7 } from "path";
 
 // src/pentest/findings.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { readFile as readFile17 } from "fs/promises";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 function createFinding(input) {
   return {
     id: "",
@@ -7608,8 +7642,8 @@ function buildModuleFindings(docs, tests) {
   return findings;
 }
 async function buildSecretFindings(artifactDir) {
-  const path = join36(artifactDir, "secrets", "matches.txt");
-  if (!existsSync16(path)) {
+  const path = join37(artifactDir, "secrets", "matches.txt");
+  if (!existsSync18(path)) {
     return [];
   }
   const matches = parseSecretMatches(await readFile17(path, "utf8"));
@@ -7721,8 +7755,8 @@ function normalizeImpact(content) {
 }
 async function readNativeAuditFindings(artifactDir) {
   const findings = [];
-  const dependencyDir = join36(artifactDir, "dependencies");
-  const npmAudit = await readJsonMaybe(join36(dependencyDir, "npm-audit.json"));
+  const dependencyDir = join37(artifactDir, "dependencies");
+  const npmAudit = await readJsonMaybe(join37(dependencyDir, "npm-audit.json"));
   for (const [name, vulnerability] of Object.entries(npmAudit?.vulnerabilities ?? {})) {
     const via = (vulnerability.via ?? []).find((entry) => typeof entry === "object");
     findings.push({
@@ -7734,7 +7768,7 @@ async function readNativeAuditFindings(artifactDir) {
       details: via?.url ?? ""
     });
   }
-  const pnpmAudit = await readJsonMaybe(join36(dependencyDir, "pnpm-audit.json"));
+  const pnpmAudit = await readJsonMaybe(join37(dependencyDir, "pnpm-audit.json"));
   for (const advisory of Object.values(pnpmAudit?.advisories ?? {})) {
     findings.push({
       package_name: advisory.module_name ?? "unknown",
@@ -7745,7 +7779,7 @@ async function readNativeAuditFindings(artifactDir) {
       details: advisory.overview ?? ""
     });
   }
-  const composerAudit = await readJsonMaybe(join36(dependencyDir, "composer-audit.json"));
+  const composerAudit = await readJsonMaybe(join37(dependencyDir, "composer-audit.json"));
   if (Array.isArray(composerAudit?.advisories)) {
     for (const advisory of composerAudit.advisories) {
       findings.push({
@@ -7782,7 +7816,7 @@ async function readNativeAuditFindings(artifactDir) {
   });
 }
 async function readJsonMaybe(path) {
-  if (!existsSync16(path)) {
+  if (!existsSync18(path)) {
     return null;
   }
   try {
@@ -7858,7 +7892,7 @@ var FileCheckMapper = class {
 
 // src/pentest/incremental-scanner.ts
 import { readFile as readFile18 } from "fs/promises";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 import { createHash as createHash8 } from "crypto";
 import { execa as execa3 } from "execa";
 var IncrementalScanner = class {
@@ -7892,7 +7926,7 @@ var IncrementalScanner = class {
     }
   }
   async gitDiff(projectRoot, lastRunId) {
-    const progressPath = join37(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
+    const progressPath = join38(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
     let baseCommit;
     try {
       const raw = await readFile18(progressPath, "utf8");
@@ -7909,7 +7943,7 @@ var IncrementalScanner = class {
     return result.stdout.split("\n").map((f) => f.trim()).filter(Boolean);
   }
   async hashDiff(projectRoot, lastRunId) {
-    const manifestPath = join37(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
+    const manifestPath = join38(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
     let fileManifest = {};
     try {
       const raw = await readFile18(manifestPath, "utf8");
@@ -7921,7 +7955,7 @@ var IncrementalScanner = class {
     const changed = [];
     for (const [filePath, storedHash] of Object.entries(fileManifest)) {
       try {
-        const content = await readFile18(join37(projectRoot, filePath), "utf8");
+        const content = await readFile18(join38(projectRoot, filePath), "utf8");
         const currentHash = createHash8("sha256").update(content).digest("hex");
         if (currentHash !== storedHash) {
           changed.push(filePath);
@@ -7934,11 +7968,11 @@ var IncrementalScanner = class {
   }
   async warnIfFullScanStale(projectRoot, thresholdDays) {
     try {
-      const runsDir = join37(projectRoot, ".paqad", "pentest", "runs");
+      const runsDir = join38(projectRoot, ".paqad", "pentest", "runs");
       const { readdir: readdir8 } = await import("fs/promises");
       const runs = await readdir8(runsDir).catch(() => []);
       for (const run of runs.sort().reverse()) {
-        const progressPath = join37(runsDir, run, "progress.json");
+        const progressPath = join38(runsDir, run, "progress.json");
         try {
           const raw = await readFile18(progressPath, "utf8");
           const progress = JSON.parse(raw);
@@ -8136,8 +8170,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 = join38(artifactsDir, "docs-summary.json");
-      const testsPath = join38(artifactsDir, "tests-summary.json");
+      const docsPath = join39(artifactsDir, "docs-summary.json");
+      const testsPath = join39(artifactsDir, "tests-summary.json");
       await writeJson(docsPath, docs);
       await writeJson(
         testsPath,
@@ -8238,7 +8272,7 @@ var PentestWorkflow = class {
         progressRunId: progress.run_id,
         reportTimestamp: new Date(progress.started_at)
       });
-      const findingIndexPath = join38(
+      const findingIndexPath = join39(
         options.projectRoot,
         PATHS.PENTEST_RUNS_DIR,
         progress.run_id,
@@ -8255,7 +8289,7 @@ var PentestWorkflow = class {
     }
     if (report === null) {
       const existingSidecar = progress.sidecar_path ? await readJsonIfExists(
-        join38(options.projectRoot, progress.sidecar_path)
+        join39(options.projectRoot, progress.sidecar_path)
       ) : null;
       report = existingSidecar;
     }
@@ -8270,18 +8304,18 @@ var PentestWorkflow = class {
       this.tracker.markStepRunning(progress, "write-report", writeHash);
       await this.tracker.save(options.projectRoot, progress);
       await writeJson(
-        join38(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "report-preview.json"),
+        join39(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "report-preview.json"),
         { report_id: report.report_id, findings: report.findings.length }
       );
-      await writeJson(join38(options.projectRoot, report.sidecar_path), report);
+      await writeJson(join39(options.projectRoot, report.sidecar_path), report);
       await writeJson(
-        join38(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "blocked-checks.json"),
+        join39(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "blocked-checks.json"),
         report.blocked_checks
       );
-      await mkdir13(join38(options.projectRoot, PATHS.PENTEST_DIR), { recursive: true });
+      await mkdir13(join39(options.projectRoot, PATHS.PENTEST_DIR), { recursive: true });
       const markdown = buildPentestMarkdown(report);
-      await writeJson(join38(options.projectRoot, report.sidecar_path), report);
-      await writeFile13(join38(options.projectRoot, report.report_path), markdown);
+      await writeJson(join39(options.projectRoot, report.sidecar_path), report);
+      await writeFile13(join39(options.projectRoot, report.report_path), markdown);
       this.tracker.markStepCompleted(
         progress,
         "write-report",
@@ -8308,7 +8342,7 @@ async function buildCurrentPentestReport(input) {
   const docs = await loadModuleDocs(input.projectRoot, input.focusModules);
   const tests = await loadTests(input.projectRoot, input.focusModules);
   const osvFindings = await queryOsv(input.snapshot.packages);
-  const osvPath = join38(input.artifactsDir, "dependencies", "osv-results.json");
+  const osvPath = join39(input.artifactsDir, "dependencies", "osv-results.json");
   await writeJson(osvPath, osvFindings);
   const dependencyFindings = await buildDependencyFindings(
     input.snapshot,
@@ -8317,7 +8351,7 @@ async function buildCurrentPentestReport(input) {
   );
   const moduleFindings = buildModuleFindings(docs, tests);
   const secretFindings = await buildSecretFindings(input.artifactsDir);
-  const runtimePayload = await readJsonIfExists(join38(input.artifactsDir, "runtime", "runtime-checks.json"));
+  const runtimePayload = await readJsonIfExists(join39(input.artifactsDir, "runtime", "runtime-checks.json"));
   const runtimeStatus = input.targetUrl ? runtimePayload?.reachable ? {
     target_url: input.targetUrl,
     status: "reachable",
@@ -8343,8 +8377,8 @@ async function buildCurrentPentestReport(input) {
     ...runtimeFindings
   ]);
   const timestamp = toLocalTimestamp(input.reportTimestamp);
-  const reportPath = join38(PATHS.PENTEST_DIR, `${timestamp}.md`);
-  const sidecarPath = join38(PATHS.PENTEST_DIR, `${timestamp}.json`);
+  const reportPath = join39(PATHS.PENTEST_DIR, `${timestamp}.md`);
+  const sidecarPath = join39(PATHS.PENTEST_DIR, `${timestamp}.json`);
   const stack = getPrimaryStack({
     routing: { domain: "coding" },
     stack_profile: input.snapshot.profile
@@ -8397,9 +8431,9 @@ async function buildCurrentPentestReport(input) {
     raw_evidence_paths: [
       relative7(input.projectRoot, osvPath),
       ...[
-        join38(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "finding-index.json"),
-        join38(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "artifacts", "docs-summary.json"),
-        join38(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "artifacts", "tests-summary.json")
+        join39(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "finding-index.json"),
+        join39(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "artifacts", "docs-summary.json"),
+        join39(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "artifacts", "tests-summary.json")
       ]
     ]
   };
@@ -8439,7 +8473,7 @@ var PentestPhase = class {
 
 // src/workflows/pentest-retest.ts
 import { mkdir as mkdir14, writeFile as writeFile14 } from "fs/promises";
-import { dirname as dirname17, join as join39 } from "path";
+import { dirname as dirname18, join as join40 } from "path";
 var RETEST_STEPS = [
   { id: "load-source-report", title: "Load source pentest report" },
   { id: "rerun-evidence", title: "Collect fresh evidence for source findings" },
@@ -8460,7 +8494,7 @@ var PentestRetestWorkflow = class {
     }
     const normalizedSourcePath = normalizeSidecarPath(sourceReportPath);
     const sourceSidecar = await readJsonIfExists(
-      join39(options.projectRoot, normalizedSourcePath)
+      join40(options.projectRoot, normalizedSourcePath)
     );
     if (sourceSidecar === null) {
       throw new Error(`Source pentest sidecar not found at ${normalizedSourcePath}`);
@@ -8485,12 +8519,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 = join39(artifactsDir, "source-report.json");
+      const sourceCopy = join40(artifactsDir, "source-report.json");
       await writeJson(sourceCopy, sourceSidecar);
       this.tracker.markStepCompleted(
         progress,
         "load-source-report",
-        [join39(PATHS.PENTEST_RUNS_DIR, progress.run_id, "artifacts", "source-report.json")],
+        [join40(PATHS.PENTEST_RUNS_DIR, progress.run_id, "artifacts", "source-report.json")],
         [...RETEST_SKILLS.source].map(skillPath)
       );
       await this.tracker.save(options.projectRoot, progress);
@@ -8507,7 +8541,7 @@ var PentestRetestWorkflow = class {
         PENTEST_RUN_ID: progress.run_id,
         PENTEST_ARTIFACT_DIR: artifactsDir,
         PENTEST_TARGET_URL: targetUrl ?? "",
-        PENTEST_SOURCE_REPORT: join39(options.projectRoot, normalizedSourcePath),
+        PENTEST_SOURCE_REPORT: join40(options.projectRoot, normalizedSourcePath),
         PENTEST_DB_CONNECTION_NAME: options.dbConnectionName ?? ""
       };
       const scriptResults = await Promise.all([
@@ -8556,8 +8590,8 @@ var PentestRetestWorkflow = class {
         ...currentReport,
         report_id: toReportId("RETEST", new Date(progress.started_at)),
         workflow: "pentest-retest",
-        report_path: join39(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.md`),
-        sidecar_path: join39(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.json`),
+        report_path: join40(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.md`),
+        sidecar_path: join40(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.json`),
         source_report_path: normalizedSourcePath,
         source_report_id: sourceSidecar.report_id,
         findings: retestFindings,
@@ -8570,7 +8604,7 @@ var PentestRetestWorkflow = class {
           ...[...RETEST_SKILLS.source, ...RETEST_SKILLS.evaluate].map(skillPath)
         ]
       };
-      const findingIndexPath = join39(
+      const findingIndexPath = join40(
         options.projectRoot,
         PATHS.PENTEST_RUNS_DIR,
         progress.run_id,
@@ -8580,14 +8614,14 @@ var PentestRetestWorkflow = class {
       this.tracker.markStepCompleted(
         progress,
         "evaluate-source-findings",
-        [join39(PATHS.PENTEST_RUNS_DIR, progress.run_id, "finding-index.json")],
+        [join40(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(
-        join39(options.projectRoot, progress.sidecar_path)
+        join40(options.projectRoot, progress.sidecar_path)
       ) : null;
       retestReport = existing;
     }
@@ -8601,12 +8635,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(join39(options.projectRoot, retestReport.sidecar_path), retestReport);
-      await mkdir14(dirname17(join39(options.projectRoot, retestReport.report_path)), {
+      await writeJson(join40(options.projectRoot, retestReport.sidecar_path), retestReport);
+      await mkdir14(dirname18(join40(options.projectRoot, retestReport.report_path)), {
         recursive: true
       });
       await writeFile14(
-        join39(options.projectRoot, retestReport.report_path),
+        join40(options.projectRoot, retestReport.report_path),
         buildPentestMarkdown(retestReport)
       );
       this.tracker.markStepCompleted(
@@ -8684,7 +8718,7 @@ var ProjectQuestionPhase = class {
 
 // src/workflows/root-cause-analysis.ts
 import { mkdir as mkdir15, writeFile as writeFile15 } from "fs/promises";
-import { dirname as dirname18, join as join40 } from "path";
+import { dirname as dirname19, join as join41 } from "path";
 var DEFAULT_TITLE_SLUG = "root-cause-analysis";
 var RCA_SECTIONS = [
   "Summary",
@@ -8703,9 +8737,9 @@ 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 = join40(PATHS.RCA_DIR, filename);
-    const outputPath = join40(options.projectRoot, relativePath);
-    await mkdir15(dirname18(outputPath), { recursive: true });
+    const relativePath = join41(PATHS.RCA_DIR, filename);
+    const outputPath = join41(options.projectRoot, relativePath);
+    await mkdir15(dirname19(outputPath), { recursive: true });
     await writeFile15(outputPath, buildRcaDocument(title, options.classification));
     return {
       output_path: relativePath,
@@ -8853,22 +8887,22 @@ var DEFAULT_PHASES = {
 
 // src/pipeline/stream-truncator.ts
 import { appendFile, mkdir as mkdir17 } from "fs/promises";
-import { join as join42, dirname as dirname20 } from "path";
+import { join as join43, dirname as dirname21 } from "path";
 
 // src/resolver/deduplicator.ts
 import { createHash as createHash9 } from "crypto";
 import { readFile as readFile19, writeFile as writeFile17, mkdir as mkdir18 } from "fs/promises";
-import { join as join43, dirname as dirname21 } from "path";
+import { join as join44, dirname as dirname22 } from "path";
 
 // src/scripts/generator.ts
 import { chmodSync as chmodSync2 } from "fs";
 import { mkdir as mkdir19, writeFile as writeFile18 } from "fs/promises";
-import { dirname as dirname22, join as join44 } from "path";
+import { dirname as dirname23, join as join45 } from "path";
 
 // src/skills/cache-manager.ts
 import { createHash as createHash10 } from "crypto";
 import { mkdir as mkdir20, readFile as readFile20, readdir as readdir5, rm as rm2, stat as stat3, writeFile as writeFile19 } from "fs/promises";
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 import fg6 from "fast-glob";
 
 // src/skills/frontmatter-parser.ts
@@ -8893,7 +8927,7 @@ var conditionalProcessor = new ConditionalSectionProcessor();
 
 // src/skills/index-generator.ts
 import { mkdir as mkdir21, readFile as readFile21, writeFile as writeFile20 } from "fs/promises";
-import { dirname as dirname23, join as join46, relative as relative8 } from "path";
+import { dirname as dirname24, join as join47, relative as relative8 } from "path";
 import fg7 from "fast-glob";
 
 // src/skills/loader.ts
@@ -8901,16 +8935,16 @@ import { readFile as readFile22 } from "fs/promises";
 import { basename as basename6 } from "pathe";
 
 // src/update/updater.ts
-import { chmodSync as chmodSync3, existsSync as existsSync17, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
+import { chmodSync as chmodSync3, existsSync as existsSync19, mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "fs";
 import { mkdtemp, readdir as readdir6, readFile as readFile23, rm as rm3 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname24, join as join47, relative as relative9 } from "path";
+import { dirname as dirname25, join as join48, relative as relative9 } from "path";
 var FrameworkUpdater = class {
   constructor(options = {}) {
     this.options = options;
   }
   async run(projectRoot) {
-    const previousVersion = readText(join47(projectRoot, PATHS.FRAMEWORK_VERSION));
+    const previousVersion = readText(join48(projectRoot, PATHS.FRAMEWORK_VERSION));
     const manifest = readManifest(projectRoot);
     const artifactPolicy = new Map(
       manifest?.generated_artifacts.map((artifact) => [artifact.path, artifact.auto_update]) ?? []
@@ -8920,19 +8954,19 @@ var FrameworkUpdater = class {
     const skipped = [];
     const newScripts = [];
     for (const candidate of candidates) {
-      const target = join47(projectRoot, candidate.path);
-      const existed = existsSync17(target);
+      const target = join48(projectRoot, candidate.path);
+      const existed = existsSync19(target);
       const autoUpdate = artifactPolicy.get(candidate.path) ?? candidate.autoUpdate;
       if (existed && autoUpdate === false) {
         skipped.push({
           path: candidate.path,
-          before: readFileSync11(target, "utf8"),
+          before: readFileSync12(target, "utf8"),
           after: candidate.content
         });
         continue;
       }
-      mkdirSync6(dirname24(target), { recursive: true });
-      writeFileSync5(target, candidate.content);
+      mkdirSync6(dirname25(target), { recursive: true });
+      writeFileSync6(target, candidate.content);
       if (candidate.executable === true) {
         chmodSync3(target, 493);
       }
@@ -8941,8 +8975,8 @@ var FrameworkUpdater = class {
         newScripts.push(candidate.path);
       }
     }
-    mkdirSync6(dirname24(join47(projectRoot, PATHS.FRAMEWORK_VERSION)), { recursive: true });
-    writeFileSync5(join47(projectRoot, PATHS.FRAMEWORK_VERSION), `${VERSION}
+    mkdirSync6(dirname25(join48(projectRoot, PATHS.FRAMEWORK_VERSION)), { recursive: true });
+    writeFileSync6(join48(projectRoot, PATHS.FRAMEWORK_VERSION), `${VERSION}
 `);
     return {
       previous_version: previousVersion,
@@ -8962,7 +8996,7 @@ var FrameworkUpdater = class {
     if (profile === null) {
       throw new Error("Cannot update framework-managed artifacts without a project profile");
     }
-    const tempRoot = await mkdtemp(join47(tmpdir(), "paqad-ai-update-"));
+    const tempRoot = await mkdtemp(join48(tmpdir(), "paqad-ai-update-"));
     try {
       const result = await new OnboardingOrchestrator().run({
         projectRoot: tempRoot,
@@ -8982,27 +9016,27 @@ var FrameworkUpdater = class {
   }
 };
 function readManifest(projectRoot) {
-  const path = join47(projectRoot, PATHS.ONBOARDING_MANIFEST);
-  if (!existsSync17(path)) {
+  const path = join48(projectRoot, PATHS.ONBOARDING_MANIFEST);
+  if (!existsSync19(path)) {
     return null;
   }
-  return JSON.parse(readFileSync11(path, "utf8"));
+  return JSON.parse(readFileSync12(path, "utf8"));
 }
 function readProfile(projectRoot) {
   return readProjectProfile(projectRoot);
 }
 function readText(path) {
-  if (!existsSync17(path)) {
+  if (!existsSync19(path)) {
     return null;
   }
-  return readFileSync11(path, "utf8").trim();
+  return readFileSync12(path, "utf8").trim();
 }
 async function collectFiles(root, generated) {
   const paths = generated.length > 0 ? generated : await walk3(root);
   return Promise.all(
     paths.map(async (file) => ({
       path: file,
-      content: await readFile23(join47(root, file), "utf8"),
+      content: await readFile23(join48(root, file), "utf8"),
       autoUpdate: true,
       executable: file.startsWith("scripts/")
     }))
@@ -9012,7 +9046,7 @@ async function walk3(root, current = root) {
   const entries = await readdir6(current, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const absolute = join47(current, entry.name);
+    const absolute = join48(current, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walk3(root, absolute));
       continue;
@@ -9023,31 +9057,31 @@ async function walk3(root, current = root) {
 }
 
 // src/verification/gates/documentation-freshness.ts
-import { existsSync as existsSync18 } from "fs";
-import { join as join48 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { join as join49 } from "path";
 var STALENESS_WINDOW_MS2 = 1e3 * 60 * 60 * 24 * 7;
 
 // src/patterns/pattern-store.ts
 import { readFile as readFile24, writeFile as writeFile21, mkdir as mkdir22, unlink } from "fs/promises";
-import { join as join49, dirname as dirname25 } from "path";
+import { join as join50, dirname as dirname26 } from "path";
 import { homedir as homedir3 } from "os";
-var GLOBAL_PATTERNS_DIR = join49(homedir3(), ".paqad", "patterns");
+var GLOBAL_PATTERNS_DIR = join50(homedir3(), ".paqad", "patterns");
 var PatternStore = class {
   get indexPath() {
-    return join49(GLOBAL_PATTERNS_DIR, "index.json");
+    return join50(GLOBAL_PATTERNS_DIR, "index.json");
   }
   get entriesDir() {
-    return join49(GLOBAL_PATTERNS_DIR, "entries");
+    return join50(GLOBAL_PATTERNS_DIR, "entries");
   }
   async save(pattern) {
     await mkdir22(this.entriesDir, { recursive: true });
-    const entryPath = join49(this.entriesDir, `${pattern.id}.json`);
+    const entryPath = join50(this.entriesDir, `${pattern.id}.json`);
     await writeFile21(entryPath, JSON.stringify(pattern, null, 2), "utf8");
     await this.updateIndex(pattern);
   }
   async load(id) {
     try {
-      const raw = await readFile24(join49(this.entriesDir, `${id}.json`), "utf8");
+      const raw = await readFile24(join50(this.entriesDir, `${id}.json`), "utf8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -9077,12 +9111,12 @@ var PatternStore = class {
     } else {
       index.entries.push(entry);
     }
-    await mkdir22(dirname25(this.indexPath), { recursive: true });
+    await mkdir22(dirname26(this.indexPath), { recursive: true });
     await writeFile21(this.indexPath, JSON.stringify(index, null, 2), "utf8");
   }
   async delete(id) {
     try {
-      await unlink(join49(this.entriesDir, `${id}.json`));
+      await unlink(join50(this.entriesDir, `${id}.json`));
     } catch {
     }
     const index = await this.loadIndex();
@@ -9182,12 +9216,12 @@ ${p.solution}
 
 // src/workflows/template-loader.ts
 import { readFile as readFile25, readdir as readdir7 } from "fs/promises";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 import YAML6 from "yaml";
 
 // src/workflows/engine.ts
 import { readFile as readFile26, writeFile as writeFile23, mkdir as mkdir23 } from "fs/promises";
-import { join as join51, dirname as dirname26 } from "path";
+import { join as join52, dirname as dirname27 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/index.ts
@@ -9367,8 +9401,8 @@ function createPacksCommand() {
 
 // src/cli/commands/refresh.ts
 import { Command as Command7 } from "commander";
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "fs";
-import { join as join52 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "fs";
+import { join as join53 } from "path";
 function createRefreshCommand() {
   return new Command7("refresh").description("Refresh derived framework artifacts").option("--project-root <path>", "Project root", process.cwd()).option("--design-system", "Refresh design-system markdown from design tokens").option("--stack", "Refresh the cached stack snapshot").action(async (options) => {
     const shouldRefreshDesignSystem = options.designSystem ?? true;
@@ -9404,14 +9438,14 @@ function createRefreshCommand() {
   });
 }
 function writeRefreshDrift(projectRoot, refreshDrift) {
-  const path = join52(projectRoot, PATHS.STACK_DRIFT);
+  const path = join53(projectRoot, PATHS.STACK_DRIFT);
   const current = readExistingJson(path);
-  writeFileSync6(path, `${JSON.stringify({ ...current ?? {}, ...refreshDrift }, null, 2)}
+  writeFileSync7(path, `${JSON.stringify({ ...current ?? {}, ...refreshDrift }, null, 2)}
 `);
 }
 function readExistingJson(path) {
   try {
-    return JSON.parse(readFileSync12(path, "utf8"));
+    return JSON.parse(readFileSync13(path, "utf8"));
   } catch {
     return null;
   }