@kaddo/cli 3.64.0 → 3.66.0

package/dist/index.js

@@ -6401,7 +6401,14 @@ function parseArtifact(filePath, raw) {
       sourceId: String(data.source_id ?? ""),
       rawFrontmatter: data,
       decisions: Array.isArray(data.decisions) ? data.decisions.map(String).filter(Boolean) : [],
-      capsules: Array.isArray(data.capsules) ? data.capsules.map(String).filter(Boolean) : []
+      capsules: Array.isArray(data.capsules) ? data.capsules.map(String).filter(Boolean) : [],
+      implementationStatus: String(data.implementation_status ?? ""),
+      validationStatus: String(data.validation_status ?? ""),
+      releaseStatus: String(data.release_status ?? ""),
+      affectedModules: Array.isArray(data.affected_modules) ? data.affected_modules.map(String).filter(Boolean) : [],
+      refinedBy: String(data.refined_by ?? ""),
+      implementedBy: String(data.implemented_by ?? ""),
+      closedBy: String(data.closed_by ?? "")
     };
   } catch {
     return null;
@@ -6833,9 +6840,125 @@ function analyzeMetadataHealth(dir) {
     if (fileDrifted) drifted++;
     else healthy++;
   }
+  const wiDir = join(dir, "knowledge/delivery/work-items");
+  if (exists(wiDir)) {
+    const walkWIs = (d) => {
+      for (const entry of readDir(d)) {
+        const p2 = join(d, entry);
+        if (isFile(p2) && entry.endsWith(".md")) {
+          try {
+            const raw = readFile(p2);
+            const fm2 = matter2(raw).data;
+            if (fm2.status === "done") {
+              const rel = p2.replace(dir + "/", "").replace(dir + "\\", "").replace(/\\/g, "/");
+              findings.push({
+                file: rel,
+                field: "status",
+                issue: "inconsistent",
+                detail: "Legacy status `done` detected. Canonical status is `completed`."
+              });
+            }
+          } catch {
+          }
+        } else if (!isFile(p2) && !entry.startsWith(".")) {
+          walkWIs(p2);
+        }
+      }
+    };
+    walkWIs(wiDir);
+  }
   return { findings, healthy, drifted };
 }
 
+// src/core/cross-repo-evidence.ts
+function analyzeCrossRepoEvidence(input) {
+  const findings = [];
+  const { id, lifecycle, implementationStatus, validationStatus, releaseStatus, affectedModules } = input;
+  const raw = input.rawFrontmatter;
+  const evidence = raw.implementation_evidence;
+  const repos = evidence?.repositories ?? {};
+  const releaseGates = Array.isArray(raw.release_gates) ? raw.release_gates : [];
+  const exceptions = Array.isArray(raw.completion_exceptions) ? raw.completion_exceptions : [];
+  const repoEvidence = {};
+  for (const [repoId, data] of Object.entries(repos)) {
+    const d = data;
+    repoEvidence[repoId] = {
+      role: String(d.role ?? (repoId === "core" ? "core" : "module")),
+      status: String(d.status ?? "unknown")
+    };
+  }
+  for (const mod of affectedModules) {
+    if (mod === "core") continue;
+    if (!input.registeredModuleIds.includes(mod)) {
+      findings.push({ id, severity: "blocking", message: `Affected module "${mod}" is not registered in .kaddo/modules.yml.` });
+    }
+  }
+  for (const repoId of input.modifiedRepoIds) {
+    if (!affectedModules.includes(repoId) && repoId !== "core") {
+      findings.push({ id, severity: "blocking", message: `Repository "${repoId}" was modified but not declared in affected_modules.` });
+    }
+  }
+  for (const mod of affectedModules) {
+    if (!repoEvidence[mod] && Object.keys(repos).length > 0) {
+      findings.push({ id, severity: "warning", message: `Declared affected module "${mod}" has no implementation evidence.` });
+    }
+  }
+  for (const [repoId, data] of Object.entries(repos)) {
+    const d = data;
+    const validations = Array.isArray(d.validations) ? d.validations : [];
+    for (const v of validations) {
+      if (v.status === "not-run") {
+        findings.push({ id, severity: "warning", message: `Validation "${v.command}" in ${repoId} was not executed.` });
+      }
+    }
+    const migrations = Array.isArray(d.migrations) ? d.migrations : [];
+    for (const m of migrations) {
+      if (m.status === "blocked") {
+        findings.push({ id, severity: "warning", message: `Migration "${m.id}" (${m.environment}) in ${repoId} is blocked.` });
+      }
+    }
+  }
+  if (lifecycle === "completed") {
+    const proposedExceptions = exceptions.filter((e) => e.status === "proposed");
+    if (proposedExceptions.length > 0) {
+      findings.push({ id, severity: "blocking", message: "Work Item is completed but has proposed (not accepted) exceptions." });
+    }
+    if (releaseStatus === "ready") {
+      const blockedGates = releaseGates.filter((g) => g.status === "blocked" || g.status === "failed");
+      if (blockedGates.length > 0) {
+        findings.push({ id, severity: "blocking", message: `Release status is "ready" but ${blockedGates.length} gate(s) are blocked/failed.` });
+      }
+    }
+  }
+  for (const [repoId, data] of Object.entries(repos)) {
+    const d = data;
+    const validations = Array.isArray(d.validations) ? d.validations : [];
+    for (const v of validations) {
+      if (v.status === "passed" && (!v.command || !v.command.trim())) {
+        findings.push({ id, severity: "blocking", message: `Evidence in ${repoId} marked "passed" without a command record.` });
+      }
+    }
+  }
+  if (raw.status === "done") {
+    findings.push({ id, severity: "warning", message: "Legacy status `done` detected. Canonical status is `completed`." });
+  }
+  if (raw.refined_by && raw.implemented_by && raw.refined_by === raw.implemented_by) {
+    findings.push({ id, severity: "fyi", message: "refined_by and implemented_by point to the same agent." });
+  }
+  return {
+    id,
+    lifecycle,
+    implementationStatus: implementationStatus || "not-started",
+    validationStatus: validationStatus || "not-started",
+    releaseStatus: releaseStatus || "not-assessed",
+    affectedModules,
+    findings,
+    releaseGates,
+    completionExceptions: exceptions,
+    repoEvidence
+  };
+}
+
 // src/commands/guard.ts
 import path4 from "path";
 import { parse as parseYaml7 } from "yaml";
@@ -7466,6 +7589,37 @@ async function runGuard(opts = {}) {
     }
     console.log("");
   }
+  const registeredModuleIds = loadMappedModules(dir).map((m) => m.id);
+  const modifiedRepoIds = workspaceScan ? [...new Set(workspaceScan.changedFiles.map((c) => c.repoId))] : [];
+  const wiArtifacts = artifacts.filter((a) => a.isWorkItem && a.affectedModules.length > 0);
+  if (wiArtifacts.length > 0) {
+    const evidenceSummaries = [];
+    for (const wi of wiArtifacts) {
+      const summary = analyzeCrossRepoEvidence({
+        id: wi.id || wi.title,
+        lifecycle: wi.lifecycle ?? "ready",
+        implementationStatus: wi.implementationStatus,
+        validationStatus: wi.validationStatus,
+        releaseStatus: wi.releaseStatus,
+        affectedModules: wi.affectedModules,
+        rawFrontmatter: wi.rawFrontmatter,
+        registeredModuleIds,
+        modifiedRepoIds
+      });
+      if (summary.findings.length > 0) evidenceSummaries.push(summary);
+    }
+    if (evidenceSummaries.length > 0) {
+      console.log("Cross-repo implementation evidence:");
+      for (const s of evidenceSummaries) {
+        console.log(`  ${s.id}:`);
+        for (const f of s.findings) {
+          const icon = f.severity === "blocking" ? "\u2717" : f.severity === "warning" ? "!" : "\xB7";
+          console.log(`    ${icon} ${f.message}`);
+        }
+      }
+      console.log("");
+    }
+  }
   const ownerMap = loadOwners(dir);
   const matchedDomains = collectMatchedDomains(activeMatches.map((m) => m.artifact.domains));
   const affectedOwners = resolveAffectedOwners(matchedDomains, ownerMap);
@@ -7594,7 +7748,7 @@ function assessPhase(input) {
     const techReady = !NOT_READY_LAYER.includes(techStatus);
     if (techReady) {
       return {
-        phase: "Active Delivery",
+        phase: "Ready for Core Orchestration",
         reasons: ["Module repo \u2014 Tech layer ready", "Business/Product managed by core"],
         recommendedAgents: [],
         nextStep: "Module knowledge is ready for core orchestration.",
@@ -10089,6 +10243,7 @@ function buildGraph(dir, config, opts = {}, now = /* @__PURE__ */ new Date()) {
   const selectedWIs = workItems.filter((a) => a.lifecycle && includedSet.has(a.lifecycle));
   for (const wi of selectedWIs) {
     const id = wi.id || wi.title;
+    if (!id || !id.trim()) continue;
     const wiNodeId = `wi:${id}`;
     addNode({
       id: wiNodeId,
@@ -10099,16 +10254,19 @@ function buildGraph(dir, config, opts = {}, now = /* @__PURE__ */ new Date()) {
       knowledge_level: wi.knowledgeLevel || void 0
     });
     for (const glob of wi.codeGlobs) {
+      if (!glob || !glob.trim()) continue;
       const codeId = `code:${glob}`;
       addNode({ id: codeId, type: "code-glob", label: glob });
       addEdge(wiNodeId, codeId, "owns");
     }
     for (const cap of wi.capabilities) {
+      if (!cap || !cap.trim()) continue;
       const capId = `capability:${slug(cap) || cap}`;
       addNode({ id: capId, type: "capability", label: cap });
       addEdge(wiNodeId, capId, "implements");
     }
     for (const dec of wi.decisions) {
+      if (!dec || !dec.trim()) continue;
       const adrId = `adr:${dec}`;
       addNode({ id: adrId, type: "decision", label: dec });
       addEdge(wiNodeId, adrId, "depends_on");
@@ -10125,16 +10283,19 @@ function buildGraph(dir, config, opts = {}, now = /* @__PURE__ */ new Date()) {
     }
   }
   for (const adr of all.filter(isAdr)) {
-    const adrId = `adr:${adr.id || adr.title}`;
+    const adrLabel = adr.id || adr.title;
+    if (!adrLabel || !adrLabel.trim()) continue;
+    const adrId = `adr:${adrLabel}`;
     const referenced = nodes.has(adrId);
     if (scope === "all" || referenced) {
       nodes.set(adrId, {
         id: adrId,
         type: "decision",
-        label: `${adr.id} ${adr.title}`.trim() || adr.id || adr.title,
+        label: `${adr.id} ${adr.title}`.trim() || adrLabel,
         path: adr.relPath
       });
       for (const glob of adr.codeGlobs) {
+        if (!glob || !glob.trim()) continue;
         const codeId = `code:${glob}`;
         addNode({ id: codeId, type: "code-glob", label: glob });
         addEdge(adrId, codeId, "governs");
@@ -10190,13 +10351,20 @@ function renderGraphMermaid(graph) {
     safeIds.set(id, candidate);
     return candidate;
   };
-  const escapeLabel = (s) => s.replace(/"/g, "'");
+  const escapeLabel = (s) => s.replace(/"/g, "'").replace(/\[/g, "(").replace(/\]/g, ")").replace(/\n/g, " ");
+  const validNodes = graph.nodes.filter(
+    (n) => n.id && n.id.trim() !== "" && n.label && n.label.trim() !== ""
+  );
+  const validNodeIds = new Set(validNodes.map((n) => n.id));
   const lines = ["flowchart LR"];
-  for (const node of graph.nodes) {
+  for (const node of validNodes) {
     lines.push(`  ${safe(node.id)}["${escapeLabel(node.label)}"]`);
   }
-  if (graph.edges.length > 0) lines.push("");
-  for (const edge of graph.edges) {
+  const validEdges = graph.edges.filter(
+    (e) => validNodeIds.has(e.from) && validNodeIds.has(e.to)
+  );
+  if (validEdges.length > 0) lines.push("");
+  for (const edge of validEdges) {
     lines.push(`  ${safe(edge.from)} -->|${edge.type}| ${safe(edge.to)}`);
   }
   return lines.join("\n") + "\n";
@@ -11921,6 +12089,47 @@ function buildReadinessReport(dir, now = /* @__PURE__ */ new Date()) {
   if (!config) return stub("not-initialized", rec.label, rec.command);
   if (config.project.state === "new") return stub("not-applicable", "This project uses the standard new-project Kaddo flow.");
   if (config.project.state === "legacy") return stub("legacy-project", "Use the legacy project flow.");
+  if (isModule(config)) {
+    const scan3 = exists(join(dir, ".kaddo", "scan.json")) ? "available" : "missing";
+    const understand2 = exists(join(dir, ".kaddo", "understand.md")) ? "available" : "missing";
+    const mcNew = "knowledge/tech/module/module-context.md";
+    const mcLegacy = "knowledge/module/module-context.md";
+    const mcPath = exists(join(dir, mcNew)) ? mcNew : mcLegacy;
+    const qMC = analyzeKnowledgeArtifact(dir, mcPath);
+    const qCS = analyzeKnowledgeArtifact(dir, "knowledge/tech/current-state.md");
+    const qCB = analyzeKnowledgeArtifact(dir, "knowledge/tech/codebase.md");
+    const moduleBaseline = qMC !== "missing" && qCS !== "missing" && qCB !== "missing" ? "complete" : "incomplete";
+    const moduleReady = qMC === "useful" && qCS === "useful" && qCB === "useful";
+    const overall2 = moduleReady ? "ready-for-core-orchestration" : moduleBaseline === "incomplete" ? "bootstrap-incomplete" : "knowledge-incomplete";
+    return {
+      project_name: config.project.name,
+      project_type: config.project.state,
+      project_role: "module",
+      overall: overall2,
+      signals: {
+        scan: scan3,
+        understand: understand2,
+        bootstrap_baseline: moduleBaseline,
+        agents: "managed-by-core",
+        skills: "managed-by-core",
+        current_state: qCS,
+        codebase: qCB,
+        module_context: qMC,
+        capabilities: "managed-by-core",
+        product: "not-applicable",
+        business: "not-applicable",
+        roadmap: "managed-by-core",
+        work_items: "managed-by-core",
+        adapters: [],
+        blocking_open_questions: 0,
+        assumed_questions: 0,
+        resolved_questions: 0,
+        deferred_questions: 0
+      },
+      recommended_next_step: { label: rec.label, ...rec.command ? { command: rec.command } : {} },
+      nextStepRecommendation: rec
+    };
+  }
   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_FILES2.map((f) => [f.key, analyzeKnowledgeArtifact(dir, f.path)]));
@@ -12891,51 +13100,73 @@ function buildProjectExplanation(dir) {
   const roadmapMd = exists(roadmapPath) ? readFile(roadmapPath) : null;
   const roadmap = roadmapStats(roadmapMd, items.length);
   const mappedModules = loadMappedModules(dir);
+  const moduleRepo = config != null && isModule(config);
   const missingKnowledge = [];
-  if (!knowledge.hasScan) missingKnowledge.push("Scan baseline (.kaddo/scan.json)");
-  if (!knowledge.hasContextPack) missingKnowledge.push("Context pack (.kaddo/context-pack.md)");
-  if (!knowledge.hasInventory) missingKnowledge.push("Inventory (knowledge/inventory.md)");
-  if (!knowledge.hasCapabilities) missingKnowledge.push("Product knowledge (knowledge/product/)");
-  if (!knowledge.hasArchitecture) missingKnowledge.push("Tech knowledge (knowledge/tech/)");
-  if (!knowledge.hasRoadmap) missingKnowledge.push("Roadmap (knowledge/delivery/roadmap.md)");
-  if (!knowledge.hasAgents) missingKnowledge.push("Agents (knowledge/agents/)");
-  if (items.length === 0) missingKnowledge.push("Work items (knowledge/delivery/work-items/)");
-  const suggestedNextSteps = [];
-  const baselineIncomplete = !knowledge.hasBusiness || !knowledge.hasProduct;
-  if (baselineIncomplete) {
-    suggestedNextSteps.push("Run `kaddo bootstrap` to create the project knowledge baseline.");
-    if (!knowledge.hasAgents) suggestedNextSteps.push("Then run `kaddo add agents`.");
-    if (!knowledge.hasSkills) suggestedNextSteps.push("Then run `kaddo add skills`.");
-    suggestedNextSteps.push("Then run `kaddo context`.");
-    suggestedNextSteps.push("Then run `kaddo understand`.");
+  if (moduleRepo) {
+    if (!knowledge.hasScan) missingKnowledge.push("Scan baseline (.kaddo/scan.json)");
+    if (!knowledge.hasContextPack) missingKnowledge.push("Context pack (.kaddo/context-pack.md)");
+    if (!knowledge.hasArchitecture) missingKnowledge.push("Tech knowledge (knowledge/tech/)");
   } else {
+    if (!knowledge.hasScan) missingKnowledge.push("Scan baseline (.kaddo/scan.json)");
+    if (!knowledge.hasContextPack) missingKnowledge.push("Context pack (.kaddo/context-pack.md)");
+    if (!knowledge.hasInventory) missingKnowledge.push("Inventory (knowledge/inventory.md)");
+    if (!knowledge.hasCapabilities) missingKnowledge.push("Product knowledge (knowledge/product/)");
+    if (!knowledge.hasArchitecture) missingKnowledge.push("Tech knowledge (knowledge/tech/)");
+    if (!knowledge.hasRoadmap) missingKnowledge.push("Roadmap (knowledge/delivery/roadmap.md)");
+    if (!knowledge.hasAgents) missingKnowledge.push("Agents (knowledge/agents/)");
+    if (items.length === 0) missingKnowledge.push("Work items (knowledge/delivery/work-items/)");
+  }
+  const suggestedNextSteps = [];
+  if (moduleRepo) {
     if (!knowledge.hasScan) {
       suggestedNextSteps.push("Run `kaddo scan` to detect the technical stack.");
     } else if (!knowledge.hasContextPack) {
       suggestedNextSteps.push("Run `kaddo context` to prepare an LLM context pack.");
+    } else if (!knowledge.hasArchitecture) {
+      suggestedNextSteps.push("Use module-context-agent to refine knowledge/tech/module/module-context.md.");
+    } else {
+      suggestedNextSteps.push("Return to the core repository.");
+      suggestedNextSteps.push("Create or continue the Work Item from the core.");
+      suggestedNextSteps.push("Add this module to `affected_modules` when the change touches it.");
+      suggestedNextSteps.push("Re-run `kaddo context` and `kaddo understand` from the core.");
     }
-    if (!knowledge.hasAgents) {
-      suggestedNextSteps.push("Run `kaddo add agents` to install knowledge agents.");
-    }
-    if (!knowledge.hasCapabilities) {
-      suggestedNextSteps.push("Use capability-agent to generate knowledge/product/capabilities.md.");
-    }
-    if (!knowledge.hasArchitecture) {
-      suggestedNextSteps.push("Use architecture-agent to generate knowledge/tech/current-state.md.");
-    }
-    if (!knowledge.hasRoadmap) {
-      suggestedNextSteps.push("Use roadmap-agent to generate knowledge/delivery/roadmap.md.");
-    } else if (roadmap.remaining > 0) {
-      suggestedNextSteps.push(
-        `Materialize ${roadmap.remaining} roadmap candidate(s) with \`kaddo create --from roadmap\`.`
-      );
-    }
-    if (items.length === 0 && !roadmap.present) {
-      suggestedNextSteps.push("Create your first Work Item with `kaddo create`.");
-    } else if (ownership.workItemsMissingOwnership > 0) {
-      suggestedNextSteps.push(
-        "Run `kaddo owners suggest` for Work Items without code ownership."
-      );
+  } else {
+    const baselineIncomplete = !knowledge.hasBusiness || !knowledge.hasProduct;
+    if (baselineIncomplete) {
+      suggestedNextSteps.push("Run `kaddo bootstrap` to create the project knowledge baseline.");
+      if (!knowledge.hasAgents) suggestedNextSteps.push("Then run `kaddo add agents`.");
+      if (!knowledge.hasSkills) suggestedNextSteps.push("Then run `kaddo add skills`.");
+      suggestedNextSteps.push("Then run `kaddo context`.");
+      suggestedNextSteps.push("Then run `kaddo understand`.");
+    } else {
+      if (!knowledge.hasScan) {
+        suggestedNextSteps.push("Run `kaddo scan` to detect the technical stack.");
+      } else if (!knowledge.hasContextPack) {
+        suggestedNextSteps.push("Run `kaddo context` to prepare an LLM context pack.");
+      }
+      if (!knowledge.hasAgents) {
+        suggestedNextSteps.push("Run `kaddo add agents` to install knowledge agents.");
+      }
+      if (!knowledge.hasCapabilities) {
+        suggestedNextSteps.push("Use capability-agent to generate knowledge/product/capabilities.md.");
+      }
+      if (!knowledge.hasArchitecture) {
+        suggestedNextSteps.push("Use architecture-agent to generate knowledge/tech/current-state.md.");
+      }
+      if (!knowledge.hasRoadmap) {
+        suggestedNextSteps.push("Use roadmap-agent to generate knowledge/delivery/roadmap.md.");
+      } else if (roadmap.remaining > 0) {
+        suggestedNextSteps.push(
+          `Materialize ${roadmap.remaining} roadmap candidate(s) with \`kaddo create --from roadmap\`.`
+        );
+      }
+      if (items.length === 0 && !roadmap.present) {
+        suggestedNextSteps.push("Create your first Work Item with `kaddo create`.");
+      } else if (ownership.workItemsMissingOwnership > 0) {
+        suggestedNextSteps.push(
+          "Run `kaddo owners suggest` for Work Items without code ownership."
+        );
+      }
     }
   }
   const readiness = buildReadinessReport(dir);
@@ -12978,7 +13209,30 @@ function buildProjectExplanation(dir) {
     projectRoute: buildProjectRoute(dir),
     scanSignals: loadScanSignals(dir),
     metadataHealth: analyzeMetadataHealth(dir),
-    isModuleRepo: config != null && isModule(config)
+    isModuleRepo: config != null && isModule(config),
+    implementationEvidence: workItemArtifacts.filter((a) => a.affectedModules.length > 0).map((a) => {
+      const fm2 = a.rawFrontmatter;
+      const evidence = fm2.implementation_evidence;
+      const repos = evidence?.repositories ?? {};
+      const repoEvidence = {};
+      for (const [repoId, data] of Object.entries(repos)) {
+        repoEvidence[repoId] = {
+          role: String(data.role ?? (repoId === "core" ? "core" : "module")),
+          status: String(data.status ?? "unknown")
+        };
+      }
+      return {
+        id: a.id || a.title,
+        lifecycle: lifecycleStateOf({ status: a.status, filePath: a.filePath }),
+        implementationStatus: a.implementationStatus || "not-started",
+        validationStatus: a.validationStatus || "not-started",
+        releaseStatus: a.releaseStatus || "not-assessed",
+        affectedModules: a.affectedModules,
+        releaseGates: Array.isArray(fm2.release_gates) ? fm2.release_gates : [],
+        completionExceptions: Array.isArray(fm2.completion_exceptions) ? fm2.completion_exceptions : [],
+        repoEvidence
+      };
+    })
   };
 }
 function stateLabel(state) {
@@ -13031,11 +13285,19 @@ function renderExplanationHuman(exp) {
   lines.push("## Knowledge Status");
   lines.push(`- Inventory: ${exp.knowledge.hasInventory ? "available" : "missing"}`);
   lines.push(`- Context pack: ${exp.knowledge.hasContextPack ? "available" : "missing"}`);
-  lines.push(`- Business: ${ls("Business")}`);
-  lines.push(`- Product: ${ls("Product")}`);
-  lines.push(`- Tech: ${ls("Tech")}`);
-  lines.push(`- Delivery: ${ls("Delivery")}`);
-  lines.push(`- Agents: ${exp.knowledge.hasAgents ? "available" : "missing"}`);
+  if (exp.isModuleRepo) {
+    lines.push("- Business: Not applicable");
+    lines.push("- Product: Not applicable");
+    lines.push(`- Tech: ${ls("Tech")}`);
+    lines.push("- Delivery: Managed by core");
+    lines.push("- Agents: Managed by core");
+  } else {
+    lines.push(`- Business: ${ls("Business")}`);
+    lines.push(`- Product: ${ls("Product")}`);
+    lines.push(`- Tech: ${ls("Tech")}`);
+    lines.push(`- Delivery: ${ls("Delivery")}`);
+    lines.push(`- Agents: ${exp.knowledge.hasAgents ? "available" : "missing"}`);
+  }
   if (exp.roadmap.present) {
     lines.push(`- Roadmap initiatives: ${exp.roadmap.initiatives}`);
     lines.push(`- Work Item candidates: ${exp.roadmap.work_item_candidates}`);
@@ -13096,6 +13358,36 @@ function renderExplanationHuman(exp) {
     }
     lines.push("");
   }
+  if (exp.implementationEvidence.length > 0) {
+    lines.push("## Implementation Evidence");
+    for (const ev of exp.implementationEvidence) {
+      lines.push("");
+      lines.push(`### ${ev.id}`);
+      lines.push(`- Lifecycle: ${ev.lifecycle.charAt(0).toUpperCase() + ev.lifecycle.slice(1)}`);
+      lines.push(`- Implementation: ${ev.implementationStatus}`);
+      lines.push(`- Validation: ${ev.validationStatus}`);
+      lines.push(`- Release: ${ev.releaseStatus}`);
+      if (Object.keys(ev.repoEvidence).length > 0) {
+        lines.push("Repositories:");
+        for (const [repoId, info] of Object.entries(ev.repoEvidence)) {
+          lines.push(`- ${repoId} \u2014 ${info.status}`);
+        }
+      } else if (ev.affectedModules.length > 0) {
+        lines.push(`Affected modules: ${ev.affectedModules.join(", ")}`);
+      }
+      const pendingGates = ev.releaseGates.filter((g) => g.status === "blocked" || g.status === "pending");
+      if (pendingGates.length > 0) {
+        lines.push("Pending release gates:");
+        for (const g of pendingGates) lines.push(`- ${g.id}${g.reason ? ` \u2014 ${g.reason}` : ""}`);
+      }
+      const acceptedExceptions = ev.completionExceptions.filter((e) => e.status === "accepted" || e.status === "deferred");
+      if (acceptedExceptions.length > 0) {
+        lines.push("Completion exceptions:");
+        for (const e of acceptedExceptions) lines.push(`- ${e.id}: ${e.status}${e.reason ? ` \u2014 ${e.reason}` : ""}`);
+      }
+    }
+    lines.push("");
+  }
   if (exp.domains.length > 0) {
     lines.push("## Domains");
     lines.push(`- ${exp.domains.join(", ")}`);
@@ -13196,14 +13488,27 @@ 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}`);
+    if (exp.isModuleRepo) {
+      lines.push("- business: not-applicable");
+      lines.push("- product: not-applicable");
+    } else {
+      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(`- roadmap: ${s.roadmap}`);
-    lines.push(`- work-items: ${s.work_items}`);
-    lines.push(`- adapters: ${s.adapters.length > 0 ? s.adapters.join(", ") + " installed" : "none installed"}`);
+    if (s.module_context != null) {
+      lines.push(`- module-context: ${s.module_context}`);
+    }
+    if (!exp.isModuleRepo) {
+      lines.push(`- roadmap: ${s.roadmap}`);
+      lines.push(`- work-items: ${s.work_items}`);
+      lines.push(`- adapters: ${s.adapters.length > 0 ? s.adapters.join(", ") + " installed" : "none installed"}`);
+    } else {
+      lines.push("- roadmap: managed-by-core");
+      lines.push("- work-items: managed-by-core");
+    }
     lines.push(`- blocking open questions: ${s.blocking_open_questions}`);
     lines.push(`- assumptions: ${s.assumed_questions}`);
     lines.push(`- deferred: ${s.deferred_questions}`);
@@ -13540,7 +13845,7 @@ var OPERATING_RULES = [
   "Kaddo itself never calls an LLM and never runs git \u2014 every git action is the human\u2019s."
 ];
 function toContextWorkItem(a) {
-  return {
+  const wi = {
     id: a.id,
     type: a.type,
     title: a.title,
@@ -13550,6 +13855,11 @@ function toContextWorkItem(a) {
     domains: a.domains,
     source: parseWorkItemSource(a.rawFrontmatter)
   };
+  if (a.implementationStatus) wi.implementationStatus = a.implementationStatus;
+  if (a.validationStatus) wi.validationStatus = a.validationStatus;
+  if (a.releaseStatus) wi.releaseStatus = a.releaseStatus;
+  if (a.affectedModules.length > 0) wi.affectedModules = a.affectedModules;
+  return wi;
 }
 function toContextArtifact(a) {
   return { id: a.id, type: a.type, title: a.title, summary: a.summary, codeGlobs: a.codeGlobs };
@@ -13568,11 +13878,11 @@ function buildContextPack(dir, config, now = /* @__PURE__ */ new Date()) {
   if (!inventoryAvailable) {
     missing.push("No technical inventory found. Run `kaddo scan` to generate it.");
   }
+  const moduleRepo = config != null && isModule(config);
   const knowledgeSummary = readMarkdownSummary(dir, "knowledge.md") ?? "";
-  if (!knowledgeSummary) {
+  if (!knowledgeSummary && !moduleRepo) {
     missing.push("No project knowledge summary found yet.");
   }
-  const moduleRepo = config != null && isModule(config);
   const roadmapSummary = readMarkdownSummary(dir, "delivery/roadmap.md") ?? "";
   if (!roadmapSummary && !moduleRepo) {
     missing.push("No roadmap baseline found.");
@@ -13746,11 +14056,12 @@ function buildContextPack(dir, config, now = /* @__PURE__ */ new Date()) {
       }
       return contexts;
     })(),
+    isModuleRepo: moduleRepo,
     missing,
     // VS-052/VS-073.2: the handoff is driven by the unified next step, so the pack never contradicts
     // the Current Phase block above it.
     handoff: {
-      recommendedAgents: isBootstrap ? [] : unifiedPhase.recommendedAgents.length > 0 ? unifiedPhase.recommendedAgents : recommendedAgentsForState(state),
+      recommendedAgents: isBootstrap ? [] : unifiedPhase.recommendedAgents.length > 0 ? unifiedPhase.recommendedAgents : moduleRepo ? [] : recommendedAgentsForState(state),
       nextSteps: [nextStepRecommendation.label],
       instructions: isBootstrap ? ["No agent handoff yet.", "Run `kaddo bootstrap` first to create the baseline files."] : unifiedPhase.llmInstructions.length > 0 ? unifiedPhase.llmInstructions : LLM_INSTRUCTIONS,
       operatingRules: OPERATING_RULES
@@ -14061,7 +14372,11 @@ function renderContextPack(pack) {
     }
   }
   parts.push("## Recommended Agent Handoff\n");
-  if (isBootstrapIncomplete) {
+  if (pack.isModuleRepo && handoff.recommendedAgents.length === 0) {
+    parts.push("No local agent action is required.\n");
+    parts.push("This module is ready for core orchestration.\n");
+    parts.push("Business, Product, Delivery, Agents and Skills are managed by the core repository.\n");
+  } else if (isBootstrapIncomplete) {
     parts.push("No agent handoff yet.\n");
     parts.push("Run `kaddo bootstrap` first to create the baseline files.\n");
   } else if (rec.agent && rec.agentInstalled === false) {
@@ -15053,7 +15368,7 @@ function findWorkItemFile(dir, id) {
 function updateWorkItemFile(filePath, learning) {
   const raw = readFile(filePath);
   const { data, content } = matter8(raw);
-  data.status = "done";
+  data.status = "completed";
   data.completed_at = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   let updatedContent = content;
   if (content.includes("_What did we learn from this change? Update after completion._")) {
@@ -15088,24 +15403,24 @@ async function runLearn(artifactId) {
   }
   intro2("kaddo learn");
   const artifacts = readArtifacts(join(dir, ARCH_DIR9));
-  const inProgress = artifacts.filter(
-    (a) => a.status === "in-progress" && a.type !== "current-state" && a.type !== "roadmap"
+  const closable = artifacts.filter(
+    (a) => (a.status === "in-progress" || a.status === "completed" || a.status === "done") && a.type !== "current-state" && a.type !== "roadmap"
   );
-  if (inProgress.length === 0) {
-    log2.warn("No in-progress work items found.");
+  if (closable.length === 0) {
+    log2.warn("No in-progress or completed work items found.");
     outro2("Nothing to close.");
     return;
   }
   let targetId;
   if (artifactId) {
     targetId = artifactId;
-  } else if (inProgress.length === 1) {
-    targetId = inProgress[0].id || inProgress[0].title;
-    log2.info(`Closing: ${targetId} \u2014 ${inProgress[0].summary || inProgress[0].title}`);
+  } else if (closable.length === 1) {
+    targetId = closable[0].id || closable[0].title;
+    log2.info(`Closing: ${targetId} \u2014 ${closable[0].summary || closable[0].title}`);
   } else {
     const chosen = await select2({
       message: "Which work item are you closing?",
-      options: inProgress.map((a) => ({
+      options: closable.map((a) => ({
         value: a.id || a.title,
         label: `${a.id || a.title} \u2014 ${a.summary || a.title}`
       }))
@@ -15122,9 +15437,26 @@ async function runLearn(artifactId) {
     placeholder: "e.g. The retry logic needed a separate queue to avoid blocking the main flow",
     validate: (v) => v.trim().length === 0 ? "Learning is required." : void 0
   });
-  updateWorkItemFile(filePath, learning.trim());
-  log2.success(`${targetId} marked as done`);
+  const wiRaw = readFile(filePath);
+  const wiData = matter8(wiRaw).data;
+  const hasExceptions = wiData.validation_status === "accepted-with-exceptions" || Array.isArray(wiData.completion_exceptions) && wiData.completion_exceptions.length > 0;
+  const releaseBlocked = wiData.release_status === "blocked";
+  let enrichedLearning = learning.trim();
+  if (hasExceptions || releaseBlocked) {
+    const notes = [];
+    if (hasExceptions) notes.push("Validation exceptions were accepted for this Work Item.");
+    if (releaseBlocked) {
+      const gates = Array.isArray(wiData.release_gates) ? wiData.release_gates.filter((g) => g.status === "blocked" || g.status === "pending").map((g) => g.id) : [];
+      notes.push(gates.length > 0 ? `Release gates remain: ${gates.join(", ")}.` : "Production release remains blocked.");
+    }
+    enrichedLearning += "\n\n> " + notes.join(" ");
+  }
+  updateWorkItemFile(filePath, enrichedLearning);
+  log2.success(`${targetId} marked as completed`);
   log2.success(`Learning recorded in ${filePath.replace(dir + "/", "")}`);
+  if (hasExceptions) {
+    log2.warn("Learning captured from a Work Item completed with validation exceptions.");
+  }
   log2.info("Consider updating knowledge/knowledge.md if this changes the current state.");
   outro2("Work item closed.");
 }

package/package.json

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