@kaddo/cli 3.74.0 → 3.75.0

package/dist/core.js

@@ -3686,9 +3686,6 @@ var RECOMMENDED_SKILLS = [...SKILL_GROUPS.delivery, ...SKILL_GROUPS.tech];
 function skillInstallPath(id) {
   return `knowledge/skills/${id}/skill.md`;
 }
-function skillById(id) {
-  return SKILLS.find((s) => s.id === id);
-}
 
 // src/agents/responsibility.ts
 var RESPONSIBILITY_MATRIX = {
@@ -7456,6 +7453,17 @@ function analyzeCrossRepoEvidence(input) {
 
 // src/core/work-items.ts
 import matter6 from "gray-matter";
+function computeRefinementStatus(wi) {
+  const aspects = {
+    outcome: Boolean(wi.currentBehavior?.trim() || wi.targetBehavior?.trim()),
+    journey: Boolean(wi.entryPoints?.trim() || wi.endToEndFlow?.trim()),
+    modules: wi.affectedModules.length > 0 || wi.moduleCoverage.length > 0,
+    impact: wi.impactAnalysis.length > 0,
+    acceptance: wi.acceptanceCriteria.length > 0
+  };
+  const refined = aspects.outcome && aspects.modules && aspects.acceptance;
+  return { status: refined ? "refined" : "needs-refinement", aspects };
+}
 var WorkItemNotFoundError = class extends Error {
   constructor(workItemId) {
     super(`Work Item "${workItemId}" was not found.`);
@@ -7531,8 +7539,9 @@ function getWorkItem(dir, workItemId) {
   const fm = match.rawFrontmatter;
   const knowledge = discoverKnowledge(dir).filter((a) => !a.isWorkItem);
   const knowledgeById = new Map(knowledge.filter((k) => k.id).map((k) => [k.id, k]));
-  return {
+  const detail = {
     ...base,
+    summary: match.summary?.trim() || null,
     actor: sectionText(sections, ["actor"]),
     outcome: sectionText(sections, ["actor and outcome", "outcome", "expected result"]),
     currentBehavior: sectionText(sections, ["current behavior", "current behaviour"]),
@@ -7552,6 +7561,7 @@ function getWorkItem(dir, workItemId) {
     source: parseWorkItemSource(fm),
     path: match.relPath
   };
+  return { ...detail, refinement: computeRefinementStatus(detail) };
 }
 function readBody(filePath) {
   try {
@@ -7724,6 +7734,194 @@ import fs2 from "fs";
 import path2 from "path";
 import crypto from "crypto";
 import matter7 from "gray-matter";
+
+// src/core/knowledge-levels.ts
+var WORK_ITEM_TYPES2 = ["feature", "bugfix", "hotfix", "spike", "chore"];
+var TYPE_ALIASES = {
+  setup: "chore",
+  maintenance: "chore",
+  tooling: "chore",
+  infrastructure: "chore",
+  infra: "chore",
+  config: "chore",
+  configuration: "chore",
+  refactor: "chore"
+};
+var LEVELS = {
+  K0: {
+    level: "K0",
+    description: "Trivial change. No formal knowledge required.",
+    questions: [],
+    qualityGate: []
+  },
+  K1: {
+    level: "K1",
+    description: "Simple fix or hotfix.",
+    questions: [
+      {
+        id: "problem",
+        prompt: "What problem does this fix?",
+        placeholder: "e.g. Button is not clickable on mobile",
+        frontMatterField: "problem",
+        required: true
+      },
+      {
+        id: "expected_result",
+        prompt: "What is the expected result after the fix?",
+        placeholder: "e.g. Button works correctly on all screen sizes",
+        frontMatterField: "expected_result",
+        required: true
+      }
+    ],
+    qualityGate: ["Problem is clear.", "Expected result is defined."]
+  },
+  K2: {
+    level: "K2",
+    description: "Feature or bugfix with functional impact.",
+    questions: [
+      {
+        id: "problem",
+        prompt: "What problem does this solve?",
+        placeholder: "e.g. Users cannot complete checkout without email verification",
+        frontMatterField: "problem",
+        required: true
+      },
+      {
+        id: "expected_result",
+        prompt: "What is the expected result?",
+        placeholder: "e.g. Users can verify email inline during checkout",
+        frontMatterField: "expected_result",
+        required: true
+      },
+      {
+        id: "impact",
+        prompt: "What is the impact if this is not done?",
+        placeholder: "e.g. ~30% of users drop off at checkout",
+        frontMatterField: "impact",
+        required: true
+      },
+      {
+        id: "acceptance_criteria",
+        prompt: "What are the acceptance criteria? (one per line, press Enter twice to finish)",
+        placeholder: "e.g. Email is verified before payment step",
+        frontMatterField: "acceptance_criteria",
+        required: true
+      }
+    ],
+    qualityGate: [
+      "Problem is clear.",
+      "Expected result is defined.",
+      "Impact of not doing it is stated.",
+      "Acceptance criteria are verifiable."
+    ]
+  },
+  K3: {
+    level: "K3",
+    description: "Capability, integration, or significant functional change.",
+    questions: [
+      {
+        id: "problem",
+        prompt: "What problem does this solve?",
+        placeholder: "e.g. Payments need to support multiple providers",
+        frontMatterField: "problem",
+        required: true
+      },
+      {
+        id: "impact",
+        prompt: "What is the impact if this is not done?",
+        placeholder: "e.g. We are locked into a single provider with no fallback",
+        frontMatterField: "impact",
+        required: true
+      },
+      {
+        id: "acceptance_criteria",
+        prompt: "What are the acceptance criteria?",
+        placeholder: "e.g. System routes to provider B when provider A fails",
+        frontMatterField: "acceptance_criteria",
+        required: true
+      },
+      {
+        id: "design",
+        prompt: "What is the proposed design or approach?",
+        placeholder: "e.g. Abstract provider interface + strategy pattern",
+        frontMatterField: "design",
+        required: true
+      }
+    ],
+    qualityGate: [
+      "Problem is clear.",
+      "Impact is stated.",
+      "Acceptance criteria are verifiable.",
+      "Design is sufficient to start."
+    ]
+  },
+  K4: {
+    level: "K4",
+    description: "Architecture change, migration, or high-risk decision.",
+    questions: [
+      {
+        id: "problem",
+        prompt: "What problem does this solve?",
+        placeholder: "e.g. Current auth system does not support SSO",
+        frontMatterField: "problem",
+        required: true
+      },
+      {
+        id: "impact",
+        prompt: "What is the impact if this is not done?",
+        placeholder: "e.g. Enterprise clients cannot onboard",
+        frontMatterField: "impact",
+        required: true
+      },
+      {
+        id: "design",
+        prompt: "What is the proposed design or approach?",
+        placeholder: "e.g. Replace JWT-only auth with OIDC + JWT hybrid",
+        frontMatterField: "design",
+        required: true
+      },
+      {
+        id: "risks",
+        prompt: "What are the main risks?",
+        placeholder: "e.g. Existing sessions may be invalidated during migration",
+        frontMatterField: "risks",
+        required: true
+      }
+    ],
+    qualityGate: [
+      "Problem is clear.",
+      "Impact is stated.",
+      "Design is documented.",
+      "Risks are identified.",
+      "ADR is created or linked if applicable."
+    ]
+  }
+};
+var TYPE_TO_LEVEL = {
+  hotfix: "K1",
+  bugfix: "K2",
+  feature: "K2",
+  spike: "K3",
+  // Chores are maintenance/config/tooling work — low ceremony (problem + expected result).
+  chore: "K1"
+};
+function getLevel(level) {
+  return LEVELS[level];
+}
+function getLevelForType(type) {
+  return TYPE_TO_LEVEL[type];
+}
+function isValidType(type) {
+  return WORK_ITEM_TYPES2.includes(type);
+}
+function normalizeType(raw) {
+  if (!raw) return null;
+  const t = raw.trim().toLowerCase();
+  if (isValidType(t)) return t;
+  return TYPE_ALIASES[t] ?? null;
+}
+
+// src/core/work-item-write.ts
 var WORK_ITEMS_DIR = "knowledge/delivery/work-items";
 var WorkItemWriteError = class extends Error {
   constructor(code, message) {
@@ -8032,8 +8230,8 @@ function captureBody(title, type, answers) {
 function createWorkItem(dir, opts) {
   const intent = opts.intent.trim();
   if (!intent) throw new WorkItemWriteError("INVALID_INPUT", "An intent or summary is required.");
-  const type = opts.type.trim() || "feature";
-  if (!WORK_ITEM_TYPES.has(type)) throw new WorkItemWriteError("INVALID_INPUT", `Unknown Work Item type "${type}".`);
+  const type = normalizeType(opts.type.trim()) ?? "";
+  if (!type) throw new WorkItemWriteError("INVALID_INPUT", `Unknown Work Item type "${opts.type}".`);
   const id = nextWorkItemId(dir);
   const title = intent.split(/\r?\n/)[0].trim().slice(0, 120);
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -8073,7 +8271,7 @@ function createWorkItem(dir, opts) {
 }
 function validateInput(input) {
   if (!input.title.trim()) throw new WorkItemWriteError("INVALID_INPUT", "Title is required.");
-  if (!WORK_ITEM_TYPES.has(input.type)) throw new WorkItemWriteError("INVALID_INPUT", `Unknown Work Item type "${input.type}".`);
+  if (!isValidType(input.type)) throw new WorkItemWriteError("INVALID_INPUT", `Unknown Work Item type "${input.type}".`);
 }
 function updateWorkItem(dir, id, input, expectedRevision) {
   validateInput(input);
@@ -8152,173 +8350,6 @@ function transitionWorkItem(dir, id, to, expectedRevision) {
   return { revision: revisionOf(nextRaw), status: to, path: targetRel };
 }
 
-// src/core/knowledge-levels.ts
-var WORK_ITEM_TYPES2 = ["feature", "bugfix", "hotfix", "spike", "chore"];
-var LEVELS = {
-  K0: {
-    level: "K0",
-    description: "Trivial change. No formal knowledge required.",
-    questions: [],
-    qualityGate: []
-  },
-  K1: {
-    level: "K1",
-    description: "Simple fix or hotfix.",
-    questions: [
-      {
-        id: "problem",
-        prompt: "What problem does this fix?",
-        placeholder: "e.g. Button is not clickable on mobile",
-        frontMatterField: "problem",
-        required: true
-      },
-      {
-        id: "expected_result",
-        prompt: "What is the expected result after the fix?",
-        placeholder: "e.g. Button works correctly on all screen sizes",
-        frontMatterField: "expected_result",
-        required: true
-      }
-    ],
-    qualityGate: ["Problem is clear.", "Expected result is defined."]
-  },
-  K2: {
-    level: "K2",
-    description: "Feature or bugfix with functional impact.",
-    questions: [
-      {
-        id: "problem",
-        prompt: "What problem does this solve?",
-        placeholder: "e.g. Users cannot complete checkout without email verification",
-        frontMatterField: "problem",
-        required: true
-      },
-      {
-        id: "expected_result",
-        prompt: "What is the expected result?",
-        placeholder: "e.g. Users can verify email inline during checkout",
-        frontMatterField: "expected_result",
-        required: true
-      },
-      {
-        id: "impact",
-        prompt: "What is the impact if this is not done?",
-        placeholder: "e.g. ~30% of users drop off at checkout",
-        frontMatterField: "impact",
-        required: true
-      },
-      {
-        id: "acceptance_criteria",
-        prompt: "What are the acceptance criteria? (one per line, press Enter twice to finish)",
-        placeholder: "e.g. Email is verified before payment step",
-        frontMatterField: "acceptance_criteria",
-        required: true
-      }
-    ],
-    qualityGate: [
-      "Problem is clear.",
-      "Expected result is defined.",
-      "Impact of not doing it is stated.",
-      "Acceptance criteria are verifiable."
-    ]
-  },
-  K3: {
-    level: "K3",
-    description: "Capability, integration, or significant functional change.",
-    questions: [
-      {
-        id: "problem",
-        prompt: "What problem does this solve?",
-        placeholder: "e.g. Payments need to support multiple providers",
-        frontMatterField: "problem",
-        required: true
-      },
-      {
-        id: "impact",
-        prompt: "What is the impact if this is not done?",
-        placeholder: "e.g. We are locked into a single provider with no fallback",
-        frontMatterField: "impact",
-        required: true
-      },
-      {
-        id: "acceptance_criteria",
-        prompt: "What are the acceptance criteria?",
-        placeholder: "e.g. System routes to provider B when provider A fails",
-        frontMatterField: "acceptance_criteria",
-        required: true
-      },
-      {
-        id: "design",
-        prompt: "What is the proposed design or approach?",
-        placeholder: "e.g. Abstract provider interface + strategy pattern",
-        frontMatterField: "design",
-        required: true
-      }
-    ],
-    qualityGate: [
-      "Problem is clear.",
-      "Impact is stated.",
-      "Acceptance criteria are verifiable.",
-      "Design is sufficient to start."
-    ]
-  },
-  K4: {
-    level: "K4",
-    description: "Architecture change, migration, or high-risk decision.",
-    questions: [
-      {
-        id: "problem",
-        prompt: "What problem does this solve?",
-        placeholder: "e.g. Current auth system does not support SSO",
-        frontMatterField: "problem",
-        required: true
-      },
-      {
-        id: "impact",
-        prompt: "What is the impact if this is not done?",
-        placeholder: "e.g. Enterprise clients cannot onboard",
-        frontMatterField: "impact",
-        required: true
-      },
-      {
-        id: "design",
-        prompt: "What is the proposed design or approach?",
-        placeholder: "e.g. Replace JWT-only auth with OIDC + JWT hybrid",
-        frontMatterField: "design",
-        required: true
-      },
-      {
-        id: "risks",
-        prompt: "What are the main risks?",
-        placeholder: "e.g. Existing sessions may be invalidated during migration",
-        frontMatterField: "risks",
-        required: true
-      }
-    ],
-    qualityGate: [
-      "Problem is clear.",
-      "Impact is stated.",
-      "Design is documented.",
-      "Risks are identified.",
-      "ADR is created or linked if applicable."
-    ]
-  }
-};
-var TYPE_TO_LEVEL = {
-  hotfix: "K1",
-  bugfix: "K2",
-  feature: "K2",
-  spike: "K3",
-  // Chores are maintenance/config/tooling work — low ceremony (problem + expected result).
-  chore: "K1"
-};
-function getLevel(level) {
-  return LEVELS[level];
-}
-function getLevelForType(type) {
-  return TYPE_TO_LEVEL[type];
-}
-
 // src/core/work-item-refinement.ts
 function toCapture(q) {
   return { id: q.id, prompt: q.prompt, placeholder: q.placeholder, field: q.frontMatterField, required: q.required };
@@ -8333,140 +8364,70 @@ function getWorkItemCaptureDefinition() {
     questions
   };
 }
-function getWorkItemAgentAssets() {
-  const agent = AGENT_PROMPTS.find((p2) => p2.fileName === "work-item-agent.md");
-  const skill2 = skillById("work-item-refinement");
-  return { agentPrompt: agent?.content ?? "", skill: skill2?.content ?? null };
-}
-function assembleRefinementContext(dir, workItemId) {
-  const edit = getWorkItemForEdit(dir, workItemId);
+var RECOMMENDED_AGENT = "work-item-agent";
+var RECOMMENDED_SKILL = "work-item-refinement";
+function buildRefinementHandoff(dir, workItemId) {
+  const wi = getWorkItem(dir, workItemId);
   const config = loadConfig(dir);
-  const knowledgeArtifacts = discoverKnowledge(dir).filter(
-    (a) => !a.isWorkItem && a.type !== "skill" && a.type !== "agent" && a.layer !== "unknown"
+  const projectName = config?.project.name ?? "this project";
+  const mappedModules = loadMappedModules(dir).map((m) => m.id);
+  const multirepo = mappedModules.length > 0;
+  const lines = [
+    `Refine Work Item ${wi.id} \u2014 "${wi.title}" \u2014 in project "${projectName}" using Kaddo.`,
+    "",
+    "Use a Kaddo-enabled agent with access to this repository. Drive the refinement with the",
+    `canonical ${RECOMMENDED_AGENT} and the ${RECOMMENDED_SKILL} skill (via Kaddo MCP or skills).`,
+    "",
+    "Inspect the actual implementation before defining scope \u2014 do not guess affected modules from",
+    "the Work Item title. Read the current behavior in the code first, then classify."
+  ];
+  if (multirepo) {
+    lines.push(
+      "",
+      `This is a multirepo project. Evaluate the scope across all relevant mapped modules (${mappedModules.join(", ")})`,
+      "before finalizing affected_modules and module_coverage."
+    );
+  }
+  lines.push(
+    "",
+    `Update the canonical Work Item ${wi.id} with:`,
+    "- current and target behavior;",
+    "- the end-to-end flow (journey);",
+    "- affected modules;",
+    "- module coverage;",
+    "- impact analysis across the relevant surfaces;",
+    "- scope confidence and open unknowns;",
+    "- acceptance criteria;",
+    "- relevant Knowledge / ADR relationships.",
+    "",
+    "Do not implement the Work Item. Do not run mutating Git operations."
   );
-  const decisions = knowledgeArtifacts.filter((a) => a.type === "adr" || /^adr-/i.test(a.id)).map((a) => ({ id: a.id, title: a.title || a.id }));
-  const knowledge = knowledgeArtifacts.filter((a) => !(a.type === "adr" || /^adr-/i.test(a.id))).map((a) => ({ id: a.id || a.relPath, title: a.title || a.id, layer: a.layer, type: a.type || void 0, summary: a.summary || void 0 }));
-  const modules = ["core", ...loadMappedModules(dir).map((m) => m.id)].filter((v, i, arr) => arr.indexOf(v) === i);
   return {
-    workItem: { id: edit.id, title: edit.title, status: edit.status, intent: edit.summary ?? edit.title, current: stripEdit(edit) },
-    project: { name: config?.project.name ?? "unknown", state: config?.project.state ?? "unknown", structure: config?.project.structure ?? "unknown" },
-    modules,
-    knowledge,
-    decisions,
-    revision: edit.revision
+    workItemId: wi.id,
+    title: wi.title,
+    projectName,
+    refinement: wi.refinement,
+    recommendedAgent: RECOMMENDED_AGENT,
+    recommendedSkill: RECOMMENDED_SKILL,
+    text: lines.join("\n")
   };
 }
-function stripEdit(edit) {
-  const { id: _i, status: _s, revision: _r, path: _p, editable: _e, editableReason: _er, ...input } = edit;
-  return input;
-}
-var VALID_COVERAGE2 = /* @__PURE__ */ new Set(["affected", "reviewed-not-affected", "unknown", "not-applicable"]);
-var VALID_CONFIDENCE2 = /* @__PURE__ */ new Set(["high", "medium", "low"]);
-function str(v) {
-  return typeof v === "string" && v.trim() ? v.trim() : void 0;
-}
-function strList(v) {
-  return Array.isArray(v) ? v.map((x) => typeof x === "string" ? x.trim() : "").filter(Boolean) : [];
-}
-function normalizeAndValidateProposal(dir, workItemId, proposal) {
-  const ctx = assembleRefinementContext(dir, workItemId);
-  const knownModules = new Set(ctx.modules);
-  const knownDecisions = new Set(ctx.decisions.map((d) => d.id));
-  const knownKnowledge = new Set(ctx.knowledge.map((k) => k.id));
-  const extraFindings = [];
-  const input = { ...ctx.workItem.current };
-  if (str(proposal.title)) input.title = str(proposal.title);
-  const o = proposal.outcome ?? {};
-  if (str(o.actor) !== void 0) input.actor = str(o.actor);
-  if (str(o.observableOutcome) !== void 0) input.outcome = str(o.observableOutcome);
-  if (str(o.currentBehavior) !== void 0) input.currentBehavior = str(o.currentBehavior);
-  if (str(o.targetBehavior) !== void 0) input.targetBehavior = str(o.targetBehavior);
-  const j = proposal.journey ?? {};
-  if (j.entryPoints) input.entryPoints = strList(j.entryPoints).join("\n");
-  if (j.flow) input.endToEndFlow = strList(j.flow).map((s) => `- ${s}`).join("\n");
-  if (proposal.moduleCoverage) {
-    input.moduleCoverage = proposal.moduleCoverage.filter((c) => {
-      if (!knownModules.has(c.id)) {
-        extraFindings.push({ level: "warning", message: `Proposed module "${c.id}" is not registered and was not included.` });
-        return false;
-      }
-      return VALID_COVERAGE2.has(c.status);
-    }).map((c) => ({ id: c.id, status: c.status, ...str(c.reason) ? { reason: str(c.reason) } : {} }));
-  }
-  const affected = /* @__PURE__ */ new Set();
-  for (const m of proposal.affectedModules ?? []) if (knownModules.has(m)) affected.add(m);
-  for (const c of input.moduleCoverage) if (c.status === "affected") affected.add(c.id);
-  if (proposal.affectedModules || proposal.moduleCoverage) input.affectedModules = [...affected];
-  if (proposal.impactAnalysis) {
-    input.impactAnalysis = proposal.impactAnalysis.filter((s) => VALID_COVERAGE2.has(s.status) && str(s.surface)).map((s) => ({ surface: str(s.surface), status: s.status, ...str(s.reason) ? { reason: str(s.reason) } : {}, ...str(s.question) ? { question: str(s.question) } : {} }));
-  }
-  if (proposal.scopeConfidence && VALID_CONFIDENCE2.has(proposal.scopeConfidence.level)) {
-    input.scopeConfidence = { level: proposal.scopeConfidence.level, reasons: strList(proposal.scopeConfidence.reasons) };
-  }
-  if (proposal.scopeUnknowns) input.scopeUnknowns = strList(proposal.scopeUnknowns);
-  if (proposal.acceptanceCriteria) input.acceptanceCriteria = strList(proposal.acceptanceCriteria).map((t) => ({ text: t, checked: null }));
-  if (proposal.linkedDecisions) {
-    input.decisions = proposal.linkedDecisions.filter((id) => {
-      if (!knownDecisions.has(id)) {
-        extraFindings.push({ level: "warning", message: `Proposed decision "${id}" does not exist and was not linked.` });
-        return false;
-      }
-      return true;
-    });
-  }
-  if (proposal.relatedKnowledge) {
-    input.relatedKnowledge = proposal.relatedKnowledge.filter((id) => {
-      if (!knownKnowledge.has(id)) {
-        extraFindings.push({ level: "warning", message: `Proposed knowledge "${id}" could not be resolved and was not linked.` });
-        return false;
-      }
-      return true;
-    });
-  }
-  const findings = [...extraFindings, ...evaluate(input, knownModules)];
-  const blocking = findings.filter((f) => f.level === "blocking").length;
-  const warning = findings.filter((f) => f.level === "warning").length;
-  const fyi = findings.filter((f) => f.level === "fyi").length;
-  return { input, validation: { findings, blocking, warning, fyi, canApply: true } };
-}
-function evaluate(input, knownModules) {
-  const findings = [];
-  for (const c of input.moduleCoverage) {
-    if (c.status === "affected" && !input.affectedModules.includes(c.id)) {
-      findings.push({ level: "blocking", message: `${c.id} is marked affected in module coverage but is missing from affected_modules.` });
-    }
-  }
-  for (const m of input.affectedModules) {
-    if (!knownModules.has(m)) findings.push({ level: "blocking", message: `Module "${m}" is not registered in this project.` });
-  }
-  if (!input.targetBehavior?.trim()) findings.push({ level: "warning", message: "Target behavior is not defined." });
-  if (input.acceptanceCriteria.length === 0) findings.push({ level: "warning", message: "No acceptance criteria have been defined." });
-  if (input.scopeConfidence?.level === "low") findings.push({ level: "warning", message: "Scope confidence is Low." });
-  if (!input.scopeConfidence) findings.push({ level: "warning", message: "Scope confidence has not been assessed." });
-  for (const s of input.impactAnalysis) if (s.status === "unknown") findings.push({ level: "fyi", message: `Impact on ${s.surface} is unknown.` });
-  return findings;
-}
-function applyRefinement(dir, workItemId, proposal, expectedRevision) {
-  const { input } = normalizeAndValidateProposal(dir, workItemId, proposal);
-  return updateWorkItem(dir, workItemId, input, expectedRevision);
-}
 export {
   WorkItemNotFoundError,
   WorkItemWriteError,
   analyzeCrossRepoEvidence,
   analyzeScopeCoverage,
-  applyRefinement,
-  assembleRefinementContext,
   buildProjectExplanation,
   buildProjectRoute,
   buildReadinessReport,
+  buildRefinementHandoff,
+  computeRefinementStatus,
   createWorkItem,
   cwd,
   discoverKnowledge,
   discoverWorkItems,
   exists,
   getWorkItem,
-  getWorkItemAgentAssets,
   getWorkItemCaptureDefinition,
   getWorkItemForEdit,
   getWorkItems,
@@ -8479,7 +8440,6 @@ export {
   lifecycleStateOf,
   loadConfig,
   loadMappedModules,
-  normalizeAndValidateProposal,
   readFile,
   transitionWorkItem,
   updateWorkItem,

package/package.json

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