npm - @kaddo/cli - Versions diffs - 3.74.1 → 3.75.0 - Mend

@kaddo/cli 3.74.1 → 3.75.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/admin-dist/assets/{index-AAaxSvT4.js → index-BpOMKXrf.js} +20 -20
package/dist/admin-dist/index.html +1 -1
package/dist/admin-server/index.js +19 -325
package/dist/core.js +59 -120
package/package.json +1 -1

package/dist/admin-dist/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>admin</title>
-    <script type="module" crossorigin src="/assets/index-AAaxSvT4.js"></script>
+    <script type="module" crossorigin src="/assets/index-BpOMKXrf.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BPt-9--k.css">
   </head>
   <body>

package/dist/admin-server/index.js CHANGED Viewed

@@ -67,6 +67,7 @@ import {
   validateWorkItem as coreValidateWorkItem,
   transitionWorkItem as coreTransitionWorkItem,
   getWorkItemCaptureDefinition as coreGetCaptureDefinition,
+  buildRefinementHandoff as coreBuildRefinementHandoff,
   WorkItemWriteError,
   exists,
   join,
@@ -128,11 +129,20 @@ function assertValidWorkItemId(workItemId) {
 }
 function mapWriteError(err) {
   if (err instanceof WorkItemWriteError) throw new CoreError(err.code, err.message);
+  if (err instanceof WorkItemNotFoundError) throw new CoreError("WORK_ITEM_NOT_FOUND", "This Work Item does not exist in the current project.");
   throw err;
 }
 function getCaptureDefinition() {
   return coreGetCaptureDefinition();
 }
+function getRefinementHandoff(dir, workItemId) {
+  assertValidWorkItemId(workItemId);
+  try {
+    return coreBuildRefinementHandoff(dir, workItemId);
+  } catch (err) {
+    mapWriteError(err);
+  }
+}
 function createWorkItemAdmin(dir, body) {
   try {
     const res = coreCreateWorkItem(dir, { intent: body.intent, type: body.type, answers: body.answers });
@@ -490,6 +500,7 @@ var LinkedDecisionSchema = z.object({
 });
 var LinkedKnowledgeSchema = z.object({ id: z.string(), title: z.string(), layer: z.string() });
 var WorkItemDetailSchema = WorkItemListItemSchema.extend({
+  summary: z.string().nullable(),
   actor: z.string().nullable(),
   outcome: z.string().nullable(),
   currentBehavior: z.string().nullable(),
@@ -507,7 +518,11 @@ var WorkItemDetailSchema = WorkItemListItemSchema.extend({
   decisions: z.array(LinkedDecisionSchema),
   relatedKnowledge: z.array(LinkedKnowledgeSchema),
   source: z.object({ type: z.string(), id: z.string().optional(), inferred: z.boolean() }).passthrough(),
-  path: z.string()
+  path: z.string(),
+  refinement: z.object({
+    status: z.enum(["needs-refinement", "refined"]),
+    aspects: z.object({ outcome: z.boolean(), journey: z.boolean(), modules: z.boolean(), impact: z.boolean(), acceptance: z.boolean() })
+  })
 });
 var WorkItemInputSchema = z.object({
   title: z.string(),
@@ -562,14 +577,6 @@ var WorkItemCreateWithAnswersSchema = z.object({
   type: z.string().min(1),
   answers: z.record(z.string(), z.string()).optional()
 });
-var RefinementFeedbackSchema = z.object({
-  refinementId: z.string().min(1),
-  feedback: z.string().min(1)
-});
-var RefinementApplySchema = z.object({
-  refinementId: z.string().min(1),
-  expectedRevision: z.string().min(1)
-});
 var ErrorResponseSchema = z.object({
   error: z.object({
     code: z.string(),
@@ -577,303 +584,11 @@ var ErrorResponseSchema = z.object({
   })
 });
-// src/refinement/service.ts
-import crypto from "crypto";
-import {
-  assembleRefinementContext,
-  getWorkItemAgentAssets,
-  normalizeAndValidateProposal,
-  applyRefinement,
-  WorkItemWriteError as WorkItemWriteError2
-} from "@kaddo/cli/core";
-// src/refinement/provider.ts
-var RefinementProviderError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "RefinementProviderError";
-    this.code = code;
-  }
-};
-// src/refinement/service.ts
-var MAX_REPAIR_ATTEMPTS = 2;
-var DEFAULT_TIMEOUT_MS = 6e4;
-var RefinementService = class {
-  constructor(provider, timeoutMs = DEFAULT_TIMEOUT_MS) {
-    this.provider = provider;
-    this.timeoutMs = timeoutMs;
-  }
-  provider;
-  timeoutMs;
-  sessions = /* @__PURE__ */ new Map();
-  view(s) {
-    return { ...s };
-  }
-  async run(dir, workItemId, feedback, previous) {
-    const context = assembleRefinementContext(dir, workItemId);
-    if (context.workItem.status !== "draft") {
-      throw new RefinementProviderError("WORK_ITEM_NOT_EDITABLE", `A ${context.workItem.status} Work Item cannot be refined. Reopen it as Draft first.`);
-    }
-    const assets = getWorkItemAgentAssets();
-    const request = { context, assets, intent: context.workItem.intent, previousProposal: previous, feedback };
-    let lastErr;
-    for (let attempt = 0; attempt <= MAX_REPAIR_ATTEMPTS; attempt++) {
-      const ac = new AbortController();
-      const timer = setTimeout(() => ac.abort(), this.timeoutMs);
-      try {
-        const result = await this.provider.refine(request, ac.signal);
-        const { validation } = normalizeAndValidateProposal(dir, workItemId, result.proposal);
-        const contextUsed = context.knowledge.map((k) => ({ id: k.id, title: k.title, layer: k.layer }));
-        return { context, proposal: result.proposal, validation, contextUsed, meta: { ...result.meta, repairAttempts: attempt } };
-      } catch (err) {
-        lastErr = err;
-        if (!(err instanceof RefinementProviderError && err.code === "INVALID_RESPONSE")) break;
-      } finally {
-        clearTimeout(timer);
-      }
-    }
-    throw lastErr instanceof Error ? lastErr : new RefinementProviderError("PROVIDER_ERROR", "Refinement failed.");
-  }
-  async start(dir, workItemId) {
-    const { context, proposal, validation, contextUsed, meta } = await this.run(dir, workItemId);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const session = {
-      refinementId: `ref_${crypto.randomBytes(8).toString("hex")}`,
-      workItemId,
-      sourceRevision: context.revision,
-      status: "ready-for-review",
-      intent: context.workItem.intent,
-      proposal,
-      validation,
-      contextUsed,
-      meta,
-      createdAt: now,
-      updatedAt: now
-    };
-    this.sessions.set(session.refinementId, session);
-    return this.view(session);
-  }
-  async feedback(dir, workItemId, refinementId, feedback) {
-    const session = this.get(refinementId, workItemId);
-    const { context, proposal, validation, contextUsed, meta } = await this.run(dir, workItemId, feedback, session.proposal);
-    session.sourceRevision = context.revision;
-    session.status = "ready-for-review";
-    session.proposal = proposal;
-    session.validation = validation;
-    session.contextUsed = contextUsed;
-    session.meta = meta;
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return this.view(session);
-  }
-  apply(dir, workItemId, refinementId, expectedRevision) {
-    const session = this.get(refinementId, workItemId);
-    const current = assembleRefinementContext(dir, workItemId);
-    if (current.revision !== session.sourceRevision || expectedRevision !== session.sourceRevision) {
-      session.status = "stale";
-      throw new RefinementProviderError("WORK_ITEM_CONFLICT", "This Work Item changed while the refinement was running. The proposal has not been applied.");
-    }
-    let res;
-    try {
-      res = applyRefinement(dir, workItemId, session.proposal, session.sourceRevision);
-    } catch (err) {
-      if (err instanceof WorkItemWriteError2) throw new RefinementProviderError(err.code, err.message);
-      throw err;
-    }
-    session.status = "applied";
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return { id: workItemId, path: res.path, revision: res.revision, status: "draft" };
-  }
-  get(refinementId, workItemId) {
-    const s = this.sessions.get(refinementId);
-    if (!s || s.workItemId !== workItemId) throw new RefinementProviderError("REFINEMENT_NOT_FOUND", "Refinement session not found.");
-    return s;
-  }
-};
-// src/refinement/heuristic-provider.ts
-function firstSentence(s) {
-  const m = s.trim().match(/^(.*?[.!?])(\s|$)/);
-  return (m ? m[1] : s.trim()).trim();
-}
-function mentionsNegation(feedback, module) {
-  const re = new RegExp(`(not|no)\\b[^.]*\\b${module}\\b|\\b${module}\\b[^.]*(not affected|no afecta|reviewed)`, "i");
-  return re.test(feedback);
-}
-var HeuristicRefinementProvider = class {
-  name = "heuristic";
-  async refine(request) {
-    const start = Date.now();
-    const { context, intent, previousProposal, feedback } = request;
-    const modules = context.modules;
-    const affected = new Set(previousProposal?.affectedModules ?? ["core"]);
-    if (feedback) {
-      for (const m of modules) {
-        if (new RegExp(`\\b${m}\\b`, "i").test(feedback)) {
-          if (mentionsNegation(feedback, m)) affected.delete(m);
-          else affected.add(m);
-        }
-      }
-    }
-    const affectedModules = modules.filter((m) => affected.has(m));
-    const moduleCoverage = modules.map(
-      (m) => affected.has(m) ? { id: m, status: "affected", reason: m === "core" ? "Backend behavior changes." : "User-facing change identified." } : { id: m, status: "unknown" }
-    );
-    const frontendAffected = affected.has("frontend");
-    const impactAnalysis = [
-      { surface: "backend", status: "affected" },
-      { surface: "frontend", status: frontendAffected ? "affected" : "unknown", ...frontendAffected ? {} : { question: "Is a user-facing surface involved?" } },
-      { surface: "database", status: "reviewed-not-affected" },
-      { surface: "feature-flags", status: "unknown", question: "Is this behavior controlled by a feature flag?" }
-    ];
-    const summary = firstSentence(intent);
-    const proposal = {
-      outcome: {
-        actor: "User",
-        observableOutcome: summary,
-        currentBehavior: `Today: ${summary.toLowerCase()} is not yet supported as described.`,
-        targetBehavior: summary
-      },
-      journey: {
-        entryPoints: [frontendAffected ? "Public entry point" : "Application entry point"],
-        flow: ["Entry point", "Application logic", "Persistence", "Result"]
-      },
-      affectedModules,
-      moduleCoverage,
-      impactAnalysis,
-      scopeConfidence: {
-        level: "medium",
-        reasons: ["Primary behavior identified from the intent.", "Feature flag ownership not yet confirmed."]
-      },
-      scopeUnknowns: ["Is this behavior controlled by a feature flag?"],
-      acceptanceCriteria: [
-        `${summary}`,
-        "The change is covered by the affected modules above."
-      ],
-      linkedDecisions: [],
-      relatedKnowledge: []
-    };
-    return { proposal, meta: { provider: this.name, durationMs: Date.now() - start, repairAttempts: 0 } };
-  }
-};
-// src/refinement/anthropic-provider.ts
-var API_URL = "https://api.anthropic.com/v1/messages";
-var SCHEMA_HINT = `Return ONLY a JSON object (no prose, no code fences) with this shape \u2014 omit fields you cannot determine:
-{
-  "title"?: string,
-  "outcome"?: { "actor"?: string, "observableOutcome"?: string, "currentBehavior"?: string, "targetBehavior"?: string },
-  "journey"?: { "entryPoints"?: string[], "flow"?: string[] },
-  "affectedModules"?: string[],
-  "moduleCoverage"?: [{ "id": string, "status": "affected"|"reviewed-not-affected"|"unknown"|"not-applicable", "reason"?: string }],
-  "impactAnalysis"?: [{ "surface": string, "status": "affected"|"reviewed-not-affected"|"unknown"|"not-applicable", "reason"?: string, "question"?: string }],
-  "scopeConfidence"?: { "level": "high"|"medium"|"low", "reasons"?: string[] },
-  "scopeUnknowns"?: string[],
-  "acceptanceCriteria"?: string[],
-  "linkedDecisions"?: string[],
-  "relatedKnowledge"?: string[]
-}
-Only reference module ids, decision ids and knowledge ids that appear in the provided context. Prefer "unknown" over inventing facts.`;
-function extractJson(text) {
-  const start = text.indexOf("{");
-  const end = text.lastIndexOf("}");
-  if (start < 0 || end <= start) throw new RefinementProviderError("INVALID_RESPONSE", "The model did not return a JSON proposal.");
-  try {
-    return JSON.parse(text.slice(start, end + 1));
-  } catch {
-    throw new RefinementProviderError("INVALID_RESPONSE", "The model returned a proposal that could not be parsed.");
-  }
-}
-var AnthropicRefinementProvider = class {
-  name = "anthropic";
-  apiKey;
-  model;
-  constructor(apiKey, model) {
-    this.apiKey = apiKey;
-    this.model = model;
-  }
-  async refine(request, signal) {
-    const start = Date.now();
-    const { context, assets, intent, previousProposal, feedback } = request;
-    const system = [
-      assets.agentPrompt,
-      assets.skill ?? "",
-      "# Output format",
-      SCHEMA_HINT
-    ].filter(Boolean).join("\n\n");
-    const userParts = [
-      `# Work Item intent
-${intent}`,
-      `# Project
-${JSON.stringify(context.project)}`,
-      `# Registered modules
-${context.modules.join(", ")}`,
-      `# Known decisions
-${context.decisions.map((d) => `${d.id} \u2014 ${d.title}`).join("\n") || "(none)"}`,
-      `# Knowledge
-${context.knowledge.map((k) => `${k.id} \u2014 ${k.title} (${k.layer})`).join("\n") || "(none)"}`,
-      `# Current Work Item model
-${JSON.stringify(context.workItem.current)}`
-    ];
-    if (previousProposal) userParts.push(`# Previous proposal
-${JSON.stringify(previousProposal)}`);
-    if (feedback) userParts.push(`# Human feedback (augments the original intent, does not replace it)
-${feedback}`);
-    let res;
-    try {
-      res = await fetch(API_URL, {
-        method: "POST",
-        signal,
-        headers: {
-          "content-type": "application/json",
-          "x-api-key": this.apiKey,
-          "anthropic-version": "2023-06-01"
-        },
-        body: JSON.stringify({
-          model: this.model,
-          max_tokens: 2048,
-          system,
-          messages: [{ role: "user", content: userParts.join("\n\n") }]
-        })
-      });
-    } catch (err) {
-      if (err.name === "AbortError") throw new RefinementProviderError("TIMEOUT", "The refinement timed out.");
-      throw new RefinementProviderError("PROVIDER_ERROR", "The refinement provider could not be reached.");
-    }
-    if (!res.ok) {
-      throw new RefinementProviderError("PROVIDER_ERROR", `The refinement provider returned an error (${res.status}).`);
-    }
-    const body = await res.json();
-    const text = (body.content ?? []).filter((c) => c.type === "text").map((c) => c.text ?? "").join("");
-    const proposal = extractJson(text);
-    return {
-      proposal,
-      meta: {
-        provider: this.name,
-        model: this.model,
-        durationMs: Date.now() - start,
-        inputTokens: body.usage?.input_tokens,
-        outputTokens: body.usage?.output_tokens
-      }
-    };
-  }
-};
-// src/refinement/index.ts
-function createRefinementService() {
-  const key = process.env.ANTHROPIC_API_KEY;
-  const model = process.env.KADDO_REFINEMENT_MODEL || "claude-3-5-sonnet-latest";
-  const provider = key ? new AnthropicRefinementProvider(key, model) : new HeuristicRefinementProvider();
-  return new RefinementService(provider);
-}
 // src/server.ts
 var WRITE_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
 function statusForCode(code) {
   switch (code) {
     case "WORK_ITEM_NOT_FOUND":
-    case "REFINEMENT_NOT_FOUND":
       return 404;
     case "WORK_ITEM_CONFLICT":
     case "WORK_ITEM_NOT_EDITABLE":
@@ -882,11 +597,6 @@ function statusForCode(code) {
     case "INVALID_WORK_ITEM_ID":
     case "INVALID_TRANSITION":
       return 400;
-    case "TIMEOUT":
-      return 504;
-    case "PROVIDER_ERROR":
-    case "INVALID_RESPONSE":
-      return 502;
     default:
       return 500;
   }
@@ -895,7 +605,6 @@ async function createAdminServer(opts) {
   const { projectDir, storage, staticDir, host = "127.0.0.1", port = 4173 } = opts;
   const app = Fastify({ logger: false });
   const sessionManager = new SessionManager(storage);
-  const refinement = createRefinementService();
   await app.register(fastifyCookie);
   await app.register(fastifyCors, {
     origin: `http://${host}:${port}`,
@@ -1003,28 +712,15 @@ async function createAdminServer(opts) {
     if (!parsed.success) return reply.code(400).send({ error: { code: "INVALID_INPUT", message: "expectedRevision is required." } });
     return writeHandler(reply, () => transitionWorkItemAdmin(projectDir, request.params.workItemId, "draft", parsed.data.expectedRevision));
   });
-  const refineHandler = async (reply, fn) => {
+  app.get("/api/v1/admin/work-items/:workItemId/refinement-handoff", async (request, reply) => {
     try {
-      return await fn();
+      return getRefinementHandoff(projectDir, request.params.workItemId);
     } catch (err) {
-      if (err instanceof RefinementProviderError || err instanceof CoreError) {
+      if (err instanceof CoreError) {
         return reply.code(statusForCode(err.code)).send({ error: { code: err.code, message: err.message } });
       }
       throw err;
     }
-  };
-  app.post("/api/v1/admin/work-items/:workItemId/refinement", async (request, reply) => {
-    return refineHandler(reply, () => refinement.start(projectDir, request.params.workItemId));
-  });
-  app.post("/api/v1/admin/work-items/:workItemId/refinement/feedback", async (request, reply) => {
-    const parsed = RefinementFeedbackSchema.safeParse(request.body);
-    if (!parsed.success) return reply.code(400).send({ error: { code: "INVALID_INPUT", message: "refinementId and feedback are required." } });
-    return refineHandler(reply, () => refinement.feedback(projectDir, request.params.workItemId, parsed.data.refinementId, parsed.data.feedback));
-  });
-  app.post("/api/v1/admin/work-items/:workItemId/refinement/apply", async (request, reply) => {
-    const parsed = RefinementApplySchema.safeParse(request.body);
-    if (!parsed.success) return reply.code(400).send({ error: { code: "INVALID_INPUT", message: "refinementId and expectedRevision are required." } });
-    return refineHandler(reply, () => refinement.apply(projectDir, request.params.workItemId, parsed.data.refinementId, parsed.data.expectedRevision));
   });
   app.get("/api/v1/admin/work-items/:workItemId", async (request, reply) => {
     try {
@@ -1192,8 +888,6 @@ export {
   ProjectReadinessSchema,
   ProjectRouteSchema,
   ProjectSummarySchema,
-  RefinementApplySchema,
-  RefinementFeedbackSchema,
   RouteStepSchema,
   SQLiteAdminStorage,
   SessionManager,

package/dist/core.js CHANGED Viewed

@@ -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 {
@@ -8354,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,
@@ -8500,7 +8440,6 @@ export {
   lifecycleStateOf,
   loadConfig,
   loadMappedModules,
-  normalizeAndValidateProposal,
   readFile,
   transitionWorkItem,
   updateWorkItem,

package/package.json CHANGED Viewed

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