@kaddo/cli 3.45.0 → 3.47.0

package/dist/index.js

@@ -8680,6 +8680,407 @@ function buildRoadmapQuality(dir) {
   return { initiatives, work_item_candidates };
 }
 
+// src/core/project-route.ts
+function isUseful(q) {
+  return q === "useful";
+}
+var enableKaddo = {
+  id: "enable-kaddo",
+  label: "Enable Kaddo",
+  evaluate: (ctx) => ({
+    status: ctx.hasConfig ? "done" : "current",
+    evidence: ctx.hasConfig ? [".kaddo/config.yml"] : void 0,
+    command: ctx.hasConfig ? void 0 : "kaddo init"
+  })
+};
+var scanRepository = {
+  id: "scan-repository",
+  label: "Scan repository",
+  evaluate: (ctx) => ({
+    status: ctx.hasScan ? "done" : ctx.hasConfig ? "pending" : "pending",
+    evidence: ctx.hasScan ? [".kaddo/scan.json"] : void 0,
+    command: ctx.hasScan ? void 0 : "kaddo scan"
+  })
+};
+var defineBusiness = {
+  id: "define-business",
+  label: "Define business context",
+  evaluate: (ctx) => ({
+    status: isUseful(ctx.qBusiness) ? "done" : ctx.qBusiness === "missing" ? "pending" : "warning",
+    evidence: isUseful(ctx.qBusiness) ? ["knowledge/business/business.md"] : void 0,
+    reason: ctx.qBusiness === "placeholder" ? "Business context is still a bootstrap placeholder." : void 0,
+    agent: isUseful(ctx.qBusiness) ? void 0 : "business-agent"
+  })
+};
+var defineProduct = {
+  id: "define-product",
+  label: "Define product context",
+  evaluate: (ctx) => ({
+    status: isUseful(ctx.qProduct) ? "done" : ctx.qProduct === "missing" ? "pending" : "warning",
+    evidence: isUseful(ctx.qProduct) ? ["knowledge/product/product.md"] : void 0,
+    agent: isUseful(ctx.qProduct) ? void 0 : "capability-agent"
+  })
+};
+var discoverCapabilities = {
+  id: "discover-capabilities",
+  label: "Discover capabilities",
+  evaluate: (ctx) => ({
+    status: isUseful(ctx.qCapabilities) ? "done" : ctx.qCapabilities === "missing" ? "pending" : "warning",
+    evidence: isUseful(ctx.qCapabilities) ? ["knowledge/product/capabilities.md"] : void 0,
+    agent: isUseful(ctx.qCapabilities) ? void 0 : "capability-agent"
+  })
+};
+var describeArchitecture = {
+  id: "describe-architecture",
+  label: "Describe current architecture",
+  evaluate: (ctx) => {
+    const done = isUseful(ctx.qCurrentState) && isUseful(ctx.qCodebase);
+    const evidence = [];
+    if (isUseful(ctx.qCurrentState)) evidence.push("knowledge/tech/current-state.md");
+    if (isUseful(ctx.qCodebase)) evidence.push("knowledge/tech/codebase.md");
+    return {
+      status: done ? "done" : "pending",
+      evidence: evidence.length > 0 ? evidence : void 0,
+      agent: done ? void 0 : "architecture-agent"
+    };
+  }
+};
+var captureTechDecisions = {
+  id: "capture-technical-decisions",
+  label: "Capture technical decisions",
+  evaluate: (ctx) => {
+    if (ctx.decisionCandidates === 0 && ctx.totalAdrs === 0) {
+      return { status: "optional", reason: "No decision candidates found." };
+    }
+    if (ctx.totalAdrs > 0) {
+      return { status: "done", evidence: ["knowledge/tech/decisions/"], reason: `${ctx.totalAdrs} ADR(s) exist.` };
+    }
+    return {
+      status: "warning",
+      reason: `${ctx.decisionCandidates} decision candidate(s) exist but no ADRs have been materialized.`,
+      command: "kaddo adr",
+      skill: "adr-writing"
+    };
+  }
+};
+var createWorkSource = {
+  id: "create-work-source",
+  label: "Create or connect work source",
+  evaluate: (ctx) => ({
+    status: ctx.hasRoadmap || ctx.totalWorkItems > 0 ? "done" : "pending",
+    evidence: ctx.hasRoadmap ? ["knowledge/delivery/roadmap.md"] : void 0,
+    command: ctx.hasRoadmap ? void 0 : "kaddo roadmap",
+    agent: ctx.hasRoadmap ? void 0 : "roadmap-agent"
+  })
+};
+var materializeWorkItem = {
+  id: "materialize-work-item",
+  label: "Materialize first Work Item",
+  evaluate: (ctx) => {
+    if (ctx.totalWorkItems > 0) {
+      return { status: "done", evidence: ["knowledge/delivery/work-items/"] };
+    }
+    if (ctx.roadmapCandidates > 0) {
+      return { status: "current", command: "kaddo create --from roadmap", reason: "Roadmap has candidates but no Work Item exists." };
+    }
+    return { status: "pending" };
+  }
+};
+var refineWorkItem = {
+  id: "refine-work-item",
+  label: "Refine Work Item",
+  evaluate: (ctx) => {
+    if (ctx.readyWorkItems > 0 || ctx.inProgressWorkItems > 0) return { status: "done" };
+    if (ctx.draftWorkItems > 0) {
+      return {
+        status: "current",
+        reason: `There ${ctx.draftWorkItems === 1 ? "is" : "are"} ${ctx.draftWorkItems} draft Work Item${ctx.draftWorkItems === 1 ? "" : "s"} and no Work Item is ready.`,
+        agent: "work-item-agent",
+        skill: "work-item-refinement"
+      };
+    }
+    return { status: "pending" };
+  }
+};
+var suggestOwnership = {
+  id: "suggest-ownership",
+  label: "Suggest ownership",
+  evaluate: (ctx) => {
+    if (ctx.totalWorkItems === 0) return { status: "pending" };
+    if (ctx.ownershipComplete) return { status: "done" };
+    return {
+      status: "next",
+      reason: `Ownership coverage is ${ctx.ownershipCoverage}.`,
+      command: "kaddo owners suggest"
+    };
+  }
+};
+var resolveAdrs = {
+  id: "resolve-adrs",
+  label: "Resolve ADRs if needed",
+  evaluate: (ctx) => {
+    if (ctx.decisionCandidates === 0 && ctx.totalAdrs === 0) return { status: "optional" };
+    if (ctx.totalAdrs > 0) return { status: "done" };
+    return {
+      status: "warning",
+      reason: `${ctx.decisionCandidates} decision candidate(s) without ADRs.`,
+      command: "kaddo adr",
+      skill: "adr-writing"
+    };
+  }
+};
+var prepareImplementation = {
+  id: "prepare-implementation",
+  label: "Prepare implementation",
+  evaluate: (ctx) => {
+    if (ctx.inProgressWorkItems > 0 || ctx.completedWorkItems > 0) return { status: "done" };
+    if (ctx.readyWorkItems > 0) {
+      if (ctx.adaptersInstalled === 0) {
+        return { status: "current", reason: "Ready Work Items exist but no adapter is installed.", command: "kaddo adapters list" };
+      }
+      return { status: "current", agent: "implementation-agent" };
+    }
+    return { status: "pending" };
+  }
+};
+var runGuard2 = {
+  id: "run-guard",
+  label: "Run guard",
+  evaluate: (ctx) => {
+    if (ctx.hasGuardHistory) return { status: "done", evidence: [".kaddo/history/guard-runs.jsonl"] };
+    if (ctx.inProgressWorkItems > 0) return { status: "current", command: "kaddo guard" };
+    return { status: "pending" };
+  }
+};
+var captureLearning = {
+  id: "capture-learning",
+  label: "Capture learning",
+  evaluate: (ctx) => {
+    if (ctx.completedWorkItems > 0) return { status: "done" };
+    if (ctx.totalWorkItems === 0) return { status: "optional", reason: "Project is still in early discovery." };
+    return { status: "pending" };
+  }
+};
+var identifyLegacyModules = {
+  id: "identify-legacy-modules",
+  label: "Identify legacy modules",
+  evaluate: (ctx) => {
+    const hasLegacy = exists(join(ctx.dir, "knowledge/legacy/risks.md"));
+    return {
+      status: hasLegacy ? "done" : "pending",
+      evidence: hasLegacy ? ["knowledge/legacy/risks.md"] : void 0,
+      agent: hasLegacy ? void 0 : "legacy-agent"
+    };
+  }
+};
+var identifyRisks = {
+  id: "identify-risks",
+  label: "Identify operational risks",
+  evaluate: (ctx) => {
+    const hasLegacy = exists(join(ctx.dir, "knowledge/legacy/risks.md"));
+    return { status: hasLegacy ? "done" : "pending", agent: hasLegacy ? void 0 : "legacy-agent" };
+  }
+};
+var NEW_STEPS = [
+  enableKaddo,
+  defineBusiness,
+  defineProduct,
+  { ...discoverCapabilities, label: "Define initial capabilities" },
+  { ...describeArchitecture, label: "Define initial architecture" },
+  { ...createWorkSource, label: "Create initial work source" },
+  { ...materializeWorkItem, label: "Create first Work Item" },
+  refineWorkItem,
+  suggestOwnership,
+  prepareImplementation,
+  runGuard2,
+  captureLearning
+];
+var PRE_AI_STEPS = [
+  enableKaddo,
+  scanRepository,
+  defineBusiness,
+  defineProduct,
+  discoverCapabilities,
+  describeArchitecture,
+  captureTechDecisions,
+  createWorkSource,
+  materializeWorkItem,
+  refineWorkItem,
+  suggestOwnership,
+  resolveAdrs,
+  prepareImplementation,
+  runGuard2,
+  captureLearning
+];
+var LEGACY_STEPS = [
+  enableKaddo,
+  scanRepository,
+  identifyLegacyModules,
+  { ...discoverCapabilities, label: "Discover critical capabilities" },
+  describeArchitecture,
+  identifyRisks,
+  captureTechDecisions,
+  { ...createWorkSource, label: "Create modernization candidates" },
+  { ...materializeWorkItem, label: "Materialize safe Work Item" },
+  refineWorkItem,
+  suggestOwnership,
+  resolveAdrs,
+  { ...prepareImplementation, label: "Prepare safe implementation" },
+  runGuard2,
+  captureLearning
+];
+function stepsForState(state) {
+  switch (state) {
+    case "new":
+      return NEW_STEPS;
+    case "legacy":
+      return LEGACY_STEPS;
+    case "pre-ai":
+    default:
+      return PRE_AI_STEPS;
+  }
+}
+function buildRouteContext(dir) {
+  const config = loadConfig(dir);
+  const hasScan = exists(join(dir, ".kaddo", "scan.json"));
+  const hasInventory = exists(join(dir, "knowledge", "inventory.md"));
+  const qa = (rel) => analyzeKnowledgeArtifact(dir, rel);
+  const wis = discoverWorkItems(dir);
+  const td = buildTechDecisions(dir);
+  const roadmapPath = join(dir, "knowledge/delivery/roadmap.md");
+  const hasRoadmap = exists(roadmapPath);
+  let roadmapMd = null;
+  if (hasRoadmap) {
+    try {
+      roadmapMd = readFile(roadmapPath);
+    } catch {
+    }
+  }
+  const stats = roadmapStats(roadmapMd, wis.length);
+  const byState = (s) => wis.filter((w) => w.lifecycle === s).length;
+  const total = wis.length;
+  const withOwnership = wis.filter((w) => w.codeGlobs.length > 0).length;
+  const adapters = installedAdapters(dir);
+  const nextStep = resolveNextStep(dir);
+  return {
+    dir,
+    hasConfig: config !== null,
+    hasScan,
+    hasInventory,
+    qBusiness: qa("knowledge/business/business.md"),
+    qProduct: qa("knowledge/product/product.md"),
+    qCapabilities: qa("knowledge/product/capabilities.md"),
+    qCurrentState: qa("knowledge/tech/current-state.md"),
+    qCodebase: qa("knowledge/tech/codebase.md"),
+    hasRoadmap,
+    roadmapCandidates: stats.work_item_candidates,
+    totalWorkItems: total,
+    draftWorkItems: byState("draft"),
+    readyWorkItems: byState("ready"),
+    inProgressWorkItems: byState("in-progress"),
+    completedWorkItems: byState("completed"),
+    ownershipCoverage: `${withOwnership}/${total}`,
+    ownershipComplete: total > 0 && withOwnership >= total,
+    decisionCandidates: td.candidates,
+    acceptedAdrs: td.accepted_adrs,
+    draftAdrs: td.draft_adrs,
+    totalAdrs: td.adrs,
+    adaptersInstalled: adapters.length,
+    hasGuardHistory: exists(join(dir, ".kaddo", "history", "guard-runs.jsonl")),
+    nextStepId: mapNextStepId(nextStep.id)
+  };
+}
+function mapNextStepId(id) {
+  const MAP = {
+    init: "enable-kaddo",
+    bootstrap: "define-business",
+    "add-agents": "enable-kaddo",
+    "add-skills": "enable-kaddo",
+    scan: "scan-repository",
+    context: "scan-repository",
+    understand: "scan-repository"
+  };
+  return MAP[id] ?? id;
+}
+function buildProjectRoute(dir) {
+  const config = loadConfig(dir);
+  const state = config?.project.state ?? "pre-ai";
+  const defs = stepsForState(state);
+  const ctx = buildRouteContext(dir);
+  const steps = defs.map((d) => {
+    const result = d.evaluate(ctx);
+    return { id: d.id, label: d.label, ...result };
+  });
+  for (const s of steps) {
+    if (s.id === ctx.nextStepId && s.status !== "done") {
+      s.status = "current";
+    }
+  }
+  let seenCurrent = false;
+  for (const s of steps) {
+    if (s.status === "current") seenCurrent = true;
+    if (seenCurrent && s.status === "pending") {
+      s.status = "next";
+      break;
+    }
+  }
+  const completed = steps.filter((s) => s.status === "done").length;
+  const total = steps.length;
+  const progressPercent = total > 0 ? Math.round(completed / total * 100) : 0;
+  return {
+    type: state,
+    currentStep: steps.find((s) => s.status === "current")?.id ?? steps.find((s) => s.status !== "done")?.id ?? "complete",
+    completed,
+    total,
+    progressPercent,
+    steps
+  };
+}
+var STATUS_MARKER = {
+  done: "[x]",
+  current: "[>]",
+  next: "[ ]",
+  pending: "[ ]",
+  optional: "[o]",
+  blocked: "[!]",
+  warning: "[~]",
+  skipped: "[-]"
+};
+function renderRouteMarkdown(route) {
+  const lines = [];
+  lines.push("## Project Route\n");
+  lines.push(`Route: ${route.type}`);
+  lines.push(`Progress: ${route.completed}/${route.total}
+`);
+  for (const s of route.steps) {
+    lines.push(`- ${STATUS_MARKER[s.status]} ${s.label}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderRouteCompact(route) {
+  const lines = [];
+  lines.push(`Route: ${route.type} \xB7 Progress: ${route.completed}/${route.total}
+`);
+  const current = route.steps.find((s) => s.status === "current");
+  if (current) {
+    const agent = current.agent ? ` \u2014 ${current.agent}` : "";
+    const skill2 = current.skill ? ` / ${current.skill}` : "";
+    lines.push(`Current:
+- ${current.label}${agent}${skill2}
+`);
+  }
+  const warnings = route.steps.filter((s) => s.status === "warning");
+  if (warnings.length > 0) {
+    lines.push("Warnings:");
+    for (const w of warnings) {
+      lines.push(`- ${w.label}${w.reason ? ` \u2014 ${w.reason}` : ""}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
 // src/core/project-explain.ts
 var ARCH_DIR4 = "knowledge";
 function normalizeTitle(t) {
@@ -8905,7 +9306,8 @@ function buildProjectExplanation(dir) {
       }
     },
     installedAssets: installedAssetsSummary(dir),
-    roadmapQuality: buildRoadmapQuality(dir)
+    roadmapQuality: buildRoadmapQuality(dir),
+    projectRoute: buildProjectRoute(dir)
   };
 }
 function stateLabel(state) {
@@ -9080,6 +9482,7 @@ function renderExplanationHuman(exp) {
     lines.push("Review before continuing (non-blocking).");
     lines.push("");
   }
+  lines.push(renderRouteMarkdown(exp.projectRoute));
   const assessment = assessPhase(exp);
   lines.push("## Phase");
   lines.push(`- Phase: ${assessment.phase}`);
@@ -9614,6 +10017,7 @@ function buildContextPack(dir, config, now = /* @__PURE__ */ new Date()) {
     graph: loadGraphSummary(dir),
     graphHints: loadGraphHints(dir),
     skills: discoverInstalledSkills(dir).map((s) => s.id),
+    projectRoute: buildProjectRoute(dir),
     mappedModules,
     missing,
     // VS-052/VS-073.2: the handoff is driven by the unified next step, so the pack never contradicts
@@ -9690,6 +10094,8 @@ function renderContextPack(pack) {
       parts.push(rec.secondary.map((s) => `- ${s.label}`).join("\n") + "\n");
     }
   }
+  parts.push("## Project Route\n");
+  parts.push(renderRouteCompact(pack.projectRoute));
   parts.push("## Knowledge Layers\n");
   parts.push(
     "Project knowledge is organized in four layers: **Business \u2192 Product \u2192 Tech \u2192 Delivery**.\n"
@@ -9975,7 +10381,8 @@ function buildUnderstandPlan(dir, config) {
       name: config.project.name,
       state,
       teamSize: config.team.size,
-      structure: config.project.structure
+      structure: config.project.structure,
+      language: "English"
     },
     scanAvailable: exists(join(dir, ".kaddo", "scan.json")),
     contextPackPath: ".kaddo/context-pack.md",
@@ -9984,6 +10391,19 @@ function buildUnderstandPlan(dir, config) {
     steps
   };
 }
+function enrichUnderstandPlan(plan, opts) {
+  return {
+    ...plan,
+    project: { ...plan.project, language: opts.language },
+    phase: opts.phase,
+    nextStepRecommendation: opts.nextStepRecommendation,
+    deliveryState: opts.deliveryState,
+    activeWorkItems: opts.activeWorkItems,
+    recommendedPaths: opts.recommendedPaths,
+    recommendedSkillPaths: opts.recommendedSkillPaths,
+    projectRoute: opts.projectRoute
+  };
+}
 
 // src/templates/understand-template.ts
 function stateLabel2(state) {
@@ -9994,42 +10414,144 @@ function agentName(file) {
 }
 function renderUnderstand(plan) {
   const { project, steps } = plan;
+  const rec = plan.nextStepRecommendation;
+  const ds = plan.deliveryState;
   const parts = [];
   parts.push("# Kaddo Understand Handoff\n");
   parts.push(
     "> Generated by `kaddo understand`. Kaddo does not call an LLM \u2014 you stay in control of the interpretation.\n"
   );
   parts.push("## Project\n");
-  parts.push(
-    [
-      `- Name: ${project.name}`,
-      `- State: ${project.state}`,
-      `- Team: ${project.teamSize}`,
-      `- Structure: ${project.structure}`
-    ].join("\n") + "\n"
-  );
-  parts.push("## Recommended Agent Flow\n");
-  parts.push(`Recommended order for a ${stateLabel2(project.state)} project:
+  const projectLines = [
+    `- Name: ${project.name}`,
+    `- State: ${project.state}`,
+    `- Team: ${project.teamSize}`,
+    `- Structure: ${project.structure}`
+  ];
+  if (project.language) projectLines.push(`- Language: ${project.language}`);
+  parts.push(projectLines.join("\n") + "\n");
+  if (plan.phase && rec) {
+    parts.push("## Current Phase\n");
+    const phaseLines = [`- Phase: ${plan.phase}`];
+    if (rec.agent) phaseLines.push(`- Recommended agent: ${agentName(rec.agent)}`);
+    if (rec.skill) phaseLines.push(`- Recommended skill: ${rec.skill}`);
+    phaseLines.push(`- Next step: ${rec.label}`);
+    if (rec.reason) phaseLines.push(`- Reason: ${rec.reason}`);
+    parts.push(phaseLines.join("\n") + "\n");
+  }
+  if (ds && ds.total_work_items > 0) {
+    parts.push("## Delivery State\n");
+    parts.push(
+      [
+        `- Draft Work Items: ${ds.draft_work_items}`,
+        `- Ready Work Items: ${ds.ready_work_items}`,
+        `- In-progress Work Items: ${ds.in_progress_work_items}`,
+        `- Blocked Work Items: ${ds.blocked_work_items}`,
+        `- Ownership coverage: ${ds.ownership_coverage}`,
+        `- Remaining Work Item candidates: ${ds.remaining_work_item_candidates}`,
+        `- Technical decision candidates: ${ds.decision_candidates}`,
+        `- Accepted ADRs: ${ds.accepted_adrs}`,
+        `- Installed adapters: ${ds.adapters_installed}`
+      ].join("\n") + "\n"
+    );
+  }
+  if (plan.projectRoute) {
+    parts.push("## Project Route\n");
+    parts.push(renderRouteCompact(plan.projectRoute));
+  }
+  if (steps.length > 0) {
+    parts.push("## Recommended Agent Flow\n");
+    parts.push(`Recommended order for a ${stateLabel2(project.state)} project:
 `);
-  parts.push(
-    steps.map((s, i) => {
-      const flag = s.installed ? "" : "  _(not installed \u2014 run `kaddo add agents`)_";
-      return `${i + 1}. ${agentName(s.agent)} \u2192 \`${s.output}\`${flag}`;
-    }).join("\n") + "\n"
-  );
+    parts.push(
+      steps.map((s, i) => {
+        const flag = s.installed ? "" : "  _(not installed \u2014 run `kaddo add agents`)_";
+        return `${i + 1}. ${agentName(s.agent)} \u2192 \`${s.output}\`${flag}`;
+      }).join("\n") + "\n"
+    );
+  } else if (rec) {
+    parts.push("## Recommended Agent Flow\n");
+    const flowSteps = [];
+    if (rec.agent) flowSteps.push(agentName(rec.agent));
+    if (rec.secondary) {
+      for (const s of rec.secondary) {
+        if (s.agent) flowSteps.push(agentName(s.agent));
+        else if (s.skill) flowSteps.push(`${s.skill} skill`);
+        else if (s.command) flowSteps.push(`\`${s.command}\``);
+      }
+    }
+    if (flowSteps.length > 0) {
+      parts.push(flowSteps.map((f, i) => `${i + 1}. ${f}`).join("\n") + "\n");
+    }
+  }
+  if (rec) {
+    parts.push("## Primary Recommendation\n");
+    const recLines = [`- id: ${rec.id}`];
+    if (rec.agent) recLines.push(`- agent: ${agentName(rec.agent)}`);
+    if (rec.skill) recLines.push(`- skill: ${rec.skill}`);
+    if (rec.command) recLines.push(`- command: \`${rec.command}\``);
+    recLines.push(`- reason: ${rec.reason}`);
+    parts.push(recLines.join("\n") + "\n");
+  }
+  if (rec?.secondary && rec.secondary.length > 0) {
+    parts.push("## Secondary Recommendations\n");
+    parts.push(rec.secondary.map((s, i) => `${i + 1}. ${s.label}`).join("\n") + "\n");
+  }
+  if (plan.activeWorkItems && plan.activeWorkItems.length > 0) {
+    parts.push("## Active Work Items\n");
+    parts.push(
+      plan.activeWorkItems.map((w) => `- ${w.id} [${w.type}] ${w.lifecycle} \u2014 ${w.title}`).join("\n") + "\n"
+    );
+  }
   parts.push("## Context Pack\n");
   const scanNote = plan.scanAvailable ? "" : " (incomplete \u2014 run `kaddo scan` first for a richer baseline)";
   parts.push(`Use \`${plan.contextPackPath}\` as the primary input${scanNote}.
 `);
+  const agentPaths = [];
+  if (plan.recommendedPaths && plan.recommendedPaths.length > 0) {
+    agentPaths.push(...plan.recommendedPaths);
+  } else if (steps.length > 0) {
+    agentPaths.push(...steps.map((s) => agentInstallPath(s.agent)));
+  }
+  if (plan.recommendedSkillPaths && plan.recommendedSkillPaths.length > 0) {
+    agentPaths.push(...plan.recommendedSkillPaths);
+  }
+  agentPaths.push(plan.contextPackPath);
   parts.push("## Agent Prompts\n");
-  parts.push(
-    steps.map((s) => `- \`${agentInstallPath(s.agent)}\``).join("\n") + "\n"
-  );
-  parts.push("## Expected Outputs\n");
-  parts.push(steps.map((s) => `- \`${s.output}\``).join("\n") + "\n");
+  if (agentPaths.length > 1) {
+    parts.push("Use:\n");
+    parts.push(agentPaths.map((p2) => `- \`${p2}\``).join("\n") + "\n");
+  } else {
+    parts.push(`- \`${plan.contextPackPath}\`
+`);
+  }
+  if (steps.length > 0) {
+    parts.push("## Expected Outputs\n");
+    parts.push(steps.map((s) => `- \`${s.output}\``).join("\n") + "\n");
+  } else if (rec) {
+    parts.push("## Expected Outputs\n");
+    const outputs = [];
+    if (rec.target) outputs.push(`- \`${rec.target}\``);
+    if (rec.id === "refine-work-item" || rec.id === "resolve-blocker")
+      outputs.push("- Refined Work Item content.");
+    if (rec.id === "create-work-item")
+      outputs.push("- A new Work Item under `knowledge/delivery/work-items/`.");
+    if (rec.id === "implement")
+      outputs.push("- Implementation plan or code changes guided by the Work Item.");
+    if (rec.id === "guard")
+      outputs.push("- Updated knowledge artifacts reflecting recent code changes.");
+    if (rec.id === "install-adapter")
+      outputs.push("- An adapter configured and injected (`kaddo adapters list`).");
+    if (outputs.length > 0) {
+      parts.push("The LLM should produce:\n");
+      parts.push(outputs.join("\n") + "\n");
+    } else {
+      parts.push("_See the primary recommendation above._\n");
+    }
+  }
   parts.push("## Copy/Paste Instructions\n");
-  const first2 = steps[0];
-  if (first2) {
+  if (steps.length > 0) {
+    const first2 = steps[0];
     parts.push(
       [
         `Start with **${agentName(first2.agent)}**:`,
@@ -10041,9 +10563,31 @@ function renderUnderstand(plan) {
         `5. Save the result in: \`${first2.output}\``
       ].join("\n") + "\n"
     );
+  } else if (agentPaths.length > 1) {
+    parts.push("Paste the following into your LLM chat:\n");
+    parts.push(agentPaths.map((p2, i) => `${i + 1}. \`${p2}\``).join("\n") + "\n");
+    if (rec?.agent) {
+      parts.push(`Ask the LLM to follow the ${agentName(rec.agent)} instructions.
+`);
+    }
+  } else {
+    parts.push(`Paste \`${plan.contextPackPath}\` into your LLM chat.
+`);
   }
   parts.push("## Next Steps\n");
-  if (steps.length > 1) {
+  if (rec) {
+    const nextLines = [];
+    nextLines.push(`1. ${rec.label}`);
+    let n = 2;
+    if (rec.secondary) {
+      for (const s of rec.secondary) {
+        nextLines.push(`${n}. ${s.label}`);
+        n++;
+      }
+    }
+    nextLines.push(`${n}. Re-run \`kaddo explain\`.`);
+    parts.push(nextLines.join("\n") + "\n");
+  } else if (steps.length > 1) {
     parts.push(
       `After saving \`${steps[0].output}\`, continue with **${agentName(steps[1].agent)}** (feed it the context pack plus the artifacts you already produced). Re-run \`kaddo understand\` any time to see this plan again.
 `
@@ -10268,7 +10812,42 @@ function runUnderstand() {
       console.log(`Other active work items: ${active.slice(1).map((w) => w.id).join(", ")}`);
     }
   }
-  writeFile(join(dir, ".kaddo", "understand.md"), renderUnderstand(plan));
+  const ds = buildDeliveryState(dir);
+  ds.phase = assessment.phase;
+  const wis = discoverWorkItems(dir);
+  const activeWis = wis.filter((w) => w.lifecycle && ["draft", "ready", "in-progress", "blocked"].includes(w.lifecycle)).map((w) => ({
+    id: w.id,
+    title: w.title,
+    type: w.type,
+    lifecycle: w.lifecycle ?? "draft",
+    knowledgeLevel: w.knowledgeLevel,
+    hasOwnership: w.codeGlobs.length > 0
+  }));
+  const recommendedPaths = [];
+  if (rec.agent) {
+    const agentFile = rec.agent.endsWith(".md") ? rec.agent : `${rec.agent}.md`;
+    if (agentIsInstalled(dir, agentFile)) {
+      recommendedPaths.push(agentInstallPath(agentFile));
+    }
+  }
+  const recommendedSkillPaths = [];
+  if (rec.skill) {
+    const sp = skillInstallPath(rec.skill);
+    if (exists(join(dir, sp))) {
+      recommendedSkillPaths.push(sp);
+    }
+  }
+  const enrichedPlan = enrichUnderstandPlan(plan, {
+    phase: assessment.phase,
+    nextStepRecommendation: rec,
+    deliveryState: ds,
+    activeWorkItems: activeWis,
+    recommendedPaths,
+    recommendedSkillPaths,
+    language: languageLabel(projectLanguage(config)),
+    projectRoute: buildProjectRoute(dir)
+  });
+  writeFile(join(dir, ".kaddo", "understand.md"), renderUnderstand(enrichedPlan));
   log2.success("Wrote .kaddo/understand.md");
   printCommandFooter("understand");
   outro2("Handoff ready. CLI prepares context \u2014 your LLM creates the understanding.");

package/package.json

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