@kaddo/mcp 3.66.0 → 3.68.0

package/dist/index.js

@@ -500,6 +500,53 @@ function isCore(config) {
 
 // ../cli/src/services/artifact-reader.ts
 import matter3 from "gray-matter";
+var VALID_SCOPE_CONFIDENCE_LEVELS = /* @__PURE__ */ new Set(["high", "medium", "low"]);
+var VALID_COVERAGE_STATUSES = /* @__PURE__ */ new Set(["affected", "reviewed-not-affected", "unknown", "not-applicable"]);
+function parseScopeConfidence(data) {
+  const sc = data.scope_confidence;
+  if (!sc || typeof sc !== "object" || Array.isArray(sc)) return null;
+  const obj = sc;
+  const level = String(obj.level ?? "");
+  if (!VALID_SCOPE_CONFIDENCE_LEVELS.has(level)) return null;
+  const reasons = Array.isArray(obj.reasons) ? obj.reasons.map(String).filter(Boolean) : [];
+  return { level, reasons };
+}
+function parseModuleCoverage(data) {
+  const mc = data.module_coverage;
+  if (!mc || typeof mc !== "object" || Array.isArray(mc)) return null;
+  const result = {};
+  for (const [id, val] of Object.entries(mc)) {
+    if (!val || typeof val !== "object" || Array.isArray(val)) continue;
+    const v = val;
+    const status = String(v.status ?? "");
+    if (!VALID_COVERAGE_STATUSES.has(status)) continue;
+    result[id] = {
+      status,
+      ...v.reason ? { reason: String(v.reason) } : {},
+      ...Array.isArray(v.evidence) ? { evidence: v.evidence.map(String).filter(Boolean) } : {}
+    };
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function parseImpactAnalysis(data) {
+  const ia = data.impact_analysis;
+  if (!ia || typeof ia !== "object" || Array.isArray(ia)) return null;
+  const surfaces = ia.surfaces;
+  if (!surfaces || typeof surfaces !== "object" || Array.isArray(surfaces)) return null;
+  const result = {};
+  for (const [id, val] of Object.entries(surfaces)) {
+    if (!val || typeof val !== "object" || Array.isArray(val)) continue;
+    const v = val;
+    const status = String(v.status ?? "");
+    if (!VALID_COVERAGE_STATUSES.has(status)) continue;
+    result[id] = {
+      status,
+      ...v.reason ? { reason: String(v.reason) } : {},
+      ...v.question ? { question: String(v.question) } : {}
+    };
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
 function parseArtifact(filePath, raw) {
   try {
     const { data } = matter3(raw);
@@ -528,7 +575,10 @@ function parseArtifact(filePath, raw) {
       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 ?? "")
+      closedBy: String(data.closed_by ?? ""),
+      scopeConfidence: parseScopeConfidence(data),
+      moduleCoverage: parseModuleCoverage(data),
+      impactAnalysis: parseImpactAnalysis(data)
     };
   } catch {
     return null;
@@ -1105,12 +1155,44 @@ domains: []
 capabilities: []
 code: []
 created_at: YYYY-MM-DD
+# scope_confidence:
+#   level: medium
+#   reasons: []
+# module_coverage:
+#   core:
+#     status: affected
+#     reason: ""
+# impact_analysis:
+#   surfaces:
+#     frontend:
+#       status: affected
+#       reason: ""
 ---
 
 # <Title>
 
 > Type: feature \xB7 Level: K2
 
+## Actor and outcome
+
+_Who experiences the change and what is the observable result?_
+
+## Current behavior
+
+_What happens today?_
+
+## Target behavior
+
+_What should happen after this change?_
+
+## Entry points
+
+_Where does the flow start for the actor?_
+
+## End-to-end flow
+
+_Describe the complete flow from entry point to final result._
+
 ## Problem
 
 _What problem or opportunity does this address?_
@@ -1119,9 +1201,26 @@ _What problem or opportunity does this address?_
 
 _What should be true once this is done?_
 
+## Impact analysis
+
+_Which surfaces are affected, reviewed-not-affected, unknown, or not-applicable?_
+
+## Module coverage
+
+_For multirepo: which modules were evaluated and their status._
+
+## Scope unknowns
+
+_What remains unknown? Include focused questions._
+
+## Scope confidence
+
+_high / medium / low \u2014 with reasons._
+
 ## Acceptance criteria
 
 - [ ] ...
+- [ ] _Include at least one end-to-end criterion for user-facing changes._
 
 ## Design
 
@@ -1153,6 +1252,9 @@ ${QUALITY}
 - [ ] Title is specific and action-oriented.
 - [ ] \`code:\` globs declared so Guard can relate changes.
 - [ ] Knowledge level matches the real uncertainty.
+- [ ] Actor and outcome are identified.
+- [ ] Current and target behavior are documented.
+- [ ] Scope confidence is declared.
 `;
 var ROADMAP = `---
 type: roadmap
@@ -3963,6 +4065,8 @@ function workItemsSignal(dir) {
   if (wis.length === 0) return "none";
   if (wis.some((w3) => w3.lifecycle === "in-progress")) return "in-progress";
   if (wis.some((w3) => w3.lifecycle === "ready")) return "ready";
+  const hasActive = wis.some((w3) => w3.lifecycle === "draft" || w3.lifecycle === "blocked");
+  if (!hasActive && wis.some((w3) => w3.lifecycle === "completed" || w3.lifecycle === "archived")) return "completed-only";
   return "none-ready";
 }
 function installedAdapters(dir) {
@@ -4391,6 +4495,8 @@ function buildReadinessReport(dir, now = /* @__PURE__ */ new Date()) {
   else if (understand === "missing") overall = "scanned";
   else if (firstWeak) overall = "knowledge-incomplete";
   else if (oq.summary.blocking_open > 0) overall = "needs-decisions";
+  else if (work_items === "in-progress") overall = "active-implementation";
+  else if (work_items === "completed-only") overall = deriveDeliveryCompletedStatus(dir);
   else if (roadmap !== "has-candidates") overall = "ready-for-roadmap";
   else if (work_items === "none" || work_items === "none-ready") overall = "ready-for-work-item";
   else overall = "ready-for-implementation";
@@ -4403,6 +4509,16 @@ function buildReadinessReport(dir, now = /* @__PURE__ */ new Date()) {
     nextStepRecommendation: rec
   };
 }
+function deriveDeliveryCompletedStatus(dir) {
+  const wis = discoverWorkItems(dir);
+  const completed = wis.filter((w3) => lifecycleStateOf({ status: w3.status, filePath: w3.filePath }) === "completed");
+  if (completed.length === 0) return "delivery-completed";
+  const hasReleaseBlocked = completed.some((w3) => w3.releaseStatus === "blocked");
+  const hasReleaseReady = completed.some((w3) => w3.releaseStatus === "ready" || w3.releaseStatus === "released");
+  if (hasReleaseBlocked) return "delivery-completed-release-blocked";
+  if (hasReleaseReady) return "delivery-completed-release-ready";
+  return "delivery-completed";
+}
 
 // ../cli/src/core/assets.ts
 import matter6 from "gray-matter";
@@ -4545,8 +4661,23 @@ The context pack and the Work Item (draft or candidate).
 
 ## Output
 
-An improved Work Item with: problem, expected result, scope, out of scope, acceptance criteria,
-validation (how to test it), definition of done, open questions and dependencies.
+An improved Work Item with: actor and outcome, current behavior, target behavior, entry points,
+end-to-end flow, impact analysis, module coverage, scope unknowns, scope confidence, problem,
+expected result, scope, out of scope, acceptance criteria (including end-to-end criteria for
+user-facing changes), validation (how to test it), definition of done, open questions and
+dependencies.
+
+## Steps
+
+1. **Outcome framing** \u2014 identify actor, current behavior, target behavior, observable completion.
+2. **Journey reconstruction** \u2014 map entry point, interaction, service/API, state change, response,
+   final outcome.
+3. **Surface review** \u2014 evaluate: product/UI, frontend, backend, database, configuration, feature
+   flags, content/copy, authentication/authorization, notifications, analytics, documentation,
+   operations/release \u2014 as affected, reviewed-not-affected, unknown, or not-applicable.
+4. **Module review** \u2014 for multirepo, evaluate each mapped module with the same statuses.
+5. **Completeness review** \u2014 confirm: outcome covered, journey covered, modules assessed, unknowns
+   visible, acceptance criteria end-to-end, scope and out-of-scope coherent.
 
 ## Rules
 
@@ -4554,14 +4685,23 @@ validation (how to test it), definition of done, open questions and dependencies
 - Do not expand scope without explicit confirmation.
 - Do not create mega Work Items \u2014 split when it covers multiple outcomes.
 - Keep acceptance criteria testable.
+- Include at least one end-to-end acceptance criterion for user-facing changes.
+- Do not reduce a product intent to the first technical implementation found.
+- Evaluate surfaces and modules before proposing files.
 - This skill refines scope and acceptance criteria but does not approve implementation readiness.
   Readiness requires human confirmation through \`kaddo ready\` or the MCP \`mark_work_item_ready\` action.
 
 ## Quality checklist
 
+- Actor and outcome are identified.
+- Current and target behavior are documented.
+- Journey is reconstructed for user-facing changes.
+- Surfaces and modules are evaluated with explicit statuses.
 - Problem and expected result are unambiguous.
 - Scope and out-of-scope are explicit.
-- Acceptance criteria and validation are present and testable.
+- Acceptance criteria include end-to-end validation when applicable.
+- Scope unknowns are visible, not hidden.
+- Scope confidence is declared with reasons.
 - Open questions and dependencies are surfaced, not hidden.
 
 ## Example output
@@ -4782,14 +4922,19 @@ steps, and stop criteria (when to pause and ask).
 ## Rules
 
 - Do not start coding without confirmation.
-- Do not expand scope.
+- Do not expand scope without updating the Work Item.
 - Never make commits or push \u2014 suggest only.
+- Review scope coverage before planning: check that expected result, current/target behavior,
+  module coverage, and acceptance criteria are consistent. Flag contradictions (e.g., user-facing
+  change with unassessed frontend module).
 
 ## Quality checklist
 
+- Pre-implementation scope review is documented.
 - Scope and expected files are explicit.
 - Risks and validations are listed.
 - Stop criteria are defined.
+- Module coverage aligns with planned changes.
 
 ## Example output
 
@@ -5937,18 +6082,31 @@ A refined Work Item intended to be saved under the lifecycle workspace:
 
 ## Instructions
 
-1. Restate the problem in one clear sentence.
-2. Split the candidate if it is too large for a single Work Item.
-3. Preserve the candidate's type (\`feature\`, \`bugfix\`, \`hotfix\`, \`spike\`, \`chore\`).
-   Keep \`chore\` for maintenance/tooling/config/infra work \u2014 never upgrade a chore to a feature.
-4. Validate the Knowledge Level (K0\u2013K4) and propose a different one if needed.
-5. Propose acceptance criteria.
-6. Propose an Out of scope section.
-7. Propose **how to test it** \u2014 concrete validation steps (commands to run, manual steps, or
-   test cases) that prove the change works once implemented. This is mandatory.
-8. Propose a Definition of Done.
-9. Identify open questions and assumptions.
-10. Suggest ownership candidates (code globs) if evident.
+1. **Interpret the outcome** \u2014 what must change for the actor or consumer of this change.
+2. **Identify the actor** \u2014 who experiences or triggers the change.
+3. **Describe current behavior** \u2014 what happens today.
+4. **Describe target behavior** \u2014 what should happen after the change.
+5. **Reconstruct the journey** \u2014 for user-facing changes, map the end-to-end flow from entry
+   point to final observable result before proposing files.
+6. **Evaluate surfaces** \u2014 assess each potentially affected surface (frontend, backend, database,
+   configuration, content, feature flags, authentication, notifications, analytics, documentation,
+   operations) as \`affected\`, \`reviewed-not-affected\`, \`unknown\`, or \`not-applicable\`.
+7. **Evaluate modules** \u2014 for multirepo projects, assess each plausibly related mapped module with
+   the same statuses. A module must be \`affected\`, \`reviewed-not-affected\`, \`unknown\`, or
+   \`not-applicable\`. Do not leave related modules unmentioned.
+8. Restate the problem in one clear sentence.
+9. Split the candidate if it is too large for a single Work Item.
+10. Preserve the candidate's type (\`feature\`, \`bugfix\`, \`hotfix\`, \`spike\`, \`chore\`).
+    Keep \`chore\` for maintenance/tooling/config/infra work \u2014 never upgrade a chore to a feature.
+11. Validate the Knowledge Level (K0\u2013K4) and propose a different one if needed.
+12. Propose acceptance criteria \u2014 include at least one end-to-end criterion for user-facing changes.
+13. Propose an Out of scope section.
+14. Propose **how to test it** \u2014 concrete validation steps (commands to run, manual steps, or
+    test cases) that prove the change works once implemented. This is mandatory.
+15. Propose a Definition of Done.
+16. Identify open questions, assumptions, and scope unknowns.
+17. Determine scope confidence (high, medium, low) with reasons.
+18. Suggest ownership candidates (code globs) if evident.
 
 ## Constraints
 
@@ -5956,19 +6114,49 @@ A refined Work Item intended to be saved under the lifecycle workspace:
 - Do not invent business facts.
 - Do not assign a Knowledge Level higher than the change requires.
 - Mark assumptions explicitly.
+- Do not reduce a product intent to the first technical implementation found.
+- Inspect the observable outcome before proposing files.
+- For user-facing changes, assess the entry point, interaction surface, backend behavior, and
+  final user-visible result.
+- For multirepo projects, assess each plausibly related mapped module.
+- Do not mark the Work Item ready while material scope remains unknown.
+- Ask focused questions instead of silently narrowing the request.
+- Preserve unsupported assumptions as assumptions.
 
 ## Output Format
 
 \`\`\`markdown
 # <Work Item title>
 
+**Actor and outcome:**
+
+**Current behavior:**
+
+**Target behavior:**
+
+**Entry points:**
+
+**End-to-end flow:**
+
 **Problem:**
 
 **Expected result:**
 
 **Suggested Knowledge Level:** K1 / K2 / K3 / K4
 
+**Impact analysis:**
+<!-- surfaces: affected / reviewed-not-affected / unknown / not-applicable -->
+
+**Module coverage:**
+<!-- for multirepo: each module as affected / reviewed-not-affected / unknown / not-applicable -->
+
+**Scope unknowns:**
+
+**Scope confidence:** high / medium / low
+<!-- reasons: -->
+
 **Acceptance criteria:**
+<!-- include at least one end-to-end criterion for user-facing changes -->
 
 **Out of scope:**
 
@@ -6705,6 +6893,20 @@ Working code, tests and migrations, plus updated knowledge (ADR / capabilities /
 when the change affects them. You also produce a suggested branch name and a suggested
 Conventional Commit message \u2014 as suggestions, never executed.
 
+## Pre-implementation Scope Review (VS-095)
+
+Before implementing, review the Work Item's scope coverage:
+- Check that expected result, current behavior, and target behavior are documented.
+- Verify the journey covers the full user-facing flow when applicable.
+- Confirm affected surfaces and modules are declared.
+- Check module_coverage: if a mapped module is plausibly related but not assessed, flag it.
+- Verify acceptance criteria include end-to-end validation for user-facing changes.
+- Check for unresolved scope unknowns that could change the implementation.
+
+If you find a contradiction (e.g., target behavior describes a user-facing registration flow but
+the mapped frontend module was not assessed), explain the finding, propose updating the Work Item,
+and wait for confirmation before proceeding. Do not silently expand scope.
+
 ## Instructions
 
 1. **Suggest a branch first** (do not run it). Follow the Git strategy
@@ -7627,7 +7829,7 @@ var refineWorkItem = {
   id: "refine-work-item",
   label: "Refine Work Item",
   evaluate: (ctx) => {
-    if (ctx.readyWorkItems > 0 || ctx.inProgressWorkItems > 0) return { status: "done" };
+    if (ctx.readyWorkItems > 0 || ctx.inProgressWorkItems > 0 || ctx.blockedWorkItems > 0 || ctx.completedWorkItems > 0 || ctx.archivedWorkItems > 0) return { status: "done" };
     if (ctx.draftWorkItems > 0) {
       return {
         status: "current",
@@ -7878,7 +8080,9 @@ function buildRouteContext(dir) {
     draftWorkItems: byState("draft"),
     readyWorkItems: byState("ready"),
     inProgressWorkItems: byState("in-progress"),
+    blockedWorkItems: byState("blocked"),
     completedWorkItems: byState("completed"),
+    archivedWorkItems: byState("archived"),
     ownershipCoverage: `${withOwnership}/${total}`,
     ownershipComplete: total > 0 && withOwnership >= total,
     decisionCandidates: td.candidates,
@@ -8368,6 +8572,30 @@ function buildProjectExplanation(dir) {
     scanSignals: loadScanSignals(dir),
     metadataHealth: analyzeMetadataHealth(dir),
     isModuleRepo: config != null && isModule(config),
+    deliverySummary: (() => {
+      const completed = workItemArtifacts.filter((a2) => lifecycleStateOf({ status: a2.status, filePath: a2.filePath }) === "completed");
+      const archived = workItemArtifacts.filter((a2) => lifecycleStateOf({ status: a2.status, filePath: a2.filePath }) === "archived");
+      const active = workItemArtifacts.filter((a2) => isActiveState(lifecycleStateOf({ status: a2.status, filePath: a2.filePath })));
+      if (completed.length === 0 && archived.length === 0) return null;
+      return {
+        completedWorkItems: completed.length,
+        archivedWorkItems: archived.length,
+        activeWorkItems: active.length,
+        implementationCompleted: completed.filter((a2) => a2.implementationStatus === "completed").length,
+        releaseBlocked: completed.filter((a2) => a2.releaseStatus === "blocked").length,
+        releaseReady: completed.filter((a2) => a2.releaseStatus === "ready" || a2.releaseStatus === "released").length
+      };
+    })(),
+    scopeCoverage: workItemArtifacts.filter((a2) => a2.scopeConfidence || a2.moduleCoverage || a2.impactAnalysis).map((a2) => {
+      const unknownModules = a2.moduleCoverage ? Object.entries(a2.moduleCoverage).filter(([, v]) => v.status === "unknown").map(([k2]) => k2) : [];
+      return {
+        id: a2.id || a2.title,
+        scopeConfidence: a2.scopeConfidence,
+        moduleCoverage: a2.moduleCoverage,
+        unknownModules,
+        hasScopeCoverage: true
+      };
+    }),
     implementationEvidence: workItemArtifacts.filter((a2) => a2.affectedModules.length > 0).map((a2) => {
       const fm = a2.rawFrontmatter;
       const evidence = fm.implementation_evidence;
@@ -8379,11 +8607,13 @@ function buildProjectExplanation(dir) {
           status: String(data.status ?? "unknown")
         };
       }
+      const lc = lifecycleStateOf({ status: a2.status, filePath: a2.filePath });
+      const historicalDefault = lc === "completed" || lc === "archived" ? "not-assessed" : "not-started";
       return {
         id: a2.id || a2.title,
-        lifecycle: lifecycleStateOf({ status: a2.status, filePath: a2.filePath }),
-        implementationStatus: a2.implementationStatus || "not-started",
-        validationStatus: a2.validationStatus || "not-started",
+        lifecycle: lc,
+        implementationStatus: a2.implementationStatus || historicalDefault,
+        validationStatus: a2.validationStatus || historicalDefault,
         releaseStatus: a2.releaseStatus || "not-assessed",
         affectedModules: a2.affectedModules,
         releaseGates: Array.isArray(fm.release_gates) ? fm.release_gates : [],
@@ -8546,6 +8776,23 @@ function renderExplanationHuman(exp) {
     }
     lines.push("");
   }
+  if (exp.scopeCoverage.length > 0) {
+    lines.push("## Work Item Scope Coverage");
+    for (const sc of exp.scopeCoverage) {
+      lines.push("");
+      lines.push(`### ${sc.id}`);
+      if (sc.scopeConfidence) lines.push(`- Scope confidence: ${sc.scopeConfidence.level}`);
+      if (sc.moduleCoverage) {
+        const affected = Object.entries(sc.moduleCoverage).filter(([, v]) => v.status === "affected").map(([k2]) => k2);
+        const reviewed = Object.entries(sc.moduleCoverage).filter(([, v]) => v.status === "reviewed-not-affected").map(([k2]) => k2);
+        const unknown = Object.entries(sc.moduleCoverage).filter(([, v]) => v.status === "unknown").map(([k2]) => k2);
+        if (affected.length > 0) lines.push(`Affected: ${affected.join(", ")}`);
+        if (reviewed.length > 0) lines.push(`Reviewed, not affected: ${reviewed.join(", ")}`);
+        if (unknown.length > 0) lines.push(`Unknown: ${unknown.join(", ")}`);
+      }
+    }
+    lines.push("");
+  }
   if (exp.domains.length > 0) {
     lines.push("## Domains");
     lines.push(`- ${exp.domains.join(", ")}`);
@@ -8628,6 +8875,17 @@ function renderExplanationHuman(exp) {
   }
   lines.push(`- Next step: ${exp.readiness.recommended_next_step.label}`);
   lines.push("");
+  if (exp.deliverySummary) {
+    const ds = exp.deliverySummary;
+    lines.push("## Delivery Summary");
+    lines.push(`- Completed Work Items: ${ds.completedWorkItems}`);
+    if (ds.archivedWorkItems > 0) lines.push(`- Archived Work Items: ${ds.archivedWorkItems}`);
+    lines.push(`- Active Work Items: ${ds.activeWorkItems}`);
+    if (ds.implementationCompleted > 0) lines.push(`- Implementation completed: ${ds.implementationCompleted}`);
+    if (ds.releaseBlocked > 0) lines.push(`- Release blocked: ${ds.releaseBlocked}`);
+    if (ds.releaseReady > 0) lines.push(`- Release ready: ${ds.releaseReady}`);
+    lines.push("");
+  }
   const rec = exp.nextStepRecommendation;
   const secondary = rec.secondary ?? [];
   const steps = secondary.length > 0 || /Delivery|Active|Maintenance/.test(rec.phase) ? [rec.label, ...secondary.map((s2) => s2.label)] : exp.suggestedNextSteps;
@@ -8662,6 +8920,10 @@ function renderExplanationHuman(exp) {
     if (!exp.isModuleRepo) {
       lines.push(`- roadmap: ${s.roadmap}`);
       lines.push(`- work-items: ${s.work_items}`);
+      if (exp.deliverySummary) {
+        lines.push(`- work-items completed: ${exp.deliverySummary.completedWorkItems}`);
+        lines.push(`- work-items active: ${exp.deliverySummary.activeWorkItems}`);
+      }
       lines.push(`- adapters: ${s.adapters.length > 0 ? s.adapters.join(", ") + " installed" : "none installed"}`);
     } else {
       lines.push("- roadmap: managed-by-core");
@@ -9709,6 +9971,49 @@ function firstParagraph2(body) {
   }
   return "";
 }
+var VALID_COVERAGE_STATUSES2 = /* @__PURE__ */ new Set(["affected", "reviewed-not-affected", "unknown", "not-applicable"]);
+function parseScopeMeta(data) {
+  const result = {};
+  const sc = data.scope_confidence;
+  if (sc && typeof sc === "object" && !Array.isArray(sc)) {
+    const obj = sc;
+    const level = String(obj.level ?? "");
+    if (["high", "medium", "low"].includes(level)) {
+      result.scope_confidence = { level, reasons: Array.isArray(obj.reasons) ? obj.reasons.map(String) : [] };
+    }
+  }
+  const mc = data.module_coverage;
+  if (mc && typeof mc === "object" && !Array.isArray(mc)) {
+    const parsed = {};
+    const unknowns = [];
+    for (const [id, val] of Object.entries(mc)) {
+      if (!val || typeof val !== "object" || Array.isArray(val)) continue;
+      const v = val;
+      const status = String(v.status ?? "");
+      if (!VALID_COVERAGE_STATUSES2.has(status)) continue;
+      parsed[id] = { status, ...v.reason ? { reason: String(v.reason) } : {} };
+      if (status === "unknown") unknowns.push(id);
+    }
+    if (Object.keys(parsed).length > 0) result.module_coverage = parsed;
+    if (unknowns.length > 0) result.scope_unknowns = unknowns;
+  }
+  const ia = data.impact_analysis;
+  if (ia && typeof ia === "object" && !Array.isArray(ia)) {
+    const surfaces = ia.surfaces;
+    if (surfaces && typeof surfaces === "object" && !Array.isArray(surfaces)) {
+      const parsed = {};
+      for (const [id, val] of Object.entries(surfaces)) {
+        if (!val || typeof val !== "object" || Array.isArray(val)) continue;
+        const v = val;
+        const status = String(v.status ?? "");
+        if (!VALID_COVERAGE_STATUSES2.has(status)) continue;
+        parsed[id] = { status, ...v.reason ? { reason: String(v.reason) } : {} };
+      }
+      if (Object.keys(parsed).length > 0) result.impact_analysis = parsed;
+    }
+  }
+  return result;
+}
 function listWorkItems(root) {
   const files = listFiles(root, "knowledge/delivery/work-items", ".md");
   const items = [];
@@ -9751,7 +10056,8 @@ function listWorkItems(root) {
       ...data.implemented_by ? { implemented_by: String(data.implemented_by) } : {},
       ...data.closed_by ? { closed_by: String(data.closed_by) } : {},
       ...Array.isArray(data.release_gates) && data.release_gates.length > 0 ? { release_gates: data.release_gates } : {},
-      ...Array.isArray(data.completion_exceptions) && data.completion_exceptions.length > 0 ? { completion_exceptions: data.completion_exceptions } : {}
+      ...Array.isArray(data.completion_exceptions) && data.completion_exceptions.length > 0 ? { completion_exceptions: data.completion_exceptions } : {},
+      ...parseScopeMeta(data)
     });
   }
   return items.sort((a2, b2) => a2.id.localeCompare(b2.id));
@@ -10173,6 +10479,16 @@ function projectStatus(root) {
       agents: "managed-by-core",
       skills: "managed-by-core"
     };
+  } else {
+    result.readiness = {
+      overall: explain.readiness?.overall ?? "unknown"
+    };
+  }
+  if (explain.deliverySummary) {
+    result.deliverySummary = explain.deliverySummary;
+  }
+  if (explain.scopeCoverage && Array.isArray(explain.scopeCoverage) && explain.scopeCoverage.length > 0) {
+    result.scopeCoverage = explain.scopeCoverage;
   }
   return ok(result);
 }
@@ -10876,20 +11192,29 @@ var OPERATING_RULES = [
   "Kaddo itself never calls an LLM and never runs git \u2014 every git action is the human\u2019s."
 ];
 function toContextWorkItem(a2) {
+  const lifecycle = lifecycleStateOf({ status: a2.status, filePath: a2.filePath });
+  const isHistorical = lifecycle === "completed" || lifecycle === "archived";
   const wi = {
     id: a2.id,
     type: a2.type,
     title: a2.title,
     status: a2.status,
-    lifecycle: lifecycleStateOf({ status: a2.status, filePath: a2.filePath }),
+    lifecycle,
     knowledgeLevel: a2.knowledgeLevel,
     domains: a2.domains,
     source: parseWorkItemSource(a2.rawFrontmatter)
   };
-  if (a2.implementationStatus) wi.implementationStatus = a2.implementationStatus;
-  if (a2.validationStatus) wi.validationStatus = a2.validationStatus;
-  if (a2.releaseStatus) wi.releaseStatus = a2.releaseStatus;
+  wi.implementationStatus = a2.implementationStatus || (isHistorical ? "not-assessed" : void 0);
+  wi.validationStatus = a2.validationStatus || (isHistorical ? "not-assessed" : void 0);
+  wi.releaseStatus = a2.releaseStatus || (isHistorical ? "not-assessed" : void 0);
   if (a2.affectedModules.length > 0) wi.affectedModules = a2.affectedModules;
+  if (a2.scopeConfidence) wi.scopeConfidence = a2.scopeConfidence;
+  if (a2.moduleCoverage) wi.moduleCoverage = a2.moduleCoverage;
+  if (a2.impactAnalysis) wi.impactAnalysis = a2.impactAnalysis;
+  if (a2.moduleCoverage) {
+    const unknowns = Object.entries(a2.moduleCoverage).filter(([, v]) => v.status === "unknown").map(([k2]) => k2);
+    if (unknowns.length > 0) wi.scopeUnknowns = unknowns;
+  }
   return wi;
 }
 function toContextArtifact(a2) {
@@ -10919,10 +11244,17 @@ function buildContextPack(dir, config, now = /* @__PURE__ */ new Date()) {
     missing.push("No roadmap baseline found.");
   }
   const allArtifacts = discoverKnowledge(dir);
-  const workItems = allArtifacts.filter(
-    (a2) => isDeliveryWorkItem(a2) && isActiveState(lifecycleStateOf({ status: a2.status, filePath: a2.filePath }))
+  const allWorkItemArtifacts = allArtifacts.filter((a2) => isDeliveryWorkItem(a2));
+  const workItems = allWorkItemArtifacts.filter(
+    (a2) => isActiveState(lifecycleStateOf({ status: a2.status, filePath: a2.filePath }))
+  );
+  const completedWorkItems = allWorkItemArtifacts.filter(
+    (a2) => lifecycleStateOf({ status: a2.status, filePath: a2.filePath }) === "completed"
   );
-  if (workItems.length === 0 && !moduleRepo) {
+  const archivedWorkItems = allWorkItemArtifacts.filter(
+    (a2) => lifecycleStateOf({ status: a2.status, filePath: a2.filePath }) === "archived"
+  );
+  if (allWorkItemArtifacts.length === 0 && !moduleRepo) {
     missing.push("No work items found.");
   }
   const state = config.project.state;
@@ -11037,6 +11369,10 @@ function buildContextPack(dir, config, now = /* @__PURE__ */ new Date()) {
       roadmapSummary,
       inventoryAvailable,
       workItems: workItems.map(toContextWorkItem),
+      activeWorkItems: workItems.map(toContextWorkItem),
+      completedWorkItems: completedWorkItems.map(toContextWorkItem),
+      archivedWorkItems: archivedWorkItems.map(toContextWorkItem),
+      allWorkItems: allWorkItemArtifacts.map(toContextWorkItem),
       artifacts: allArtifacts.filter((a2) => a2.codeGlobs.length > 0).map(toContextArtifact)
     },
     layers,
@@ -11053,6 +11389,30 @@ function buildContextPack(dir, config, now = /* @__PURE__ */ new Date()) {
       const compact = (a2) => ({ total: a2.total, installed: a2.total - a2.missing, outdated: a2.outdated, unknown_version: a2.unknown_version, modified: a2.modified });
       return { version: s.version, agents: compact(s.agents), skills: compact(s.skills) };
     })(),
+    workItemSummary: (() => {
+      const lc = (s) => allWorkItemArtifacts.filter(
+        (a2) => lifecycleStateOf({ status: a2.status, filePath: a2.filePath }) === s
+      ).length;
+      const draft = lc("draft");
+      const ready = lc("ready");
+      const inProgress = lc("in-progress");
+      const blocked = lc("blocked");
+      const completed = lc("completed");
+      const archived = lc("archived");
+      const active = draft + ready + inProgress + blocked;
+      const total = allWorkItemArtifacts.length;
+      let summary = "none";
+      if (total === 0) summary = "none";
+      else if (active === 0 && completed > 0 && archived === 0) summary = "completed-only";
+      else if (active === 0 && archived > 0 && completed === 0) summary = "archived-only";
+      else if (active === 0 && completed + archived > 0) summary = "historical-only";
+      else if (inProgress > 0) summary = "active";
+      else if (blocked > 0 && ready === 0 && inProgress === 0) summary = "blocked";
+      else if (ready > 0) summary = "ready";
+      else if (draft > 0 && ready === 0) summary = "draft-only";
+      else summary = "mixed-active";
+      return { total, active, draft, ready, in_progress: inProgress, blocked, completed, archived, summary };
+    })(),
     deliveryMix,
     external: loadExternalCapsules(dir),
     graph: loadGraphSummary(dir),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaddo/mcp",
-  "version": "3.66.0",
+  "version": "3.68.0",
   "description": "MCP server for Kaddo project knowledge: read-only resources/tools/prompts plus safe derived generation under .kaddo/.",
   "license": "MIT",
   "repository": {