paqad-ai 0.1.4 → 0.1.5

package/dist/cli/index.js

@@ -360,13 +360,18 @@ function buildDetectedStackProfile(input) {
   if (input.fallbackStack === "laravel") {
     frameworks.add("laravel");
   }
-  const versionBands = input.packages.filter((pkg) => VERSIONED_PACKAGES.has(pkg.name)).map((pkg) => ({
-    name: `${pkg.name}:${majorBand(pkg.locked_version || pkg.version_constraint)}`,
-    package_name: pkg.name,
-    range: majorBand(pkg.locked_version || pkg.version_constraint),
-    locked_version: pkg.locked_version,
-    source: pkg.locked_version !== "" && pkg.locked_version !== pkg.version_constraint ? "lockfile" : "manifest"
-  })).sort((left, right) => left.package_name.localeCompare(right.package_name));
+  const versionBands = Array.from(
+    input.packages.filter((pkg) => VERSIONED_PACKAGES.has(pkg.name)).sort(compareVersionBandPackages).reduce(
+      (bands, pkg) => bands.has(pkg.name) ? bands : bands.set(pkg.name, {
+        name: `${pkg.name}:${majorBand(pkg.locked_version || pkg.version_constraint)}`,
+        package_name: pkg.name,
+        range: majorBand(pkg.locked_version || pkg.version_constraint),
+        locked_version: pkg.locked_version,
+        source: pkg.locked_version !== "" && pkg.locked_version !== pkg.version_constraint ? "lockfile" : "manifest"
+      }),
+      /* @__PURE__ */ new Map()
+    ).values()
+  ).sort((left, right) => left.package_name.localeCompare(right.package_name));
   return {
     frameworks: Array.from(frameworks).sort(compareFrameworks),
     traits: Array.from(traits).sort(),
@@ -498,6 +503,15 @@ function deriveReviewTargets(changes) {
 function compareFrameworks(left, right) {
   return frameworkRank(left) - frameworkRank(right) || left.localeCompare(right);
 }
+function compareVersionBandPackages(left, right) {
+  return rootDepth(left.root) - rootDepth(right.root) || left.name.localeCompare(right.name);
+}
+function rootDepth(root) {
+  if (!root || root === ".") {
+    return 0;
+  }
+  return root.split("/").filter(Boolean).length;
+}
 function frameworkRank(name) {
   switch (name) {
     case "laravel":
@@ -749,7 +763,58 @@ var detection_report_schema_default = {
         }
       }
     },
-    timestamp: { type: "string" }
+    timestamp: { type: "string" },
+    repository: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "selected_root",
+        "scan_max_depth",
+        "ignored_paths",
+        "projects",
+        "applications",
+        "primary_project_root"
+      ],
+      properties: {
+        selected_root: { type: "string" },
+        scan_max_depth: { type: "integer" },
+        ignored_paths: { type: "array", items: { type: "string" } },
+        primary_project_root: { type: ["string", "null"] },
+        projects: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["root", "role", "parent_root", "markers", "ecosystems"],
+            properties: {
+              root: { type: "string" },
+              role: { type: "string", enum: ["standalone", "component"] },
+              parent_root: { type: ["string", "null"] },
+              markers: { type: "array", items: { type: "string" } },
+              ecosystems: {
+                type: "array",
+                items: {
+                  type: "string",
+                  enum: ["node", "php", "python", "ruby", "jvm", "go", "rust", "dart"]
+                }
+              }
+            }
+          }
+        },
+        applications: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["root", "component_roots"],
+            properties: {
+              root: { type: "string" },
+              component_roots: { type: "array", items: { type: "string" } }
+            }
+          }
+        }
+      }
+    }
   }
 };
 
@@ -885,6 +950,93 @@ var error_catalog_schema_default = {
   }
 };
 
+// src/validators/schemas/feature-development-policy.schema.json
+var feature_development_policy_schema_default = {
+  $id: "feature-development-policy",
+  type: "object",
+  additionalProperties: false,
+  required: ["schema_version", "stages"],
+  properties: {
+    schema_version: { type: "string", const: "1" },
+    merge_mode: { type: "string", enum: ["append"] },
+    stages: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        planning: { $ref: "#/$defs/stagePolicy" },
+        specification: { $ref: "#/$defs/stagePolicy" },
+        development: { $ref: "#/$defs/stagePolicy" },
+        review: { $ref: "#/$defs/stagePolicy" },
+        checks: { $ref: "#/$defs/stagePolicy" },
+        documentation_sync: { $ref: "#/$defs/stagePolicy" }
+      }
+    }
+  },
+  $defs: {
+    stagePolicy: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        read: {
+          type: "array",
+          items: { type: "string" }
+        },
+        instructions: {
+          type: "array",
+          items: { type: "string" }
+        },
+        required_inputs: {
+          type: "array",
+          items: { type: "string" }
+        },
+        strictness: {
+          type: "object",
+          additionalProperties: { type: "boolean" }
+        },
+        escalation: {
+          type: "object",
+          additionalProperties: {
+            type: "string",
+            enum: ["warn", "ask", "stop"]
+          }
+        },
+        artifacts: {
+          type: "array",
+          items: { type: "string" }
+        },
+        checks: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            use_project_profile_commands: { type: "boolean" },
+            commands: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: [
+                  "install",
+                  "dev",
+                  "test",
+                  "test_single",
+                  "lint",
+                  "format",
+                  "migrate",
+                  "build"
+                ]
+              }
+            },
+            shell_commands: {
+              type: "array",
+              items: { type: "string" }
+            },
+            block_on_failure: { type: "boolean" }
+          }
+        }
+      }
+    }
+  }
+};
+
 // src/validators/schemas/gate-result.schema.json
 var gate_result_schema_default = {
   $id: "gate-result",
@@ -1004,6 +1156,7 @@ var onboarding_manifest_schema_default = {
     "project_root",
     "profile",
     "detected",
+    "repository",
     "generated_at",
     "generated_artifacts"
   ],
@@ -1013,6 +1166,9 @@ var onboarding_manifest_schema_default = {
     project_root: { type: "string" },
     profile: { $ref: "project-profile" },
     detected: { anyOf: [{ $ref: "detection-report" }, { type: "null" }] },
+    repository: {
+      anyOf: [{ $ref: "detection-report#/properties/repository" }, { type: "null" }]
+    },
     generated_at: { type: "string" },
     generated_artifacts: {
       type: "array",
@@ -1814,6 +1970,7 @@ var SCHEMAS = [
   api_endpoint_doc_schema_default,
   integration_doc_schema_default,
   error_catalog_schema_default,
+  feature_development_policy_schema_default,
   skill_frontmatter_schema_default,
   gate_result_schema_default,
   stack_pack_schema_default
@@ -2607,24 +2764,232 @@ function removeActiveCapability(profile, capability) {
 
 // src/detection/detector.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 import fg from "fast-glob";
 
+// src/introspection/stack-introspector.ts
+import { join as join14 } from "path";
+
+// src/repository/discovery.ts
+import { readdir } from "fs/promises";
+import { basename as basename3, join as join10 } from "path";
+var DEFAULT_SCAN_MAX_DEPTH = 5;
+var PROJECT_MARKERS = /* @__PURE__ */ new Map([
+  ["package.json", "node"],
+  ["composer.json", "php"],
+  ["pubspec.yaml", "dart"],
+  ["pyproject.toml", "python"],
+  ["requirements.txt", "python"],
+  ["Pipfile", "python"],
+  ["setup.py", "python"],
+  ["Gemfile", "ruby"],
+  ["go.mod", "go"],
+  ["Cargo.toml", "rust"],
+  ["pom.xml", "jvm"],
+  ["build.gradle", "jvm"],
+  ["build.gradle.kts", "jvm"],
+  ["artisan", "php"],
+  ["manage.py", "python"]
+]);
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".next",
+  ".nuxt",
+  ".dart_tool",
+  ".gradle",
+  ".turbo",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "out",
+  "target",
+  "vendor"
+]);
+var NON_CANONICAL_DIRECTORIES = /* @__PURE__ */ new Set([
+  "__fixtures__",
+  "demo",
+  "demos",
+  "example",
+  "examples",
+  "fixtures",
+  "test-fixtures",
+  "tmp"
+]);
+var COMPONENT_DIRECTORY_NAMES = /* @__PURE__ */ new Set(["client", "frontend", "ui", "web"]);
+async function discoverRepositoryContext(projectRoot, options) {
+  const maxDepth = options?.maxDepth ?? DEFAULT_SCAN_MAX_DEPTH;
+  const ignoredPaths = /* @__PURE__ */ new Set();
+  const candidates = /* @__PURE__ */ new Map();
+  await walk(projectRoot, ".", 0, maxDepth, candidates, ignoredPaths);
+  const sortedCandidates = Array.from(candidates.values()).sort(compareCandidates);
+  const projects = classifyProjects(sortedCandidates);
+  const applications = buildApplications(projects);
+  const primaryProjectRoot = resolvePrimaryProjectRoot(projects, applications);
+  return {
+    selected_root: projectRoot,
+    scan_max_depth: maxDepth,
+    ignored_paths: Array.from(ignoredPaths).sort(),
+    projects,
+    applications,
+    primary_project_root: primaryProjectRoot
+  };
+}
+function prefixRepositoryPath(root, relativePath) {
+  if (root === "." || root === "") {
+    return relativePath;
+  }
+  return join10(root, relativePath);
+}
+async function walk(projectRoot, relativeDir, depth, maxDepth, candidates, ignoredPaths) {
+  const absoluteDir = relativeDir === "." ? projectRoot : join10(projectRoot, relativeDir);
+  let entries;
+  try {
+    entries = await readdir(absoluteDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const entryNames = new Set(entries.map((entry) => entry.name));
+  const markers = Array.from(PROJECT_MARKERS.keys()).filter((marker) => entryNames.has(marker));
+  if (markers.length > 0) {
+    const ecosystems = Array.from(
+      new Set(markers.map((marker) => PROJECT_MARKERS.get(marker)).filter(isDefined))
+    ).sort();
+    candidates.set(relativeDir, {
+      root: relativeDir,
+      role: "standalone",
+      parent_root: null,
+      markers: markers.sort(),
+      ecosystems
+    });
+  }
+  if (depth >= maxDepth) {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const childRelativePath = relativeDir === "." ? entry.name : join10(relativeDir, entry.name);
+    if (IGNORED_DIRECTORIES.has(entry.name) || NON_CANONICAL_DIRECTORIES.has(entry.name)) {
+      ignoredPaths.add(childRelativePath);
+      continue;
+    }
+    await walk(projectRoot, childRelativePath, depth + 1, maxDepth, candidates, ignoredPaths);
+  }
+}
+function classifyProjects(candidates) {
+  const byRoot = new Map(candidates.map((candidate) => [candidate.root, candidate]));
+  const result = [];
+  for (const candidate of candidates) {
+    const ancestors = findAncestorCandidates(candidate.root, byRoot);
+    const parent = ancestors[0] ?? null;
+    const role = parent && isLinkedComponent(parent, candidate) ? "component" : "standalone";
+    result.push({
+      ...candidate,
+      role,
+      parent_root: role === "component" ? parent.root : null
+    });
+  }
+  return result.sort(compareCandidates);
+}
+function findAncestorCandidates(root, candidates) {
+  if (root === ".") {
+    return [];
+  }
+  const segments = root.split("/").filter(Boolean);
+  const ancestors = [];
+  for (let index = segments.length - 1; index >= 1; index -= 1) {
+    const candidate = candidates.get(segments.slice(0, index).join("/"));
+    if (candidate) {
+      ancestors.push(candidate);
+    }
+  }
+  const selectedRoot = candidates.get(".");
+  if (selectedRoot) {
+    ancestors.push(selectedRoot);
+  }
+  return ancestors.sort(compareCandidates);
+}
+function isLinkedComponent(parent, candidate) {
+  const candidateName = basename3(candidate.root);
+  const candidateNodeOnly = candidate.ecosystems.length > 0 && candidate.ecosystems.every((ecosystem) => ecosystem === "node");
+  const parentHasNonNode = parent.ecosystems.some((ecosystem) => ecosystem !== "node");
+  return candidateNodeOnly && parentHasNonNode && COMPONENT_DIRECTORY_NAMES.has(candidateName);
+}
+function buildApplications(projects) {
+  const standaloneRoots = projects.filter((project) => project.role === "standalone").map((project) => project.root);
+  return standaloneRoots.map((root) => ({
+    root,
+    component_roots: projects.filter((project) => project.parent_root === root).map((project) => project.root).sort()
+  }));
+}
+function resolvePrimaryProjectRoot(projects, applications) {
+  if (applications.length === 0) {
+    return null;
+  }
+  const byRoot = new Map(projects.map((project) => [project.root, project]));
+  return [...applications].sort((left, right) => {
+    const leftProject = byRoot.get(left.root);
+    const rightProject = byRoot.get(right.root);
+    return scoreCandidate(rightProject) - scoreCandidate(leftProject) || compareByRoot(left.root, right.root);
+  })[0]?.root ?? null;
+}
+function compareCandidates(left, right) {
+  return compareByRoot(left.root, right.root);
+}
+function compareByRoot(left, right) {
+  return depthOf(left) - depthOf(right) || left.localeCompare(right);
+}
+function depthOf(root) {
+  return root === "." ? 0 : root.split("/").filter(Boolean).length;
+}
+function scoreCandidate(candidate) {
+  if (!candidate) {
+    return -1;
+  }
+  return candidate.markers.reduce((score, marker) => score + markerScore(marker), 0) - depthOf(candidate.root);
+}
+function markerScore(marker) {
+  switch (marker) {
+    case "composer.json":
+    case "package.json":
+    case "pubspec.yaml":
+      return 5;
+    case "artisan":
+    case "manage.py":
+      return 4;
+    case "pyproject.toml":
+    case "Gemfile":
+    case "go.mod":
+    case "Cargo.toml":
+    case "pom.xml":
+    case "build.gradle":
+    case "build.gradle.kts":
+      return 3;
+    default:
+      return 1;
+  }
+}
+function isDefined(value) {
+  return value !== void 0;
+}
+
 // src/introspection/cache.ts
 import { createHash as createHash5 } from "crypto";
 import { mkdir as mkdir6, readFile as readFile6, stat as stat2, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname9, join as join10 } from "path";
+import { dirname as dirname9, join as join11 } from "path";
 var StackSnapshotCache = class {
   async read(projectRoot) {
     try {
-      const raw = await readFile6(join10(projectRoot, PATHS.STACK_SNAPSHOT), "utf8");
+      const raw = await readFile6(join11(projectRoot, PATHS.STACK_SNAPSHOT), "utf8");
       return JSON.parse(raw);
     } catch {
       return null;
     }
   }
   async write(projectRoot, snapshot) {
-    const target = join10(projectRoot, PATHS.STACK_SNAPSHOT);
+    const target = join11(projectRoot, PATHS.STACK_SNAPSHOT);
     await mkdir6(dirname9(target), { recursive: true });
     await writeFile6(target, `${JSON.stringify(snapshot, null, 2)}
 `);
@@ -2633,11 +2998,11 @@ var StackSnapshotCache = class {
     const hashes = {};
     for (const relativePath of relativePaths) {
       try {
-        const content = await readFile6(join10(projectRoot, relativePath), "utf8");
+        const content = await readFile6(join11(projectRoot, relativePath), "utf8");
         hashes[relativePath] = `sha256:${createHash5("sha256").update(content).digest("hex")}`;
       } catch {
         try {
-          const pathStat = await stat2(join10(projectRoot, relativePath));
+          const pathStat = await stat2(join11(projectRoot, relativePath));
           hashes[relativePath] = pathStat.isDirectory() ? "exists:directory" : "exists:file";
         } catch {
           continue;
@@ -2650,10 +3015,10 @@ var StackSnapshotCache = class {
 
 // src/introspection/ecosystems/shared.ts
 import { readFile as readFile7 } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 async function readProjectFile(projectRoot, relativePath) {
   try {
-    return await readFile7(join11(projectRoot, relativePath), "utf8");
+    return await readFile7(join12(projectRoot, relativePath), "utf8");
   } catch {
     return null;
   }
@@ -3133,7 +3498,7 @@ function createDefaultEcosystemParserRegistry() {
 
 // src/introspection/environment-traits.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var COMPOSE_FILES = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
 function detectEnvironmentTraits(projectRoot, options) {
   const packageNames = new Set(options?.packageNames ?? []);
@@ -3141,7 +3506,7 @@ function detectEnvironmentTraits(projectRoot, options) {
   const sources = [];
   const signals = [];
   for (const file of COMPOSE_FILES) {
-    if (existsSync3(join12(projectRoot, file))) {
+    if (existsSync3(join13(projectRoot, file))) {
       traits.add("compose");
       sources.push({
         file,
@@ -3211,14 +3576,14 @@ function listDockerIndicators(projectRoot) {
   const indicators = [];
   const directFiles = ["Dockerfile", "Dockerfile.dev", "Dockerfile.prod"];
   for (const file of directFiles) {
-    if (existsSync3(join12(projectRoot, file))) {
+    if (existsSync3(join13(projectRoot, file))) {
       indicators.push(file);
     }
   }
-  if (existsSync3(join12(projectRoot, "docker"))) {
+  if (existsSync3(join13(projectRoot, "docker"))) {
     indicators.push("docker/");
   }
-  if (existsSync3(join12(projectRoot, ".docker"))) {
+  if (existsSync3(join13(projectRoot, ".docker"))) {
     indicators.push(".docker/");
   }
   return indicators;
@@ -3230,7 +3595,7 @@ function detectSailReferenceFile(projectRoot) {
   const candidates = ["composer.json", "package.json"];
   for (const relativePath of candidates) {
     try {
-      const content = readFileSync3(join12(projectRoot, relativePath), "utf8");
+      const content = readFileSync3(join13(projectRoot, relativePath), "utf8");
       if (content.includes("vendor/bin/sail")) {
         return relativePath;
       }
@@ -3246,50 +3611,101 @@ var StackIntrospector = class {
   cache = new StackSnapshotCache();
   parserRegistry = createDefaultEcosystemParserRegistry();
   async snapshot(projectRoot) {
-    const currentHashes = await this.cache.hashFiles(projectRoot, [
-      ...this.parserRegistry.getKnownFiles(),
-      "docker-compose.yml",
-      "docker-compose.yaml",
-      "compose.yml",
-      "compose.yaml",
-      "Dockerfile",
-      "Dockerfile.dev",
-      "Dockerfile.prod",
-      "docker",
-      ".docker"
-    ]);
+    const repository = await discoverRepositoryContext(projectRoot);
+    const candidateRoots = repository.projects.map((project) => project.root);
+    const currentHashes = await this.cache.hashFiles(
+      projectRoot,
+      buildRepositoryHashInputs(candidateRoots, this.parserRegistry.getKnownFiles())
+    );
     const cached = await this.cache.read(projectRoot);
     if (cached !== null && JSON.stringify(cached.source_hashes) === JSON.stringify(currentHashes)) {
       return cached;
     }
-    const results = await this.parserRegistry.parseProject(projectRoot);
-    const toolchains = results.map((result) => result.toolchain);
-    const packages = results.flatMap((result) => result.packages);
-    const environment = detectEnvironmentTraits(projectRoot, {
-      packageNames: packages.map((pkg) => pkg.name)
-    });
+    const toolchains = [];
+    const packages = [];
+    const environmentSources = [];
+    const environmentTraits = /* @__PURE__ */ new Set();
+    for (const project of repository.projects) {
+      const absoluteRoot = project.root === "." ? projectRoot : join14(projectRoot, project.root);
+      const results = await this.parserRegistry.parseProject(absoluteRoot);
+      for (const result of results) {
+        toolchains.push({
+          ...result.toolchain,
+          lockfile: prefixRepositoryPath(project.root, result.toolchain.lockfile)
+        });
+        packages.push(
+          ...result.packages.map((pkg) => ({
+            ...pkg,
+            root: project.root
+          }))
+        );
+      }
+      const packageNames = packages.filter((pkg) => pkg.root === project.root).map((pkg) => pkg.name);
+      const environment = detectEnvironmentTraits(absoluteRoot, { packageNames });
+      for (const trait of environment.traits) {
+        environmentTraits.add(trait);
+      }
+      environmentSources.push(
+        ...environment.sources.map((source) => ({
+          ...source,
+          file: prefixRepositoryPath(project.root, source.file)
+        }))
+      );
+    }
     const hashedSources = Object.keys(currentHashes).sort().map((file) => ({
       file,
       kind: classifySourceKind(file),
       detail: classifySourceKind(file) === "config" ? "Used for environment trait detection" : "Used for stack detection and version resolution"
     }));
-    const sources = dedupeSources([...hashedSources, ...environment.sources]);
+    const sources = dedupeSources([...hashedSources, ...environmentSources]);
     const snapshot = {
       generated_at: (/* @__PURE__ */ new Date()).toISOString(),
       source_hashes: currentHashes,
-      toolchains,
+      toolchains: dedupeToolchains(toolchains),
       packages,
       profile: buildDetectedStackProfile({
-        toolchains,
+        toolchains: dedupeToolchains(toolchains),
         packages,
         sources,
-        detectedTraits: environment.traits
-      })
+        detectedTraits: Array.from(environmentTraits).sort()
+      }),
+      repository
     };
     await this.cache.write(projectRoot, snapshot);
     return snapshot;
   }
 };
+function buildRepositoryHashInputs(candidateRoots, knownFiles) {
+  const inputs = /* @__PURE__ */ new Set();
+  const extraFiles = [
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml",
+    "Dockerfile",
+    "Dockerfile.dev",
+    "Dockerfile.prod",
+    "docker",
+    ".docker"
+  ];
+  for (const root of candidateRoots.length > 0 ? candidateRoots : ["."]) {
+    for (const file of [...knownFiles, ...extraFiles]) {
+      inputs.add(prefixRepositoryPath(root, file));
+    }
+  }
+  return Array.from(inputs).sort();
+}
+function dedupeToolchains(toolchains) {
+  const seen = /* @__PURE__ */ new Set();
+  return toolchains.filter((toolchain) => {
+    const key = `${toolchain.ecosystem}:${toolchain.package_manager}:${toolchain.lockfile}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
 function classifySourceKind(file) {
   if (file.endsWith(".lock") || file.includes("lock")) {
     return "lockfile";
@@ -3323,17 +3739,18 @@ function buildDetectionReport(input) {
     detection_phase: input.detectionPhase,
     confidence: input.confidence,
     signals: input.signals,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    repository: input.repository
   };
 }
 
 // src/detection/signals/short-video.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join13 } from "path";
+import { join as join15 } from "path";
 import { parse } from "yaml";
 function detectShortVideoSignals(projectRoot) {
-  const profilePath = join13(projectRoot, ".paqad", "project-profile.yaml");
-  const markerPath = join13(projectRoot, ".short-video-project");
+  const profilePath = join15(projectRoot, ".paqad", "project-profile.yaml");
+  const markerPath = join15(projectRoot, ".short-video-project");
   const signals = [];
   if (existsSync4(profilePath)) {
     const profile = parse(readFileSync4(profilePath, "utf8"));
@@ -3363,10 +3780,7 @@ var Detector = class {
   packLoader = new StackPackLoader();
   async detect(projectRoot) {
     const snapshot = await this.introspector.snapshot(projectRoot);
-    const packageNames = new Set(snapshot.packages.map((pkg) => pkg.name));
-    const environment = detectEnvironmentTraits(projectRoot, {
-      packageNames: snapshot.packages.map((pkg) => pkg.name)
-    });
+    const repository = snapshot.repository ?? emptyRepositoryContext(projectRoot);
     const registry = this.packLoader.load({
       runtimeRoot: getRuntimeRoot(),
       projectRoot
@@ -3374,17 +3788,24 @@ var Detector = class {
     const allPacks = Array.from(registry.packs.values());
     const frameworkPacks = allPacks.filter((p) => (p.manifest.tier ?? "framework") === "framework");
     const archetypePacks = allPacks.filter((p) => p.manifest.tier === "archetype");
-    const frameworkMatches = frameworkPacks.map((pack) => evaluatePack(projectRoot, pack, packageNames)).filter((match) => match !== null).sort(compareMatchedPacks);
-    let matchedPacks;
-    let detectionPhase;
-    if (frameworkMatches.length > 0) {
-      matchedPacks = frameworkMatches;
-      detectionPhase = "framework";
-    } else {
-      const archetypeMatches = archetypePacks.map((pack) => evaluatePack(projectRoot, pack, packageNames)).filter((match) => match !== null).sort(compareMatchedPacks);
-      matchedPacks = archetypeMatches;
-      detectionPhase = archetypeMatches.length > 0 ? "archetype" : "none";
-    }
+    const applications = repository.applications.length > 0 ? repository.applications : [{ root: ".", component_roots: [] }];
+    const applicationResults = applications.map(
+      (application) => detectApplication(
+        projectRoot,
+        application,
+        snapshot.packages,
+        frameworkPacks,
+        archetypePacks
+      )
+    ).sort(compareApplicationResults);
+    const primaryResult = applicationResults[0];
+    const matchedPacks = primaryResult?.matches ?? [];
+    const detectionPhase = primaryResult?.detectionPhase ?? "none";
+    const repositoryEnvironment = mergeEnvironmentTraits(
+      projectRoot,
+      repository.projects.map((project) => project.root),
+      snapshot.packages
+    );
     if (matchedPacks.length === 0) {
       const shortVideoSignals = detectShortVideoSignals(projectRoot);
       if (shortVideoSignals.length > 0) {
@@ -3395,58 +3816,97 @@ var Detector = class {
           detectedTraits: [],
           recommendedCapabilities: ["content"],
           detectionPhase: "none",
-          signals: [...shortVideoSignals, ...environment.signals],
-          capabilities: environment.traits,
-          confidence: "low"
+          signals: [...shortVideoSignals, ...repositoryEnvironment.signals],
+          capabilities: repositoryEnvironment.traits,
+          confidence: "low",
+          repository
         });
       }
       return buildDetectionReport({
         domain: null,
         stack: null,
         matchedPacks: [],
-        detectedTraits: environment.traits,
+        detectedTraits: repositoryEnvironment.traits,
         recommendedCapabilities: ["content"],
         detectionPhase: "none",
-        capabilities: environment.traits,
-        signals: environment.signals,
-        confidence: "low"
+        capabilities: repositoryEnvironment.traits,
+        signals: repositoryEnvironment.signals,
+        confidence: "low",
+        repository
       });
     }
     const topScore = matchedPacks[0].score;
     const topMatches = matchedPacks.filter((match) => match.score === topScore);
     const ambiguous = topMatches.length > 1;
     const detectedTraits = Array.from(
-      /* @__PURE__ */ new Set([...matchedPacks.flatMap((match) => match.traits), ...environment.traits])
+      /* @__PURE__ */ new Set([
+        ...applicationResults.flatMap((result) => result.matches.flatMap((match) => match.traits)),
+        ...repositoryEnvironment.traits
+      ])
+    ).sort();
+    const repositoryMatchedPacks = Array.from(
+      new Set(applicationResults.flatMap((result) => result.matches.map((match) => match.name)))
     ).sort();
+    const confidence = ambiguous ? "low" : applicationResults.length > 1 ? "medium" : scoreToConfidence(topScore);
     return buildDetectionReport({
       domain: ambiguous ? null : "coding",
       stack: ambiguous ? null : matchedPacks[0].name,
-      matchedPacks: matchedPacks.map((match) => match.name),
+      matchedPacks: repositoryMatchedPacks,
       detectedTraits,
       recommendedCapabilities: ["content", "coding", "security"],
       detectionPhase,
       capabilities: detectedTraits.filter(isCapability2),
-      signals: [...matchedPacks.flatMap((match) => match.signals), ...environment.signals],
-      confidence: ambiguous ? "low" : scoreToConfidence(topScore)
+      signals: [
+        ...applicationResults.flatMap((result) => result.matches.flatMap((match) => match.signals)),
+        ...repositoryEnvironment.signals
+      ],
+      confidence,
+      repository
     });
   }
 };
-function evaluatePack(projectRoot, pack, packageNames) {
+function detectApplication(projectRoot, application, packages, frameworkPacks, archetypePacks) {
+  const roots = [application.root, ...application.component_roots];
+  const packageNames = new Set(
+    packages.filter((pkg) => roots.includes(pkg.root ?? ".")).map((pkg) => pkg.name)
+  );
+  const environment = mergeEnvironmentTraits(projectRoot, roots, packages);
+  const frameworkMatches = frameworkPacks.map((pack) => evaluatePack(projectRoot, roots, pack, packageNames)).filter((match) => match !== null).sort(compareMatchedPacks);
+  if (frameworkMatches.length > 0) {
+    return {
+      application,
+      matches: frameworkMatches,
+      detectionPhase: "framework",
+      environment
+    };
+  }
+  const archetypeMatches = archetypePacks.map((pack) => evaluatePack(projectRoot, roots, pack, packageNames)).filter((match) => match !== null).sort(compareMatchedPacks);
+  return {
+    application,
+    matches: archetypeMatches,
+    detectionPhase: archetypeMatches.length > 0 ? "archetype" : "none",
+    environment
+  };
+}
+function evaluatePack(projectRoot, roots, pack, packageNames) {
   const signals = [
     ...evaluateRules(
       projectRoot,
+      roots,
       pack.manifest.name,
       pack.manifest.detection.manifests,
       packageNames
     ),
     ...evaluateRules(
       projectRoot,
+      roots,
       pack.manifest.name,
       pack.manifest.detection.lockfiles,
       packageNames
     ),
     ...evaluateRules(
       projectRoot,
+      roots,
       pack.manifest.name,
       pack.manifest.detection.heuristics,
       packageNames
@@ -3455,7 +3915,7 @@ function evaluatePack(projectRoot, pack, packageNames) {
   if (signals.length === 0) {
     return null;
   }
-  const traitMatches = detectTraits(projectRoot, pack.manifest.traits ?? [], packageNames);
+  const traitMatches = detectTraits(projectRoot, roots, pack.manifest.traits ?? [], packageNames);
   const allSignals = [...signals, ...traitMatches.signals];
   return {
     name: pack.manifest.name,
@@ -3464,27 +3924,38 @@ function evaluatePack(projectRoot, pack, packageNames) {
     traits: traitMatches.names
   };
 }
-function evaluateRules(projectRoot, implies, rules, packageNames) {
-  return (rules ?? []).map((rule) => evaluateRule(projectRoot, implies, rule, packageNames)).filter((signal) => signal !== null);
+function evaluateRules(projectRoot, roots, implies, rules, packageNames) {
+  return (rules ?? []).map((rule) => evaluateRule(projectRoot, roots, implies, rule, packageNames)).filter((signal) => signal !== null);
 }
-function evaluateRule(projectRoot, implies, rule, packageNames) {
-  const fileMatched = rule.file ? existsSync5(join14(projectRoot, rule.file)) : true;
-  const directoryMatched = rule.directory ? existsSync5(join14(projectRoot, rule.directory)) : true;
+function evaluateRule(projectRoot, roots, implies, rule, packageNames) {
   const packagesMatched = rule.packages === void 0 || rule.packages.every((pkg) => packageNames.has(pkg));
-  const patternsMatched = rule.patterns === void 0 || rule.patterns.every((pattern) => fg.sync(pattern, { cwd: projectRoot }).length > 0);
-  const contentMatched = rule.content_match === void 0 || rule.file !== void 0 && existsSync5(join14(projectRoot, rule.file)) && readFileSync5(join14(projectRoot, rule.file), "utf8").includes(rule.content_match);
-  const fieldsMatched = evaluateFieldRules(projectRoot, rule);
-  const fieldAbsentMatched = evaluateFieldAbsentRules(projectRoot, rule);
-  if (!fileMatched || !directoryMatched || !packagesMatched || !patternsMatched || !contentMatched || !fieldsMatched || !fieldAbsentMatched) {
+  const matchedRoot = roots.find(
+    (root) => matchesRuleAtRoot(projectRoot, root, rule, packageNames)
+  );
+  if (!packagesMatched || matchedRoot === void 0) {
     return null;
   }
   return {
     signal: buildRuleSignal(rule, implies),
-    file: rule.file ?? rule.directory ?? rule.patterns?.[0] ?? "package metadata",
+    file: prefixRepositoryPath(
+      matchedRoot,
+      rule.file ?? rule.directory ?? rule.patterns?.[0] ?? "package metadata"
+    ),
     implies,
     confidence: rule.file && rule.packages ? "high" : rule.file || rule.directory ? "medium" : "low"
   };
 }
+function matchesRuleAtRoot(projectRoot, root, rule, packageNames) {
+  const absoluteRoot = root === "." ? projectRoot : join16(projectRoot, root);
+  const fileMatched = rule.file ? existsSync5(join16(absoluteRoot, rule.file)) : true;
+  const directoryMatched = rule.directory ? existsSync5(join16(absoluteRoot, rule.directory)) : true;
+  const patternsMatched = rule.patterns === void 0 || rule.patterns.every((pattern) => fg.sync(pattern, { cwd: absoluteRoot }).length > 0);
+  const contentMatched = rule.content_match === void 0 || rule.file !== void 0 && existsSync5(join16(absoluteRoot, rule.file)) && readFileSync5(join16(absoluteRoot, rule.file), "utf8").includes(rule.content_match);
+  const fieldsMatched = evaluateFieldRules(absoluteRoot, rule);
+  const fieldAbsentMatched = evaluateFieldAbsentRules(absoluteRoot, rule);
+  const packagesMatched = rule.packages === void 0 || rule.packages.every((pkg) => packageNames.has(pkg));
+  return fileMatched && directoryMatched && patternsMatched && contentMatched && fieldsMatched && fieldAbsentMatched && packagesMatched;
+}
 function evaluateFieldRules(projectRoot, rule) {
   if (!rule.fields?.length) return true;
   if (!rule.file) return false;
@@ -3528,7 +3999,7 @@ function getNestedField(obj, dotPath) {
   return current;
 }
 function parseManifestFile(projectRoot, file) {
-  const filePath = join14(projectRoot, file);
+  const filePath = join16(projectRoot, file);
   if (!existsSync5(filePath)) return null;
   try {
     const content = readFileSync5(filePath, "utf8");
@@ -3537,7 +4008,7 @@ function parseManifestFile(projectRoot, file) {
     return null;
   }
 }
-function detectTraits(projectRoot, traits, packageNames) {
+function detectTraits(projectRoot, roots, traits, packageNames) {
   const names = [];
   const signals = [];
   for (const trait of traits) {
@@ -3551,21 +4022,31 @@ function detectTraits(projectRoot, traits, packageNames) {
       });
       continue;
     }
-    if (trait.detect_file && existsSync5(join14(projectRoot, trait.detect_file))) {
+    const fileRoot = trait.detect_file ? roots.find(
+      (root) => existsSync5(
+        join16(root === "." ? projectRoot : join16(projectRoot, root), trait.detect_file)
+      )
+    ) : void 0;
+    if (trait.detect_file && fileRoot) {
       names.push(trait.name);
       signals.push({
         signal: `${trait.name} detected from ${trait.detect_file}`,
-        file: trait.detect_file,
+        file: prefixRepositoryPath(fileRoot, trait.detect_file),
         implies: trait.name,
         confidence: "medium"
       });
       continue;
     }
-    if (trait.detect_directory && existsSync5(join14(projectRoot, trait.detect_directory))) {
+    const directoryRoot = trait.detect_directory ? roots.find(
+      (root) => existsSync5(
+        join16(root === "." ? projectRoot : join16(projectRoot, root), trait.detect_directory)
+      )
+    ) : void 0;
+    if (trait.detect_directory && directoryRoot) {
       names.push(trait.name);
       signals.push({
         signal: `${trait.name} detected from ${trait.detect_directory}`,
-        file: trait.detect_directory,
+        file: prefixRepositoryPath(directoryRoot, trait.detect_directory),
         implies: trait.name,
         confidence: "medium"
       });
@@ -3594,12 +4075,68 @@ function buildRuleSignal(rule, implies) {
 function compareMatchedPacks(left, right) {
   return right.score - left.score || left.name.localeCompare(right.name);
 }
+function compareApplicationResults(left, right) {
+  const leftScore = left.matches[0]?.score ?? -1;
+  const rightScore = right.matches[0]?.score ?? -1;
+  return rightScore - leftScore || left.application.root.localeCompare(right.application.root);
+}
 function scoreToConfidence(score) {
   if (score >= 2) {
     return "high";
   }
   return "low";
 }
+function mergeEnvironmentTraits(projectRoot, roots, packages) {
+  const traits = /* @__PURE__ */ new Set();
+  const signals = [];
+  const sources = [];
+  for (const root of roots.length > 0 ? roots : ["."]) {
+    const packageNames = packages.filter((pkg) => (pkg.root ?? ".") === root).map((pkg) => pkg.name);
+    const absoluteRoot = root === "." ? projectRoot : join16(projectRoot, root);
+    const environment = detectEnvironmentTraits(absoluteRoot, { packageNames });
+    for (const trait of environment.traits) {
+      traits.add(trait);
+    }
+    sources.push(
+      ...environment.sources.map((source) => ({
+        ...source,
+        file: prefixRepositoryPath(root, source.file)
+      }))
+    );
+    signals.push(
+      ...environment.signals.map((signal) => ({
+        ...signal,
+        file: prefixRepositoryPath(root, signal.file)
+      }))
+    );
+  }
+  return {
+    traits: Array.from(traits).sort(),
+    sources,
+    signals: dedupeSignals(signals)
+  };
+}
+function dedupeSignals(signals) {
+  const seen = /* @__PURE__ */ new Set();
+  return signals.filter((signal) => {
+    const key = `${signal.signal}:${signal.file}:${signal.implies}:${signal.confidence}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+function emptyRepositoryContext(projectRoot) {
+  return {
+    selected_root: projectRoot,
+    scan_max_depth: 0,
+    ignored_paths: [],
+    projects: [],
+    applications: [],
+    primary_project_root: null
+  };
+}
 function isCapability2(value) {
   return [
     "inertia",
@@ -3623,20 +4160,20 @@ function isCapability2(value) {
 
 // src/detection/signals/flutter.ts
 import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
-import { join as join15 } from "path";
+import { join as join17 } from "path";
 import { parse as parse2 } from "yaml";
 
 // src/detection/signals/laravel.ts
 import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
-import { join as join16 } from "path";
+import { join as join18 } from "path";
 
 // src/detection/signals/react.ts
 import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 
 // src/detection/signals/vue.ts
 import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 
 // src/design-tokens/defaults.ts
 var DEFAULT_DESIGN_TOKENS = {
@@ -3750,13 +4287,13 @@ var DEFAULT_DESIGN_TOKENS = {
 
 // src/design-tokens/service.ts
 import { mkdir as mkdir7, readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname10, join as join19 } from "path";
+import { dirname as dirname10, join as join21 } from "path";
 var DesignTokenService = class {
   constructor(validator = new SchemaValidator()) {
     this.validator = validator;
   }
   async seed(projectRoot) {
-    const target = join19(projectRoot, PATHS.DESIGN_TOKENS_FILE);
+    const target = join21(projectRoot, PATHS.DESIGN_TOKENS_FILE);
     await mkdir7(dirname10(target), { recursive: true });
     await writeFile7(target, `${JSON.stringify(DEFAULT_DESIGN_TOKENS, null, 2)}
 `, {
@@ -3768,7 +4305,7 @@ var DesignTokenService = class {
     });
   }
   async load(projectRoot) {
-    const target = join19(projectRoot, PATHS.DESIGN_TOKENS_FILE);
+    const target = join21(projectRoot, PATHS.DESIGN_TOKENS_FILE);
     const raw = await readFile8(target, "utf8");
     const parsed = JSON.parse(raw);
     const validation = this.validator.validate("design-tokens", parsed);
@@ -3785,27 +4322,27 @@ var DesignTokenService = class {
     const sections = groupTokens(flattened);
     return [
       {
-        path: join19(PATHS.DESIGN_SYSTEM_DIR, "tokens.md"),
+        path: join21(PATHS.DESIGN_SYSTEM_DIR, "tokens.md"),
         content: buildTokensMarkdown(flattened)
       },
       {
-        path: join19(PATHS.DESIGN_SYSTEM_DIR, "components.md"),
+        path: join21(PATHS.DESIGN_SYSTEM_DIR, "components.md"),
         content: buildSectionMarkdown("Component Defaults", sections.components)
       },
       {
-        path: join19(PATHS.DESIGN_SYSTEM_DIR, "motion.md"),
+        path: join21(PATHS.DESIGN_SYSTEM_DIR, "motion.md"),
         content: buildSectionMarkdown("Motion", sections.motion)
       },
       {
-        path: join19(PATHS.DESIGN_SYSTEM_DIR, "accessibility.md"),
+        path: join21(PATHS.DESIGN_SYSTEM_DIR, "accessibility.md"),
         content: buildSectionMarkdown("Accessibility", sections.accessibility)
       },
       {
-        path: join19(PATHS.DESIGN_SYSTEM_DIR, "responsive.md"),
+        path: join21(PATHS.DESIGN_SYSTEM_DIR, "responsive.md"),
         content: buildResponsiveMarkdown(sections.spacing)
       },
       {
-        path: join19(PATHS.DESIGN_SYSTEM_DIR, "patterns.md"),
+        path: join21(PATHS.DESIGN_SYSTEM_DIR, "patterns.md"),
         content: buildPatternsMarkdown(flattened)
       }
     ];
@@ -3814,7 +4351,7 @@ var DesignTokenService = class {
     const docs = await this.generateDocs(projectRoot);
     await Promise.all(
       docs.map(async (artifact) => {
-        const target = join19(projectRoot, artifact.path);
+        const target = join21(projectRoot, artifact.path);
         await mkdir7(dirname10(target), { recursive: true });
         await writeFile7(target, artifact.content);
       })
@@ -3865,7 +4402,7 @@ ${flutterEntries}
     const artifacts = await this.exportTheme(projectRoot, stack);
     await Promise.all(
       artifacts.map(async (artifact) => {
-        const target = join19(projectRoot, artifact.path);
+        const target = join21(projectRoot, artifact.path);
         await mkdir7(dirname10(target), { recursive: true });
         await writeFile7(target, artifact.content);
       })
@@ -3954,7 +4491,7 @@ function toIdentifier(value) {
 
 // src/health/checker.ts
 import { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync10, statSync } from "fs";
-import { join as join20 } from "path";
+import { join as join22 } from "path";
 var STALENESS_WINDOW_MS = 1e3 * 60 * 60 * 24 * 7;
 var HealthChecker = class {
   validator = new SchemaValidator();
@@ -3989,7 +4526,7 @@ var HealthChecker = class {
     return readProjectProfile(projectRoot);
   }
   detectModules(projectRoot) {
-    const modulesRoot = join20(projectRoot, "docs/modules");
+    const modulesRoot = join22(projectRoot, "docs/modules");
     if (!existsSync10(modulesRoot)) {
       return [];
     }
@@ -3997,7 +4534,7 @@ var HealthChecker = class {
   }
   checkFrameworkArtifacts(projectRoot) {
     const required = [PATHS.PROJECT_PROFILE, PATHS.FRAMEWORK_VERSION, PATHS.FRAMEWORK_PATH];
-    const missing = required.filter((relative11) => !existsSync10(join20(projectRoot, relative11)));
+    const missing = required.filter((relative11) => !existsSync10(join22(projectRoot, relative11)));
     return missing.length === 0 ? pass("Framework artifacts exist", "Framework artifacts are present") : fail(
       "Framework artifacts exist",
       `Missing framework artifacts: ${missing.join(", ")}`,
@@ -4020,15 +4557,15 @@ var HealthChecker = class {
     );
   }
   checkInstructionCopies(projectRoot, profile) {
-    const rulesRoot = join20(projectRoot, PATHS.RULES_DIR);
+    const rulesRoot = join22(projectRoot, PATHS.RULES_DIR);
     const stack = profile === null ? null : getPrimaryStack(profile);
-    const toolsRoot = stack === null || profile === null || getProfileDomain(profile) !== "coding" ? null : join20(projectRoot, PATHS.TOOLS_DIR, stack);
+    const toolsRoot = stack === null || profile === null || getProfileDomain(profile) !== "coding" ? null : join22(projectRoot, PATHS.TOOLS_DIR, stack);
     const missing = [];
     if (!existsSync10(rulesRoot)) {
       missing.push(PATHS.RULES_DIR);
     }
     if (toolsRoot !== null && !existsSync10(toolsRoot)) {
-      missing.push(join20(PATHS.TOOLS_DIR, stack ?? "unknown"));
+      missing.push(join22(PATHS.TOOLS_DIR, stack ?? "unknown"));
     }
     return missing.length === 0 ? pass("Instruction copies exist", "Copied rules and tools are present") : fail(
       "Instruction copies exist",
@@ -4038,9 +4575,9 @@ var HealthChecker = class {
   }
   checkIndexesCurrent(projectRoot) {
     const missing = REGISTRIES.filter(
-      (registry) => !existsSync10(join20(projectRoot, PATHS.REGISTRIES_DIR, registry))
+      (registry) => !existsSync10(join22(projectRoot, PATHS.REGISTRIES_DIR, registry))
     );
-    const statusPath = join20(projectRoot, ".paqad/indexes/registry-status.json");
+    const statusPath = join22(projectRoot, ".paqad/indexes/registry-status.json");
     if (missing.length > 0 || !existsSync10(statusPath)) {
       return warn(
         "Indexes are current",
@@ -4053,7 +4590,7 @@ var HealthChecker = class {
   }
   checkAdapterConfig(projectRoot) {
     const configs = [PATHS.CLAUDE_MD, PATHS.AGENTS_MD, PATHS.GEMINI_MD];
-    const existing = configs.filter((config) => existsSync10(join20(projectRoot, config)));
+    const existing = configs.filter((config) => existsSync10(join22(projectRoot, config)));
     return existing.length > 0 ? pass("Adapter config is present", "Adapter config files are present") : fail(
       "Adapter config is present",
       "No adapter config files were found",
@@ -4083,7 +4620,7 @@ var HealthChecker = class {
     );
   }
   checkStableFrameworkPaths(projectRoot) {
-    const frameworkPath = join20(projectRoot, PATHS.FRAMEWORK_PATH);
+    const frameworkPath = join22(projectRoot, PATHS.FRAMEWORK_PATH);
     if (!existsSync10(frameworkPath)) {
       return fail(
         "Stable framework paths only",
@@ -4100,7 +4637,7 @@ var HealthChecker = class {
     ) : pass("Stable framework paths only", "Framework path is stable");
   }
   checkBrokenScaffold(projectRoot) {
-    const broken = walk(projectRoot).filter(
+    const broken = walk2(projectRoot).filter(
       (path) => path.endsWith(".partial") || path.endsWith(".tmp")
     );
     return broken.length === 0 ? pass("No broken scaffold state", "No partial scaffold artifacts detected") : fail(
@@ -4114,7 +4651,7 @@ var HealthChecker = class {
       return pass("UI docs present", "UI docs are checked after documentation generation");
     }
     const missing = modules.filter(
-      (moduleName) => !existsSync10(join20(projectRoot, "docs/modules", moduleName, "ui/screens.md")) || !existsSync10(join20(projectRoot, "docs/modules", moduleName, "ui/components.md")) || !existsSync10(join20(projectRoot, "docs/modules", moduleName, "ui/states.md"))
+      (moduleName) => !existsSync10(join22(projectRoot, "docs/modules", moduleName, "ui/screens.md")) || !existsSync10(join22(projectRoot, "docs/modules", moduleName, "ui/components.md")) || !existsSync10(join22(projectRoot, "docs/modules", moduleName, "ui/states.md"))
     );
     return missing.length === 0 ? pass("UI docs present", "UI docs are present for all modules with UI docs") : fail(
       "UI docs present",
@@ -4127,7 +4664,7 @@ var HealthChecker = class {
       return pass("API docs present", "API docs are checked after documentation generation");
     }
     const missing = modules.filter(
-      (moduleName) => !existsSync10(join20(projectRoot, "docs/modules", moduleName, "api/endpoints.md")) || !existsSync10(join20(projectRoot, "docs/modules", moduleName, "api/schemas.md")) || !existsSync10(join20(projectRoot, "docs/modules", moduleName, "api/error-codes.md"))
+      (moduleName) => !existsSync10(join22(projectRoot, "docs/modules", moduleName, "api/endpoints.md")) || !existsSync10(join22(projectRoot, "docs/modules", moduleName, "api/schemas.md")) || !existsSync10(join22(projectRoot, "docs/modules", moduleName, "api/error-codes.md"))
     );
     return missing.length === 0 ? pass("API docs present", "API docs are present for all modules with APIs") : fail(
       "API docs present",
@@ -4143,7 +4680,7 @@ var HealthChecker = class {
       );
     }
     const missing = modules.filter(
-      (moduleName) => !existsSync10(join20(projectRoot, "docs/modules", moduleName, "integration/events.md")) || !existsSync10(join20(projectRoot, "docs/modules", moduleName, "integration/contracts.md"))
+      (moduleName) => !existsSync10(join22(projectRoot, "docs/modules", moduleName, "integration/events.md")) || !existsSync10(join22(projectRoot, "docs/modules", moduleName, "integration/contracts.md"))
     );
     return missing.length === 0 ? pass("Integration docs present", "Integration docs are present for all modules") : fail(
       "Integration docs present",
@@ -4159,7 +4696,7 @@ var HealthChecker = class {
       );
     }
     const missing = modules.filter(
-      (moduleName) => !existsSync10(join20(projectRoot, "docs/modules", moduleName, "error-catalog.md"))
+      (moduleName) => !existsSync10(join22(projectRoot, "docs/modules", moduleName, "error-catalog.md"))
     );
     return missing.length === 0 ? pass("Error catalog present", "Error catalogs are present for all modules") : fail(
       "Error catalog present",
@@ -4176,7 +4713,7 @@ var HealthChecker = class {
       );
     }
     const candidates = [".claude/settings.mcp.json", ".codex/mcp.json", ".gemini/mcp.json"];
-    const existing = candidates.filter((candidate) => existsSync10(join20(projectRoot, candidate)));
+    const existing = candidates.filter((candidate) => existsSync10(join22(projectRoot, candidate)));
     const expectedServers = getServersForStack(
       getPrimaryStack(profile),
       getLegacyCapabilities(profile)
@@ -4191,7 +4728,7 @@ var HealthChecker = class {
     const configured = /* @__PURE__ */ new Set();
     for (const path of existing) {
       try {
-        const parsed = JSON.parse(readFileSync10(join20(projectRoot, path), "utf8"));
+        const parsed = JSON.parse(readFileSync10(join22(projectRoot, path), "utf8"));
         Object.keys(parsed.mcpServers ?? {}).forEach((server) => configured.add(server));
       } catch {
         continue;
@@ -4205,7 +4742,7 @@ var HealthChecker = class {
     );
   }
   checkSkillCache(projectRoot) {
-    const cacheDir = join20(projectRoot, PATHS.SKILL_CACHE_DIR);
+    const cacheDir = join22(projectRoot, PATHS.SKILL_CACHE_DIR);
     if (!existsSync10(cacheDir)) {
       return warn(
         "Skill cache healthy",
@@ -4215,7 +4752,7 @@ var HealthChecker = class {
     }
     const corrupt = readdirSync2(cacheDir).filter((entry) => entry.endsWith(".json")).filter((entry) => {
       try {
-        JSON.parse(readFileSync10(join20(cacheDir, entry), "utf8"));
+        JSON.parse(readFileSync10(join22(cacheDir, entry), "utf8"));
         return false;
       } catch {
         return true;
@@ -4228,7 +4765,7 @@ var HealthChecker = class {
     );
   }
   checkContextHitRate(projectRoot, profile) {
-    const path = join20(projectRoot, PATHS.CONTEXT_HIT_LOG);
+    const path = join22(projectRoot, PATHS.CONTEXT_HIT_LOG);
     if (!existsSync10(path) || profile === null) {
       return pass("Context hit rate acceptable", "No recent context logs yet");
     }
@@ -4250,7 +4787,7 @@ var HealthChecker = class {
     }
   }
   buildEfficiencySummary(projectRoot, profile) {
-    const path = join20(projectRoot, PATHS.CONTEXT_HIT_LOG);
+    const path = join22(projectRoot, PATHS.CONTEXT_HIT_LOG);
     let contextHitRate = 1;
     if (existsSync10(path)) {
       try {
@@ -4262,12 +4799,12 @@ var HealthChecker = class {
     }
     return {
       context_hit_rate: contextHitRate,
-      skill_cache_hit_rate: existsSync10(join20(projectRoot, PATHS.SKILL_CACHE_DIR)) ? 1 : 0,
+      skill_cache_hit_rate: existsSync10(join22(projectRoot, PATHS.SKILL_CACHE_DIR)) ? 1 : 0,
       mcp_usage_rate: profile?.efficiency?.mcp_first ? 1 : 0
     };
   }
   documentationHasRun(projectRoot) {
-    return existsSync10(join20(projectRoot, PATHS.DOC_PROGRESS));
+    return existsSync10(join22(projectRoot, PATHS.DOC_PROGRESS));
   }
 };
 function pass(name, detail) {
@@ -4291,12 +4828,12 @@ function deriveOverallStatus(checks) {
 function isStale(timestampMs) {
   return Date.now() - timestampMs > STALENESS_WINDOW_MS;
 }
-function walk(root) {
+function walk2(root) {
   const results = [];
   for (const entry of readdirSync2(root, { withFileTypes: true })) {
-    const path = join20(root, entry.name);
+    const path = join22(root, entry.name);
     if (entry.isDirectory()) {
-      results.push(...walk(path));
+      results.push(...walk2(path));
       continue;
     }
     results.push(path);
@@ -4311,35 +4848,35 @@ import { dirname as dirname12 } from "path";
 // src/onboarding/manifest-writer.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname11, join as join21 } from "path";
+import { dirname as dirname11, join as join23 } from "path";
 function writeProjectProfile2(projectRoot, profile) {
   return writeProjectProfile(projectRoot, profile);
 }
 function writeDetectionReport(projectRoot, report) {
-  const path = join21(projectRoot, PATHS.DETECTION_REPORT);
+  const path = join23(projectRoot, PATHS.DETECTION_REPORT);
   mkdirSync2(dirname11(path), { recursive: true });
   writeFileSync2(path, JSON.stringify(report, null, 2));
   return path;
 }
 function writeFrameworkMetadata(projectRoot, version) {
-  mkdirSync2(dirname11(join21(projectRoot, PATHS.FRAMEWORK_VERSION)), {
+  mkdirSync2(dirname11(join23(projectRoot, PATHS.FRAMEWORK_VERSION)), {
     recursive: true
   });
   const content = `version=${version}
 updated_at=${(/* @__PURE__ */ new Date()).toISOString()}
 `;
-  writeFileSync2(join21(projectRoot, PATHS.FRAMEWORK_VERSION), content);
-  writeFileSync2(join21(projectRoot, PATHS.FRAMEWORK_PATH), `${resolveFrameworkInstallPath()}
+  writeFileSync2(join23(projectRoot, PATHS.FRAMEWORK_VERSION), content);
+  writeFileSync2(join23(projectRoot, PATHS.FRAMEWORK_PATH), `${resolveFrameworkInstallPath()}
 `);
 }
 function writeOnboardingManifest(projectRoot, manifest) {
-  const path = join21(projectRoot, PATHS.ONBOARDING_MANIFEST);
+  const path = join23(projectRoot, PATHS.ONBOARDING_MANIFEST);
   mkdirSync2(dirname11(path), { recursive: true });
   writeFileSync2(path, JSON.stringify(manifest, null, 2));
   return path;
 }
 function resolveFrameworkInstallPath() {
-  return process.env.PAQAD_FRAMEWORK_HOME ?? join21(homedir(), ".paqad-ai/current");
+  return process.env.PAQAD_FRAMEWORK_HOME ?? join23(homedir(), ".paqad-ai/current");
 }
 
 // src/install/bootstrap.ts
@@ -4384,23 +4921,23 @@ function isExpectedRuntimeSymlink(runtimeRoot, frameworkHome) {
 }
 
 // src/document/workflow.ts
-import { mkdir as mkdir10, readFile as readFile12, readdir as readdir2, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname14, join as join26, relative } from "path";
+import { mkdir as mkdir10, readFile as readFile12, readdir as readdir3, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname14, join as join28, relative } from "path";
 
 // src/onboarding/registry-generator.ts
-import { readdir } from "fs/promises";
-import { join as join22 } from "path";
+import { readdir as readdir2 } from "fs/promises";
+import { join as join24 } from "path";
 async function discoverModules(projectRoot) {
   const candidates = [
-    join22(projectRoot, "docs/modules"),
-    join22(projectRoot, "app"),
-    join22(projectRoot, "lib"),
-    join22(projectRoot, "src")
+    join24(projectRoot, "docs/modules"),
+    join24(projectRoot, "app"),
+    join24(projectRoot, "lib"),
+    join24(projectRoot, "src")
   ];
   const modules = /* @__PURE__ */ new Set(["core"]);
   for (const root of candidates) {
     try {
-      const entries = await readdir(root, { withFileTypes: true });
+      const entries = await readdir2(root, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) {
           continue;
@@ -4419,36 +4956,36 @@ async function discoverModules(projectRoot) {
 
 // src/stack-docs/generator.ts
 import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join25 } from "path";
 async function writeStackArtifacts(projectRoot, snapshot, previousSnapshot, options = {}) {
   const existingDrift = await readExistingDrift(projectRoot);
   const computedDrift = compareStackProfiles(previousSnapshot?.profile ?? null, snapshot.profile);
   const drift = computedDrift.status === "no-drift" && existingDrift !== null ? existingDrift : computedDrift;
   await writeFile8(
-    join23(projectRoot, PATHS.STACK_SNAPSHOT),
+    join25(projectRoot, PATHS.STACK_SNAPSHOT),
     `${JSON.stringify(snapshot, null, 2)}
 `
   );
-  await writeFile8(join23(projectRoot, PATHS.STACK_DRIFT), `${JSON.stringify(drift, null, 2)}
+  await writeFile8(join25(projectRoot, PATHS.STACK_DRIFT), `${JSON.stringify(drift, null, 2)}
 `);
   if (!options.writeHumanDocs) {
     return drift;
   }
-  await mkdir8(join23(projectRoot, PATHS.FRAMEWORK_STACK_DIR), { recursive: true });
-  const stackDir = join23(projectRoot, PATHS.FRAMEWORK_STACK_DIR);
-  await writeFile8(join23(stackDir, "overview.md"), await buildOverview(projectRoot, snapshot, drift));
-  await writeFile8(join23(stackDir, "frameworks.md"), await buildFrameworks(projectRoot, snapshot));
-  await writeFile8(join23(stackDir, "dependencies.md"), buildDependencies(snapshot));
-  await writeFile8(join23(stackDir, "tooling.md"), buildTooling(snapshot));
-  await writeFile8(join23(stackDir, "version-rules.md"), buildVersionRules(snapshot, drift));
-  await writeFile8(join23(stackDir, "sources.md"), buildSources(snapshot));
-  await writeFile8(join23(stackDir, "drift-report.md"), buildDriftReport(drift));
+  await mkdir8(join25(projectRoot, PATHS.FRAMEWORK_STACK_DIR), { recursive: true });
+  const stackDir = join25(projectRoot, PATHS.FRAMEWORK_STACK_DIR);
+  await writeFile8(join25(stackDir, "overview.md"), await buildOverview(projectRoot, snapshot, drift));
+  await writeFile8(join25(stackDir, "frameworks.md"), await buildFrameworks(projectRoot, snapshot));
+  await writeFile8(join25(stackDir, "dependencies.md"), buildDependencies(snapshot));
+  await writeFile8(join25(stackDir, "tooling.md"), buildTooling(snapshot));
+  await writeFile8(join25(stackDir, "version-rules.md"), buildVersionRules(snapshot, drift));
+  await writeFile8(join25(stackDir, "sources.md"), buildSources(snapshot));
+  await writeFile8(join25(stackDir, "drift-report.md"), buildDriftReport(drift));
   return drift;
 }
 async function readExistingDrift(projectRoot) {
   try {
     return JSON.parse(
-      await readFile9(join23(projectRoot, PATHS.STACK_DRIFT), "utf8")
+      await readFile9(join25(projectRoot, PATHS.STACK_DRIFT), "utf8")
     );
   } catch {
     return null;
@@ -4611,7 +5148,7 @@ async function readTemplate(packRoot, templatePath) {
     return null;
   }
   try {
-    return await readFile9(join23(packRoot, templatePath), "utf8");
+    return await readFile9(join25(packRoot, templatePath), "utf8");
   } catch {
     return null;
   }
@@ -4619,7 +5156,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 dirname13, join as join24 } from "path";
+import { dirname as dirname13, join as join26 } from "path";
 var DocumentProgressTracker = class {
   constructor(validator = new SchemaValidator()) {
     this.validator = validator;
@@ -4627,7 +5164,7 @@ var DocumentProgressTracker = class {
   async load(projectRoot) {
     try {
       const parsed = JSON.parse(
-        await readFile10(join24(projectRoot, PATHS.DOC_PROGRESS), "utf8")
+        await readFile10(join26(projectRoot, PATHS.DOC_PROGRESS), "utf8")
       );
       const validation = this.validator.validate("doc-progress", parsed);
       if (!validation.valid) {
@@ -4639,7 +5176,7 @@ var DocumentProgressTracker = class {
     }
   }
   async save(projectRoot, progress) {
-    const target = join24(projectRoot, PATHS.DOC_PROGRESS);
+    const target = join26(projectRoot, PATHS.DOC_PROGRESS);
     await mkdir9(dirname13(target), { recursive: true });
     await writeFile9(target, `${JSON.stringify(progress, null, 2)}
 `);
@@ -4647,7 +5184,7 @@ var DocumentProgressTracker = class {
   async resetGeneratingEntries(projectRoot, progress) {
     await Promise.all(
       resetGeneratingEntries(progress).map(
-        (entry) => rm(join24(projectRoot, entry.output_path), { force: true })
+        (entry) => rm(join26(projectRoot, entry.output_path), { force: true })
       )
     );
   }
@@ -4697,12 +5234,12 @@ function collectEntries(progress) {
 // src/document/staleness.ts
 import { createHash as createHash6 } from "crypto";
 import { readFile as readFile11 } from "fs/promises";
-import { join as join25 } from "path";
+import { join as join27 } from "path";
 async function hashSourceFiles(projectRoot, sourceFiles) {
   const hash = createHash6("sha1");
   for (const relativePath of sourceFiles) {
     try {
-      hash.update(await readFile11(join25(projectRoot, relativePath), "utf8"));
+      hash.update(await readFile11(join27(projectRoot, relativePath), "utf8"));
     } catch {
       hash.update(`missing:${relativePath}`);
     }
@@ -4760,7 +5297,11 @@ var DocumentationWorkflow = class {
       routing,
       stackSnapshot
     );
-    const sourceFiles = await gatherSourceFiles(options.projectRoot, routing.stack);
+    const sourceFiles = await gatherSourceFiles(
+      options.projectRoot,
+      routing.stack,
+      stackSnapshot.repository
+    );
     const modules = await discoverModules(options.projectRoot);
     const generated = [];
     const skipped = [];
@@ -4778,13 +5319,13 @@ var DocumentationWorkflow = class {
       { writeHumanDocs: true }
     );
     const stackDocs = [
-      join26(PATHS.FRAMEWORK_STACK_DIR, "overview.md"),
-      join26(PATHS.FRAMEWORK_STACK_DIR, "frameworks.md"),
-      join26(PATHS.FRAMEWORK_STACK_DIR, "dependencies.md"),
-      join26(PATHS.FRAMEWORK_STACK_DIR, "tooling.md"),
-      join26(PATHS.FRAMEWORK_STACK_DIR, "version-rules.md"),
-      join26(PATHS.FRAMEWORK_STACK_DIR, "sources.md"),
-      join26(PATHS.FRAMEWORK_STACK_DIR, "drift-report.md")
+      join28(PATHS.FRAMEWORK_STACK_DIR, "overview.md"),
+      join28(PATHS.FRAMEWORK_STACK_DIR, "frameworks.md"),
+      join28(PATHS.FRAMEWORK_STACK_DIR, "dependencies.md"),
+      join28(PATHS.FRAMEWORK_STACK_DIR, "tooling.md"),
+      join28(PATHS.FRAMEWORK_STACK_DIR, "version-rules.md"),
+      join28(PATHS.FRAMEWORK_STACK_DIR, "sources.md"),
+      join28(PATHS.FRAMEWORK_STACK_DIR, "drift-report.md")
     ];
     generated.push(...stackDocs);
     steps.push({
@@ -4803,8 +5344,8 @@ var DocumentationWorkflow = class {
         stackSnapshot,
         profile
       });
-      await mkdir10(dirname14(join26(options.projectRoot, contentOutputPath)), { recursive: true });
-      await writeFile10(join26(options.projectRoot, contentOutputPath), contentBody);
+      await mkdir10(dirname14(join28(options.projectRoot, contentOutputPath)), { recursive: true });
+      await writeFile10(join28(options.projectRoot, contentOutputPath), contentBody);
       generated.push(contentOutputPath);
       steps.push({
         id: "content-deliverable",
@@ -4827,7 +5368,7 @@ var DocumentationWorkflow = class {
     await processEntry({
       projectRoot: options.projectRoot,
       entry: progress.global.designSystem.designTokens,
-      content: await readFile12(join26(options.projectRoot, PATHS.DESIGN_TOKENS_FILE), "utf8"),
+      content: await readFile12(join28(options.projectRoot, PATHS.DESIGN_TOKENS_FILE), "utf8"),
       generated: designSystemGenerated,
       skipped: designSystemSkipped
     });
@@ -4846,8 +5387,8 @@ var DocumentationWorkflow = class {
     }
     await Promise.all(
       themeArtifacts.map(async (artifact) => {
-        await mkdir10(dirname14(join26(options.projectRoot, artifact.path)), { recursive: true });
-        await writeFile10(join26(options.projectRoot, artifact.path), artifact.content);
+        await mkdir10(dirname14(join28(options.projectRoot, artifact.path)), { recursive: true });
+        await writeFile10(join28(options.projectRoot, artifact.path), artifact.content);
         designSystemGenerated.push(artifact.path);
       })
     );
@@ -4861,15 +5402,15 @@ var DocumentationWorkflow = class {
     });
     progress.global.architecture ??= {};
     progress.global.architecture.overview ??= this.tracker.createEntry(
-      join26(PATHS.ARCHITECTURE_DIR, "overview.md"),
+      join28(PATHS.ARCHITECTURE_DIR, "overview.md"),
       sourceFiles
     );
     progress.global.architecture.decisions ??= this.tracker.createEntry(
-      join26(PATHS.ARCHITECTURE_DIR, "decisions.md"),
+      join28(PATHS.ARCHITECTURE_DIR, "decisions.md"),
       sourceFiles
     );
     progress.global.architecture.patterns ??= this.tracker.createEntry(
-      join26(PATHS.ARCHITECTURE_DIR, "patterns.md"),
+      join28(PATHS.ARCHITECTURE_DIR, "patterns.md"),
       sourceFiles
     );
     const architectureGenerated = [];
@@ -4907,7 +5448,7 @@ var DocumentationWorkflow = class {
     const registrySkipped = [];
     progress.global.registries ??= {};
     for (const registry of REGISTRIES) {
-      const path = join26(PATHS.REGISTRIES_DIR, registry);
+      const path = join28(PATHS.REGISTRIES_DIR, registry);
       progress.global.registries[registry] ??= this.tracker.createEntry(path, sourceFiles);
       await processEntry({
         projectRoot: options.projectRoot,
@@ -4927,12 +5468,12 @@ var DocumentationWorkflow = class {
     });
     progress.global.benchmarks ??= {};
     progress.global.benchmarks.index ??= this.tracker.createEntry(
-      join26(PATHS.BENCHMARKS_DIR, "index.md"),
+      join28(PATHS.BENCHMARKS_DIR, "index.md"),
       sourceFiles
     );
     progress.global.techDebt ??= {};
     progress.global.techDebt.index ??= this.tracker.createEntry(
-      join26(PATHS.TECH_DEBT_DIR, "index.md"),
+      join28(PATHS.TECH_DEBT_DIR, "index.md"),
       sourceFiles
     );
     const maintenanceGenerated = [];
@@ -4972,7 +5513,7 @@ var DocumentationWorkflow = class {
       );
       for (const feature of features) {
         for (const definition of FEATURE_DOCS) {
-          const path = join26(
+          const path = join28(
             PATHS.MODULES_DIR,
             moduleName,
             PATHS.MODULE_FEATURES_DIR,
@@ -5005,7 +5546,7 @@ var DocumentationWorkflow = class {
         }
       }
       for (const definition of MODULE_DOCS) {
-        const path = join26(PATHS.MODULES_DIR, moduleName, definition.outputPath);
+        const path = join28(PATHS.MODULES_DIR, moduleName, definition.outputPath);
         progress.modules[moduleName][definition.key] ??= this.tracker.createEntry(
           path,
           moduleFiles
@@ -5037,7 +5578,7 @@ var DocumentationWorkflow = class {
     }
     progress.global.handover ??= {};
     progress.global.handover.summary ??= this.tracker.createEntry(
-      join26(".paqad/handover", "product-summary.md"),
+      join28(".paqad/handover", "product-summary.md"),
       sourceFiles
     );
     const handoverGenerated = [];
@@ -5062,7 +5603,7 @@ var DocumentationWorkflow = class {
       generated,
       skipped,
       progress_path: PATHS.DOC_PROGRESS,
-      handover_path: join26(".paqad/handover", "product-summary.md"),
+      handover_path: join28(".paqad/handover", "product-summary.md"),
       stack_snapshot: stackSnapshot,
       effective_routing: routing,
       profile_updated: profileUpdated,
@@ -5093,7 +5634,8 @@ async function syncOnboardingState(projectRoot, profile, detection, routing, sta
   if (manifest !== null) {
     writeOnboardingManifest(projectRoot, {
       ...manifest,
-      profile: updatedProfile
+      profile: updatedProfile,
+      repository: detection.repository ?? stackSnapshot.repository
     });
   }
   return true;
@@ -5133,8 +5675,8 @@ async function processEntry(input) {
   input.entry.state = "generating";
   input.entry.started_at = (/* @__PURE__ */ new Date()).toISOString();
   input.entry.error = null;
-  await mkdir10(dirname14(join26(input.projectRoot, input.entry.output_path)), { recursive: true });
-  await writeFile10(join26(input.projectRoot, input.entry.output_path), input.content);
+  await mkdir10(dirname14(join28(input.projectRoot, input.entry.output_path)), { recursive: true });
+  await writeFile10(join28(input.projectRoot, input.entry.output_path), input.content);
   input.generated.push(input.entry.output_path);
   input.entry.state = "done";
   input.entry.completed_at = (/* @__PURE__ */ new Date()).toISOString();
@@ -5153,8 +5695,8 @@ async function processEntry(input) {
   }
   return { generated: [input.entry.output_path], skipped: [] };
 }
-async function gatherSourceFiles(projectRoot, stack) {
-  const roots = stack === "flutter" ? ["lib", "test", "web", "assets", "pubspec.yaml"] : stack === "short-video" ? ["src", "content", "scripts", "package.json"] : [
+async function gatherSourceFiles(projectRoot, stack, repository) {
+  const roots = repository?.projects.length ? repository.projects.map((project) => project.root) : stack === "flutter" ? ["lib", "test", "web", "assets", "pubspec.yaml"] : stack === "short-video" ? ["src", "content", "scripts", "package.json"] : [
     "app",
     "routes",
     "config",
@@ -5183,7 +5725,7 @@ async function gatherSourceFiles(projectRoot, stack) {
   const results = /* @__PURE__ */ new Set();
   for (const root of roots) {
     try {
-      for (const file of await walk2(join26(projectRoot, root))) {
+      for (const file of await walk3(join28(projectRoot, root))) {
         results.add(relative(projectRoot, file));
       }
     } catch {
@@ -5200,7 +5742,7 @@ async function gatherSourceFiles(projectRoot, stack) {
 }
 async function buildContentDeliverable(input) {
   const styleGuide = await readOptionalFile(
-    join26(input.projectRoot, "docs/instructions/rules/writing-style.md")
+    join28(input.projectRoot, "docs/instructions/rules/writing-style.md")
   );
   const codingContext = input.profile.active_capabilities.includes("coding") && input.stackSnapshot.profile.frameworks.length > 0 ? [
     "## Technical Context",
@@ -5248,19 +5790,36 @@ async function readOptionalFile(path) {
   }
 }
 function defaultContentOutputPath(requestText) {
-  return join26("content", `${slugify(requestText)}.md`);
+  return join28("content", `${slugify(requestText)}.md`);
 }
 function slugify(requestText) {
   const slug = requestText.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
   return slug.length > 0 ? slug : "content-draft";
 }
-async function walk2(root) {
-  const entries = await readdir2(root, { withFileTypes: true });
+async function walk3(root) {
+  const entries = await readdir3(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const target = join26(root, entry.name);
+    const target = join28(root, entry.name);
     if (entry.isDirectory()) {
-      files.push(...await walk2(target));
+      if ([
+        ".dart_tool",
+        ".git",
+        ".gradle",
+        ".next",
+        ".nuxt",
+        ".turbo",
+        "build",
+        "coverage",
+        "dist",
+        "node_modules",
+        "out",
+        "target",
+        "vendor"
+      ].includes(entry.name)) {
+        continue;
+      }
+      files.push(...await walk3(target));
       continue;
     }
     files.push(target);
@@ -5301,8 +5860,8 @@ async function discoverFeaturesForModule(projectRoot, moduleName, moduleFiles) {
 }
 async function readExistingFeatures(projectRoot, moduleName) {
   try {
-    const root = join26(projectRoot, PATHS.MODULES_DIR, moduleName, PATHS.MODULE_FEATURES_DIR);
-    const entries = await readdir2(root, { withFileTypes: true });
+    const root = join28(projectRoot, PATHS.MODULES_DIR, moduleName, PATHS.MODULE_FEATURES_DIR);
+    const entries = await readdir3(root, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name).sort();
   } catch {
     return [];
@@ -5321,7 +5880,7 @@ function loadProjectProfile(projectRoot) {
 async function readOnboardingManifest(projectRoot) {
   try {
     return JSON.parse(
-      await readFile12(join26(projectRoot, PATHS.ONBOARDING_MANIFEST), "utf8")
+      await readFile12(join28(projectRoot, PATHS.ONBOARDING_MANIFEST), "utf8")
     );
   } catch {
     return null;
@@ -5712,12 +6271,12 @@ function basenameWithoutExtension(path) {
 
 // src/onboarding/file-writer.ts
 import { chmodSync, existsSync as existsSync12, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname15, join as join27 } from "path";
+import { dirname as dirname15, join as join29 } from "path";
 function writeGeneratedFiles(projectRoot, files) {
   const written = [];
   const skipped = [];
   for (const file of files) {
-    const target = join27(projectRoot, file.path);
+    const target = join29(projectRoot, file.path);
     mkdirSync4(dirname15(target), { recursive: true });
     if (!file.autoUpdate && existsSync12(target)) {
       skipped.push(file.path);
@@ -5732,13 +6291,190 @@ function writeGeneratedFiles(projectRoot, files) {
   return { written, skipped };
 }
 
+// src/pipeline/feature-development-policy.ts
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
+import { join as join30 } from "path";
+import YAML5 from "yaml";
+function resolveFeatureDevelopmentCheckCommands(checks, profile) {
+  if (checks === null) {
+    return { commands: [], warnings: [] };
+  }
+  const commands = [];
+  const warnings = [];
+  if (checks.use_project_profile_commands) {
+    if (profile === null) {
+      return { commands, warnings };
+    }
+    for (const logicalCommand of checks.commands) {
+      const resolved = profile?.commands?.[logicalCommand];
+      if (!resolved) {
+        warnings.push(
+          `Feature development policy requested project command "${logicalCommand}" but it was not found in ${PATHS.PROJECT_PROFILE}.`
+        );
+        continue;
+      }
+      commands.push({
+        logical_command: logicalCommand,
+        command: resolved,
+        source: "project-profile"
+      });
+    }
+  }
+  for (const shellCommand of checks.shell_commands) {
+    commands.push({
+      logical_command: null,
+      command: shellCommand,
+      source: "policy"
+    });
+  }
+  return { commands, warnings };
+}
+function renderDefaultFeatureDevelopmentPolicyYaml() {
+  return `# Feature Development Stage Policy
+# This file customizes how the built-in feature-development workflow behaves in this project.
+# The framework still owns routing, phase order, and mandatory safety stages.
+schema_version: "1"
+merge_mode: append
+
+stages:
+  planning:
+    # Extra context to load before planning starts.
+    read:
+      - docs/modules/**
+      - docs/instructions/**
+    instructions:
+      - Review the canonical module and instruction docs before planning the change.
+      - Keep planning scoped to the requested feature and the current repository state.
+    required_inputs:
+      - active request
+      - canonical docs
+    strictness:
+      require_docs_context: true
+    escalation:
+      missing_docs_context: warn
+    artifacts:
+      - implementation sequence
+
+  specification:
+    instructions:
+      - Write or refine the feature specification before implementation when the lane includes specification.
+    required_inputs:
+      - approved spec boundary
+    strictness:
+      require_spec: true
+    escalation:
+      missing_spec: stop
+    artifacts:
+      - specification
+
+  development:
+    instructions:
+      - Implement only the requested feature behavior and avoid unrelated refactors.
+    required_inputs:
+      - approved spec
+      - implementation sequence
+    strictness:
+      avoid_unrelated_refactors: true
+    escalation:
+      scope_expansion: ask
+    artifacts:
+      - code changes
+
+  review:
+    instructions:
+      - Review the change against correctness, regressions, and rollback risk before treating it as complete.
+    required_inputs:
+      - code diff
+      - verification summary
+    strictness:
+      require_review: true
+    escalation:
+      review_findings: stop
+    artifacts:
+      - review summary
+
+  checks:
+    instructions:
+      - Run the project command checks after implementation and before finalizing the feature.
+    required_inputs:
+      - working tree diff
+    strictness:
+      block_on_failure: true
+    escalation:
+      missing_command_mapping: stop
+    artifacts:
+      - verification summary
+    checks:
+      use_project_profile_commands: true
+      commands:
+        - format
+        - test
+        - build
+      shell_commands: []
+      block_on_failure: true
+      # Add project-specific commands here when needed.
+      # shell_commands:
+      #   - pnpm typecheck
+
+  documentation_sync:
+    instructions:
+      - Sync canonical docs affected by the feature diff after verification passes.
+    required_inputs:
+      - changed files
+    strictness:
+      require_canonical_sync: true
+    escalation:
+      stale_docs: stop
+    artifacts:
+      - stale doc targets
+`;
+}
+function summarizeFeatureDevelopmentStage(policy, stageName) {
+  if (policy === null) {
+    return null;
+  }
+  const stage = policy.stages[stageName];
+  const fragments = [];
+  if (stage.read.length > 0) {
+    fragments.push(`reads ${stage.read.length} path(s)`);
+  }
+  if (stage.instructions.length > 0) {
+    fragments.push(`${stage.instructions.length} instruction(s)`);
+  }
+  if (stage.required_inputs.length > 0) {
+    fragments.push(`${stage.required_inputs.length} required input(s)`);
+  }
+  if (stage.artifacts.length > 0) {
+    fragments.push(`${stage.artifacts.length} expected artifact(s)`);
+  }
+  if (stage.checks !== null) {
+    const checkCount = stage.checks.commands.length + stage.checks.shell_commands.length;
+    fragments.push(`${checkCount} configured check(s)`);
+  }
+  return fragments.length > 0 ? fragments.join(", ") : null;
+}
+
+// src/onboarding/feature-policy-generator.ts
+function generateFeatureDevelopmentPolicy(domain) {
+  if (domain !== "coding") {
+    return [];
+  }
+  return [
+    {
+      path: `${PATHS.WORKFLOWS_DIR}/feature-development.yaml`,
+      content: renderDefaultFeatureDevelopmentPolicyYaml(),
+      autoUpdate: false
+    }
+  ];
+}
+
 // src/onboarding/orchestrator.ts
-import { readFileSync as readFileSync12 } from "fs";
-import { join as join33 } from "path";
+import { readFileSync as readFileSync13 } from "fs";
+import { join as join36 } from "path";
 
 // src/resolver/resolver.ts
 import fg2 from "fast-glob";
-import { basename as basename3, extname, relative as relative3 } from "pathe";
+import { basename as basename4, extname, relative as relative3 } from "pathe";
 
 // src/resolver/artifact-types.ts
 var ARTIFACT_TYPES = [
@@ -5776,14 +6512,14 @@ var ARTIFACT_OUTPUT_KEYS = {
 };
 
 // src/resolver/inheritance.ts
-import { join as join29, relative as relative2 } from "pathe";
+import { join as join32, relative as relative2 } from "pathe";
 
 // src/resolver/capability-resolver.ts
-import { join as join28 } from "pathe";
+import { join as join31 } from "pathe";
 function resolveCapabilityDirectories(runtimeRoot, stack, capabilities, artifactType) {
   const directoryName = resolveCapabilityArtifactDirectory(artifactType);
   return capabilities.map(
-    (capability) => join28(
+    (capability) => join31(
       runtimeRoot,
       "capabilities",
       "coding",
@@ -5800,9 +6536,9 @@ function resolveCapabilityArtifactDirectory(artifactType) {
     case "mcp-configs":
       return "mcp";
     case "patterns":
-      return join28("benchmarks", "patterns");
+      return join31("benchmarks", "patterns");
     case "anti-patterns":
-      return join28("benchmarks", "anti-patterns");
+      return join31("benchmarks", "anti-patterns");
     default:
       return artifactType;
   }
@@ -5813,18 +6549,18 @@ function getInheritanceDirectories(runtimeRoot, routing, artifactType) {
   if (artifactType === "hooks") {
     return [
       {
-        path: join29(runtimeRoot, "hooks"),
+        path: join32(runtimeRoot, "hooks"),
         level: 0,
-        source: relative2(runtimeRoot, join29(runtimeRoot, "hooks"))
+        source: relative2(runtimeRoot, join32(runtimeRoot, "hooks"))
       }
     ];
   }
   if (artifactType === "templates") {
     return [
       {
-        path: join29(runtimeRoot, "templates"),
+        path: join32(runtimeRoot, "templates"),
         level: 0,
-        source: relative2(runtimeRoot, join29(runtimeRoot, "templates"))
+        source: relative2(runtimeRoot, join32(runtimeRoot, "templates"))
       }
     ];
   }
@@ -5834,37 +6570,37 @@ function getInheritanceDirectories(runtimeRoot, routing, artifactType) {
   const traits = deriveTraits(routing);
   const directories = [
     {
-      path: join29(runtimeRoot, "base", directoryName),
+      path: join32(runtimeRoot, "base", directoryName),
       level: 0,
-      source: relative2(runtimeRoot, join29(runtimeRoot, "base", directoryName))
+      source: relative2(runtimeRoot, join32(runtimeRoot, "base", directoryName))
     },
     {
-      path: join29(runtimeRoot, "capabilities", "content", directoryName),
+      path: join32(runtimeRoot, "capabilities", "content", directoryName),
       level: 1,
-      source: relative2(runtimeRoot, join29(runtimeRoot, "capabilities", "content", directoryName))
+      source: relative2(runtimeRoot, join32(runtimeRoot, "capabilities", "content", directoryName))
     }
   ];
   if (activeCapabilities.includes("coding")) {
     directories.push(
       {
-        path: join29(runtimeRoot, "capabilities", "coding", directoryName),
+        path: join32(runtimeRoot, "capabilities", "coding", directoryName),
         level: 2,
-        source: relative2(runtimeRoot, join29(runtimeRoot, "capabilities", "coding", directoryName))
+        source: relative2(runtimeRoot, join32(runtimeRoot, "capabilities", "coding", directoryName))
       },
       {
-        path: join29(runtimeRoot, "capabilities", "coding", "stacks", "_shared", directoryName),
+        path: join32(runtimeRoot, "capabilities", "coding", "stacks", "_shared", directoryName),
         level: 3,
         source: relative2(
           runtimeRoot,
-          join29(runtimeRoot, "capabilities", "coding", "stacks", "_shared", directoryName)
+          join32(runtimeRoot, "capabilities", "coding", "stacks", "_shared", directoryName)
         )
       },
       ...matchedPacks.map((pack, index) => ({
-        path: join29(runtimeRoot, "capabilities", "coding", "stacks", pack, directoryName),
+        path: join32(runtimeRoot, "capabilities", "coding", "stacks", pack, directoryName),
         level: 4 + Math.min(index, 1),
         source: relative2(
           runtimeRoot,
-          join29(runtimeRoot, "capabilities", "coding", "stacks", pack, directoryName)
+          join32(runtimeRoot, "capabilities", "coding", "stacks", pack, directoryName)
         )
       })),
       ...matchedPacks.flatMap(
@@ -5878,9 +6614,9 @@ function getInheritanceDirectories(runtimeRoot, routing, artifactType) {
   }
   if (activeCapabilities.includes("security")) {
     directories.push({
-      path: join29(runtimeRoot, "capabilities", "security", directoryName),
+      path: join32(runtimeRoot, "capabilities", "security", directoryName),
       level: 6,
-      source: relative2(runtimeRoot, join29(runtimeRoot, "capabilities", "security", directoryName))
+      source: relative2(runtimeRoot, join32(runtimeRoot, "capabilities", "security", directoryName))
     });
   }
   return directories;
@@ -5917,9 +6653,9 @@ function resolveArtifactDirectoryName(artifactType) {
     case "mcp-configs":
       return "mcp";
     case "patterns":
-      return join29("benchmarks", "patterns");
+      return join32("benchmarks", "patterns");
     case "anti-patterns":
-      return join29("benchmarks", "anti-patterns");
+      return join32("benchmarks", "anti-patterns");
     default:
       return artifactType;
   }
@@ -6021,14 +6757,14 @@ function compareRuleSeedOrder(left, right) {
   return left.source.localeCompare(right.source);
 }
 function getRulePriority(filePath) {
-  const name = basename3(filePath, extname(filePath));
+  const name = basename4(filePath, extname(filePath));
   const index = RULE_SEED_PRIORITY.indexOf(name);
   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";
+import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
+import { join as join33 } from "path";
 var PAQAD_MARKER = "# paqad-ai";
 var PAQAD_GITIGNORE_ENTRIES = [
   PAQAD_MARKER,
@@ -6041,8 +6777,8 @@ var PAQAD_GITIGNORE_ENTRIES = [
   ".paqad/theme/"
 ].join("\n");
 function writeGitignore(projectRoot) {
-  const gitignorePath = join30(projectRoot, ".gitignore");
-  const existing = existsSync13(gitignorePath) ? readFileSync11(gitignorePath, "utf8") : "";
+  const gitignorePath = join33(projectRoot, ".gitignore");
+  const existing = existsSync14(gitignorePath) ? readFileSync12(gitignorePath, "utf8") : "";
   if (existing.includes(PAQAD_MARKER)) {
     return;
   }
@@ -6514,9 +7250,9 @@ function inferSelectionDomain(detection, overrides, snapshot) {
 }
 
 // src/onboarding/reference-generator.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { readFile as readFile13 } from "fs/promises";
-import { join as join31, relative as relative4 } from "path";
+import { join as join34, relative as relative4 } from "path";
 import fg3 from "fast-glob";
 async function generateReferenceGuides(runtimeRoot, context) {
   if (context.domain !== "coding") {
@@ -6527,8 +7263,8 @@ async function generateReferenceGuides(runtimeRoot, context) {
     routing: { domain: context.domain },
     stack_profile: context.stack_profile
   });
-  const referencesRoot = join31(runtimeRoot, "capabilities", "coding", "stacks", stack, "references");
-  if (!existsSync14(referencesRoot)) {
+  const referencesRoot = join34(runtimeRoot, "capabilities", "coding", "stacks", stack, "references");
+  if (!existsSync15(referencesRoot)) {
     return [buildFallbackReferenceGuide(stack)];
   }
   const entries = await fg3(["tools/*.md", "tools-catalog.md"], {
@@ -6550,14 +7286,14 @@ async function generateReferenceGuides(runtimeRoot, context) {
 function toProjectReferencePath(stack, relativePath) {
   const normalized = relativePath.replaceAll("\\", "/");
   if (normalized === "tools-catalog.md") {
-    return join31(PATHS.TOOLS_DIR, stack, "README.md");
+    return join34(PATHS.TOOLS_DIR, stack, "README.md");
   }
-  return join31(PATHS.TOOLS_DIR, stack, normalized.replace(/^tools\//, ""));
+  return join34(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: join31(PATHS.TOOLS_DIR, stack, "README.md"),
+    path: join34(PATHS.TOOLS_DIR, stack, "README.md"),
     autoUpdate: false,
     content: [
       `# ${title} Tool References`,
@@ -6575,7 +7311,7 @@ function buildFallbackReferenceGuide(stack) {
 
 // src/onboarding/rule-generator.ts
 import { readFile as readFile14 } from "fs/promises";
-import { join as join32 } from "path";
+import { join as join35 } from "path";
 async function generateProjectRules(rules) {
   return Promise.all(
     rules.map(async (rule) => ({
@@ -6588,22 +7324,22 @@ async function generateProjectRules(rules) {
 function toProjectRulePath(source) {
   const normalized = source.replaceAll("\\", "/");
   if (normalized.startsWith("base/rules/")) {
-    return join32(PATHS.RULES_DIR, "_shared", normalized.replace(/^base\/rules\//, ""));
+    return join35(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 join32(PATHS.RULES_DIR, prefix2, target2);
+      return join35(PATHS.RULES_DIR, prefix2, target2);
     }
   }
   const [prefix, suffix] = normalized.split("/rules/");
   if (prefix === void 0 || suffix === void 0) {
-    return join32(PATHS.RULES_DIR, normalized);
+    return join35(PATHS.RULES_DIR, normalized);
   }
   const target = suffix.endsWith("/guide.md") ? suffix.replace("/guide.md", ".md") : suffix;
-  return join32(PATHS.RULES_DIR, prefix, target);
+  return join35(PATHS.RULES_DIR, prefix, target);
 }
 
 // src/onboarding/orchestrator.ts
@@ -6641,15 +7377,16 @@ var OnboardingOrchestrator = class {
       }
     }
     generatedFiles.push(...await generateProjectRules(resolved.rules));
+    generatedFiles.push(...generateFeatureDevelopmentPolicy(selections.domain));
     generatedFiles.push(
       ...await generateReferenceGuides(runtimeRoot, {
         domain: selections.domain,
         stack_profile: selections.stack_profile
       })
     );
-    const silentUpdateSrc = join33(runtimeRoot, "hooks", "silent-update.sh");
+    const silentUpdateSrc = join36(runtimeRoot, "hooks", "silent-update.sh");
     try {
-      const hookContent = readFileSync12(silentUpdateSrc, "utf8");
+      const hookContent = readFileSync13(silentUpdateSrc, "utf8");
       generatedFiles.push({
         path: PATHS.HOOKS_SILENT_UPDATE,
         content: hookContent,
@@ -6676,6 +7413,7 @@ var OnboardingOrchestrator = class {
       project_root: options.projectRoot,
       profile,
       detected: detection,
+      repository: detection.repository,
       generated_at: (/* @__PURE__ */ new Date()).toISOString(),
       generated_artifacts: generatedFiles.map((file) => ({
         path: file.path,
@@ -6942,22 +7680,22 @@ function buildRustCommands(usingCompose) {
 }
 
 // src/onboarding/scaffold-generator.ts
-import { join as join34 } from "path";
+import { join as join37 } from "path";
 
 // src/templates/registry.ts
 import fg4 from "fast-glob";
-import { basename as basename4, relative as relative5 } from "pathe";
+import { basename as basename5, relative as relative5 } from "pathe";
 
 // src/onboarding/scaffold-generator.ts
 var FEATURE_TEMPLATE_TARGETS = [
-  ["business.md.hbs", join34(PATHS.MODULE_FEATURES_DIR, "core", "business.md")],
-  ["technical.md.hbs", join34(PATHS.MODULE_FEATURES_DIR, "core", "technical.md")]
+  ["business.md.hbs", join37(PATHS.MODULE_FEATURES_DIR, "core", "business.md")],
+  ["technical.md.hbs", join37(PATHS.MODULE_FEATURES_DIR, "core", "technical.md")]
 ];
 
 // src/packs/manager.ts
 import {
   cpSync,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   mkdirSync as mkdirSync5,
   mkdtempSync,
   readdirSync as readdirSync3,
@@ -6965,14 +7703,14 @@ import {
   writeFileSync as writeFileSync5
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join35, resolve as resolve2 } from "path";
+import { join as join38, 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 ?? join35(homedir2(), ".paqad", "packs"),
-    projectPacksRoot: overrides.projectPacksRoot ?? join35(projectRoot, ".paqad", "packs"),
+    globalPacksRoot: overrides.globalPacksRoot ?? process.env.PAQAD_GLOBAL_PACKS_ROOT ?? join38(homedir2(), ".paqad", "packs"),
+    projectPacksRoot: overrides.projectPacksRoot ?? join38(projectRoot, ".paqad", "packs"),
     registryUrl: overrides.registryUrl ?? process.env.PAQAD_PACK_REGISTRY_URL
   };
 }
@@ -7021,7 +7759,7 @@ async function installPack(source, options = {}) {
   if (!pack.validation.valid) {
     throw new Error(formatValidationIssues(pack.validation.issues));
   }
-  const destination = join35(installRoot, pack.manifest.name);
+  const destination = join38(installRoot, pack.manifest.name);
   rmSync2(destination, { recursive: true, force: true });
   cpSync(candidateRoot, destination, { recursive: true });
   const installed = loader.validatePack(destination, scope === "project" ? "project" : "global");
@@ -7033,13 +7771,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 = join35(targetRoot, name);
-  if (existsSync15(target)) {
+  const target = join38(targetRoot, name);
+  if (existsSync16(target)) {
     rmSync2(target, { recursive: true, force: true });
     return;
   }
-  const builtInRoot = join35(roots.runtimeRoot, "capabilities", "coding", "stacks", name);
-  if (existsSync15(builtInRoot)) {
+  const builtInRoot = join38(roots.runtimeRoot, "capabilities", "coding", "stacks", name);
+  if (existsSync16(builtInRoot)) {
     throw new Error(
       `Cannot remove built-in pack "${name}"; remove a global or project override instead`
     );
@@ -7057,14 +7795,14 @@ function createPack(name, options = {}) {
   const destinationRoot = options.destinationRoot ?? process.cwd();
   const ecosystem = options.ecosystem ?? "node";
   const tier = options.tier ?? "framework";
-  const packRoot = join35(destinationRoot, name);
-  if (existsSync15(packRoot)) {
+  const packRoot = join38(destinationRoot, name);
+  if (existsSync16(packRoot)) {
     throw new Error(`Pack scaffold already exists at ${packRoot}`);
   }
-  mkdirSync5(join35(packRoot, "rules"), { recursive: true });
-  writeFileSync5(join35(packRoot, "pack.yaml"), renderPackTemplate(name, ecosystem, tier));
+  mkdirSync5(join38(packRoot, "rules"), { recursive: true });
+  writeFileSync5(join38(packRoot, "pack.yaml"), renderPackTemplate(name, ecosystem, tier));
   writeFileSync5(
-    join35(packRoot, "rules", "conventions.md"),
+    join38(packRoot, "rules", "conventions.md"),
     `# ${name}
 
 Document project-specific conventions for the ${name} stack here.
@@ -7074,14 +7812,14 @@ Document project-specific conventions for the ${name} stack here.
 }
 function listPackNamesForSource(source, roots) {
   const sourceRoot = resolveSourceRoot(source, roots);
-  if (!existsSync15(sourceRoot)) {
+  if (!existsSync16(sourceRoot)) {
     return [];
   }
   return readdirSync3(sourceRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
 }
 function resolveSourceRoot(source, roots) {
   if (source === "built-in") {
-    return join35(roots.runtimeRoot, "capabilities", "coding", "stacks");
+    return join38(roots.runtimeRoot, "capabilities", "coding", "stacks");
   }
   return source === "global" ? roots.globalPacksRoot : roots.projectPacksRoot;
 }
@@ -7101,13 +7839,13 @@ async function materializePackSource(source, roots) {
   return clonePackSource(buildRegistryPackUrl(roots.registryUrl, source));
 }
 function looksLikeLocalPath(source) {
-  return source.startsWith(".") || source.startsWith("/") || existsSync15(resolve2(source));
+  return source.startsWith(".") || source.startsWith("/") || existsSync16(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(join35(homedir2(), ".paqad-pack-clone-"));
+  const tempRoot = mkdtempSync(join38(homedir2(), ".paqad-pack-clone-"));
   try {
     await execa("git", ["clone", "--depth", "1", source, tempRoot]);
   } catch (error) {
@@ -7117,11 +7855,11 @@ async function clonePackSource(source) {
   return findPackRoot(tempRoot);
 }
 function findPackRoot(root) {
-  const rootManifest = join35(root, "pack.yaml");
-  if (existsSync15(rootManifest)) {
+  const rootManifest = join38(root, "pack.yaml");
+  if (existsSync16(rootManifest)) {
     return root;
   }
-  const candidates = readdirSync3(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join35(root, entry.name)).filter((candidate) => existsSync15(join35(candidate, "pack.yaml")));
+  const candidates = readdirSync3(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join38(root, entry.name)).filter((candidate) => existsSync16(join38(candidate, "pack.yaml")));
   if (candidates.length === 1) {
     return candidates[0];
   }
@@ -7239,15 +7977,15 @@ async function queryOsv(packages) {
 }
 
 // src/pentest/progress-tracker.ts
-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 dirname17, join as join37 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { mkdir as mkdir12, readdir as readdir5, readFile as readFile16, writeFile as writeFile12 } from "fs/promises";
+import { dirname as dirname17, join as join40 } from "path";
 
 // src/pentest/shared.ts
 import { createHash as createHash7 } from "crypto";
-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 dirname16, join as join36, relative as relative6 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { mkdir as mkdir11, readFile as readFile15, readdir as readdir4, writeFile as writeFile11 } from "fs/promises";
+import { basename as basename6, dirname as dirname16, join as join39, relative as relative6 } from "path";
 import { execa as execa2 } from "execa";
 import fg5 from "fast-glob";
 function toLocalTimestamp(date) {
@@ -7265,7 +8003,7 @@ async function writeJson(target, data) {
 `);
 }
 async function readJsonIfExists(target) {
-  if (!existsSync16(target)) {
+  if (!existsSync17(target)) {
     return null;
   }
   return JSON.parse(await readFile15(target, "utf8"));
@@ -7311,8 +8049,8 @@ async function discoverTargetUrl(projectRoot, stack, explicit) {
   }
   const envFiles = [".env", ".env.local", ".env.example"];
   for (const envFile of envFiles) {
-    const path = join36(projectRoot, envFile);
-    if (!existsSync16(path)) {
+    const path = join39(projectRoot, envFile);
+    if (!existsSync17(path)) {
       continue;
     }
     const content = await readFile15(path, "utf8");
@@ -7333,11 +8071,11 @@ async function discoverTargetUrl(projectRoot, stack, explicit) {
   return null;
 }
 async function runProjectScript(projectRoot, scriptName, env, logDir) {
-  const scriptPath = join36(projectRoot, PATHS.SCRIPTS_DIR, scriptName);
-  const stdoutPath = join36(logDir, `${scriptName}.stdout.log`);
-  const stderrPath = join36(logDir, `${scriptName}.stderr.log`);
+  const scriptPath = join39(projectRoot, PATHS.SCRIPTS_DIR, scriptName);
+  const stdoutPath = join39(logDir, `${scriptName}.stdout.log`);
+  const stderrPath = join39(logDir, `${scriptName}.stderr.log`);
   await mkdir11(logDir, { recursive: true });
-  if (!existsSync16(scriptPath)) {
+  if (!existsSync17(scriptPath)) {
     await writeFile11(stdoutPath, "");
     await writeFile11(stderrPath, `Missing script: ${relative6(projectRoot, scriptPath)}
 `);
@@ -7365,11 +8103,11 @@ async function runProjectScript(projectRoot, scriptName, env, logDir) {
   };
 }
 async function loadModuleDocs(projectRoot, focusModules = []) {
-  const moduleRoot = join36(projectRoot, PATHS.MODULES_DIR);
-  if (!existsSync16(moduleRoot)) {
+  const moduleRoot = join39(projectRoot, PATHS.MODULES_DIR);
+  if (!existsSync17(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();
+  const dirs = (await readdir4(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 fg5(
@@ -7434,7 +8172,7 @@ function inferSourceArtifacts(baseDir, scriptResults) {
   return [
     ...new Set(
       artifacts.map(
-        (artifact) => artifact.startsWith(".") ? artifact : relative6(dirname16(baseDir), join36(dirname16(baseDir), artifact))
+        (artifact) => artifact.startsWith(".") ? artifact : relative6(dirname16(baseDir), join39(dirname16(baseDir), artifact))
       )
     )
   ];
@@ -7508,8 +8246,8 @@ var PentestProgressTracker = class {
     };
   }
   async load(projectRoot, runId) {
-    const target = join37(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "progress.json");
-    if (!existsSync17(target)) {
+    const target = join40(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "progress.json");
+    if (!existsSync18(target)) {
       return null;
     }
     const parsed = JSON.parse(await readFile16(target, "utf8"));
@@ -7520,7 +8258,7 @@ var PentestProgressTracker = class {
     return parsed;
   }
   async save(projectRoot, progress) {
-    const target = join37(projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "progress.json");
+    const target = join40(projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "progress.json");
     progress.updated_at = (/* @__PURE__ */ new Date()).toISOString();
     await mkdir12(dirname17(target), { recursive: true });
     await writeFile12(target, `${JSON.stringify(progress, null, 2)}
@@ -7579,11 +8317,11 @@ var PentestProgressTracker = class {
     return step.status === "completed" && step.input_hash === inputHash;
   }
   async findIncompleteRun(projectRoot, workflow, sourceReportPath) {
-    const runsDir = join37(projectRoot, PATHS.PENTEST_RUNS_DIR);
-    if (!existsSync17(runsDir)) {
+    const runsDir = join40(projectRoot, PATHS.PENTEST_RUNS_DIR);
+    if (!existsSync18(runsDir)) {
       return null;
     }
-    const entries = (await readdir4(runsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().reverse();
+    const entries = (await readdir5(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) {
@@ -7622,21 +8360,21 @@ var PentestProgressTracker = class {
   }
 };
 function runArtifactsDir(projectRoot, runId) {
-  return join37(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "artifacts");
+  return join40(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "artifacts");
 }
 function runLogsDir(projectRoot, runId) {
-  return join37(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "logs");
+  return join40(projectRoot, PATHS.PENTEST_RUNS_DIR, runId, "logs");
 }
 
 // src/pipeline/lane-runner.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { mkdir as mkdir17, readFile as readFile22, writeFile as writeFile17 } from "fs/promises";
-import { dirname as dirname21, join as join46 } from "path";
-import { basename as basename6, dirname as pathDirname } from "pathe";
+import { dirname as dirname21, join as join49 } from "path";
+import { basename as basename7, dirname as pathDirname } from "pathe";
 import fg7 from "fast-glob";
 
 // src/skills/frontmatter-parser.ts
-import YAML5 from "yaml";
+import YAML6 from "yaml";
 
 // src/skills/conditional-processor.ts
 var ConditionalSectionProcessor = class {
@@ -7657,13 +8395,13 @@ var conditionalProcessor = new ConditionalSectionProcessor();
 
 // src/workflows/engine.ts
 import { readFile as readFile18, writeFile as writeFile13, mkdir as mkdir13 } from "fs/promises";
-import { join as join39, dirname as dirname18 } from "path";
+import { join as join42, dirname as dirname18 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/workflows/template-loader.ts
-import { readFile as readFile17, readdir as readdir5 } from "fs/promises";
-import { join as join38 } from "path";
-import YAML6 from "yaml";
+import { readFile as readFile17, readdir as readdir6 } from "fs/promises";
+import { join as join41 } from "path";
+import YAML7 from "yaml";
 
 // src/pipeline/phases/shared.ts
 function createPassResult(phase, summary, context, artifacts = [`handoff:${context.phases.length + 1}`]) {
@@ -7725,7 +8463,15 @@ var DocumentationUpdatePhase = class {
         );
       }
     }
-    return createPassResult(this.phase, "Canonical docs updated", context);
+    const stageSummary = summarizeFeatureDevelopmentStage(
+      context.feature_policy,
+      "documentation_sync"
+    );
+    return createPassResult(
+      this.phase,
+      stageSummary === null ? "Canonical docs updated" : `Canonical docs updated (${stageSummary})`,
+      context
+    );
   }
 };
 
@@ -7761,7 +8507,12 @@ var ImplementationReviewPhase = class {
   async execute(context) {
     const tier = selectReviewTier(context.classification, context.lane);
     const mode = selectReviewMode(false, 0);
-    return createPassResult(this.phase, `Implementation review passed (${tier}, ${mode})`, context);
+    const stageSummary = summarizeFeatureDevelopmentStage(context.feature_policy, "review");
+    return createPassResult(
+      this.phase,
+      stageSummary === null ? `Implementation review passed (${tier}, ${mode})` : `Implementation review passed (${tier}, ${mode}; ${stageSummary})`,
+      context
+    );
   }
 };
 
@@ -7769,7 +8520,12 @@ var ImplementationReviewPhase = class {
 var ImplementationPhase = class {
   phase = "implementation";
   async execute(context) {
-    return createPassResult(this.phase, "Implementation completed", context);
+    const stageSummary = summarizeFeatureDevelopmentStage(context.feature_policy, "development");
+    return createPassResult(
+      this.phase,
+      stageSummary === null ? "Implementation completed" : `Implementation completed (${stageSummary})`,
+      context
+    );
   }
 };
 
@@ -7777,18 +8533,23 @@ var ImplementationPhase = class {
 var LoadDocsPhase = class {
   phase = "docs-first-load";
   async execute(context) {
-    return createPassResult(this.phase, "Docs-first context prepared", context);
+    const stageSummary = summarizeFeatureDevelopmentStage(context.feature_policy, "planning");
+    return createPassResult(
+      this.phase,
+      stageSummary === null ? "Docs-first context prepared" : `Docs-first context prepared (${stageSummary})`,
+      context
+    );
   }
 };
 
 // src/workflows/pentest.ts
 import { mkdir as mkdir14, writeFile as writeFile14 } from "fs/promises";
-import { join as join42, relative as relative7 } from "path";
+import { join as join45, relative as relative7 } from "path";
 
 // src/pentest/findings.ts
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import { readFile as readFile19 } from "fs/promises";
-import { join as join40 } from "path";
+import { join as join43 } from "path";
 function createFinding(input) {
   return {
     id: "",
@@ -8215,8 +8976,8 @@ function buildModuleFindings(docs, tests) {
   return findings;
 }
 async function buildSecretFindings(artifactDir) {
-  const path = join40(artifactDir, "secrets", "matches.txt");
-  if (!existsSync18(path)) {
+  const path = join43(artifactDir, "secrets", "matches.txt");
+  if (!existsSync19(path)) {
     return [];
   }
   const matches = parseSecretMatches(await readFile19(path, "utf8"));
@@ -8331,8 +9092,8 @@ function normalizeImpact(content) {
 }
 async function readNativeAuditFindings(artifactDir) {
   const findings = [];
-  const dependencyDir = join40(artifactDir, "dependencies");
-  const npmAudit = await readJsonMaybe(join40(dependencyDir, "npm-audit.json"));
+  const dependencyDir = join43(artifactDir, "dependencies");
+  const npmAudit = await readJsonMaybe(join43(dependencyDir, "npm-audit.json"));
   for (const [name, vulnerability] of Object.entries(npmAudit?.vulnerabilities ?? {})) {
     const via = (vulnerability.via ?? []).find((entry) => typeof entry === "object");
     findings.push({
@@ -8344,7 +9105,7 @@ async function readNativeAuditFindings(artifactDir) {
       details: via?.url ?? ""
     });
   }
-  const pnpmAudit = await readJsonMaybe(join40(dependencyDir, "pnpm-audit.json"));
+  const pnpmAudit = await readJsonMaybe(join43(dependencyDir, "pnpm-audit.json"));
   for (const advisory of Object.values(pnpmAudit?.advisories ?? {})) {
     findings.push({
       package_name: advisory.module_name ?? "unknown",
@@ -8355,7 +9116,7 @@ async function readNativeAuditFindings(artifactDir) {
       details: advisory.overview ?? ""
     });
   }
-  const composerAudit = await readJsonMaybe(join40(dependencyDir, "composer-audit.json"));
+  const composerAudit = await readJsonMaybe(join43(dependencyDir, "composer-audit.json"));
   if (Array.isArray(composerAudit?.advisories)) {
     for (const advisory of composerAudit.advisories) {
       findings.push({
@@ -8392,7 +9153,7 @@ async function readNativeAuditFindings(artifactDir) {
   });
 }
 async function readJsonMaybe(path) {
-  if (!existsSync18(path)) {
+  if (!existsSync19(path)) {
     return null;
   }
   try {
@@ -8491,7 +9252,7 @@ var FileCheckMapper = class {
 
 // src/pentest/incremental-scanner.ts
 import { readFile as readFile20 } from "fs/promises";
-import { join as join41 } from "path";
+import { join as join44 } from "path";
 import { createHash as createHash8 } from "crypto";
 import { execa as execa3 } from "execa";
 var IncrementalScanner = class {
@@ -8525,7 +9286,7 @@ var IncrementalScanner = class {
     }
   }
   async gitDiff(projectRoot, lastRunId) {
-    const progressPath = join41(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
+    const progressPath = join44(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
     let baseCommit;
     try {
       const raw = await readFile20(progressPath, "utf8");
@@ -8542,7 +9303,7 @@ var IncrementalScanner = class {
     return result.stdout.split("\n").map((f) => f.trim()).filter(Boolean);
   }
   async hashDiff(projectRoot, lastRunId) {
-    const manifestPath = join41(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
+    const manifestPath = join44(projectRoot, ".paqad", "pentest", "runs", lastRunId, "progress.json");
     let fileManifest = {};
     try {
       const raw = await readFile20(manifestPath, "utf8");
@@ -8554,7 +9315,7 @@ var IncrementalScanner = class {
     const changed = [];
     for (const [filePath, storedHash] of Object.entries(fileManifest)) {
       try {
-        const content = await readFile20(join41(projectRoot, filePath), "utf8");
+        const content = await readFile20(join44(projectRoot, filePath), "utf8");
         const currentHash = createHash8("sha256").update(content).digest("hex");
         if (currentHash !== storedHash) {
           changed.push(filePath);
@@ -8567,11 +9328,11 @@ var IncrementalScanner = class {
   }
   async warnIfFullScanStale(projectRoot, thresholdDays) {
     try {
-      const runsDir = join41(projectRoot, ".paqad", "pentest", "runs");
-      const { readdir: readdir8 } = await import("fs/promises");
-      const runs = await readdir8(runsDir).catch(() => []);
+      const runsDir = join44(projectRoot, ".paqad", "pentest", "runs");
+      const { readdir: readdir9 } = await import("fs/promises");
+      const runs = await readdir9(runsDir).catch(() => []);
       for (const run of runs.sort().reverse()) {
-        const progressPath = join41(runsDir, run, "progress.json");
+        const progressPath = join44(runsDir, run, "progress.json");
         try {
           const raw = await readFile20(progressPath, "utf8");
           const progress = JSON.parse(raw);
@@ -8769,8 +9530,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 = join42(artifactsDir, "docs-summary.json");
-      const testsPath = join42(artifactsDir, "tests-summary.json");
+      const docsPath = join45(artifactsDir, "docs-summary.json");
+      const testsPath = join45(artifactsDir, "tests-summary.json");
       await writeJson(docsPath, docs);
       await writeJson(
         testsPath,
@@ -8871,7 +9632,7 @@ var PentestWorkflow = class {
         progressRunId: progress.run_id,
         reportTimestamp: new Date(progress.started_at)
       });
-      const findingIndexPath = join42(
+      const findingIndexPath = join45(
         options.projectRoot,
         PATHS.PENTEST_RUNS_DIR,
         progress.run_id,
@@ -8888,7 +9649,7 @@ var PentestWorkflow = class {
     }
     if (report === null) {
       const existingSidecar = progress.sidecar_path ? await readJsonIfExists(
-        join42(options.projectRoot, progress.sidecar_path)
+        join45(options.projectRoot, progress.sidecar_path)
       ) : null;
       report = existingSidecar;
     }
@@ -8903,18 +9664,18 @@ var PentestWorkflow = class {
       this.tracker.markStepRunning(progress, "write-report", writeHash);
       await this.tracker.save(options.projectRoot, progress);
       await writeJson(
-        join42(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "report-preview.json"),
+        join45(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "report-preview.json"),
         { report_id: report.report_id, findings: report.findings.length }
       );
-      await writeJson(join42(options.projectRoot, report.sidecar_path), report);
+      await writeJson(join45(options.projectRoot, report.sidecar_path), report);
       await writeJson(
-        join42(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "blocked-checks.json"),
+        join45(options.projectRoot, PATHS.PENTEST_RUNS_DIR, progress.run_id, "blocked-checks.json"),
         report.blocked_checks
       );
-      await mkdir14(join42(options.projectRoot, PATHS.PENTEST_DIR), { recursive: true });
+      await mkdir14(join45(options.projectRoot, PATHS.PENTEST_DIR), { recursive: true });
       const markdown = buildPentestMarkdown(report);
-      await writeJson(join42(options.projectRoot, report.sidecar_path), report);
-      await writeFile14(join42(options.projectRoot, report.report_path), markdown);
+      await writeJson(join45(options.projectRoot, report.sidecar_path), report);
+      await writeFile14(join45(options.projectRoot, report.report_path), markdown);
       this.tracker.markStepCompleted(
         progress,
         "write-report",
@@ -8941,7 +9702,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 = join42(input.artifactsDir, "dependencies", "osv-results.json");
+  const osvPath = join45(input.artifactsDir, "dependencies", "osv-results.json");
   await writeJson(osvPath, osvFindings);
   const dependencyFindings = await buildDependencyFindings(
     input.snapshot,
@@ -8950,7 +9711,7 @@ async function buildCurrentPentestReport(input) {
   );
   const moduleFindings = buildModuleFindings(docs, tests);
   const secretFindings = await buildSecretFindings(input.artifactsDir);
-  const runtimePayload = await readJsonIfExists(join42(input.artifactsDir, "runtime", "runtime-checks.json"));
+  const runtimePayload = await readJsonIfExists(join45(input.artifactsDir, "runtime", "runtime-checks.json"));
   const runtimeStatus = input.targetUrl ? runtimePayload?.reachable ? {
     target_url: input.targetUrl,
     status: "reachable",
@@ -8976,8 +9737,8 @@ async function buildCurrentPentestReport(input) {
     ...runtimeFindings
   ]);
   const timestamp = toLocalTimestamp(input.reportTimestamp);
-  const reportPath = join42(PATHS.PENTEST_DIR, `${timestamp}.md`);
-  const sidecarPath = join42(PATHS.PENTEST_DIR, `${timestamp}.json`);
+  const reportPath = join45(PATHS.PENTEST_DIR, `${timestamp}.md`);
+  const sidecarPath = join45(PATHS.PENTEST_DIR, `${timestamp}.json`);
   const stack = getPrimaryStack({
     routing: { domain: "coding" },
     stack_profile: input.snapshot.profile
@@ -9030,9 +9791,9 @@ async function buildCurrentPentestReport(input) {
     raw_evidence_paths: [
       relative7(input.projectRoot, osvPath),
       ...[
-        join42(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "finding-index.json"),
-        join42(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "artifacts", "docs-summary.json"),
-        join42(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "artifacts", "tests-summary.json")
+        join45(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "finding-index.json"),
+        join45(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "artifacts", "docs-summary.json"),
+        join45(PATHS.PENTEST_RUNS_DIR, input.progressRunId, "artifacts", "tests-summary.json")
       ]
     ]
   };
@@ -9072,7 +9833,7 @@ var PentestPhase = class {
 
 // src/workflows/pentest-retest.ts
 import { mkdir as mkdir15, writeFile as writeFile15 } from "fs/promises";
-import { dirname as dirname19, join as join43 } from "path";
+import { dirname as dirname19, join as join46 } from "path";
 var RETEST_STEPS = [
   { id: "load-source-report", title: "Load source pentest report" },
   { id: "rerun-evidence", title: "Collect fresh evidence for source findings" },
@@ -9093,7 +9854,7 @@ var PentestRetestWorkflow = class {
     }
     const normalizedSourcePath = normalizeSidecarPath(sourceReportPath);
     const sourceSidecar = await readJsonIfExists(
-      join43(options.projectRoot, normalizedSourcePath)
+      join46(options.projectRoot, normalizedSourcePath)
     );
     if (sourceSidecar === null) {
       throw new Error(`Source pentest sidecar not found at ${normalizedSourcePath}`);
@@ -9118,12 +9879,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 = join43(artifactsDir, "source-report.json");
+      const sourceCopy = join46(artifactsDir, "source-report.json");
       await writeJson(sourceCopy, sourceSidecar);
       this.tracker.markStepCompleted(
         progress,
         "load-source-report",
-        [join43(PATHS.PENTEST_RUNS_DIR, progress.run_id, "artifacts", "source-report.json")],
+        [join46(PATHS.PENTEST_RUNS_DIR, progress.run_id, "artifacts", "source-report.json")],
         [...RETEST_SKILLS.source].map(skillPath)
       );
       await this.tracker.save(options.projectRoot, progress);
@@ -9140,7 +9901,7 @@ var PentestRetestWorkflow = class {
         PENTEST_RUN_ID: progress.run_id,
         PENTEST_ARTIFACT_DIR: artifactsDir,
         PENTEST_TARGET_URL: targetUrl ?? "",
-        PENTEST_SOURCE_REPORT: join43(options.projectRoot, normalizedSourcePath),
+        PENTEST_SOURCE_REPORT: join46(options.projectRoot, normalizedSourcePath),
         PENTEST_DB_CONNECTION_NAME: options.dbConnectionName ?? ""
       };
       const scriptResults = await Promise.all([
@@ -9189,8 +9950,8 @@ var PentestRetestWorkflow = class {
         ...currentReport,
         report_id: toReportId("RETEST", new Date(progress.started_at)),
         workflow: "pentest-retest",
-        report_path: join43(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.md`),
-        sidecar_path: join43(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.json`),
+        report_path: join46(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.md`),
+        sidecar_path: join46(PATHS.PENTEST_RETEST_DIR, `${timestamp}-${sourceSlug}.json`),
         source_report_path: normalizedSourcePath,
         source_report_id: sourceSidecar.report_id,
         findings: retestFindings,
@@ -9203,7 +9964,7 @@ var PentestRetestWorkflow = class {
           ...[...RETEST_SKILLS.source, ...RETEST_SKILLS.evaluate].map(skillPath)
         ]
       };
-      const findingIndexPath = join43(
+      const findingIndexPath = join46(
         options.projectRoot,
         PATHS.PENTEST_RUNS_DIR,
         progress.run_id,
@@ -9213,14 +9974,14 @@ var PentestRetestWorkflow = class {
       this.tracker.markStepCompleted(
         progress,
         "evaluate-source-findings",
-        [join43(PATHS.PENTEST_RUNS_DIR, progress.run_id, "finding-index.json")],
+        [join46(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(
-        join43(options.projectRoot, progress.sidecar_path)
+        join46(options.projectRoot, progress.sidecar_path)
       ) : null;
       retestReport = existing;
     }
@@ -9234,12 +9995,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(join43(options.projectRoot, retestReport.sidecar_path), retestReport);
-      await mkdir15(dirname19(join43(options.projectRoot, retestReport.report_path)), {
+      await writeJson(join46(options.projectRoot, retestReport.sidecar_path), retestReport);
+      await mkdir15(dirname19(join46(options.projectRoot, retestReport.report_path)), {
         recursive: true
       });
       await writeFile15(
-        join43(options.projectRoot, retestReport.report_path),
+        join46(options.projectRoot, retestReport.report_path),
         buildPentestMarkdown(retestReport)
       );
       this.tracker.markStepCompleted(
@@ -9317,7 +10078,7 @@ var ProjectQuestionPhase = class {
 
 // src/workflows/root-cause-analysis.ts
 import { mkdir as mkdir16, writeFile as writeFile16 } from "fs/promises";
-import { dirname as dirname20, join as join44 } from "path";
+import { dirname as dirname20, join as join47 } from "path";
 var DEFAULT_TITLE_SLUG = "root-cause-analysis";
 var RCA_SECTIONS = [
   "Summary",
@@ -9336,8 +10097,8 @@ 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 = join44(PATHS.RCA_DIR, filename);
-    const outputPath = join44(options.projectRoot, relativePath);
+    const relativePath = join47(PATHS.RCA_DIR, filename);
+    const outputPath = join47(options.projectRoot, relativePath);
     await mkdir16(dirname20(outputPath), { recursive: true });
     await writeFile16(outputPath, buildRcaDocument(title, options.classification));
     return {
@@ -9445,7 +10206,12 @@ var SpecReviewPhase = class {
 var SpecWritingPhase = class {
   phase = "specification";
   async execute(context) {
-    return createPassResult(this.phase, "Specification written", context);
+    const stageSummary = summarizeFeatureDevelopmentStage(context.feature_policy, "specification");
+    return createPassResult(
+      this.phase,
+      stageSummary === null ? "Specification written" : `Specification written (${stageSummary})`,
+      context
+    );
   }
 };
 
@@ -9453,7 +10219,12 @@ var SpecWritingPhase = class {
 var StoryPlanningPhase = class {
   phase = "sequence-planning";
   async execute(context) {
-    return createPassResult(this.phase, "Story sequence planned", context);
+    const stageSummary = summarizeFeatureDevelopmentStage(context.feature_policy, "planning");
+    return createPassResult(
+      this.phase,
+      stageSummary === null ? "Story sequence planned" : `Story sequence planned (${stageSummary})`,
+      context
+    );
   }
 };
 
@@ -9461,14 +10232,30 @@ var StoryPlanningPhase = class {
 var VerificationPhase = class {
   phase = "verification-gates";
   async execute(context) {
-    return createPassResult(this.phase, "Verification gates passed", context);
+    const profile = readProjectProfile(context.project_root);
+    const stage = context.feature_policy?.stages.checks ?? null;
+    const resolved = resolveFeatureDevelopmentCheckCommands(stage?.checks ?? null, profile);
+    const stageSummary = summarizeFeatureDevelopmentStage(context.feature_policy, "checks");
+    if (resolved.warnings.length > 0 && stage?.checks?.block_on_failure) {
+      return createFailResult(
+        this.phase,
+        `Verification blocked (${resolved.warnings.join(" ")})`,
+        context
+      );
+    }
+    const commandSummary = resolved.commands.length > 0 ? `commands: ${resolved.commands.map((command) => command.command).join("; ")}` : "no configured commands";
+    return createPassResult(
+      this.phase,
+      stageSummary === null ? `Verification gates passed (${commandSummary})` : `Verification gates passed (${stageSummary}; ${commandSummary})`,
+      context
+    );
   }
 };
 
 // src/pipeline/workflow-router.ts
 import { readFile as readFile21 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
-import { join as join45, relative as relative8 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { join as join48, relative as relative8 } from "path";
 import fg6 from "fast-glob";
 
 // src/pipeline/lane-runner.ts
@@ -9492,38 +10279,38 @@ var DEFAULT_PHASES = {
 
 // src/pipeline/stream-truncator.ts
 import { appendFile, mkdir as mkdir18 } from "fs/promises";
-import { join as join47, dirname as dirname22 } from "path";
+import { join as join50, dirname as dirname22 } from "path";
 
 // src/resolver/deduplicator.ts
 import { createHash as createHash9 } from "crypto";
 import { readFile as readFile23, writeFile as writeFile18, mkdir as mkdir19 } from "fs/promises";
-import { join as join48, dirname as dirname23 } from "path";
+import { join as join51, dirname as dirname23 } from "path";
 
 // src/scripts/generator.ts
 import { chmodSync as chmodSync2 } from "fs";
 import { mkdir as mkdir20, writeFile as writeFile19 } from "fs/promises";
-import { dirname as dirname24, join as join49 } from "path";
+import { dirname as dirname24, join as join52 } from "path";
 
 // src/skills/cache-manager.ts
 import { createHash as createHash10 } from "crypto";
-import { mkdir as mkdir21, readFile as readFile24, readdir as readdir6, rm as rm2, stat as stat3, writeFile as writeFile20 } from "fs/promises";
-import { join as join50 } from "path";
+import { mkdir as mkdir21, readFile as readFile24, readdir as readdir7, rm as rm2, stat as stat3, writeFile as writeFile20 } from "fs/promises";
+import { join as join53 } from "path";
 import fg8 from "fast-glob";
 
 // src/skills/index-generator.ts
 import { mkdir as mkdir22, readFile as readFile25, writeFile as writeFile21 } from "fs/promises";
-import { dirname as dirname25, join as join51, relative as relative9 } from "path";
+import { dirname as dirname25, join as join54, relative as relative9 } from "path";
 import fg9 from "fast-glob";
 
 // src/skills/loader.ts
 import { readFile as readFile26 } from "fs/promises";
-import { basename as basename7 } from "pathe";
+import { basename as basename8 } from "pathe";
 
 // src/update/audit.ts
 import { appendFileSync, mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname26, join as join52 } from "path";
+import { dirname as dirname26, join as join55 } from "path";
 function auditPath(projectRoot) {
-  return join52(projectRoot, PATHS.AUDIT_LOG);
+  return join55(projectRoot, PATHS.AUDIT_LOG);
 }
 function ts() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -9545,16 +10332,16 @@ function appendAuditLogFailure(projectRoot, previous, target, error) {
 }
 
 // src/update/updater.ts
-import { chmodSync as chmodSync3, existsSync as existsSync21, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
-import { mkdtemp, readdir as readdir7, readFile as readFile27, rm as rm3 } from "fs/promises";
+import { chmodSync as chmodSync3, existsSync as existsSync22, mkdirSync as mkdirSync7, readFileSync as readFileSync14, writeFileSync as writeFileSync6 } from "fs";
+import { mkdtemp, readdir as readdir8, readFile as readFile27, rm as rm3 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname27, join as join53, relative as relative10 } from "path";
+import { dirname as dirname27, join as join56, relative as relative10 } from "path";
 var FrameworkUpdater = class {
   constructor(options = {}) {
     this.options = options;
   }
   async run(projectRoot) {
-    const previousVersion = readText(join53(projectRoot, PATHS.FRAMEWORK_VERSION));
+    const previousVersion = readText(join56(projectRoot, PATHS.FRAMEWORK_VERSION));
     const manifest = readManifest(projectRoot);
     const artifactPolicy = new Map(
       manifest?.generated_artifacts.map((artifact) => [artifact.path, artifact.auto_update]) ?? []
@@ -9564,13 +10351,13 @@ var FrameworkUpdater = class {
     const skipped = [];
     const newScripts = [];
     for (const candidate of candidates) {
-      const target = join53(projectRoot, candidate.path);
-      const existed = existsSync21(target);
+      const target = join56(projectRoot, candidate.path);
+      const existed = existsSync22(target);
       const autoUpdate = artifactPolicy.get(candidate.path) ?? candidate.autoUpdate;
       if (existed && autoUpdate === false) {
         skipped.push({
           path: candidate.path,
-          before: readFileSync13(target, "utf8"),
+          before: readFileSync14(target, "utf8"),
           after: candidate.content
         });
         continue;
@@ -9585,9 +10372,9 @@ var FrameworkUpdater = class {
         newScripts.push(candidate.path);
       }
     }
-    mkdirSync7(dirname27(join53(projectRoot, PATHS.FRAMEWORK_VERSION)), { recursive: true });
+    mkdirSync7(dirname27(join56(projectRoot, PATHS.FRAMEWORK_VERSION)), { recursive: true });
     writeFileSync6(
-      join53(projectRoot, PATHS.FRAMEWORK_VERSION),
+      join56(projectRoot, PATHS.FRAMEWORK_VERSION),
       `version=${VERSION}
 updated_at=${(/* @__PURE__ */ new Date()).toISOString()}
 `
@@ -9610,7 +10397,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(join53(tmpdir(), "paqad-ai-update-"));
+    const tempRoot = await mkdtemp(join56(tmpdir(), "paqad-ai-update-"));
     try {
       const result = await new OnboardingOrchestrator().run({
         projectRoot: tempRoot,
@@ -9630,41 +10417,41 @@ updated_at=${(/* @__PURE__ */ new Date()).toISOString()}
   }
 };
 function readManifest(projectRoot) {
-  const path = join53(projectRoot, PATHS.ONBOARDING_MANIFEST);
-  if (!existsSync21(path)) {
+  const path = join56(projectRoot, PATHS.ONBOARDING_MANIFEST);
+  if (!existsSync22(path)) {
     return null;
   }
-  return JSON.parse(readFileSync13(path, "utf8"));
+  return JSON.parse(readFileSync14(path, "utf8"));
 }
 function readProfile(projectRoot) {
   return readProjectProfile(projectRoot);
 }
 function readText(path) {
-  if (!existsSync21(path)) {
+  if (!existsSync22(path)) {
     return null;
   }
-  const raw = readFileSync13(path, "utf8");
+  const raw = readFileSync14(path, "utf8");
   const match = raw.match(/^version=(.+)$/m);
   return match ? match[1].trim() : raw.trim();
 }
 async function collectFiles(root, generated) {
-  const paths = generated.length > 0 ? generated : await walk3(root);
+  const paths = generated.length > 0 ? generated : await walk4(root);
   return Promise.all(
     paths.map(async (file) => ({
       path: file,
-      content: await readFile27(join53(root, file), "utf8"),
+      content: await readFile27(join56(root, file), "utf8"),
       autoUpdate: true,
       executable: file.startsWith("scripts/")
     }))
   );
 }
-async function walk3(root, current = root) {
-  const entries = await readdir7(current, { withFileTypes: true });
+async function walk4(root, current = root) {
+  const entries = await readdir8(current, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const absolute = join53(current, entry.name);
+    const absolute = join56(current, entry.name);
     if (entry.isDirectory()) {
-      files.push(...await walk3(root, absolute));
+      files.push(...await walk4(root, absolute));
       continue;
     }
     files.push(relative10(root, absolute));
@@ -9673,31 +10460,31 @@ async function walk3(root, current = root) {
 }
 
 // src/verification/gates/documentation-freshness.ts
-import { existsSync as existsSync22 } from "fs";
-import { join as join54 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { join as join57 } from "path";
 var STALENESS_WINDOW_MS2 = 1e3 * 60 * 60 * 24 * 7;
 
 // src/patterns/pattern-store.ts
 import { readFile as readFile28, writeFile as writeFile22, mkdir as mkdir23, unlink } from "fs/promises";
-import { join as join55, dirname as dirname28 } from "path";
+import { join as join58, dirname as dirname28 } from "path";
 import { homedir as homedir3 } from "os";
-var GLOBAL_PATTERNS_DIR = join55(homedir3(), ".paqad", "patterns");
+var GLOBAL_PATTERNS_DIR = join58(homedir3(), ".paqad", "patterns");
 var PatternStore = class {
   get indexPath() {
-    return join55(GLOBAL_PATTERNS_DIR, "index.json");
+    return join58(GLOBAL_PATTERNS_DIR, "index.json");
   }
   get entriesDir() {
-    return join55(GLOBAL_PATTERNS_DIR, "entries");
+    return join58(GLOBAL_PATTERNS_DIR, "entries");
   }
   async save(pattern) {
     await mkdir23(this.entriesDir, { recursive: true });
-    const entryPath = join55(this.entriesDir, `${pattern.id}.json`);
+    const entryPath = join58(this.entriesDir, `${pattern.id}.json`);
     await writeFile22(entryPath, JSON.stringify(pattern, null, 2), "utf8");
     await this.updateIndex(pattern);
   }
   async load(id) {
     try {
-      const raw = await readFile28(join55(this.entriesDir, `${id}.json`), "utf8");
+      const raw = await readFile28(join58(this.entriesDir, `${id}.json`), "utf8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -9732,7 +10519,7 @@ var PatternStore = class {
   }
   async delete(id) {
     try {
-      await unlink(join55(this.entriesDir, `${id}.json`));
+      await unlink(join58(this.entriesDir, `${id}.json`));
     } catch {
     }
     const index = await this.loadIndex();
@@ -9831,7 +10618,7 @@ ${p.solution}
 };
 
 // src/index.ts
-var VERSION = "0.1.4";
+var VERSION = "0.1.5";
 
 // src/cli/commands/capabilities.ts
 import { Command } from "commander";
@@ -10010,12 +10797,13 @@ function createPacksCommand() {
 
 // src/cli/commands/refresh.ts
 import { Command as Command7 } from "commander";
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
-import { join as join56 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
+import { join as join59 } 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;
-    const shouldRefreshStack = options.stack ?? true;
+    const hasExplicitTarget = options.designSystem === true || options.stack === true;
+    const shouldRefreshDesignSystem = hasExplicitTarget ? options.designSystem === true : true;
+    const shouldRefreshStack = hasExplicitTarget ? options.stack === true : true;
     if (shouldRefreshDesignSystem) {
       await new DesignTokenService().writeDocs(options.projectRoot);
     }
@@ -10047,14 +10835,14 @@ function createRefreshCommand() {
   });
 }
 function writeRefreshDrift(projectRoot, refreshDrift) {
-  const path = join56(projectRoot, PATHS.STACK_DRIFT);
+  const path = join59(projectRoot, PATHS.STACK_DRIFT);
   const current = readExistingJson(path);
   writeFileSync7(path, `${JSON.stringify({ ...current ?? {}, ...refreshDrift }, null, 2)}
 `);
 }
 function readExistingJson(path) {
   try {
-    return JSON.parse(readFileSync14(path, "utf8"));
+    return JSON.parse(readFileSync15(path, "utf8"));
   } catch {
     return null;
   }