archondev 2.19.30 → 2.19.32

package/README.md

@@ -123,6 +123,8 @@ pnpm exec tsx scripts/init-governance-db.ts
 - You can paste multi‑line requests into interactive prompts; Archon captures them as a single response.
 - Proposal approvals like `approve plan` now bind to the pending proposal context in chat mode.
 - Governance boundary/path checks in execute now steer with actionable guidance and set atoms to `BLOCKED` rather than hard failing.
+- Analysis-first requests now return recommendations first and require explicit `create atom` before task creation.
+- Chat execution now requires explicit execute intent (for example, `execute atom`) instead of generic `continue`.
 
 **Tip:** Use `archon plan --edit` to adjust title and acceptance criteria before planning.
 **Web Checks:** If Archon detects a web project, it prompts to run A11y/SEO/GEO checks and stores your preference in `.archon/config.yaml`.

package/dist/index.js

@@ -3701,6 +3701,10 @@ async function handleAgentConversationInput(cwd, input) {
     return true;
   }
   if (wantsProposalBeforeExecution(input)) {
+    if (shouldDoAnalysisBeforeAtom(input)) {
+      await provideAnalysisFirstPlan(cwd, input);
+      return true;
+    }
     await showProposalForApproval(input);
     return true;
   }
@@ -3780,16 +3784,70 @@ Showing latest planned atom (${latest.externalId})...
   await show2(latest.externalId);
 }
 function isPlanApprovalDirective(input) {
-  const normalized = input.trim().toLowerCase();
-  return normalized === "approve" || normalized === "approve plan" || normalized === "approved" || normalized === "yes" || normalized === "yes, proceed" || normalized === "proceed";
+  const normalized = normalizeDirectiveInput(input);
+  if (!normalized) return false;
+  const directApprovals = /* @__PURE__ */ new Set([
+    "approve",
+    "approve plan",
+    "approved",
+    "yes",
+    "yes proceed",
+    "y",
+    "ok",
+    "okay",
+    "proceed",
+    "go ahead",
+    "continue",
+    "do it",
+    "sounds good",
+    "looks good"
+  ]);
+  if (directApprovals.has(normalized)) return true;
+  if (normalized.startsWith("yes ")) return true;
+  if (/\b(approve|approved)\b/.test(normalized)) return true;
+  const hasProceedSignal = /\b(go ahead|proceed|continue|do it|move forward|keep going)\b/.test(normalized);
+  const hasPlanReference = /\b(plan|proposal|that|this|capsule|capsules)\b/.test(normalized);
+  return hasProceedSignal && hasPlanReference;
 }
 function isExecutionDirective(input) {
-  const normalized = input.trim().toLowerCase();
-  return normalized === "execute" || normalized === "execute atom" || normalized === "run atom" || normalized === "run it now" || normalized === "implement now" || normalized === "start execution" || normalized === "go ahead and execute";
+  const normalized = normalizeDirectiveInput(input);
+  if (!normalized) return false;
+  const directExecution = /* @__PURE__ */ new Set([
+    "execute",
+    "execute atom",
+    "run atom",
+    "run it now",
+    "implement now",
+    "start execution",
+    "go ahead and execute",
+    "execute now",
+    "run now",
+    "start now"
+  ]);
+  if (directExecution.has(normalized)) return true;
+  return /\b(execute|run|implement|start)\b/.test(normalized) && /\b(atom|task|plan|it|now)\b/.test(normalized);
 }
 function isCreateAtomDirective(input) {
-  const normalized = input.trim().toLowerCase();
-  return normalized === "create atom" || normalized === "make atom" || normalized === "save as atom" || normalized === "turn this into a task" || normalized === "create task";
+  const normalized = normalizeDirectiveInput(input);
+  if (!normalized) return false;
+  const directCreate = /* @__PURE__ */ new Set([
+    "create",
+    "create atom",
+    "save this",
+    "make atom",
+    "save as atom",
+    "turn this into a task",
+    "create task",
+    "save it",
+    "go ahead",
+    "proceed",
+    "yes"
+  ]);
+  if (directCreate.has(normalized)) return true;
+  return /\b(create|save|make|turn)\b/.test(normalized) && /\b(atom|task|plan|this|it)\b/.test(normalized);
+}
+function normalizeDirectiveInput(input) {
+  return input.trim().toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
 }
 function shouldDoAnalysisBeforeAtom(input) {
   const normalized = input.toLowerCase();
@@ -3816,9 +3874,9 @@ async function applyApprovedProposal(cwd) {
   console.log(chalk5.dim('\nReply "execute atom" when you want implementation to start, or tell me what to change.'));
 }
 async function provideAnalysisFirstPlan(cwd, request) {
-  console.log(chalk5.dim("\n> Great. I will analyze first and return a concrete recommendation before creating atoms.\n"));
+  console.log(chalk5.dim("\n> I analyzed your request and generated a recommendation + sample draft first.\n"));
   const markdownFiles = collectMarkdownFiles(cwd);
-  const dayOneCandidates = markdownFiles.filter((file) => /(day[-_ ]?0?1|lesson[-_ ]?0?1|first)/i.test(file));
+  const dayOneCandidates = markdownFiles.filter((file) => isDayOnePath(file));
   const capsuleCandidates = markdownFiles.filter((file) => /capsule/i.test(file));
   const primaryCandidates = dayOneCandidates.length > 0 ? dayOneCandidates : capsuleCandidates;
   const reviewedFiles = primaryCandidates.slice(0, 8);
@@ -3851,9 +3909,15 @@ async function provideAnalysisFirstPlan(cwd, request) {
   console.log(chalk5.dim(`  2. Define capsule boundaries and titles (${capsuleCount} capsule${capsuleCount > 1 ? "s" : ""}).`));
   console.log(chalk5.dim("  3. Draft capsule markdown(s) with consistent template and learning objective per capsule."));
   console.log(chalk5.dim("  4. Add index/manifest links and quick validation checks for user flow."));
+  const sampleDraft = buildSampleCapsuleDraft(cwd, reviewedFiles, capsuleCount);
+  if (sampleDraft) {
+    console.log();
+    console.log(chalk5.bold("Sample output for day 1 (draft):"));
+    console.log(sampleDraft);
+  }
   pendingAnalysisToAtomRequest = request;
   console.log();
-  console.log(chalk5.dim('Reply "create atom" to save this as a governed task, or tell me what to adjust first.'));
+  console.log(chalk5.dim('Reply with "yes", "go ahead", or "create atom" when you want me to implement this in governed mode.'));
 }
 function collectMarkdownFiles(cwd) {
   const results = [];
@@ -3897,6 +3961,51 @@ function computeContentStats(cwd, files) {
   }
   return { totalWords, totalHeadings };
 }
+function isDayOnePath(path2) {
+  const normalized = path2.toLowerCase();
+  return /\b(day[-_ ]?0*1|lesson[-_ ]?0*1|email[-_ ]?day[-_ ]?0*1)\b/.test(normalized) && !/\b(day[-_ ]?(?:1[0-9]|[2-9])|lesson[-_ ]?(?:1[0-9]|[2-9]))\b/.test(normalized);
+}
+function buildSampleCapsuleDraft(cwd, files, capsuleCount) {
+  if (files.length === 0) return null;
+  const primary = files[0];
+  if (!primary) return null;
+  let content = "";
+  try {
+    content = readFileSync3(join6(cwd, primary), "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = content.split("\n").map((line) => line.trim());
+  const heading = lines.find((line) => line.startsWith("#"))?.replace(/^#+\s*/, "") || "Day 1 Lesson";
+  const paragraphs = content.split("\n\n").map((p) => p.replace(/\s+/g, " ").trim()).filter((p) => p.length > 40 && !p.startsWith("#") && !p.startsWith("- ") && !p.startsWith("* "));
+  const objective = paragraphs[0] ?? "Introduce the day-1 core idea with a clear, practical framing.";
+  const concept = paragraphs[1] ?? "Explain the key concept in plain language with one relatable example.";
+  const practice = paragraphs[2] ?? "Give one guided prompt so the learner can apply the idea immediately.";
+  if (capsuleCount <= 1) {
+    return [
+      chalk5.dim("  ---"),
+      chalk5.dim(`  title: "${heading} - Core Capsule"`),
+      chalk5.dim('  type: "lesson_capsule"'),
+      chalk5.dim("  day: 1"),
+      chalk5.dim("  ---"),
+      chalk5.dim("  ## Objective"),
+      chalk5.dim(`  ${objective}`),
+      chalk5.dim("  ## Core Concept"),
+      chalk5.dim(`  ${concept}`),
+      chalk5.dim("  ## Practice"),
+      chalk5.dim(`  ${practice}`)
+    ].join("\n");
+  }
+  return [
+    chalk5.dim("  Capsule 1: Foundation"),
+    chalk5.dim(`  - Objective: ${objective}`),
+    chalk5.dim(`  - Core Concept: ${concept}`),
+    chalk5.dim(""),
+    chalk5.dim("  Capsule 2: Application"),
+    chalk5.dim(`  - Guided Practice: ${practice}`),
+    chalk5.dim("  - Reflection Prompt: What changed in your understanding after this exercise?")
+  ].join("\n");
+}
 async function continueWithCurrentTask(cwd) {
   const { listLocalAtoms: listLocalAtoms2 } = await import("./plan-RHDFDSZE.js");
   const atoms = await listLocalAtoms2();
@@ -4031,6 +4140,10 @@ function containsActionIntent(input) {
 async function handlePostExploreAction(cwd, request, options = {}) {
   const sourceInput = options.originalInput?.trim() || request;
   if (wantsProposalBeforeExecution(sourceInput)) {
+    if (shouldDoAnalysisBeforeAtom(sourceInput)) {
+      await provideAnalysisFirstPlan(cwd, sourceInput);
+      return;
+    }
     await showProposalForApproval(sourceInput);
     return;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archondev",
-  "version": "2.19.30",
+  "version": "2.19.32",
   "description": "Local-first AI-powered development governance system",
   "main": "dist/index.js",
   "bin": {