@kaddo/cli 3.35.0 → 3.37.0

package/README.md

@@ -531,6 +531,8 @@ create --from roadmap → owners → guard → explain`.
 | v3.33 | Open questions resolution tracking: mark questions `[open]`/`[resolved]`/`[assumed]`/`[deferred]` (EN+ES); only `open` blocks readiness, so assumed/resolved/deferred decisions stop false blocks. `kaddo questions` shows status counts + `resolution_status` in JSON |
 | v3.34 | Pre-AI onboarding: `kaddo onboarding` (alias `onboard`) / `kaddo report onboarding` — read-only diagnosis of an existing project's readiness (scan/understand/knowledge/questions/roadmap/work-items/adapters) with a single recommended next step; `--json` |
 | v3.35 | Folded onboarding into `kaddo explain`: removed `kaddo onboarding`/`onboard`/`report onboarding`; project readiness + single recommended next step now live in `kaddo explain` (human `## Project Readiness` + `readiness` in agent JSON) |
+| v3.36 | State-aware bootstrap: `kaddo bootstrap` creates the full knowledge baseline for any `project.state` (new/pre-ai/legacy) with state-specific templates — no more new-only warning; idempotent, never overwrites, ensures `tech/decisions/` and `delivery/work-items/` |
+| v3.37 | Placeholder-aware readiness: knowledge files are classified missing/placeholder/weak/useful; a bootstrap file isn't treated as ready knowledge. Layers downgrade to Placeholder/Weak, a new Knowledge Refinement phase recommends the right agent, and `create --from roadmap` is never suggested with 0 candidates |
 
 **Optional modules (installed with `kaddo add`):**
 

package/dist/index.js

@@ -6041,14 +6041,23 @@ import { parse as parseYaml9 } from "yaml";
 function layer(layers, name) {
   return layers.find((l) => l.layer === name)?.status ?? "Missing";
 }
+var NOT_READY_LAYER = ["Missing", "Placeholder", "Weak"];
 function baseComplete(layers) {
   return layer(layers, "Business") !== "Missing" && layer(layers, "Product") !== "Missing" && layer(layers, "Tech") !== "Missing";
 }
+function baseUseful(layers) {
+  return ["Business", "Product", "Tech"].every((n) => !NOT_READY_LAYER.includes(layer(layers, n)));
+}
+function roadmapHasCandidates(roadmap) {
+  return roadmap.candidates > 0 || roadmap.remaining > 0;
+}
 function determinePhase(input) {
   const { roadmap, workItems } = input;
   const active = workItems.byState.draft + workItems.byState.ready + workItems.byState["in-progress"] + workItems.byState.blocked;
   if (!baseComplete(input.layers)) return "Discovery";
+  if (!baseUseful(input.layers)) return "Knowledge Refinement";
   if (!roadmap.present) return "Planning";
+  if (!roadmapHasCandidates(roadmap) && workItems.total === 0) return "Planning";
   if (workItems.total === 0) return "Delivery Preparation";
   if (active > 0) return "Active Delivery";
   return "Maintenance";
@@ -6078,6 +6087,14 @@ function firstMissingLayerAgent(layers) {
     return { agent: "capability-agent", step: "Use capability-agent to create knowledge/product/capabilities.md" };
   return { agent: "architecture-agent", step: "Use architecture-agent to create knowledge/tech/current-state.md" };
 }
+function firstUnrefinedLayerAgent(layers) {
+  const isThin = (n) => NOT_READY_LAYER.includes(layer(layers, n));
+  if (isThin("Business"))
+    return { agent: "business-agent", step: "Use business-agent to complete knowledge/business/business.md" };
+  if (isThin("Product"))
+    return { agent: "capability-agent", step: "Use capability-agent to complete knowledge/product/capabilities.md" };
+  return { agent: "architecture-agent", step: "Use architecture-agent to complete knowledge/tech/current-state.md" };
+}
 function assessPhase(input) {
   const phase = determinePhase(input);
   const reasons = buildReasons(input);
@@ -6095,6 +6112,17 @@ function assessPhase(input) {
       llmInstructions = [`Use the ${m.agent} to fill the missing base knowledge.`, "Do not write code."];
       break;
     }
+    case "Knowledge Refinement": {
+      const m = firstUnrefinedLayerAgent(input.layers);
+      recommendedAgents2 = [m.agent];
+      nextStep = m.step;
+      llmInstructions = [
+        "The baseline files exist but still look like bootstrap placeholders.",
+        `Use the ${m.agent} to replace the placeholders with real, project-specific knowledge.`,
+        "Do not write code."
+      ];
+      break;
+    }
     case "Planning": {
       recommendedAgents2 = ["roadmap-agent"];
       nextStep = "Use roadmap-agent to create knowledge/delivery/roadmap.md";
@@ -6230,7 +6258,7 @@ ${items.map((i) => `- ${i}`).join("\n")}
 `;
 }
 function renderCapsuleMarkdown(c) {
-  const fm = [
+  const fm2 = [
     "---",
     "type: knowledge-capsule",
     `system: ${c.system}`,
@@ -6242,7 +6270,7 @@ function renderCapsuleMarkdown(c) {
     "---"
   ].join("\n");
   const parts = [
-    fm,
+    fm2,
     "",
     `# ${c.system} \u2014 Knowledge Capsule`,
     "",
@@ -6723,9 +6751,9 @@ var QUALITY_NOTE = {
   sparse: "The graph has many nodes but few meaningful edges.",
   empty: "The graph has almost no relationships."
 };
-function yamlBlock(fm) {
+function yamlBlock(fm2) {
   const lines = ["```yaml"];
-  for (const [k, vals] of Object.entries(fm)) {
+  for (const [k, vals] of Object.entries(fm2)) {
     lines.push(`${k}:`);
     for (const v of vals) lines.push(`  - ${v}`);
   }
@@ -6957,9 +6985,97 @@ function statusFor(layer2, a) {
   return "Missing";
 }
 
+// src/core/artifact-quality.ts
+function isPlaceholderLine(line) {
+  const t = line.trim();
+  if (/^_.+_$/.test(t)) return true;
+  if (/^[-*]\s+(\[[^\]]+\]\s*)?_.+_$/.test(t)) return true;
+  if (/^[-*]\s+\[[^\]]+\]\s*$/.test(t)) return true;
+  if (/^_(?:Describe|List|Document|What|Which|Who|Use|To be defined|No production code)\b/i.test(t)) return true;
+  return false;
+}
+function isStructuralLine(line, inFrontMatter) {
+  const t = line.trim();
+  if (inFrontMatter) return true;
+  if (t === "") return true;
+  if (/^#{1,6}\s/.test(t)) return true;
+  if (/^<!--/.test(t)) return true;
+  if (/^>/.test(t)) return true;
+  return false;
+}
+function analyzeContent(md) {
+  const lines = md.split(/\r?\n/);
+  let inFrontMatter = false;
+  let seenFmFence = 0;
+  let currentSectionHasUseful = false;
+  const sectionsWithUseful = /* @__PURE__ */ new Set();
+  let sectionIndex = 0;
+  const contentLines = [];
+  const usefulLines = [];
+  for (const raw of lines) {
+    const t = raw.trim();
+    if (t === "---" && seenFmFence < 2) {
+      seenFmFence += 1;
+      inFrontMatter = seenFmFence === 1;
+      continue;
+    }
+    if (seenFmFence === 1) continue;
+    if (/^#{1,6}\s/.test(t)) {
+      sectionIndex += 1;
+      currentSectionHasUseful = false;
+      continue;
+    }
+    if (isStructuralLine(raw, false)) continue;
+    contentLines.push(t);
+    if (!isPlaceholderLine(raw)) {
+      usefulLines.push(t);
+      if (!currentSectionHasUseful) {
+        currentSectionHasUseful = true;
+        sectionsWithUseful.add(sectionIndex);
+      }
+    }
+  }
+  if (usefulLines.length === 0) return "placeholder";
+  const usefulWordCount = usefulLines.join(" ").split(/\s+/).filter(Boolean).length;
+  const placeholderRatio = contentLines.length > 0 ? (contentLines.length - usefulLines.length) / contentLines.length : 1;
+  if (usefulWordCount >= 80 && placeholderRatio < 0.25 && sectionsWithUseful.size >= 2) return "useful";
+  return "weak";
+}
+function analyzeKnowledgeArtifact(dir, rel) {
+  const p2 = join(dir, rel);
+  if (!exists(p2)) return "missing";
+  try {
+    return analyzeContent(readFile(p2));
+  } catch {
+    return "missing";
+  }
+}
+
 // src/core/layers.ts
+var LAYER_BASELINE = {
+  Business: ["knowledge/business/business.md"],
+  Product: ["knowledge/product/product.md", "knowledge/product/capabilities.md"],
+  Tech: ["knowledge/tech/codebase.md", "knowledge/tech/current-state.md"],
+  Delivery: ["knowledge/delivery/roadmap.md"]
+};
+function layerQuality(dir, layer2) {
+  const order = ["missing", "placeholder", "weak", "useful"];
+  let worst = null;
+  for (const rel of LAYER_BASELINE[layer2]) {
+    const q = analyzeKnowledgeArtifact(dir, rel);
+    if (q === "missing") continue;
+    if (worst === null || order.indexOf(q) < order.indexOf(worst)) worst = q;
+  }
+  return worst;
+}
 function knowledgeLayers(dir) {
-  return discoverLayers(dir);
+  return discoverLayers(dir).map((l) => {
+    if (l.status !== "Consolidated" && l.status !== "Structured") return l;
+    const q = layerQuality(dir, l.layer);
+    if (q === "placeholder") return { ...l, status: "Placeholder" };
+    if (q === "weak") return { ...l, status: "Weak" };
+    return l;
+  });
 }
 function renderLayersMarkdown(layers) {
   const lines = [];
@@ -7631,24 +7747,12 @@ function buildSharedFileStatuses(statuses) {
 
 // src/core/readiness.ts
 var KNOWLEDGE_FILES = [
-  { key: "current_state", path: "knowledge/tech/current-state.md", label: "knowledge/tech/current-state.md" },
-  { key: "codebase", path: "knowledge/tech/codebase.md", label: "knowledge/tech/codebase.md" },
-  { key: "capabilities", path: "knowledge/product/capabilities.md", label: "knowledge/product/capabilities.md" },
-  { key: "product", path: "knowledge/product/product.md", label: "knowledge/product/product.md" },
-  { key: "business", path: "knowledge/business/business.md", label: "knowledge/business/business.md" }
+  { key: "current_state", path: "knowledge/tech/current-state.md", label: "knowledge/tech/current-state.md", agent: "architecture-agent" },
+  { key: "codebase", path: "knowledge/tech/codebase.md", label: "knowledge/tech/codebase.md", agent: "codebase-agent" },
+  { key: "capabilities", path: "knowledge/product/capabilities.md", label: "knowledge/product/capabilities.md", agent: "capability-agent" },
+  { key: "product", path: "knowledge/product/product.md", label: "knowledge/product/product.md", agent: "product-agent" },
+  { key: "business", path: "knowledge/business/business.md", label: "knowledge/business/business.md", agent: "business-agent" }
 ];
-function knowledgePresence(dir, rel) {
-  const p2 = join(dir, rel);
-  if (!exists(p2)) return "missing";
-  let md;
-  try {
-    md = readFile(p2);
-  } catch {
-    return "missing";
-  }
-  const body = md.replace(/^---[\s\S]*?---/m, "").split(/\r?\n/).filter((l) => !/^\s*#{1,6}\s/.test(l) && !/^\s*$/.test(l) && !/^\s*<!--/.test(l)).join(" ").trim();
-  return body.length >= 40 ? "present" : "weak";
-}
 function roadmapSignal(dir) {
   const p2 = join(dir, "knowledge/delivery/roadmap.md");
   if (!exists(p2)) return "missing";
@@ -7711,7 +7815,7 @@ function buildReadinessReport(dir, now = /* @__PURE__ */ new Date()) {
   if (config.project.state === "legacy") return stub("legacy-project", "Use the legacy project flow.");
   const scan2 = exists(join(dir, ".kaddo", "scan.json")) ? "available" : "missing";
   const understand = exists(join(dir, ".kaddo", "understand.md")) ? "available" : "missing";
-  const presence = Object.fromEntries(KNOWLEDGE_FILES.map((f) => [f.key, knowledgePresence(dir, f.path)]));
+  const presence = Object.fromEntries(KNOWLEDGE_FILES.map((f) => [f.key, analyzeKnowledgeArtifact(dir, f.path)]));
   const ctx = buildCodexAdapterContext(dir);
   const agents = ctx.hasAgents ? "present" : "missing";
   const skills = ctx.hasSkills ? "present" : "missing";
@@ -7741,7 +7845,7 @@ function buildReadinessReport(dir, now = /* @__PURE__ */ new Date()) {
   };
   let overall;
   let next;
-  const firstWeak = KNOWLEDGE_FILES.find((f) => presence[f.key] !== "present");
+  const firstWeak = KNOWLEDGE_FILES.find((f) => presence[f.key] !== "useful");
   if (scan2 === "missing") {
     overall = "initialized";
     next = { label: "Run `kaddo scan` to capture deterministic signals from the existing code.", command: "kaddo scan" };
@@ -7759,7 +7863,7 @@ function buildReadinessReport(dir, now = /* @__PURE__ */ new Date()) {
     next = { label: "Run `kaddo understand` to summarize the project context.", command: "kaddo understand" };
   } else if (firstWeak) {
     overall = "knowledge-incomplete";
-    next = { label: `Complete \`${firstWeak.label}\` (it is ${presence[firstWeak.key]}).` };
+    next = { label: `Use ${firstWeak.agent} to complete \`${firstWeak.label}\` (it is ${presence[firstWeak.key]}).` };
   } else if (oq.summary.blocking_open > 0) {
     overall = "needs-decisions";
     next = { label: "Resolve, assume or defer the blocking open questions (`kaddo questions`).", command: "kaddo questions" };
@@ -8183,6 +8287,9 @@ function renderExplanationHuman(exp) {
     lines.push(`- understand: ${s.understand}`);
     lines.push(`- agents: ${s.agents}`);
     lines.push(`- skills: ${s.skills}`);
+    lines.push(`- business: ${s.business}`);
+    lines.push(`- product: ${s.product}`);
+    lines.push(`- capabilities: ${s.capabilities}`);
     lines.push(`- current-state: ${s.current_state}`);
     lines.push(`- codebase: ${s.codebase}`);
     lines.push(`- capabilities: ${s.capabilities}`);
@@ -8240,9 +8347,9 @@ function readConfig(dir) {
 }
 function filterBySince(artifacts, since) {
   return artifacts.filter((a) => {
-    const fm = a;
-    if (!fm.created_at) return true;
-    return fm.created_at >= since;
+    const fm2 = a;
+    if (!fm2.created_at) return true;
+    return fm2.created_at >= since;
   });
 }
 function filterByScope(artifacts, scope) {
@@ -8522,6 +8629,24 @@ function buildContextPack(dir, config, now = /* @__PURE__ */ new Date()) {
   }
   const mappedModules = loadMappedModules(dir);
   const layers = knowledgeLayers(dir);
+  const qa = (rel) => analyzeKnowledgeArtifact(dir, rel);
+  const qBusiness = qa("knowledge/business/business.md");
+  const qProduct = qa("knowledge/product/product.md");
+  const qCapabilities = qa("knowledge/product/capabilities.md");
+  const qCodebase = qa("knowledge/tech/codebase.md");
+  const qCurrentState = qa("knowledge/tech/current-state.md");
+  const qRoadmap = qa("knowledge/delivery/roadmap.md");
+  const layerStatusOf = (name) => layers.find((l) => l.layer === name)?.status ?? "Missing";
+  const knowledgeQuality = {
+    business: { status: layerStatusOf("Business"), artifacts: { "knowledge/business/business.md": qBusiness } },
+    product: { status: layerStatusOf("Product"), artifacts: { "knowledge/product/product.md": qProduct, "knowledge/product/capabilities.md": qCapabilities } },
+    tech: { status: layerStatusOf("Tech"), artifacts: { "knowledge/tech/codebase.md": qCodebase, "knowledge/tech/current-state.md": qCurrentState } },
+    delivery: { status: layerStatusOf("Delivery"), artifacts: { "knowledge/delivery/roadmap.md": qRoadmap } }
+  };
+  if (qBusiness === "placeholder") missing.push("Business context exists but still looks like a bootstrap placeholder.");
+  if (qProduct === "placeholder" || qCapabilities === "placeholder") missing.push("Product capabilities exist but still look like a bootstrap placeholder.");
+  if (qCurrentState === "placeholder") missing.push("Current state exists but still looks like a bootstrap placeholder.");
+  if (qCodebase === "placeholder") missing.push("Codebase map exists but still looks like a bootstrap placeholder.");
   const allWorkItems = allArtifacts.filter((a) => a.isWorkItem);
   const wiWithOwnership = allWorkItems.filter((a) => a.codeGlobs.length > 0).length;
   const phase = assessPhase({
@@ -8572,6 +8697,7 @@ function buildContextPack(dir, config, now = /* @__PURE__ */ new Date()) {
       artifacts: allArtifacts.filter((a) => a.codeGlobs.length > 0).map(toContextArtifact)
     },
     layers,
+    knowledgeQuality,
     roadmap,
     phase,
     deliveryMix,
@@ -9102,6 +9228,12 @@ function runUnderstand() {
   if (assessment.nextStep) {
     console.log(`Next step: ${assessment.nextStep}`);
   }
+  const readiness = exp.readiness;
+  if (readiness.overall === "initialized" || readiness.overall === "bootstrap-incomplete") {
+    console.log("");
+    console.log(`Project readiness: ${readiness.overall}.`);
+    console.log(`  \u2192 ${readiness.recommended_next_step.label}`);
+  }
   const installedSkills = discoverInstalledSkills(dir);
   if (installedSkills.length > 0 && assessment.recommendedAgents.length > 0) {
     const recSkills = skillsForAgents(installedSkills, assessment.recommendedAgents);
@@ -11835,48 +11967,431 @@ function runModulesList(dir = cwd()) {
   console.log("");
 }
 
+// src/core/bootstrap-templates.ts
+function fm(type, state) {
+  return `---
+type: ${type}
+project_state: ${state}
+generated_by: kaddo-bootstrap
+template_version: 1
+---
+
+`;
+}
+var T = {
+  business: {
+    new: `# Business Context
+
+## Problem
+
+_What problem are we solving?_
+
+## Users
+
+_Who will use this product?_
+
+## Business goals
+
+_What outcomes matter?_
+
+## Constraints
+
+_Business, operational or regulatory constraints._
+`,
+    "pre-ai": `# Business Context
+
+## What this product appears to support
+
+_Describe the business purpose based on confirmed knowledge._
+
+## Users or roles
+
+_List known users or roles. Mark unknowns explicitly._
+
+## Existing business rules
+
+_Document confirmed business rules._
+
+## Open questions
+
+- [open] _What business context still needs confirmation?_
+`,
+    legacy: `# Business Context
+
+## Critical business purpose
+
+_What critical business process does this system support?_
+
+## Users and operational dependency
+
+_Who depends on this system?_
+
+## Business continuity constraints
+
+_What cannot be interrupted?_
+
+## Open questions
+
+- [open] _What business risk still needs confirmation?_
+`
+  },
+  product: {
+    new: `# Product Context
+
+## Product vision
+
+_What are we building?_
+
+## User journeys
+
+_Main user journeys._
+
+## Scope
+
+_What is in scope and out of scope?_
+
+## Success criteria
+
+_How will we know this product is working?_
+`,
+    "pre-ai": `# Product Context
+
+## Existing product behavior
+
+_Describe what the product currently does._
+
+## Main flows
+
+_List confirmed user or system flows._
+
+## Inferred or uncertain behavior
+
+_Document uncertain behavior as assumptions, not facts._
+
+## Open questions
+
+- [open] _What product behavior still needs confirmation?_
+`,
+    legacy: `# Product Context
+
+## Existing behavior
+
+_What does the legacy system do today?_
+
+## Critical flows
+
+_Which flows are business-critical?_
+
+## Known pain points
+
+_What problems are known?_
+
+## Out of scope
+
+_What should not be changed yet?_
+`
+  },
+  capabilities: {
+    new: `# Capabilities
+
+## Planned capabilities
+
+- [planned] _Capability name_
+
+## Capability map
+
+_Document the product capabilities that should exist._
+
+## Open questions
+
+- [open] _What capability decisions are still unclear?_
+`,
+    "pre-ai": `# Existing Capabilities
+
+## Observed capabilities
+
+- [observed] _Capability observed in the existing system._
+
+## Partial capabilities
+
+- [partial] _Capability that appears incomplete or uncertain._
+
+## Assumptions
+
+- [assumed] _Safe assumption to confirm later._
+
+## Open questions
+
+- [open] _What capability is unclear?_
+`,
+    legacy: `# Legacy Capabilities
+
+## Critical capabilities
+
+- [critical] _Capability that must keep working._
+
+## Risky capabilities
+
+- [risky] _Capability that is hard to change or poorly understood._
+
+## Replacement candidates
+
+- [candidate] _Capability that may be modernized later._
+
+## Open questions
+
+- [open] _What capability risk is unclear?_
+`
+  },
+  codebase: {
+    new: `# Codebase Map
+
+## Repository structure
+
+_No production code yet. Describe the intended structure as it emerges._
+
+## Entry points
+
+_To be defined._
+
+## How to run
+
+_To be defined._
+
+## How to test
+
+_To be defined._
+
+## Open questions
+
+- [open] _What structural decisions are still open?_
+`,
+    "pre-ai": `# Codebase Map
+
+## Repository structure
+
+_Describe the main folders and their purpose._
+
+## Entry points
+
+_List known entry points._
+
+## Important modules
+
+_List modules or areas that appear important._
+
+## How to run
+
+_Document commands to run the project._
+
+## How to test
+
+_Document how this project is tested. If unknown, mark as open._
+
+## Open questions
+
+- [open] _What part of the codebase still needs explanation?_
+`,
+    legacy: `# Codebase Map
+
+## Repository structure
+
+_Describe the main folders and their purpose._
+
+## Entry points
+
+_List known entry points._
+
+## Fragile / delicate areas
+
+_List modules that are risky to change._
+
+## How to run
+
+_Document commands to run the project._
+
+## How to test
+
+_Document how this project is tested. If unknown, mark as open._
+
+## Open questions
+
+- [open] _What part of the codebase still needs explanation?_
+`
+  },
+  "current-state": {
+    new: `# Current State
+
+## Initial technical direction
+
+_What technical direction has been decided?_
+
+## Known constraints
+
+_What constraints shape implementation?_
+
+## Unknowns
+
+- [open] _What technical questions remain open?_
+`,
+    "pre-ai": `# Current State
+
+## What exists today
+
+_Describe the confirmed current state of the system._
+
+## Observed technical signals
+
+_Use \`kaddo scan\` output to document language, framework, package manager, source directories and infrastructure._
+
+## Inferred architecture
+
+_Document inferred architecture carefully. Mark uncertainty._
+
+## Known constraints
+
+_List technical, operational, business or infrastructure constraints._
+
+## Risks of interpretation
+
+_What could an agent misunderstand?_
+
+## Open questions
+
+- [open] _What technical decisions still need confirmation?_
+`,
+    legacy: `# Legacy Current State
+
+## Current architecture
+
+_Describe the existing architecture._
+
+## Critical dependencies
+
+_List systems, databases, integrations or manual operations this system depends on._
+
+## Known risks
+
+_List known technical or operational risks._
+
+## Change constraints
+
+_What should not be changed without validation?_
+
+## Modernization notes
+
+_Initial notes about possible modernization paths._
+
+## Open questions
+
+- [open] _What legacy risk still needs confirmation?_
+`
+  },
+  roadmap: {
+    new: `# Roadmap
+
+## Now
+
+_First outcomes to pursue._
+
+## Next
+
+_What comes after._
+
+## Later
+
+_Deferred ideas._
+`,
+    "pre-ai": `# Roadmap
+
+## Now
+
+_First outcomes to pursue for this existing project._
+
+## Next
+
+_What comes after._
+
+## Later
+
+_Deferred ideas._
+`,
+    legacy: `# Modernization Roadmap
+
+## Stabilize
+
+_What must be made safe first._
+
+## Modernize
+
+_Controlled modernization steps._
+
+## Later
+
+_Deferred modernization ideas._
+`
+  }
+};
+function baselineTemplate(kind, state) {
+  const st = state === "pre-ai" || state === "legacy" ? state : "new";
+  return fm(kind, st) + T[kind][st];
+}
+
 // src/commands/bootstrap.ts
 var CONFIG_PATH8 = ".kaddo/config.yml";
-var TARGETS = [
-  // Minimum sufficient knowledge: one consolidated file per layer. Specialized
-  // artifacts (problem.md, users.md, capabilities.md, …) appear later, as the project
-  // matures, via agents and refinement — not at bootstrap.
-  { layer: "Business", path: "knowledge/business/business.md", templateId: "business" },
-  { layer: "Product", path: "knowledge/product/product.md", templateId: "product" },
-  { layer: "Tech", path: "knowledge/tech/codebase.md", templateId: "codebase" }
+var FILE_TARGETS = [
+  { path: "knowledge/business/business.md", kind: "business" },
+  { path: "knowledge/product/product.md", kind: "product" },
+  { path: "knowledge/product/capabilities.md", kind: "capabilities" },
+  { path: "knowledge/tech/codebase.md", kind: "codebase" },
+  { path: "knowledge/tech/current-state.md", kind: "current-state" },
+  { path: "knowledge/delivery/roadmap.md", kind: "roadmap" }
 ];
-var BOOTSTRAP_LAYERS = ["Business", "Product", "Tech"];
+var DIR_TARGETS = ["knowledge/tech/decisions", "knowledge/delivery/work-items"];
+function withLanguageDirective(content, language) {
+  if (language !== "es") return content;
+  const note = "> Idioma del proyecto: **espa\xF1ol**. Escribe este conocimiento en espa\xF1ol. Mant\xE9n en ingl\xE9s el c\xF3digo, los nombres de archivo, los comandos y las claves de configuraci\xF3n.\n";
+  const fm2 = content.match(/^---\n[\s\S]*?\n---\n/);
+  if (fm2) return content.slice(0, fm2[0].length) + "\n" + note + content.slice(fm2[0].length);
+  return `${note}
+${content}`;
+}
 function bootstrap(dir) {
   const written = [];
   const skipped = [];
+  const createdDirs = [];
+  let state = "new";
   let language = "en";
   try {
     const config = loadConfig(dir);
-    if (config) language = projectLanguage(config);
+    if (config) {
+      state = config.project.state;
+      language = projectLanguage(config);
+    }
   } catch {
   }
-  for (const target of TARGETS) {
+  for (const target of FILE_TARGETS) {
     const full = join(dir, target.path);
     if (exists(full)) {
       skipped.push(target.path);
       continue;
     }
-    const tpl = getTemplate(target.templateId);
-    const base = tpl ? tpl.content : "";
-    const content = withLanguageDirective(base, language);
+    const content = withLanguageDirective(baselineTemplate(target.kind, state), language);
     writeFile(full, content.endsWith("\n") ? content : `${content}
 `);
     written.push(target.path);
   }
-  return { written, skipped, layers: BOOTSTRAP_LAYERS };
-}
-function withLanguageDirective(content, language) {
-  if (language !== "es") return content;
-  const note = "> Idioma del proyecto: **espa\xF1ol**. Escribe este conocimiento en espa\xF1ol. Mant\xE9n en ingl\xE9s el c\xF3digo, los nombres de archivo, los comandos y las claves de configuraci\xF3n.\n";
-  const fm = content.match(/^---\n[\s\S]*?\n---\n/);
-  if (fm) return content.slice(0, fm[0].length) + "\n" + note + content.slice(fm[0].length);
-  return `${note}
-${content}`;
+  for (const d of DIR_TARGETS) {
+    const full = join(dir, d);
+    if (exists(full)) {
+      skipped.push(`${d}/`);
+      continue;
+    }
+    ensureDir(full);
+    writeFile(join(full, ".gitkeep"), "");
+    createdDirs.push(`${d}/`);
+  }
+  return { state, written, skipped, createdDirs };
 }
 async function runBootstrap(dir = cwd()) {
   intro2("kaddo bootstrap");
@@ -11885,46 +12400,37 @@ async function runBootstrap(dir = cwd()) {
     console.error("Run `kaddo init` first.");
     process.exit(1);
   }
-  let state = "unknown";
+  let state = "new";
   try {
     const config = loadConfig(dir);
-    state = config?.project.state ?? "unknown";
+    state = config?.project.state ?? "new";
   } catch (err) {
-    const message = err instanceof ConfigError ? err.message : String(err);
-    console.error(message);
+    console.error(err instanceof ConfigError ? err.message : String(err));
     process.exit(1);
   }
-  log2.info(`Project state: ${state}`);
-  log2.info("Base layers: Business \u2192 Product \u2192 Tech \u2192 Delivery");
-  if (state !== "new") {
-    log2.warn("This project is not marked as new. Bootstrap is designed for new projects.");
-    const ok = await confirm2({ message: "Continue anyway?", initialValue: false });
-    if (!ok) {
-      outro2("Bootstrap cancelled.");
-      return;
-    }
-  }
+  const stateLabel3 = state === "pre-ai" ? "pre-ai" : state;
+  log2.info(`Project state: ${stateLabel3}`);
+  log2.info(`Creating ${stateLabel3} knowledge baseline.`);
+  log2.info("Existing files will not be overwritten.");
   const result = bootstrap(dir);
   console.log("");
-  console.log("Bootstrap layers:");
-  for (const layer2 of result.layers) console.log(`  \u2713 ${layer2}`);
-  console.log("");
-  if (result.written.length > 0) {
+  if (result.written.length > 0 || result.createdDirs.length > 0) {
     console.log("Created:");
     for (const p2 of result.written) console.log(`  - ${p2}`);
+    for (const d of result.createdDirs) console.log(`  - ${d}`);
   }
   if (result.skipped.length > 0) {
     console.log("");
-    console.log("Kept existing (skipped):");
+    console.log("Skipped (kept existing):");
     for (const p2 of result.skipped) console.log(`  - ${p2}`);
   }
   console.log("");
-  console.log("");
   log2.info(
     "When you pass the context pack to your LLM/coding agent, it must never commit, push or merge without your confirmation \u2014 and create a branch before implementing."
   );
+  printCommandFooter("bootstrap");
   outro2(
-    "Minimal knowledge base ready (Business \u2192 Product \u2192 Tech). Run `kaddo context` and `kaddo add agents`, then refine with the business-agent, bootstrap-agent and codebase-agent. Roadmap and work items come next under knowledge/delivery/."
+    `${stateLabel3} knowledge baseline ready. Next: \`kaddo add agents\` (then \`kaddo add skills\`), and refine the knowledge with the relevant agents.`
   );
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaddo/cli",
-  "version": "3.35.0",
+  "version": "3.37.0",
   "description": "Knowledge Driven Development toolkit",
   "license": "MIT",
   "repository": {