smartlisa 0.1.11 → 0.1.12

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "lisa",
   "description": "Project planning with milestones, epics, and stories. Break down work, track progress, and implement with full context.",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "author": {
     "name": "Rodrigo Klosowski",
     "url": "https://rklosowski.com/"

package/dist/cli.js

@@ -93,6 +93,7 @@ var ValueSchema = z.object({
 var DiscoveryContextSchema = z.object({
   problem: z.string().optional(),
   vision: z.string().optional(),
+  users: z.array(z.string()).default([]),
   values: z.array(ValueSchema).default([]),
   success_criteria: z.array(z.string()).default([]),
   gathered: z.string().datetime().optional()
@@ -118,8 +119,6 @@ var DiscoveryDepth = z.enum(["quick", "standard", "deep"]);
 var DiscoveryHistorySchema = z.object({
   entries: z.array(DiscoveryHistoryEntrySchema).default([]),
   started: z.string().datetime().optional(),
-  completed: z.string().datetime().optional(),
-  is_complete: z.boolean().default(false),
   // Depth preference - affects which topics Claude explores
   depth_preference: DiscoveryDepth.optional(),
   // Last activity timestamp for continuous discovery
@@ -199,12 +198,13 @@ var EpicSchema = z.object({
     coverage: z.number().default(0)
   })
 });
+var StoryType = z.enum(["feature", "bug", "chore", "spike"]);
 var StorySchema = z.object({
   id: z.string(),
   // E1.S1, E1.S2, etc.
   title: z.string(),
   description: z.string(),
-  type: z.enum(["feature", "bug", "chore", "spike"]),
+  type: StoryType,
   requirements: z.array(z.string()).default([]),
   // E1.R1, E1.R2, etc.
   acceptance_criteria: z.array(z.string()).default([]),
@@ -215,6 +215,31 @@ var StorySchema = z.object({
   assignee: z.string().nullable().default(null),
   blocked_reason: z.string().optional()
 });
+var StoryInputSchema = z.object({
+  id: z.string().optional(),
+  // Auto-generated if not provided
+  title: z.string().min(1, "Story title is required"),
+  description: z.string().min(1, "Story description is required"),
+  type: StoryType.default("feature"),
+  requirements: z.array(z.string()).default([]),
+  acceptance_criteria: z.array(z.string()).default([]).transform(
+    (arr) => (
+      // Also accept 'criteria' as alias
+      arr
+    )
+  ),
+  criteria: z.array(z.string()).optional(),
+  // Alias for acceptance_criteria
+  dependencies: z.array(z.string()).default([]),
+  estimated_points: z.number().optional(),
+  status: StoryStatus.default("todo"),
+  assignee: z.string().nullable().default(null),
+  blocked_reason: z.string().optional()
+}).transform((data) => {
+  const acceptance_criteria = data.criteria?.length ? [...data.acceptance_criteria, ...data.criteria] : data.acceptance_criteria;
+  const { criteria, ...rest } = data;
+  return { ...rest, acceptance_criteria };
+});
 var StoriesFileSchema = z.object({
   epic_id: z.string(),
   stories: z.array(StorySchema).default([]),
@@ -811,13 +836,13 @@ var StateManager = class {
     await this.writeStuckQueue({ stuck: [], resolved: [] });
     await this.writeFeedbackQueue({ feedback: [], incorporated: [] });
     await this.writeDiscoveryContext({
+      users: [],
       values: [],
       success_criteria: []
     });
     await this.writeConstraints({ constraints: [] });
     await this.writeDiscoveryHistory({
-      entries: [],
-      is_complete: false
+      entries: []
     });
     await this.writeMilestoneIndex({ milestones: [] });
     const defaultConfig = {
@@ -894,8 +919,8 @@ var StateManager = class {
   async readDiscoveryHistory() {
     return this.adapter.readJson(PATHS.discovery.history, DiscoveryHistorySchema);
   }
-  async writeDiscoveryHistory(history) {
-    await this.adapter.writeJson(PATHS.discovery.history, history);
+  async writeDiscoveryHistory(history2) {
+    await this.adapter.writeJson(PATHS.discovery.history, history2);
   }
   // --------------------------------------------------------------------------
   // Milestones
@@ -1299,11 +1324,11 @@ function success(data, sections = [], aiGuidance) {
     aiGuidance
   };
 }
-function error(message, code, data = null) {
+function error(message, code, sections) {
   return {
     status: "error",
-    data,
-    sections: [{ type: "text", content: message, style: "error" }],
+    data: null,
+    sections: sections ?? [{ type: "text", content: message, style: "error" }],
     error: message,
     errorCode: code
   };
@@ -1741,10 +1766,231 @@ function getHowGuidance(storyId, hasArchitecture) {
   );
 }
 
+// src/core/prompts/discovery.ts
+function getDiscoveryGuidance(context2, _history, constraints, depth, gaps, justInitialized) {
+  const hasGaps = gaps.length > 0;
+  const hasSomeContext = !!context2?.problem || !!context2?.vision;
+  let situation;
+  if (justInitialized) {
+    situation = "Project initialized, starting discovery";
+  } else if (!hasSomeContext) {
+    situation = "Discovery starting - no context gathered yet";
+  } else if (hasGaps) {
+    situation = `Discovery in progress (${depth} depth) - gaps in: ${gaps.join(", ")}`;
+  } else {
+    situation = "Discovery has sufficient context - ready to move to planning when you are";
+  }
+  const instructions = [];
+  if (!hasSomeContext) {
+    instructions.push("Start a discovery conversation to deeply understand the project");
+    instructions.push("Capture the problem domain, users, values, and constraints");
+    instructions.push(`Ask the user: "${getStarterQuestion(gaps[0] || "problem")}"`);
+    instructions.push("If this is an existing codebase, briefly acknowledge what you learned (1-2 sentences), then ask the question");
+    instructions.push("Focus on understanding, not on what to build next");
+  } else {
+    instructions.push("Continue the discovery conversation naturally");
+    instructions.push("Run 'lisa status context' first to review what's been discovered so far");
+    instructions.push("Run 'lisa discover history' to see all Q&A entries recorded");
+  }
+  instructions.push("Ask follow-up questions based on user's answers");
+  instructions.push("For short answers on important topics, probe deeper");
+  instructions.push("For detailed answers, acknowledge and move on");
+  if (gaps.includes("other")) {
+    instructions.push("For research/benchmarks: use web search to find competitors and best practices");
+  }
+  instructions.push("Record key insights as you go");
+  instructions.push(
+    "When user indicates what they want to do next (plan, add milestones/epics, continue discovery, etc.), follow their lead"
+  );
+  const commands = [
+    {
+      command: "discover add-entry",
+      args: "--category <cat> --question '<q>' --answer '<a>'",
+      description: "Record a discovery insight",
+      when: "After gathering important context"
+    },
+    {
+      command: "plan milestones",
+      description: "View/create milestones",
+      when: "When user wants to structure work"
+    },
+    {
+      command: "plan add-milestone",
+      args: "--name '<name>' --description '<desc>'",
+      description: "Add a milestone directly",
+      when: "When user has a specific milestone in mind"
+    },
+    {
+      command: "discover --deep",
+      description: "Switch to deep discovery",
+      when: "If user wants more thorough exploration"
+    },
+    {
+      command: "discover --quick",
+      description: "Switch to quick discovery",
+      when: "If user wants to move faster"
+    }
+  ];
+  return {
+    situation,
+    instructions,
+    commands,
+    context: {
+      depth,
+      gaps,
+      // Full discovery context so AI knows what's been learned
+      discovery: context2 ? {
+        problem: context2.problem,
+        vision: context2.vision,
+        values: context2.values,
+        successCriteria: context2.success_criteria
+      } : null,
+      constraints: constraints?.constraints || []
+    }
+  };
+}
+function getStarterQuestion(category) {
+  const starters = {
+    problem: "What problem are we solving?",
+    vision: "What does the ideal end state look like?",
+    users: "Who are the primary users?",
+    values: "What's the most important quality this solution must have?",
+    constraints: "What's your current tech stack and team setup?",
+    success: "How will we know if this is successful?",
+    other: "What existing solutions have you looked at?"
+  };
+  return starters[category] || starters.problem;
+}
+function getAddEntryGuidance() {
+  return {
+    situation: "Discovery entry recorded",
+    instructions: [
+      "Continue the conversation naturally based on what user wants",
+      "You can: continue discovery, move to planning, add milestones/epics, or follow user's lead"
+    ],
+    commands: [
+      {
+        command: "discover add-entry",
+        args: "--category <cat> --question '<q>' --answer '<a>'",
+        description: "Record another insight",
+        when: "After gathering context"
+      },
+      {
+        command: "plan milestones",
+        description: "View/create milestones",
+        when: "When ready to structure work"
+      },
+      {
+        command: "plan add-milestone",
+        args: "--name '<name>' --description '<desc>'",
+        description: "Add milestone directly",
+        when: "When user has specific milestone"
+      }
+    ]
+  };
+}
+var EPIC_DISCOVERY_QUESTIONS = [
+  { id: "problem", question: "What problem does this epic solve?", required: true },
+  { id: "scope", question: "What's in scope for this epic?", required: true },
+  { id: "out_of_scope", question: "What's explicitly out of scope?", required: false },
+  { id: "constraints", question: "Are there any technical constraints specific to this epic?", required: false },
+  { id: "success", question: "What does success look like for this epic?", required: true }
+];
+var MILESTONE_DISCOVERY_QUESTIONS = [
+  { id: "goal", question: "What's the goal of this milestone?", required: true },
+  { id: "done", question: "What does 'done' look like for this milestone?", required: true },
+  { id: "dependencies", question: "Are there any dependencies or blockers for this milestone?", required: false }
+];
+function getElementDiscoveryGuidance(elementType, elementName, discovery) {
+  const questions = elementType === "epic" ? EPIC_DISCOVERY_QUESTIONS : MILESTONE_DISCOVERY_QUESTIONS;
+  const answeredQuestions = new Set(discovery.history.map((e) => e.question));
+  const remaining = questions.filter((q) => !answeredQuestions.has(q.question));
+  const requiredRemaining = remaining.filter((q) => q.required);
+  let situation;
+  if (discovery.status === "complete") {
+    situation = `${elementType} discovery complete for ${elementName}`;
+  } else if (remaining.length === 0) {
+    situation = `All questions answered for ${elementType} ${elementName}, ready to complete`;
+  } else {
+    situation = `${elementType} discovery in progress for ${elementName} - ${remaining.length} questions remaining`;
+  }
+  const instructions = [];
+  if (discovery.status === "complete") {
+    instructions.push("Discovery is complete. You can still add more context if needed.");
+  } else {
+    instructions.push("Ask the remaining questions conversationally, one at a time");
+    instructions.push("Record answers using the add-entry command");
+    if (remaining.length > 0) {
+      instructions.push(`Start with: "${remaining[0].question}"`);
+    }
+    if (remaining.length === 0) {
+      instructions.push("All questions answered - complete the discovery");
+    }
+  }
+  const commands = [
+    {
+      command: `discover add-element-entry`,
+      args: `--element-type ${elementType} --element-id ${discovery.element_id} --category <cat> --question '<q>' --answer '<a>'`,
+      description: "Record an answer",
+      when: "After getting an answer from the user"
+    }
+  ];
+  if (remaining.length === 0 && discovery.status !== "complete") {
+    commands.push({
+      command: `discover complete-element`,
+      args: `--element-type ${elementType} --element-id ${discovery.element_id}`,
+      description: "Mark discovery complete",
+      when: "When all required questions are answered"
+    });
+  }
+  return {
+    situation,
+    instructions,
+    commands,
+    context: {
+      elementType,
+      elementId: discovery.element_id,
+      remainingQuestions: remaining.map((q) => ({
+        id: q.id,
+        question: q.question,
+        required: q.required
+      })),
+      gatheredContext: {
+        problem: discovery.problem,
+        scope: discovery.scope,
+        outOfScope: discovery.out_of_scope,
+        successCriteria: discovery.success_criteria,
+        constraints: discovery.constraints.length
+      }
+    }
+  };
+}
+function getNotInitializedGuidance() {
+  return {
+    situation: "No Lisa project found in this directory",
+    instructions: [
+      "Ask the user for a project name, then run 'discover init' to initialize"
+    ],
+    commands: [
+      {
+        command: "discover init",
+        args: "{ name: '<project name>' }",
+        description: "Initialize Lisa project",
+        when: "After getting the project name from user"
+      }
+    ]
+  };
+}
+
 // src/core/commands/status.ts
 async function overview(state) {
   if (!await state.isInitialized()) {
-    return error("No Lisa project found. Run 'discover init' first.", "NOT_INITIALIZED");
+    const sections2 = [
+      section.info("No Lisa project found in this directory."),
+      section.blank(),
+      section.info("Run 'discover init' to start planning.")
+    ];
+    return success(null, sections2, getNotInitializedGuidance());
   }
   const project = await state.readProject();
   const index = await state.readMilestoneIndex();
@@ -2395,162 +2641,6 @@ async function how(state, options) {
   return success(data, sections, aiGuidance);
 }
 
-// src/core/prompts/discovery.ts
-function getDiscoveryGuidance(context2, history, _constraints, depth, gaps) {
-  const isComplete = history?.is_complete || false;
-  const hasGaps = gaps.length > 0;
-  const hasSomeContext = !!context2?.problem || !!context2?.vision;
-  let situation;
-  if (isComplete) {
-    situation = "Discovery complete, can continue anytime to add more context";
-  } else if (!hasSomeContext) {
-    situation = "Discovery starting - no context gathered yet";
-  } else if (hasGaps) {
-    situation = `Discovery in progress (${depth} depth) - gaps in: ${gaps.join(", ")}`;
-  } else {
-    situation = "Discovery in progress - sufficient context for current depth, consider completing";
-  }
-  const instructions = [];
-  if (!hasSomeContext) {
-    instructions.push("Start a natural conversation to understand the project");
-    instructions.push(`Ask about: "${getStarterQuestion(gaps[0] || "problem")}"`);
-  } else {
-    instructions.push("Continue the discovery conversation naturally");
-  }
-  instructions.push("Ask follow-up questions based on user's answers");
-  instructions.push("For short answers on important topics, probe deeper");
-  instructions.push("For detailed answers, acknowledge and move on");
-  if (gaps.includes("other")) {
-    instructions.push("For research/benchmarks: use web search to find competitors and best practices");
-  }
-  instructions.push("Record key insights as you go");
-  if (!hasGaps && !isComplete) {
-    instructions.push("Sufficient context gathered for this depth - suggest completing discovery");
-  }
-  const commands = [
-    {
-      command: "discover add-entry",
-      args: "--category <cat> --question '<q>' --answer '<a>'",
-      description: "Record a discovery insight",
-      when: "After gathering important context"
-    }
-  ];
-  if (!hasGaps || isComplete) {
-    commands.push({
-      command: "discover complete",
-      description: "Mark discovery as complete checkpoint",
-      when: "When sufficient context gathered"
-    });
-  }
-  commands.push({
-    command: "discover --deep",
-    description: "Switch to deep discovery",
-    when: "If user wants more thorough exploration"
-  });
-  commands.push({
-    command: "discover --quick",
-    description: "Switch to quick discovery",
-    when: "If user wants to move faster"
-  });
-  return {
-    situation,
-    instructions,
-    commands,
-    context: {
-      depth,
-      gaps
-    }
-  };
-}
-function getStarterQuestion(category) {
-  const starters = {
-    problem: "What problem are we solving?",
-    vision: "What does the ideal end state look like?",
-    users: "Who are the primary users?",
-    values: "What's the most important quality this solution must have?",
-    constraints: "What's your current tech stack and team setup?",
-    success: "How will we know if this is successful?",
-    other: "What existing solutions have you looked at?"
-  };
-  return starters[category] || starters.problem;
-}
-var EPIC_DISCOVERY_QUESTIONS = [
-  { id: "problem", question: "What problem does this epic solve?", required: true },
-  { id: "scope", question: "What's in scope for this epic?", required: true },
-  { id: "out_of_scope", question: "What's explicitly out of scope?", required: false },
-  { id: "constraints", question: "Are there any technical constraints specific to this epic?", required: false },
-  { id: "success", question: "What does success look like for this epic?", required: true }
-];
-var MILESTONE_DISCOVERY_QUESTIONS = [
-  { id: "goal", question: "What's the goal of this milestone?", required: true },
-  { id: "done", question: "What does 'done' look like for this milestone?", required: true },
-  { id: "dependencies", question: "Are there any dependencies or blockers for this milestone?", required: false }
-];
-function getElementDiscoveryGuidance(elementType, elementName, discovery) {
-  const questions = elementType === "epic" ? EPIC_DISCOVERY_QUESTIONS : MILESTONE_DISCOVERY_QUESTIONS;
-  const answeredQuestions = new Set(discovery.history.map((e) => e.question));
-  const remaining = questions.filter((q) => !answeredQuestions.has(q.question));
-  const requiredRemaining = remaining.filter((q) => q.required);
-  let situation;
-  if (discovery.status === "complete") {
-    situation = `${elementType} discovery complete for ${elementName}`;
-  } else if (remaining.length === 0) {
-    situation = `All questions answered for ${elementType} ${elementName}, ready to complete`;
-  } else {
-    situation = `${elementType} discovery in progress for ${elementName} - ${remaining.length} questions remaining`;
-  }
-  const instructions = [];
-  if (discovery.status === "complete") {
-    instructions.push("Discovery is complete. You can still add more context if needed.");
-  } else {
-    instructions.push("Ask the remaining questions conversationally, one at a time");
-    instructions.push("Record answers using the add-entry command");
-    if (remaining.length > 0) {
-      instructions.push(`Start with: "${remaining[0].question}"`);
-    }
-    if (remaining.length === 0) {
-      instructions.push("All questions answered - complete the discovery");
-    }
-  }
-  const commands = [
-    {
-      command: `discover add-element-entry`,
-      args: `--element-type ${elementType} --element-id ${discovery.element_id} --category <cat> --question '<q>' --answer '<a>'`,
-      description: "Record an answer",
-      when: "After getting an answer from the user"
-    }
-  ];
-  if (remaining.length === 0 && discovery.status !== "complete") {
-    commands.push({
-      command: `discover complete-element`,
-      args: `--element-type ${elementType} --element-id ${discovery.element_id}`,
-      description: "Mark discovery complete",
-      when: "When all required questions are answered"
-    });
-  }
-  return {
-    situation,
-    instructions,
-    commands,
-    context: {
-      elementType,
-      elementId: discovery.element_id,
-      remainingQuestions: remaining.map((q) => ({
-        id: q.id,
-        question: q.question,
-        required: q.required
-      })),
-      gatheredContext: {
-        problem: discovery.problem,
-        scope: discovery.scope,
-        outOfScope: discovery.out_of_scope,
-        successCriteria: discovery.success_criteria,
-        constraints: discovery.constraints.length
-      }
-    }
-  };
-}
-
 // src/core/commands/discover.ts
 var DISCOVERY_GUIDANCE_DATA = [
   {
@@ -2660,37 +2750,32 @@ var DISCOVERY_GUIDANCE_DATA = [
     includedIn: ["standard", "deep"]
   }
 ];
-var DISCOVERY_QUESTIONS = [
-  { id: "problem", category: "problem", question: "What problem are we solving?", required: true },
-  { id: "vision", category: "vision", question: "What does success look like?", required: true },
-  { id: "users", category: "users", question: "Who are the primary users?", required: false },
-  { id: "value1", category: "values", question: "What is the most important quality?", required: false },
-  { id: "success1", category: "success", question: "How will we know if this is successful?", required: true }
-];
-function checkCategoryHasContent(category, context2, constraints) {
+function checkCategoryHasContent(category, context2, constraints, history2) {
+  const hasHistoryEntry = history2?.entries.some((e) => e.category === category) || false;
   switch (category) {
     case "problem":
-      return !!context2?.problem;
+      return !!context2?.problem || hasHistoryEntry;
     case "vision":
-      return !!context2?.vision;
+      return !!context2?.vision || hasHistoryEntry;
     case "users":
-      return false;
-    // Stored in history
+      return context2?.users && context2.users.length > 0 || hasHistoryEntry;
     case "values":
-      return context2?.values && context2.values.length > 0 || false;
+      return context2?.values && context2.values.length > 0 || hasHistoryEntry;
     case "constraints":
-      return constraints?.constraints && constraints.constraints.length > 0 || false;
+      return constraints?.constraints && constraints.constraints.length > 0 || hasHistoryEntry;
     case "success":
-      return context2?.success_criteria && context2.success_criteria.length > 0 || false;
+      return context2?.success_criteria && context2.success_criteria.length > 0 || hasHistoryEntry;
+    case "other":
+      return hasHistoryEntry;
     default:
       return false;
   }
 }
-function findDiscoveryGaps(context2, constraints, depth) {
+function findDiscoveryGaps(context2, constraints, history2, depth) {
   const gaps = [];
   const guidanceForDepth = DISCOVERY_GUIDANCE_DATA.filter((g) => g.includedIn.includes(depth));
   for (const guidance of guidanceForDepth) {
-    if (!checkCategoryHasContent(guidance.category, context2, constraints)) {
+    if (!checkCategoryHasContent(guidance.category, context2, constraints, history2)) {
       gaps.push(guidance.category);
     }
   }
@@ -2715,6 +2800,7 @@ function createEmptyElementDiscovery(elementType, elementId, source) {
 }
 async function updateContextFromEntry(state, entry) {
   const context2 = await state.readDiscoveryContext() || {
+    users: [],
     values: [],
     success_criteria: []
   };
@@ -2730,6 +2816,12 @@ async function updateContextFromEntry(state, entry) {
       context2.gathered = now();
       await state.writeDiscoveryContext(context2);
       break;
+    case "users":
+      if (!context2.users) context2.users = [];
+      context2.users.push(entry.answer);
+      context2.gathered = now();
+      await state.writeDiscoveryContext(context2);
+      break;
     case "values":
       const valueId = `V${context2.values.length + 1}`;
       const value = {
@@ -2778,28 +2870,10 @@ async function init(state, options) {
   const projectName = options.name || "Untitled Project";
   const project = await state.initialize(projectName);
   const sections = [
-    section.header("Initializing Lisa"),
-    section.success(`Created .lisa/ directory`),
-    section.success(`Project: ${project.name}`),
-    section.success(`ID: ${project.id}`),
-    section.blank(),
-    section.info("Next step: Run discovery to gather project context")
+    section.success(`Lisa initialized: ${project.name}`)
   ];
-  const aiGuidance = {
-    situation: "Project initialized, ready to start discovery",
-    instructions: [
-      "Start a natural discovery conversation to gather project context",
-      "Ask about the problem being solved, vision, constraints, and success criteria",
-      "Keep it conversational - don't list upcoming steps or announce what you'll do"
-    ],
-    commands: [
-      {
-        command: "discover",
-        description: "Start or continue discovery conversation",
-        when: "To gather project context"
-      }
-    ]
-  };
+  const defaultGaps = ["problem", "vision", "users", "values", "constraints", "success"];
+  const aiGuidance = getDiscoveryGuidance(null, null, null, "standard", defaultGaps, true);
   return success({ project: { id: project.id, name: project.name } }, sections, aiGuidance);
 }
 async function status(state) {
@@ -2808,87 +2882,122 @@ async function status(state) {
   }
   const context2 = await state.readDiscoveryContext();
   const constraints = await state.readConstraints();
-  const history = await state.readDiscoveryHistory();
-  const answeredQuestions = new Set(history?.entries.map((e) => e.question) || []);
-  const requiredQuestions = DISCOVERY_QUESTIONS.filter((q) => q.required);
-  const answeredRequired = requiredQuestions.filter(
-    (q) => answeredQuestions.has(q.question)
-  ).length;
+  const history2 = await state.readDiscoveryHistory();
+  const coreCategories = [
+    "problem",
+    "vision",
+    "users",
+    "values",
+    "constraints",
+    "success"
+  ];
+  const completedCategories = coreCategories.filter(
+    (cat) => checkCategoryHasContent(cat, context2, constraints, history2)
+  );
   const progress = {
-    answeredRequired,
-    totalRequired: requiredQuestions.length,
-    percent: requiredQuestions.length > 0 ? Math.round(answeredRequired / requiredQuestions.length * 100) : 0
+    answeredRequired: completedCategories.length,
+    totalRequired: coreCategories.length,
+    percent: Math.round(completedCategories.length / coreCategories.length * 100)
   };
   const data = {
     context: context2,
     constraints,
-    history,
-    progress,
-    isComplete: history?.is_complete || false
+    history: history2,
+    progress
   };
   const sections = [
     section.header("Discovery Status"),
     section.subheader("Progress"),
-    section.progress(progress.answeredRequired, progress.totalRequired, "Required questions"),
+    section.progress(progress.answeredRequired, progress.totalRequired, "Core categories"),
     section.blank(),
     section.subheader("Context Gathered")
   ];
-  if (context2?.problem) {
-    sections.push(section.success(`Problem: ${context2.problem.slice(0, 60)}...`));
+  if (checkCategoryHasContent("problem", context2, constraints, history2)) {
+    sections.push(section.success(`Problem: ${context2?.problem?.slice(0, 60) || "(in history)"}${context2?.problem && context2.problem.length > 60 ? "..." : ""}`));
   } else {
     sections.push(section.dim("  Problem: Not yet defined"));
   }
-  if (context2?.vision) {
-    sections.push(section.success(`Vision: ${context2.vision.slice(0, 60)}...`));
+  if (checkCategoryHasContent("vision", context2, constraints, history2)) {
+    sections.push(section.success(`Vision: ${context2?.vision?.slice(0, 60) || "(in history)"}${context2?.vision && context2.vision.length > 60 ? "..." : ""}`));
   } else {
     sections.push(section.dim("  Vision: Not yet defined"));
   }
-  if (context2?.values && context2.values.length > 0) {
-    sections.push(section.success(`Values: ${context2.values.length} defined`));
+  if (checkCategoryHasContent("users", context2, constraints, history2)) {
+    sections.push(section.success(`Users: ${context2?.users?.length || 0} defined`));
+  } else {
+    sections.push(section.dim("  Users: None defined"));
+  }
+  if (checkCategoryHasContent("values", context2, constraints, history2)) {
+    sections.push(section.success(`Values: ${context2?.values?.length || 0} defined`));
   } else {
     sections.push(section.dim("  Values: None defined"));
   }
-  if (context2?.success_criteria && context2.success_criteria.length > 0) {
-    sections.push(section.success(`Success Criteria: ${context2.success_criteria.length} defined`));
+  if (checkCategoryHasContent("success", context2, constraints, history2)) {
+    sections.push(section.success(`Success Criteria: ${context2?.success_criteria?.length || 0} defined`));
   } else {
     sections.push(section.dim("  Success Criteria: None defined"));
   }
   sections.push(section.blank());
   sections.push(section.subheader("Constraints"));
-  if (constraints?.constraints && constraints.constraints.length > 0) {
-    for (const c of constraints.constraints) {
+  if (checkCategoryHasContent("constraints", context2, constraints, history2)) {
+    for (const c of constraints?.constraints || []) {
       sections.push(section.text(`  [${c.type}] ${c.constraint}`));
     }
   } else {
     sections.push(section.dim("  No constraints defined"));
   }
   sections.push(section.blank());
-  if (history?.is_complete) {
-    sections.push(section.success("Discovery is COMPLETE"));
+  const hasContext = checkCategoryHasContent("problem", context2, constraints, history2) || checkCategoryHasContent("vision", context2, constraints, history2);
+  if (hasContext && progress.percent >= 50) {
+    sections.push(section.success("Ready for planning - or continue adding context"));
   } else {
-    sections.push(section.warning("Discovery is INCOMPLETE"));
+    sections.push(section.info("Continue discovery to gather more context"));
   }
   return success(data, sections);
 }
+async function history(state) {
+  if (!await state.isInitialized()) {
+    return error("No Lisa project found.", "NOT_INITIALIZED");
+  }
+  const historyData = await state.readDiscoveryHistory();
+  const entries = historyData?.entries || [];
+  const sections = [
+    section.header("Discovery History"),
+    section.info(`${entries.length} entries recorded`),
+    section.blank()
+  ];
+  if (entries.length === 0) {
+    sections.push(section.dim("No discovery entries yet. Run 'lisa discover' to start."));
+  } else {
+    for (const entry of entries) {
+      const date = new Date(entry.timestamp).toLocaleDateString();
+      sections.push(section.subheader(`[${entry.category}] ${date}`));
+      sections.push(section.dim(`  Q: ${entry.question}`));
+      sections.push(section.text(`  A: ${entry.answer}`));
+      sections.push(section.blank());
+    }
+  }
+  return success({ entries, count: entries.length }, sections);
+}
 async function start(state, options = {}) {
   if (!await state.isInitialized()) {
     return error("No Lisa project found. Run 'discover init' first.", "NOT_INITIALIZED");
   }
-  const history = await state.readDiscoveryHistory();
+  const history2 = await state.readDiscoveryHistory();
   const context2 = await state.readDiscoveryContext();
   const constraints = await state.readConstraints();
-  const depth = options.depth || history?.depth_preference || "standard";
-  if (options.depth && history && history.depth_preference !== options.depth) {
-    history.depth_preference = options.depth;
-    history.last_active = now();
-    await state.writeDiscoveryHistory(history);
+  const depth = options.depth || history2?.depth_preference || "standard";
+  if (options.depth && history2 && history2.depth_preference !== options.depth) {
+    history2.depth_preference = options.depth;
+    history2.last_active = now();
+    await state.writeDiscoveryHistory(history2);
   }
-  const gaps = findDiscoveryGaps(context2, constraints, depth);
+  const gaps = findDiscoveryGaps(context2, constraints, history2, depth);
   const data = {
     depth,
     context: context2,
     constraints,
-    history,
+    history: history2,
     gaps
   };
   const depthLabels = {
@@ -2937,7 +3046,7 @@ async function start(state, options = {}) {
   sections.push(section.blank());
   const guidanceForDepth = DISCOVERY_GUIDANCE_DATA.filter((g) => g.includedIn.includes(depth));
   for (const guidance of guidanceForDepth) {
-    const hasContent = checkCategoryHasContent(guidance.category, context2, constraints);
+    const hasContent = checkCategoryHasContent(guidance.category, context2, constraints, history2);
     const icon = hasContent ? "\u2713" : "\u25CB";
     const statusText = hasContent ? "(has content)" : "(explore this)";
     sections.push(section.text(`  ${icon} [${guidance.category}] ${guidance.purpose} ${statusText}`));
@@ -2949,16 +3058,16 @@ async function start(state, options = {}) {
   sections.push(section.blank());
   sections.push(section.divider());
   sections.push(section.blank());
-  const aiGuidance = getDiscoveryGuidance(context2, history, constraints, depth, gaps);
+  const aiGuidance = getDiscoveryGuidance(context2, history2, constraints, depth, gaps);
   return success(data, sections, aiGuidance);
 }
 async function addEntry(state, options) {
   if (!await state.isInitialized()) {
     return error("No Lisa project found.", "NOT_INITIALIZED");
   }
-  let history = await state.readDiscoveryHistory();
-  if (!history) {
-    history = { entries: [], is_complete: false };
+  let history2 = await state.readDiscoveryHistory();
+  if (!history2) {
+    history2 = { entries: [] };
   }
   const entry = {
     timestamp: now(),
@@ -2966,56 +3075,17 @@ async function addEntry(state, options) {
     answer: options.answer,
     category: options.category
   };
-  history.entries.push(entry);
-  if (!history.started) {
-    history.started = now();
+  history2.entries.push(entry);
+  if (!history2.started) {
+    history2.started = now();
   }
-  history.last_active = now();
-  await state.writeDiscoveryHistory(history);
+  history2.last_active = now();
+  await state.writeDiscoveryHistory(history2);
   await updateContextFromEntry(state, entry);
   const sections = [
     section.success(`Added ${options.category} entry`)
   ];
-  return success({ entry }, sections);
-}
-async function complete(state) {
-  if (!await state.isInitialized()) {
-    return error("No Lisa project found.", "NOT_INITIALIZED");
-  }
-  const history = await state.readDiscoveryHistory();
-  if (!history) {
-    return error("No discovery history found.", "NO_HISTORY");
-  }
-  history.is_complete = true;
-  history.completed = now();
-  history.last_active = now();
-  await state.writeDiscoveryHistory(history);
-  const sections = [
-    section.success("Discovery checkpoint saved!"),
-    section.blank(),
-    section.info("You can continue discovery anytime with: discover"),
-    section.info("Next step: Generate milestones with 'plan milestones'")
-  ];
-  const aiGuidance = {
-    situation: "Discovery marked complete, ready for milestone planning",
-    instructions: [
-      "Discovery is complete but can be continued anytime",
-      "Next step is to generate milestones based on discovery context"
-    ],
-    commands: [
-      {
-        command: "plan milestones",
-        description: "Generate milestones from discovery",
-        when: "To create the project roadmap"
-      },
-      {
-        command: "discover",
-        description: "Continue adding discovery context",
-        when: "If more context is needed"
-      }
-    ]
-  };
-  return success({ completed: true }, sections, aiGuidance);
+  return success({ entry }, sections, getAddEntryGuidance());
 }
 async function findEpicByIdOrSlug(state, epicIdOrSlug) {
   const epicDirs = await state.listEpicDirs();
@@ -3455,6 +3525,30 @@ function getStoriesGuidance(ctx) {
     }
   };
 }
+function getAddEpicGuidance(epicId) {
+  return {
+    situation: `Epic ${epicId} created, ready for discovery or PRD`,
+    instructions: [
+      "Ask user if they want to run discovery for this epic",
+      "Discovery helps gather scope, constraints, and success criteria",
+      "If they skip, proceed directly to PRD generation"
+    ],
+    commands: [
+      {
+        command: "discover element",
+        args: `{ elementType: 'epic', elementId: '${epicId}' }`,
+        description: "Run epic discovery",
+        when: "To gather more context before PRD"
+      },
+      {
+        command: "plan epic",
+        args: epicId,
+        description: "Plan epic (PRD generation)",
+        when: "To skip discovery and proceed to PRD"
+      }
+    ]
+  };
+}
 
 // src/core/commands/plan.ts
 async function showMilestones(state) {
@@ -3463,11 +3557,10 @@ async function showMilestones(state) {
   }
   const index = await state.readMilestoneIndex();
   const context2 = await state.readDiscoveryContext();
-  const history = await state.readDiscoveryHistory();
-  const discoveryComplete = history?.is_complete || false;
   const sections = [section.header("Milestones")];
-  if (!discoveryComplete) {
-    sections.push(section.warning("Discovery is not complete. Complete discovery first."));
+  const hasContext = !!context2?.problem || !!context2?.vision;
+  if (!hasContext) {
+    sections.push(section.warning("No discovery context found. Run discovery first."));
     sections.push(section.dim("  Run: discover"));
     return success(
       {
@@ -3709,29 +3802,7 @@ async function addEpic(state, options) {
     section.blank(),
     section.info("Next: Run discovery for this epic or proceed to PRD")
   ];
-  const aiGuidance = {
-    situation: `Epic ${epicId} created, ready for discovery or PRD`,
-    instructions: [
-      "Ask user if they want to run discovery for this epic",
-      "Discovery helps gather scope, constraints, and success criteria",
-      "If they skip, proceed directly to PRD generation"
-    ],
-    commands: [
-      {
-        command: "discover element",
-        args: `{ elementType: 'epic', elementId: '${epicId}' }`,
-        description: "Run epic discovery",
-        when: "To gather more context before PRD"
-      },
-      {
-        command: "plan epic",
-        args: epicId,
-        description: "Plan epic (PRD generation)",
-        when: "To skip discovery and proceed to PRD"
-      }
-    ]
-  };
-  return success({ epic }, sections, aiGuidance);
+  return success({ epic }, sections, getAddEpicGuidance(epicId));
 }
 async function planEpic(state, options) {
   if (!await state.isInitialized()) {
@@ -3983,15 +4054,39 @@ async function saveStories(state, options) {
   if (!epicDir) {
     return error(`Epic ${options.epicId} not found.`, "NOT_FOUND");
   }
+  const validatedStories = [];
+  const validationErrors = [];
+  for (let i = 0; i < options.stories.length; i++) {
+    const storyInput = options.stories[i];
+    const result = StoryInputSchema.safeParse(storyInput);
+    if (!result.success) {
+      const issues = result.error.issues.map((issue) => {
+        const path3 = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
+        return `${path3}${issue.message}`;
+      });
+      validationErrors.push(`Story ${i + 1} (${storyInput.title || "untitled"}): ${issues.join(", ")}`);
+    } else {
+      const story2 = {
+        ...result.data,
+        id: result.data.id || `${options.epicId}.S${i + 1}`
+      };
+      validatedStories.push(story2);
+    }
+  }
+  if (validationErrors.length > 0) {
+    const sections2 = [
+      section.error("Story validation failed:"),
+      ...validationErrors.map((err) => section.dim(`  \u2022 ${err}`)),
+      section.blank(),
+      section.info("Required fields: title, description"),
+      section.info("Optional fields: type (feature|bug|chore|spike), requirements, criteria, dependencies")
+    ];
+    return error(validationErrors.join("\n"), "VALIDATION_ERROR", sections2);
+  }
   const slug = epicDir.split("-").slice(1).join("-");
   const storiesFile = {
     epic_id: options.epicId,
-    stories: options.stories.map((s, i) => ({
-      ...s,
-      id: s.id || `${options.epicId}.S${i + 1}`,
-      status: s.status || "todo",
-      assignee: s.assignee || null
-    })),
+    stories: validatedStories,
     coverage: {},
     validation: {
       coverage_complete: false,
@@ -5438,10 +5533,6 @@ var LisaEngine = class {
      * Add a discovery entry
      */
     addEntry: (options) => addEntry(this.state, options),
-    /**
-     * Mark discovery as complete
-     */
-    complete: () => complete(this.state),
     /**
      * Show discovery status
      */
@@ -5457,7 +5548,11 @@ var LisaEngine = class {
     /**
      * Complete element discovery
      */
-    completeElement: (options) => completeElement(this.state, options)
+    completeElement: (options) => completeElement(this.state, options),
+    /**
+     * Show discovery history (all Q&A entries)
+     */
+    history: () => history(this.state)
   };
   // ==========================================================================
   // Plan Commands
@@ -5901,7 +5996,7 @@ function showDiscoverHelp() {
   console.log("  (none)              Start or continue discovery session");
   console.log("  init <name>         Initialize a new project");
   console.log("  status              Show discovery progress and gaps");
-  console.log("  complete            Mark discovery phase as complete");
+  console.log("  history             Show all discovery Q&A entries");
   console.log("  add-entry           Add a discovery entry (project-level)");
   console.log("  epic <id>           Start discovery for a specific epic");
   console.log("  milestone <id>      Start discovery for a milestone");
@@ -6187,8 +6282,8 @@ async function main() {
             handleResult(result);
             break;
           }
-          case "complete": {
-            const result = await engine.discover.complete();
+          case "history": {
+            const result = await engine.discover.history();
             handleResult(result);
             break;
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smartlisa",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "AI-powered planning system for Claude Code",
   "type": "module",
   "license": "MIT",

package/skills/lisa/SKILL.md

@@ -8,58 +8,60 @@ user-invocable: true
 
 Plan and organize projects into milestones, epics, and stories.
 
+## Core Principles
+
+1. **Follow command output instructions.** Every Lisa command returns AI guidance with next steps. Read and follow them exactly.
+
+2. **Present before creating.** When the user describes work to be done:
+   - Summarize what you understood
+   - Propose the milestones, epics, or stories you plan to create
+   - Wait for user confirmation before running any `add-milestone`, `add-epic`, or `add-story` commands
+   - Never auto-create artifacts without explicit approval
+
 ## Quick Start
 
 ```bash
-# Check project status
+# Check if project exists
 lisa status
 
-# Start a new project
+# New project - get name first, then:
 lisa discover init "Project Name"
 
-# View the board
+# View board
 lisa status board
 ```
 
-## Workflow
-
-### New Project
+## New Project Flow
 
-1. **Ask for project name** - Confirm what they're building
-2. **Initialize**: `lisa discover init "Project Name"`
-3. **Check for existing code** - Read key files to understand patterns
-4. **Discovery conversation** - Natural Q&A about problem, vision, constraints
-   - For brownfield: suggest answers based on what you read
+1. Ask user for project name
+2. Run `lisa discover init "Project Name"`
+3. **Follow the INSTRUCTIONS section** in the output - it tells you what to do next
 
-### Existing Project
+## Existing Project
 
-1. **Check status**: `lisa status`
-2. **View board**: `lisa status board`
-3. **Add to plan** or **work on stories** as needed
+1. Run `lisa status` to see current state
+2. Follow the guidance in the output
 
-## Commands Reference
+## Commands
 
 | Action | Command |
 |--------|---------|
-| Project overview | `lisa status` |
-| Kanban board | `lisa status board` |
-| Story details | `lisa status show <id>` |
-| Start discovery | `lisa discover init "Name"` |
+| Status | `lisa status` |
+| Board | `lisa status board` |
+| Initialize | `lisa discover init "Name"` |
 | Continue discovery | `lisa discover` |
+| Add discovery entry | `lisa discover add-entry --category <cat> --question '<q>' --answer '<a>'` |
 | View milestones | `lisa plan milestones` |
 | Add milestone | `lisa plan add-milestone --name 'Name' --description 'Desc'` |
 | Add epic | `lisa plan add-epic --milestone M1 --name 'Name' --description 'Desc'` |
 | Generate stories | `lisa plan stories E1` |
 | Mark progress | `lisa feedback mark <id> <status>` |
-| Validate plan | `lisa validate` |
 
 ## ID Formats
 
-| Type | Format | Example |
-|------|--------|---------|
-| Milestone | `M#` | `M1` |
-| Epic | `E#` | `E1` |
-| Story | `E#.S#` | `E1.S2` |
+- Milestone: `M1`, `M2`
+- Epic: `E1`, `E2`
+- Story: `E1.S1`, `E1.S2`
 
 ## References
 

package/skills/lisa/references/commands.md

@@ -15,7 +15,7 @@ lisa discover [subcommand] [options]
 | *(none)* | Start or continue discovery session |
 | `init <name>` | Initialize new project |
 | `status` | Show discovery progress and gaps |
-| `complete` | Mark discovery phase complete |
+| `history` | Show all discovery Q&A entries |
 | `add-entry` | Add discovery entry manually |
 | `epic <id>` | Start discovery for specific epic |
 | `milestone <id>` | Start discovery for milestone |
@@ -32,7 +32,7 @@ lisa discover [subcommand] [options]
 
 | Option | Description |
 |--------|-------------|
-| `--category <cat>` | Category: `problem`, `goals`, `users`, `constraints`, `scope`, `technical`, `risks`, `success` |
+| `--category <cat>` | Category: `problem`, `vision`, `users`, `values`, `constraints`, `success`, `other` |
 | `--question '<q>'` | The discovery question |
 | `--answer '<a>'` | The answer/information |
 

package/skills/lisa/references/examples.md

@@ -9,77 +9,75 @@ User says: "Help me plan a todo app"
 ```bash
 # 1. Initialize the project
 lisa discover init "Todo App"
-
-# 2. Start discovery (ask about problem, users, goals)
-lisa discover
-
-# 3. Check discovery progress
-lisa discover status
-
-# 4. For comprehensive planning, use deep mode
-lisa discover --deep
+# 2. Follow the INSTRUCTIONS in the output (it will tell you to ask discovery questions)
 ```
 
 **Key points:**
-- Always ask user for the project name before initializing
-- Discovery is iterative - run it multiple times to fill gaps
-- Check status to see what's missing
+- Ask user for project name before initializing
+- After init, follow the AI guidance in the command output
+- The guidance will prompt you to start a discovery conversation
 
 ---
 
-## Example 2: Brownfield Project (Existing Codebase)
+## Example 2: Existing Codebase
 
 User says: "Help me plan features for my existing app"
 
 ```bash
-# 1. Initialize with existing codebase
+# 1. Initialize
 lisa discover init "My Existing App"
-
-# 2. Analyze the codebase first
-lisa discover codebase
-
-# 3. Continue with regular discovery
-lisa discover
+# 2. Follow the INSTRUCTIONS - acknowledge what you learned, then ask discovery questions
 ```
 
 **Key points:**
-- Run `codebase` analysis before general discovery
-- This captures existing patterns, tech stack, and structure
+- Briefly acknowledge what you learned from the codebase (1-2 sentences)
+- Then ask the discovery question (e.g., "What problem are we solving?")
+- Do NOT offer menu options - just ask the question
 
 ---
 
 ## Example 3: Creating the Roadmap
 
-User says: "Break this into milestones and epics"
-
+User says: "I have some tickets related to knowledge improvements... need to edit digests, massage prompts..."
+
+**Step 1: Summarize what you understood**
+> "I understand you have work around Knowledge V1 MVP with several areas:
+> - Editing knowledge evaluation digests
+> - Prompt improvements for interview questions
+> - New action set digests
+> - Deprecating old digest sections
+>
+> Here's what I propose to create:
+>
+> **Milestone: Knowledge V1 MVP**
+> - Epic 1: Digest Editing - ability to edit evaluation digests
+> - Epic 2: Interview Question Improvements - prompt massage for focus
+> - Epic 3: Action Set Digests - new digest type
+> - Epic 4: Digest Cleanup - deprecate pre-arrival sections
+>
+> Does this structure look right? Any adjustments?"
+
+**Step 2: Wait for user confirmation**
+
+**Step 3: Only after approval, create the artifacts**
 ```bash
-# 1. Check discovery is sufficient
-lisa discover status
-
-# 2. Generate/view milestones
-lisa plan milestones
-
-# 3. Add milestones manually if needed
 lisa plan add-milestone \
-  --name 'MVP' \
-  --description 'Core todo CRUD functionality'
-
-lisa plan add-milestone \
-  --name 'Collaboration' \
-  --description 'Shared lists and real-time sync'
-
-# 4. Generate epics for milestone
-lisa plan epics M1
+  --name 'Knowledge V1 MVP' \
+  --description 'Core knowledge system improvements including digest editing and cleanup'
 
-# 5. Add epics manually if needed
 lisa plan add-epic \
   --milestone M1 \
-  --name 'Task Management' \
-  --description 'Create, edit, delete, complete tasks'
+  --name 'Digest Editing' \
+  --description 'Enable editing of knowledge evaluation digests'
+# ... etc
 ```
 
 **Key points:**
-- Focus on one milestone at a time with `plan epics M1`
+- **ALWAYS present proposed structure before creating**
+- Summarize user's intent first
+- List milestones and epics you plan to create
+- Wait for explicit approval
+- Never auto-create artifacts
 
 ---
 

package/skills/lisa-work/SKILL.md

@@ -73,6 +73,13 @@ lisa feedback mark E1.S2 blocked --reason "Describe the issue"
 
 **Important:** Never mark done without user confirmation.
 
+## Execution
+
+Run Lisa commands with:
+```bash
+lisa <command>  # if installed globally
+```
+
 ## Commands Reference
 
 | Action | Command |