@tritard/waterbrother 0.16.44 → 0.16.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.16.44",
+  "version": "0.16.45",
   "description": "Waterbrother: bring-your-own-model coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -172,6 +172,7 @@ function buildSystemPrompt(profile, experienceMode = "standard", autonomyMode =
     }
     if (executionContext.calibration) ctxLines.push(`Scope calibration (from scored build history):\n${executionContext.calibration}`);
     if (executionContext.reminders) ctxLines.push(`Scope reminders:\n${executionContext.reminders}`);
+    if (executionContext.evolution) ctxLines.push(executionContext.evolution);
     if (ctxLines.length > 0) base += `\n\nExecution context:\n${ctxLines.join("\n")}`;
   }
   if (!memoryBlock) return base;

package/src/cli.js

@@ -47,7 +47,7 @@ import {
 } from "./frontend.js";
 import { loadTask, saveTask, listTasks, setActiveTask, getActiveTask, closeTask } from "./task-store.js";
 import { runDecisionPass, runInventPass, formatDecisionForDisplay, formatDecisionCompact, formatDecisionDetail } from "./decider.js";
-import { runBuildWorkflow, startFeatureTask, runChallengeWorkflow } from "./workflow.js";
+import { runBuildWorkflow, startFeatureTask, runChallengeWorkflow, evaluateChainRules, captureRegressionFromBuild, resolveRegressionsFromBuild, evaluatePostBuildEvolution, getEvolutionBlock } from "./workflow.js";
 import { createPanelRenderer, buildPanelState } from "./panel.js";
 import { deriveTaskNameFromPrompt, nextActionsForState, routeNaturalInput } from "./router.js";
 import { compressEpisode, compressSessionEpisode, saveEpisode, loadRecentEpisodes, findRelevantEpisodes, buildEpisodicMemoryBlock, buildReminderBlock } from "./episodic.js";
@@ -94,6 +94,10 @@ import {
   setSharedRoomMode,
   upsertSharedMember
 } from "./shared-project.js";
+import { findRelevantRegressions, buildRegressionWarningBlock } from "./regressions.js";
+import { loadUserSkills, approveSkill, disableSkill, removeSkill, buildSkillExecutionMessage, detectRepeatedPatterns } from "./skills.js";
+import { captureCorrection, findRelevantCorrections, buildLessonBlock, detectUserEdits, findPendingCorrections, extractLessons, saveLessons } from "./corrections.js";
+import { evaluateEvolution, loadProposals, approveProposal, rejectProposal, revertProposal, getActivePatches, buildEvolutionBlock, validateProposalSafety } from "./evolution.js";
 
 const execFileAsync = promisify(execFile);
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -226,7 +230,18 @@ const INTERACTIVE_COMMANDS = [
   { name: "/cost", description: "Show session token usage and cost breakdown" },
   { name: "/diff", description: "Show git changes in the current repo" },
   { name: "/voice", description: "Toggle voice dictation (press space to record)" },
-  { name: "/speak", description: "Toggle TTS — agent reads responses aloud (esc to stop)" }
+  { name: "/speak", description: "Toggle TTS — agent reads responses aloud (esc to stop)" },
+  { name: "/skill list", description: "Show all loaded skills" },
+  { name: "/skill approve <name>", description: "Approve or re-approve a skill" },
+  { name: "/skill disable <name>", description: "Disable a skill" },
+  { name: "/skill remove <name>", description: "Delete a skill file" },
+  { name: "/correct <file>", description: "Flag a file as a correction to agent work" },
+  { name: "/evolve", description: "Show evolution summary — active patches, pending proposals, stats" },
+  { name: "/evolve propose", description: "Manually trigger evolution evaluation" },
+  { name: "/evolve approve <id>", description: "Approve a pending evolution proposal" },
+  { name: "/evolve reject <id>", description: "Reject a pending evolution proposal" },
+  { name: "/evolve revert <id>", description: "Revert an applied evolution patch" },
+  { name: "/evolve history", description: "Show full evolution history with score deltas" }
 ];
 
 const AGENT_PROFILES = ["coder", "designer", "reviewer", "planner"];
@@ -1253,6 +1268,7 @@ async function enrichTurnArtifacts({ agent, context, promptText, assistantText,
     receipt = await agent.toolRuntime.updateReceipt(receipt.id, updates) || receipt;
   }
 
+  receipt._buildCompletedAt = receipt._buildCompletedAt || new Date().toISOString();
   context.runtime.lastReceipt = receipt;
   context.runtime.lastImpact = impact || receipt.impact || null;
   return receipt;
@@ -1364,7 +1380,8 @@ async function finalizeReceiptArtifacts({
   const finalReceipt = Object.keys(updates).length > 0
     ? (await agent.toolRuntime.updateReceipt(receipt.id, updates) || receipt)
     : receipt;
-  context.runtime.lastReceipt = finalReceipt;
+  finalReceipt._buildCompletedAt = new Date().toISOString();
+                context.runtime.lastReceipt = finalReceipt;
   context.runtime.lastImpact = artifacts?.impact || finalReceipt.impact || null;
   return finalReceipt;
 }
@@ -7325,7 +7342,30 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       }
     }
 
-    if (!routed || routed.kind === "none" || routed.kind === "chat") return false;
+    // Phase 2A: Skill dispatch — check user-authored skills when built-in router has no match
+    if (!routed || routed.kind === "none" || routed.kind === "chat") {
+      try {
+        const loadedSkills = await loadUserSkills(context.cwd);
+        const matchedSkill = loadedSkills.find((s) => line === s.name || line.startsWith(s.name + " "));
+        if (matchedSkill) {
+          const skillArgs = line.slice(matchedSkill.name.length).trim();
+          const skillMessage = buildSkillExecutionMessage(matchedSkill, skillArgs);
+          // Inject as user-role message, NOT system prompt
+          const skillSpinner = createProgressSpinner(`running skill ${matchedSkill.name}...`);
+          try {
+            const skillResponse = await agent.runBuildTurn(skillMessage, {});
+            skillSpinner.stop();
+            const skillContent = skillResponse?.content || "";
+            if (skillContent) printAssistantOutput(skillContent);
+          } catch (skillErr) {
+            skillSpinner.stop();
+            console.log(`Skill ${matchedSkill.name} failed: ${skillErr instanceof Error ? skillErr.message : String(skillErr)}`);
+          }
+          return true;
+        }
+      } catch {}
+      return false;
+    }
 
     try {
       if (routed.kind === "start-work") {
@@ -7725,8 +7765,19 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
     if (line.startsWith("/") && !line.includes(" ")) {
       const hasExact = INTERACTIVE_COMMANDS.some((command) => command.name === line);
       if (!hasExact) {
-        printSlashMenu(line);
-        continue;
+        // Check user-authored skills before showing "no match"
+        let isSkill = false;
+        try {
+          const { loadUserSkills } = await import("./skills.js");
+          const skills = await loadUserSkills(context.cwd);
+          isSkill = skills.some((s) => s.name === line);
+        } catch (skillErr) {
+          process.stderr.write(`[skills] Failed to load skills: ${skillErr instanceof Error ? skillErr.message : String(skillErr)}\n`);
+        }
+        if (!isSkill) {
+          printSlashMenu(line);
+          continue;
+        }
       }
     }
 
@@ -8988,25 +9039,57 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
 
       await maybeAutoCompactConversation({ agent, currentSession, context, pendingInput: buildPrompt });
 
-      // Inject adaptive reminders from episodic memory
+      // Inject adaptive reminders from episodic memory + regressions + corrections
       try {
         const contractPaths = task.activeContract?.paths || [];
         const taskTags = [task.name, task.goal].filter(Boolean).join(" ").toLowerCase().split(/\s+/).filter((w) => w.length >= 3);
         const relevant = await findRelevantEpisodes({ cwd: context.cwd, filePatterns: contractPaths, tags: taskTags, limit: 3 });
+        let reminders = "";
         if (relevant.length > 0) {
-          const reminders = buildReminderBlock({
+          reminders = buildReminderBlock({
             episodes: relevant,
             memoryText: context.runtime.projectMemory?.raw || "",
             contractPaths
           });
-          if (reminders) {
-            agent.setExecutionContext({
-              taskName: task.name,
-              chosenOption: task.chosenOption || null,
-              contractSummary: task.activeContract?.summary || null,
-              phase: "build",
-              reminders
-            });
+        }
+        // Phase 1B: Inject regression warnings for overlapping paths
+        try {
+          const regressions = await findRelevantRegressions({ cwd: context.cwd, contractPaths, limit: 5 });
+          const regBlock = buildRegressionWarningBlock(regressions);
+          if (regBlock) reminders = (reminders || "") + regBlock;
+        } catch {}
+        // Phase 2B: Inject lesson block from corrections
+        try {
+          const corrections = await findRelevantCorrections({ cwd: context.cwd, contractPaths, limit: 5 });
+          const lessonBlock = buildLessonBlock(corrections);
+          if (lessonBlock) reminders = (reminders || "") + lessonBlock;
+        } catch {}
+        if (reminders) {
+          agent.setExecutionContext({
+            taskName: task.name,
+            chosenOption: task.chosenOption || null,
+            contractSummary: task.activeContract?.summary || null,
+            phase: "build",
+            reminders
+          });
+        }
+      } catch {}
+
+      // Phase 2B: Detect and capture user corrections since last build
+      try {
+        const lastReceipt = context.runtime.lastReceipt;
+        if (lastReceipt) {
+          const editedFiles = await detectUserEdits({ cwd: context.cwd, receipt: lastReceipt });
+          for (const ef of editedFiles) {
+            try {
+              let diff = "";
+              try {
+                const { stdout } = await execFileAsync("git", ["diff", "--", ef], { cwd: context.cwd, maxBuffer: 50 * 1024 });
+                diff = stdout;
+              } catch {}
+              await captureCorrection({ cwd: context.cwd, filePath: ef, diff, type: "user-edit" });
+              console.log(dim(`Correction captured: ${ef} (you edited it after the last build). Use /correct undo to revert if unintentional.`));
+            } catch {}
           }
         }
       } catch {}
@@ -9231,6 +9314,80 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
         await setSessionRunState(currentSession, agent, "done");
         await saveCurrentSession(currentSession, agent);
         updatePanel();
+
+        // Phase 1: Post-build chain rules, regression capture/resolution
+        if (buildResult.receipt) {
+          const finalReceipt = buildResult.receipt;
+          finalReceipt._buildCompletedAt = finalReceipt._buildCompletedAt || new Date().toISOString();
+          context.runtime.lastReceipt = finalReceipt;
+
+          // Phase 1B: Capture regression on failure, resolve on success
+          try {
+            await captureRegressionFromBuild(finalReceipt, task, context.cwd);
+            await resolveRegressionsFromBuild(finalReceipt, context.cwd);
+          } catch {}
+
+          // Phase 1A: Evaluate chain rules
+          try {
+            const chainResult = evaluateChainRules(finalReceipt, buildResult.verifierResults, context.runtime.chainRules, {
+              onChainSuggestion({ key }) {
+                if (key === "build:sentinel-caution") {
+                  console.log(dim("Sentinel flagged caution. Use /challenge to adversarial review."));
+                }
+              }
+            });
+
+            if (chainResult?.nextAction === "challenge") {
+              console.log(dim("Sentinel blocked. Auto-challenging..."));
+              const challengeSpinner = createProgressSpinner("challenging...");
+              try {
+                const challengeResult = await runChallengeWorkflow({
+                  apiKey: context.runtime.apiKey,
+                  baseUrl: context.runtime.baseUrl,
+                  model: context.runtime.reviewer?.model || agent.getModel(),
+                  receipt: chainResult.receipt,
+                  impact: finalReceipt.impact || null,
+                  task,
+                  maxDiffChars: context.runtime.reviewer?.maxDiffChars,
+                  signal: null
+                });
+                challengeSpinner.stop();
+                console.log("--- Auto-Challenge Result ---");
+                console.log(challengeResult.summary);
+                if (challengeResult.concerns.length > 0) {
+                  for (const c of challengeResult.concerns) console.log(`  ${red("•")} ${c}`);
+                }
+                console.log("---");
+                await agent.toolRuntime.updateReceipt(finalReceipt.id, { challenge: challengeResult });
+                finalReceipt.challenge = challengeResult;
+                finalReceipt._buildCompletedAt = new Date().toISOString();
+                context.runtime.lastReceipt = finalReceipt;
+              } catch (challengeErr) {
+                challengeSpinner.stop();
+                console.log(`auto-challenge failed: ${challengeErr instanceof Error ? challengeErr.message : String(challengeErr)}`);
+              }
+            }
+          } catch {}
+
+          // Phase 3: Post-build evolution evaluation
+          try {
+            const evolutionResult = await evaluatePostBuildEvolution({
+              cwd: context.cwd,
+              receipt: finalReceipt,
+              task
+            });
+            if (evolutionResult.proposal) {
+              const ep = evolutionResult.proposal;
+              console.log(dim(`Evolution proposal: [${ep.category}] ${ep.description}`));
+              console.log(dim(`  Approve with: /evolve approve ${ep.id}`));
+            }
+            for (const ab of (evolutionResult.abResults || [])) {
+              if (ab.suggestion === "revert") {
+                console.log(yellow(`A/B: ${ab.message}`));
+              }
+            }
+          } catch {}
+        }
       } catch (error) {
         clearInterval(heartbeatTimer);
         detachInterruptListener();
@@ -9339,6 +9496,7 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
         // Persist challenge to receipt
         await agent.toolRuntime.updateReceipt(receipt.id, { challenge: result });
         receipt.challenge = result;
+        receipt._buildCompletedAt = receipt._buildCompletedAt || new Date().toISOString();
         context.runtime.lastReceipt = receipt;
       } catch (error) {
         spinner.stop();
@@ -9347,6 +9505,238 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       continue;
     }
 
+    // Phase 2A: /skill commands
+    if (line === "/skill" || line.startsWith("/skill ")) {
+      const skillArgs = line.replace("/skill", "").trim();
+      const skillParts = skillArgs.split(/\s+/);
+      const subCmd = skillParts[0] || "list";
+      const skillName = skillParts.slice(1).join(" ");
+
+      if (subCmd === "list") {
+        try {
+          const skills = await loadUserSkills(context.cwd);
+          if (skills.length === 0) {
+            console.log("No approved skills loaded.");
+            console.log(dim("Place .md skill files in .waterbrother/skills/ or ~/.waterbrother/skills/"));
+          } else {
+            console.log(`Loaded skills (${skills.length}):`);
+            for (const s of skills) {
+              console.log(`  ${cyan(s.name)} — ${s.description || "(no description)"}`);
+              if (s.trigger) console.log(`    ${dim("trigger:")} ${s.trigger}`);
+              console.log(`    ${dim("source:")} ${s.source}`);
+            }
+          }
+        } catch (err) {
+          console.log(`Failed to load skills: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      } else if (subCmd === "approve" && skillName) {
+        try {
+          const result = await approveSkill(context.cwd, skillName);
+          if (result) {
+            console.log(`Approved skill ${cyan(result.name)} (hash: ${result.contentHash})`);
+          } else {
+            console.log(`Skill "${skillName}" not found.`);
+          }
+        } catch (err) {
+          console.log(`Failed to approve skill: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      } else if (subCmd === "disable" && skillName) {
+        try {
+          const result = await disableSkill(context.cwd, skillName);
+          if (result) {
+            console.log(`Disabled skill ${result.name}`);
+          } else {
+            console.log(`Skill "${skillName}" not found.`);
+          }
+        } catch (err) {
+          console.log(`Failed to disable skill: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      } else if (subCmd === "remove" && skillName) {
+        try {
+          const confirmed = await promptYesNo(`Remove skill "${skillName}" permanently?`);
+          if (!confirmed) { continue; }
+          const result = await removeSkill(context.cwd, skillName);
+          if (result) {
+            console.log(`Removed skill ${result.name} from ${result.source}`);
+          } else {
+            console.log(`Skill "${skillName}" not found.`);
+          }
+        } catch (err) {
+          console.log(`Failed to remove skill: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      } else {
+        console.log("Usage: /skill list | approve <name> | disable <name> | remove <name>");
+      }
+      continue;
+    }
+
+    // Phase 2B: /correct command
+    if (line === "/correct" || line.startsWith("/correct ")) {
+      const correctArgs = line.replace("/correct", "").trim();
+      if (!correctArgs) {
+        console.log("Usage: /correct <file> — Flag a file as a correction to agent work");
+        continue;
+      }
+      try {
+        let diff = "";
+        try {
+          const { stdout } = await execFileAsync("git", ["diff", "--", correctArgs], { cwd: context.cwd, maxBuffer: 50 * 1024 });
+          diff = stdout;
+        } catch {}
+        if (!diff) {
+          try {
+            const { stdout } = await execFileAsync("git", ["diff", "HEAD", "--", correctArgs], { cwd: context.cwd, maxBuffer: 50 * 1024 });
+            diff = stdout;
+          } catch {}
+        }
+        const entry = await captureCorrection({ cwd: context.cwd, filePath: correctArgs, diff, type: "explicit" });
+        console.log(`Captured correction ${dim(entry.id)} for ${correctArgs}`);
+      } catch (err) {
+        console.log(`Failed to capture correction: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      continue;
+    }
+
+    // Phase 3: /evolve commands
+    if (line === "/evolve" || line.startsWith("/evolve ")) {
+      const evolveArgs = line.replace("/evolve", "").trim();
+      const evolveParts = evolveArgs.split(/\s+/);
+      const evolveSubCmd = evolveParts[0] || "";
+      const evolveTarget = evolveParts.slice(1).join(" ").trim();
+
+      try {
+        if (!evolveSubCmd) {
+          // /evolve — Show evolution summary
+          const proposals = await loadProposals(context.cwd);
+          const pending = proposals.filter((p) => p.status === "proposed");
+          const approved = proposals.filter((p) => p.status === "approved");
+          const rejected = proposals.filter((p) => p.status === "rejected");
+          const reverted = proposals.filter((p) => p.status === "reverted");
+
+          console.log("--- Evolution Dashboard ---");
+          console.log(`Proposals: ${proposals.length} total (${pending.length} pending, ${approved.length} active, ${rejected.length} rejected, ${reverted.length} reverted)`);
+
+          if (pending.length > 0) {
+            console.log("\nPending proposals:");
+            for (const p of pending) {
+              console.log(`  ${yellow(p.id)} [${p.category}] ${p.description}`);
+            }
+          }
+
+          if (approved.length > 0) {
+            console.log("\nActive patches:");
+            for (const p of approved) {
+              const scoreDelta = p.scoreBeforeApply != null && p.scoreAfterApply != null
+                ? ` (before: ${(p.scoreBeforeApply * 100).toFixed(0)}%, after: ${(p.scoreAfterApply * 100).toFixed(0)}%)`
+                : "";
+              console.log(`  ${green(p.id)} [${p.category}] ${p.description}${scoreDelta}`);
+            }
+          }
+
+          if (proposals.length === 0) {
+            console.log(dim("No evolution proposals yet. Proposals are generated automatically after builds."));
+          }
+        } else if (evolveSubCmd === "propose") {
+          // /evolve propose — Manual trigger
+          console.log("Evaluating evolution...");
+          const { proposal, abResults } = await evaluatePostBuildEvolution({
+            cwd: context.cwd,
+            receipt: context.runtime.lastReceipt || {},
+            task: context.runtime.activeTask || null
+          });
+          if (proposal) {
+            console.log(`New proposal: ${yellow(proposal.id)} [${proposal.category}]`);
+            console.log(`  ${proposal.description}`);
+            console.log(`  Patch: ${proposal.patch}`);
+            console.log(dim(`  Approve with: /evolve approve ${proposal.id}`));
+          } else {
+            console.log("No evolution proposals generated from current data.");
+          }
+          for (const ab of abResults) {
+            if (ab.suggestion === "revert") {
+              console.log(yellow(ab.message));
+            } else {
+              console.log(dim(ab.message));
+            }
+          }
+        } else if (evolveSubCmd === "approve") {
+          if (!evolveTarget) {
+            console.log("Usage: /evolve approve <id>");
+          } else {
+            // Load scorecards to get actual build count (not proposal count)
+            let buildCount = 0;
+            try {
+              const scDir = path.join(context.cwd, ".waterbrother", "memory", "scorecards");
+              const scIndex = JSON.parse(await fs.readFile(path.join(scDir, "index.json"), "utf8"));
+              buildCount = Array.isArray(scIndex) ? scIndex.length : 0;
+            } catch {}
+            const safety = validateProposalSafety(
+              await loadProposals(context.cwd).then((all) => all.find((p) => p.id === evolveTarget)) || { category: "unknown", patch: "" },
+              buildCount
+            );
+            if (!safety.safe) {
+              console.log(red(`Safety check failed: ${safety.reason}`));
+            } else {
+              const approved = await approveProposal(context.cwd, evolveTarget);
+              if (!approved) {
+                console.log("Proposal not found.");
+              } else if (approved.status !== "approved") {
+                console.log(`Proposal ${evolveTarget} is in status "${approved.status}" — only pending proposals can be approved.`);
+              } else {
+                console.log(green(`Approved: ${approved.description}`));
+                console.log(dim("Patch will be injected as a Learned Convention in the next build."));
+              }
+            }
+          }
+        } else if (evolveSubCmd === "reject") {
+          if (!evolveTarget) {
+            console.log("Usage: /evolve reject <id>");
+          } else {
+            const rejected = await rejectProposal(context.cwd, evolveTarget);
+            if (!rejected) {
+              console.log("Proposal not found.");
+            } else {
+              console.log(`Rejected: ${rejected.description}`);
+            }
+          }
+        } else if (evolveSubCmd === "revert") {
+          if (!evolveTarget) {
+            console.log("Usage: /evolve revert <id>");
+          } else {
+            const proposals = await loadProposals(context.cwd);
+            const target = proposals.find((p) => p.id === evolveTarget);
+            if (!target) {
+              console.log("Proposal not found.");
+            } else {
+              const reverted = await revertProposal(context.cwd, evolveTarget);
+              if (reverted) {
+                console.log(`Reverted: ${reverted.description}`);
+              }
+            }
+          }
+        } else if (evolveSubCmd === "history") {
+          const proposals = await loadProposals(context.cwd);
+          if (proposals.length === 0) {
+            console.log("No evolution history.");
+          } else {
+            console.log("--- Evolution History ---");
+            for (const p of proposals) {
+              const statusColor = p.status === "approved" ? green : p.status === "rejected" ? red : p.status === "reverted" ? yellow : dim;
+              const scoreDelta = p.scoreBeforeApply != null && p.scoreAfterApply != null
+                ? `  score: ${(p.scoreBeforeApply * 100).toFixed(0)}% -> ${(p.scoreAfterApply * 100).toFixed(0)}%`
+                : "";
+              console.log(`  ${statusColor(p.status.padEnd(10))} ${p.id} [${p.category}] ${p.description}${scoreDelta}`);
+            }
+          }
+        } else {
+          console.log("Usage: /evolve [propose|approve <id>|reject <id>|revert <id>|history]");
+        }
+      } catch (err) {
+        console.log(`Evolution error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      continue;
+    }
+
     if (line === "/experiment" || line.startsWith("/experiment ")) {
       // Parse: /experiment <goal> --metric "command" --attempts N --time M
       const rawArgs = line.replace("/experiment", "").trim();
@@ -10066,7 +10456,23 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       continue;
     }
 
+    // Check user-authored skills before rejecting unknown slash commands
     if (line.startsWith("/")) {
+      let skillHandled = false;
+      try {
+        const { loadUserSkills, buildSkillExecutionMessage } = await import("./skills.js");
+        const loadedSkills = await loadUserSkills(context.cwd);
+        const matchedSkill = loadedSkills.find((s) => line === s.name || line.startsWith(s.name + " "));
+        if (matchedSkill) {
+          skillHandled = true;
+          const skillArgs = line.slice(matchedSkill.name.length).trim();
+          const skillMessage = buildSkillExecutionMessage(matchedSkill, skillArgs);
+          await runTextTurnInteractive({ agent, currentSession, context, promptText: skillMessage, pendingInput: line, spinnerLabel: `running skill ${matchedSkill.name}...` });
+        }
+      } catch (skillErr) {
+        process.stderr.write(`[skills] Skill dispatch failed: ${skillErr instanceof Error ? skillErr.message : String(skillErr)}\n`);
+      }
+      if (skillHandled) continue;
       console.log("Unknown slash command. Use /help.");
       continue;
     }
@@ -10162,6 +10568,7 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
                 task.state = "review-ready";
                 await saveTask({ cwd: context.cwd, task });
                 context.runtime.activeTask = task;
+                receipt._buildCompletedAt = receipt._buildCompletedAt || new Date().toISOString();
                 context.runtime.lastReceipt = receipt;
               }
               console.log(`────────────────────────────────────────────────────────────────────────`);