@tritard/waterbrother 0.5.13 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.5.13",
+  "version": "0.6.0",
   "description": "Waterbrother: Grok-powered coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -15,9 +15,10 @@ import { AUTONOMY_MODES, buildOperatorIdentity, EXPERIENCE_MODES, modeDefaults,
 import { computeImpactMap } from "./impact.js";
 import { reviewTurn } from "./reviewer.js";
 import { loadTask, saveTask, listTasks, setActiveTask, getActiveTask, closeTask } from "./task-store.js";
-import { runDecisionPass, formatDecisionForDisplay } from "./decider.js";
+import { runDecisionPass, runInventPass, formatDecisionForDisplay, formatDecisionCompact, formatDecisionDetail } from "./decider.js";
 import { runBuildWorkflow, startFeatureTask, runChallengeWorkflow } from "./workflow.js";
 import { createPanelRenderer, buildPanelState } from "./panel.js";
+import { deriveTaskNameFromPrompt, nextActionsForState, routeNaturalInput } from "./router.js";
 
 const execFileAsync = promisify(execFile);
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -1633,28 +1634,6 @@ async function pathExists(targetPath) {
   }
 }
 
-function detectCasualInput(line) {
-  const text = line.trim().toLowerCase();
-  const words = text.split(/\s+/);
-  // Short messages (1-4 words) that don't look like commands or code tasks
-  if (words.length > 8) return false;
-  // Greetings and casual phrases
-  const casualPatterns = [
-    /^(hey|hi|hello|sup|yo|what'?s? up|howdy|hola|heya|hiya|good (morning|evening|afternoon|night))[\s!.?]*$/,
-    /^(thanks|thank you|thx|ty|cheers|cool|nice|ok|okay|sure|yep|yup|nope|nah|lol|lmao|haha|heh|hmm|bruh|bro|dude)[\s!.?]*$/,
-    /^(how are you|how'?s? it going|what'?s? good|what'?s? new|how do you do)[\s!.?]*$/,
-    /^(bye|goodbye|see ya|later|peace|gn|good night|ttyl|cya)[\s!.?]*$/,
-    /^(who are you|what are you|tell me about yourself)[\s!.?]*$/,
-  ];
-  for (const pattern of casualPatterns) {
-    if (pattern.test(text)) return true;
-  }
-  // Very short non-code messages (1-3 words, no code-like tokens)
-  if (words.length <= 3 && !/[./\\{}()\[\]<>=;:|`$@#]/.test(text) && !/\b(fix|build|create|add|remove|delete|update|install|run|test|write|read|edit|debug|deploy|commit|push|pull|merge|refactor|implement|check)\b/.test(text)) {
-    return true;
-  }
-  return false;
-}
 
 async function detectDroppedImageInput(line, cwd) {
   const tokens = tokenizeShellInput(line);
@@ -4087,9 +4066,240 @@ async function promptLoop(agent, session, context) {
       cwd: context.cwd,
       task,
       agent,
-      receipt
+      receipt,
+      runtime: context.runtime
     }));
   }
+
+  function setCockpitState({ pass = null, summary = null, actions = null } = {}) {
+    if (pass) context.runtime.activePass = String(pass).toUpperCase();
+    if (summary !== null) context.runtime.panelSummary = summary;
+    if (actions) context.runtime.actionHints = actions;
+    const task = context.runtime.activeTask;
+    if (task && pass) task.lastPass = String(pass).toUpperCase();
+    updatePanel();
+  }
+
+  function renderCompactDecisionBlock(task, decision, { invent = false } = {}) {
+    const mode = agent.getExperienceMode();
+    const title = task?.name || decision?.goal || (invent ? "invent" : "decision");
+    console.log(formatDecisionCompact(decision, { mode, title }));
+    const actions = decision.options.map((_, i) => String(i + 1));
+    actions.push("go");
+    if (decision.options.length >= 2) actions.push("tell me more about 2");
+    setCockpitState({
+      pass: invent ? "INVENT" : "DECIDE",
+      summary: invent ? "divergent options ready" : "options ready",
+      actions
+    });
+  }
+
+  function renderDecisionDetailBlock(task, decision, optionIndex) {
+    console.log(formatDecisionDetail(decision, optionIndex));
+    const actions = decision.options.map((_, i) => String(i + 1));
+    actions.push("go");
+    setCockpitState({ pass: task?.lastPass || "DECIDE", summary: `details for option ${optionIndex}`, actions });
+  }
+
+  function renderReviewCockpit(task, receipt) {
+    const concerns = [];
+    if (receipt?.review?.concerns?.length) concerns.push(...receipt.review.concerns);
+    if (receipt?.challenge?.concerns?.length) {
+      for (const c of receipt.challenge.concerns) if (!concerns.includes(c)) concerns.push(c);
+    }
+    const verificationFailed = Array.isArray(receipt?.verification) && receipt.verification.some((v) => !v.ok);
+    const blocked = verificationFailed || receipt?.review?.verdict === "block";
+    if (concerns.length === 0 && !blocked) {
+      console.log(`${green("✓")} no issues found`);
+      console.log(dim("accept · redo · challenge harder · ship it"));
+      setCockpitState({ pass: "CHALLENGE", summary: "no issues found", actions: ["accept", "redo", "challenge harder", "ship it"] });
+      return;
+    }
+    for (const concern of concerns.slice(0, 3)) {
+      console.log(`${yellow("⚠")} ${concern}`);
+    }
+    console.log(dim(blocked ? "fix these · ignore · challenge harder" : "fix these · ignore · challenge harder · ship it"));
+    setCockpitState({ pass: "CHALLENGE", summary: `${concerns.length || 1} issue${(concerns.length || 1) === 1 ? "" : "s"} found`, actions: blocked ? ["fix these", "ignore", "challenge harder"] : ["fix these", "ignore", "challenge harder", "ship it"] });
+  }
+
+  function latestReviewConcerns(receipt) {
+    const items = [];
+    if (receipt?.review?.concerns?.length) items.push(...receipt.review.concerns);
+    if (receipt?.challenge?.concerns?.length) {
+      for (const c of receipt.challenge.concerns) if (!items.includes(c)) items.push(c);
+    }
+    return items;
+  }
+
+  function canShipReceipt(receipt) {
+    if (!receipt) return { ok: false, reason: "no receipt available" };
+    if (Array.isArray(receipt.verification) && receipt.verification.some((v) => !v.ok)) {
+      return { ok: false, reason: "verification has failing checks" };
+    }
+    if (receipt.review?.verdict === "block") {
+      return { ok: false, reason: "sentinel marked this receipt as blocking" };
+    }
+    return { ok: true, reason: "" };
+  }
+
+  async function ensureTaskFromNaturalInput(line) {
+    const existing = context.runtime.activeTask;
+    if (existing) return existing;
+    const taskName = deriveTaskNameFromPrompt(line);
+    const branchPrefix = context.runtime.taskDefaults?.branchPrefix || "wb/";
+    const { task } = await startFeatureTask({
+      cwd: context.cwd,
+      name: taskName,
+      sessionId: currentSession.id,
+      mode: agent.getExperienceMode(),
+      autonomy: agent.getAutonomyMode(),
+      branchPrefix
+    });
+    attachTaskToSession(currentSession, task.id);
+    context.runtime.activeTask = task;
+    agent.toolRuntime.setTaskContext({ taskId: task.id, taskName: task.name });
+    await saveCurrentSession(currentSession, agent);
+    return task;
+  }
+
+  async function runNaturalDecision({ task, goal, invent = false }) {
+    const spinner = createProgressSpinner(invent ? "thinking wider..." : "running decision pass...");
+    try {
+      const decisionModel = context.runtime.decisionModel || agent.getModel();
+      const runner = invent ? runInventPass : runDecisionPass;
+      const { decision } = await runner({
+        apiKey: context.runtime.apiKey,
+        baseUrl: context.runtime.baseUrl,
+        model: decisionModel,
+        goal,
+        taskName: task.name,
+        memory: context.runtime.projectMemory?.promptText || "",
+        signal: null
+      });
+      spinner.stop();
+      task.goal = goal;
+      task.decisionId = `dec_${Date.now()}`;
+      task.lastDecision = decision;
+      task.lastDecisionType = invent ? "invent" : "decide";
+      task.state = "decision-ready";
+      task.lastPass = invent ? "INVENT" : "DECIDE";
+      await saveTask({ cwd: context.cwd, task });
+      context.runtime.activeTask = task;
+      renderCompactDecisionBlock(task, decision, { invent });
+      return decision;
+    } catch (error) {
+      spinner.stop();
+      throw error;
+    }
+  }
+
+  async function chooseDecisionOption(task, optionIndexOrId) {
+    if (!task?.lastDecision) throw new Error("no decision available");
+    let option = null;
+    if (typeof optionIndexOrId === "number") {
+      option = task.lastDecision.options[Math.max(0, optionIndexOrId - 1)] || null;
+    } else {
+      const choiceId = String(optionIndexOrId || "").trim().toLowerCase();
+      option = task.lastDecision.options.find((o) => o.id.toLowerCase() === choiceId) || null;
+    }
+    if (!option) throw new Error("option not found");
+    task.chosenOption = option.id;
+    task.activeContract = {
+      summary: `${task.name}: ${option.title}`,
+      paths: option.scope?.paths || [],
+      commands: option.scope?.commands || [],
+      verification: option.scope?.commands || [],
+      risk: option.risk || "medium"
+    };
+    task.state = "build-ready";
+    task.lastPass = task.lastDecisionType === "invent" ? "INVENT" : "DECIDE";
+    agent.toolRuntime.setCurrentContract(task.activeContract);
+    agent.toolRuntime.setTaskContext({ taskId: task.id, taskName: task.name, decisionId: task.decisionId, chosenOption: option.id });
+    await saveTask({ cwd: context.cwd, task });
+    context.runtime.activeTask = task;
+    setCockpitState({ pass: task.lastPass || "DECIDE", summary: `option locked: ${option.title}`, actions: ["build it", "check it", "think deeper"] });
+    console.log(`${cyan("locked")} ${option.title}`);
+    return option;
+  }
+
+  async function acceptLatestReceipt(task, { natural = false } = {}) {
+    if (!task) throw new Error("no active task");
+    if (!task.latestReceiptId) throw new Error("no receipt to accept");
+    const receipt = context.runtime.lastReceipt || await agent.toolRuntime.readReceipt(task.latestReceiptId);
+    const gate = canShipReceipt(receipt);
+    if (!gate.ok) throw new Error(gate.reason);
+    await agent.toolRuntime.markReceiptAccepted(task.latestReceiptId);
+    task.accepted = true;
+    task.state = "accepted";
+    task.lastPass = "CHALLENGE";
+    await saveTask({ cwd: context.cwd, task });
+    context.runtime.activeTask = task;
+    setCockpitState({ pass: "CHALLENGE", summary: natural ? "accepted — ready to close or ship" : "receipt accepted", actions: ["close", "start next task"] });
+    console.log(`receipt ${task.latestReceiptId} accepted`);
+  }
+
+  async function handleNaturalInput(line) {
+    const routed = routeNaturalInput(line, { task: context.runtime.activeTask });
+    if (!routed || routed.kind === "none" || routed.kind === "chat") return false;
+
+    try {
+      if (routed.kind === "start-work") {
+        const task = await ensureTaskFromNaturalInput(line);
+        await runNaturalDecision({ task, goal: line, invent: false });
+        return true;
+      }
+
+      const task = context.runtime.activeTask;
+      if (!task) return false;
+
+      if (routed.kind === "decision-detail") {
+        renderDecisionDetailBlock(task, task.lastDecision, routed.optionIndex);
+        return true;
+      }
+
+      if (routed.kind === "choose") {
+        await chooseDecisionOption(task, routed.optionIndex);
+        return true;
+      }
+
+      if (routed.kind === "choose-recommended-and-build") {
+        const pick = task.lastDecision?.recommendation || 1;
+        await chooseDecisionOption(task, pick);
+        line = "/build";
+      } else if (routed.kind === "decide") {
+        await runNaturalDecision({ task, goal: line, invent: false });
+        return true;
+      } else if (routed.kind === "invent") {
+        await runNaturalDecision({ task, goal: line, invent: true });
+        return true;
+      } else if (routed.kind === "accept") {
+        await acceptLatestReceipt(task, { natural: true });
+        return true;
+      } else if (routed.kind === "fix-review-findings") {
+        const receipt = context.runtime.lastReceipt || await agent.toolRuntime.readReceipt(task.latestReceiptId || "last");
+        const concerns = latestReviewConcerns(receipt);
+        const prompt = concerns.length > 0
+          ? `Fix these review findings for task ${task.name}: ${concerns.join("; ")}`
+          : `Redo the last build for task ${task.name}, tightening any obvious gaps.`;
+        return { rewrittenLine: `/build ${prompt}` };
+      } else if (routed.kind === "build" && (task.state === "build-ready" || task.state === "review-ready")) {
+        line = "/build";
+      } else if (routed.kind === "challenge") {
+        line = "/challenge";
+      } else if (routed.kind === "ignore") {
+        console.log("ignored for now — you can say ship it, build it, or challenge harder");
+        setCockpitState({ pass: "CHALLENGE", summary: "review concerns acknowledged", actions: ["fix these", "challenge harder", "ship it"] });
+        return true;
+      } else {
+        return false;
+      }
+    } catch (error) {
+      console.log(error instanceof Error ? error.message : String(error));
+      return true;
+    }
+
+    return { rewrittenLine: line };
+  }
   if (context.runtime.activeTask) {
     updatePanel();
   }
@@ -4118,7 +4328,7 @@ async function promptLoop(agent, session, context) {
   }
 
   while (true) {
-    const line = normalizeInteractiveInput(
+    let line = normalizeInteractiveInput(
       await readInteractiveLine({
         getFooterText(inputBuffer) {
           return buildInteractiveFooter({
@@ -5564,26 +5774,56 @@ async function promptLoop(agent, session, context) {
       continue;
     }
 
-    // Intent detection: casual/conversational input runs without tools
-    const isCasual = detectCasualInput(line);
-    if (isCasual) {
-      const prevTools = agent.enableTools;
-      agent.enableTools = false;
-      try {
-        await runTextTurnInteractive({
-          agent,
-          currentSession,
-          context,
-          promptText: line,
-          pendingInput: line,
-          spinnerLabel: "thinking..."
-        });
-      } finally {
-        agent.enableTools = prevTools;
+    // Natural language intent routing
+    const naturalResult = await handleNaturalInput(line);
+    if (naturalResult === true) {
+      continue;
+    }
+    if (naturalResult && typeof naturalResult === "object" && naturalResult.rewrittenLine) {
+      // Rewritten to a slash command — execute it directly as if typed
+      const rewritten = naturalResult.rewrittenLine;
+      if (rewritten === "/build" || rewritten.startsWith("/build ")) {
+        // Trigger the /build handler with the rewritten prompt
+        line = rewritten;
+        // Fall through — the /build handler above already ran or line is now /build
+        // We need to re-trigger, so just run build inline
+        const task = context.runtime.activeTask;
+        if (task) {
+          const buildArg = rewritten.replace("/build", "").trim();
+          const buildPrompt = buildArg || (task.chosenOption ? `Execute the chosen approach: ${task.chosenOption}` : `Build: ${task.name}`);
+          try {
+            await runTextTurnInteractive({
+              agent,
+              currentSession,
+              context,
+              promptText: buildPrompt,
+              pendingInput: buildPrompt,
+              spinnerLabel: "building..."
+            });
+          } catch (error) {
+            console.log(`build failed: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+      } else if (rewritten === "/challenge") {
+        const task = context.runtime.activeTask;
+        const receipt = context.runtime.lastReceipt || (task && await agent.toolRuntime.readReceipt(task?.latestReceiptId || "last"));
+        if (receipt) {
+          try {
+            const challengeResult = await runChallengeWorkflow({ agent, context, receipt });
+            if (challengeResult?.challenge) {
+              renderReviewCockpit(task, { ...receipt, challenge: challengeResult.challenge });
+            }
+          } catch (error) {
+            console.log(`challenge failed: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
       }
       continue;
     }
 
+    // Chat fallback: router returned false (chat/unhandled) — send to model without tools
+    const prevTools = agent.enableTools;
+    agent.enableTools = false;
     try {
       await runTextTurnInteractive({
         agent,
@@ -5595,6 +5835,8 @@ async function promptLoop(agent, session, context) {
       });
     } catch (error) {
       console.log(`request failed: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      agent.enableTools = prevTools;
     }
   }
 

package/src/decider.js

@@ -1,14 +1,6 @@
 import { createJsonCompletion } from "./grok-client.js";
 
-const DECISION_SYSTEM_PROMPT = `You are a senior software architect helping a developer choose an implementation strategy.
-
-You will be given a task goal and optionally some project context. Your job is to:
-1. Analyze the goal and propose 2-4 concrete implementation options
-2. Each option should have a clear scope (file paths, commands)
-3. Recommend one option with a rationale
-4. Flag open risks
-
-Respond with ONLY a JSON object matching this schema:
+const DECISION_SCHEMA = `Respond with ONLY a JSON object matching this schema:
 {
   "goal": "one-line restatement of the goal",
   "options": [
@@ -29,20 +21,44 @@ Respond with ONLY a JSON object matching this schema:
   "recommendation": "option_id",
   "rationale": "Why this option fits best given current constraints",
   "openRisks": ["risk description"]
-}
+}`;
+
+const DECISION_SYSTEM_PROMPT = `You are a senior software architect helping a developer choose an implementation strategy.
+
+Your job is to:
+1. Analyze the goal and propose 2-4 concrete implementation options
+2. Keep options terse, concrete, and scoped
+3. Recommend one option with a rationale
+4. Flag open risks
 
 Rules:
 - Always include at least a "minimal" option
 - Be concrete about file paths and commands — guess from the goal if needed
 - Keep summaries factual, not promotional
 - If you cannot determine scope, say so in openRisks
-- Do not include markdown, code fences, or explanatory text outside the JSON`;
+- Do not include markdown, code fences, or explanatory text outside the JSON
+
+${DECISION_SCHEMA}`;
+
+const INVENT_SYSTEM_PROMPT = `You are a sharp, divergent product-and-engineering strategist.
+
+Your job is to generate non-obvious ways to approach the goal.
+- Prefer surprising but plausible alternatives
+- Surface hidden assumptions and second-order effects
+- Do not just rename the same idea three times
+- At least one option should feel unconventional but still implementable
+- Still provide realistic scope and commands when possible
 
-function buildDecisionPrompt({ goal, memory, taskName }) {
+Keep the output terse and concrete.
+Do not include markdown, code fences, or explanatory text outside the JSON.
+
+${DECISION_SCHEMA}`;
+
+function buildDecisionPrompt({ goal, memory, taskName, invent = false }) {
   const parts = [`Goal: ${goal}`];
   if (taskName) parts.push(`Task: ${taskName}`);
   if (memory) parts.push(`Project context (WATERBROTHER.md):\n${memory}`);
-  parts.push("Propose implementation options as JSON.");
+  parts.push(invent ? "Generate divergent implementation options as JSON." : "Propose implementation options as JSON.");
   return parts.join("\n\n");
 }
 
@@ -51,13 +67,13 @@ export function normalizeDecision(decision) {
   const options = Array.isArray(decision.options) ? decision.options : [];
   return {
     goal: String(decision.goal || "").trim(),
-    options: options.map((opt) => ({
-      id: String(opt.id || "unknown").trim(),
+    options: options.map((opt, index) => ({
+      id: String(opt.id || `option-${index + 1}`).trim(),
       title: String(opt.title || "").trim(),
       summary: String(opt.summary || "").trim(),
       pros: Array.isArray(opt.pros) ? opt.pros.map(String) : [],
       cons: Array.isArray(opt.cons) ? opt.cons.map(String) : [],
-      risk: ["low", "medium", "high"].includes(opt.risk) ? opt.risk : "medium",
+      risk: ["low", "medium", "high"].includes(String(opt.risk || "").trim()) ? String(opt.risk).trim() : "medium",
       fileCount: Number.isFinite(Number(opt.fileCount)) ? Math.max(0, Math.floor(Number(opt.fileCount))) : null,
       scope: opt.scope && typeof opt.scope === "object"
         ? {
@@ -72,20 +88,12 @@ export function normalizeDecision(decision) {
   };
 }
 
-export async function runDecisionPass({
-  apiKey,
-  baseUrl,
-  model,
-  goal,
-  taskName,
-  memory,
-  signal
-}) {
-  if (!goal) throw new Error("goal is required for /decide");
+async function runPlannerPass({ apiKey, baseUrl, model, goal, taskName, memory, signal, invent = false }) {
+  if (!goal) throw new Error("goal is required for planning");
 
   const messages = [
-    { role: "system", content: DECISION_SYSTEM_PROMPT },
-    { role: "user", content: buildDecisionPrompt({ goal, memory, taskName }) }
+    { role: "system", content: invent ? INVENT_SYSTEM_PROMPT : DECISION_SYSTEM_PROMPT },
+    { role: "user", content: buildDecisionPrompt({ goal, memory, taskName, invent }) }
   ];
 
   const completion = await createJsonCompletion({
@@ -93,13 +101,13 @@ export async function runDecisionPass({
     baseUrl,
     model,
     messages,
-    temperature: 0.3,
+    temperature: invent ? 0.7 : 0.3,
     signal
   });
 
   const decision = normalizeDecision(completion.json);
   if (!decision || decision.options.length === 0) {
-    throw new Error("Decision pass returned no options");
+    throw new Error(`${invent ? "Invent" : "Decision"} pass returned no options`);
   }
 
   return {
@@ -108,6 +116,14 @@ export async function runDecisionPass({
   };
 }
 
+export async function runDecisionPass(args) {
+  return runPlannerPass({ ...args, invent: false });
+}
+
+export async function runInventPass(args) {
+  return runPlannerPass({ ...args, invent: true });
+}
+
 export function formatDecisionForDisplay(decision) {
   if (!decision) return "No decision available.";
   const lines = [];
@@ -129,3 +145,41 @@ export function formatDecisionForDisplay(decision) {
   if (decision.openRisks.length > 0) lines.push(`Open risks: ${decision.openRisks.join("; ")}`);
   return lines.join("\n");
 }
+
+export function formatDecisionCompact(decision, { mode = "standard", title = null } = {}) {
+  if (!decision) return "No options available.";
+  const lines = [];
+  const heading = title || decision.goal || "Decision";
+  const rule = "─".repeat(Math.min(56, Math.max(28, heading.length + 4)));
+  lines.push(rule);
+  lines.push(heading);
+  lines.push(rule);
+  for (let index = 0; index < decision.options.length; index += 1) {
+    const opt = decision.options[index];
+    const recommended = opt.id === decision.recommendation ? "  ← recommended" : "";
+    const files = opt.fileCount != null ? `~${opt.fileCount} files` : "scope varies";
+    const summary = mode === "guide" ? opt.summary : opt.title;
+    lines.push(`  ${index + 1}. ${summary}    ${files}  ${opt.risk} risk${recommended}`);
+  }
+  lines.push(rule);
+  if (mode === "guide" && decision.rationale) {
+    lines.push(`Why this one: ${decision.rationale}`);
+  }
+  return lines.join("\n");
+}
+
+export function formatDecisionDetail(decision, selector) {
+  if (!decision || !Array.isArray(decision.options) || decision.options.length === 0) return "No option details available.";
+  const option = Number.isInteger(selector)
+    ? decision.options[Math.max(0, selector - 1)]
+    : decision.options.find((opt) => opt.id === selector);
+  if (!option) return "Option not found.";
+  const lines = [];
+  lines.push(`${option.title} (${option.risk} risk)`);
+  lines.push(option.summary || "No summary.");
+  if (option.pros.length) lines.push(`Pros: ${option.pros.join(", ")}`);
+  if (option.cons.length) lines.push(`Cons: ${option.cons.join(", ")}`);
+  if (option.scope.paths.length) lines.push(`Scope: ${option.scope.paths.join(", ")}`);
+  if (option.scope.commands.length) lines.push(`Commands: ${option.scope.commands.join(", ")}`);
+  return lines.join("\n");
+}

package/src/panel.js

@@ -1,122 +1,75 @@
 const ESC = "\x1b";
 const CSI = `${ESC}[`;
-const SAVE_CURSOR = `${ESC}7`;
-const RESTORE_CURSOR = `${ESC}8`;
 
-function dim(text) {
-  return `${CSI}2m${text}${CSI}0m`;
+function dim(text) { return `${CSI}2m${text}${CSI}0m`; }
+function bold(text) { return `${CSI}1m${text}${CSI}0m`; }
+function cyan(text) { return `${CSI}36m${text}${CSI}0m`; }
+function yellow(text) { return `${CSI}33m${text}${CSI}0m`; }
+function green(text) { return `${CSI}32m${text}${CSI}0m`; }
+function red(text) { return `${CSI}31m${text}${CSI}0m`; }
+
+function formatPass(pass) {
+  const p = String(pass || "idle").toUpperCase();
+  if (p === "BUILD") return yellow(p);
+  if (p === "CHALLENGE") return red(p);
+  if (p === "DECIDE") return cyan(p);
+  if (p === "INVENT") return green(p);
+  return dim(p);
 }
 
-function bold(text) {
-  return `${CSI}1m${text}${CSI}0m`;
-}
-
-function cyan(text) {
-  return `${CSI}36m${text}${CSI}0m`;
-}
-
-function yellow(text) {
-  return `${CSI}33m${text}${CSI}0m`;
-}
-
-function green(text) {
-  return `${CSI}32m${text}${CSI}0m`;
-}
-
-function red(text) {
-  return `${CSI}31m${text}${CSI}0m`;
-}
-
-function verdictColor(verdict) {
-  if (verdict === "ship") return green(verdict);
-  if (verdict === "block") return red(verdict);
-  if (verdict === "caution") return yellow(verdict);
-  return verdict || "";
-}
-
-function stateLabel(state) {
-  if (!state) return dim("idle");
-  if (state === "build-ready") return green("build-ready");
-  if (state === "review-ready") return yellow("review-ready");
-  if (state === "accepted") return green("accepted");
-  if (state === "closed") return dim("closed");
-  if (state === "decide-required") return cyan("decide-required");
-  if (state === "decision-ready") return cyan("decision-ready");
-  return state;
+function formatVerdict(verdict) {
+  if (verdict === "ship") return green("✓ no issues found");
+  if (verdict === "block") return red("⚠ issues found");
+  if (verdict === "caution") return yellow("⚠ caution");
+  return null;
 }
 
 function truncate(text, max) {
   const s = String(text || "");
-  return s.length > max ? s.slice(0, max - 1) + "…" : s;
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s;
 }
 
-function formatPanelLine(state) {
-  const parts = [];
-
-  // Line 1: repo + task + mode
-  const l1 = [];
-  if (state.repoName) l1.push(bold(state.repoName));
-  if (state.taskName) l1.push(`task:${cyan(state.taskName)}`);
-  if (state.branch) l1.push(dim(state.branch));
-  if (state.mode) l1.push(`mode:${state.mode}`);
-  if (state.autonomy && state.autonomy !== "scoped") l1.push(`autonomy:${state.autonomy}`);
-  if (l1.length > 0) parts.push(l1.join("  "));
-
-  // Line 2: state + contract + verdict
-  const l2 = [];
-  if (state.taskState) l2.push(stateLabel(state.taskState));
-  if (state.contractSummary) l2.push(dim(truncate(state.contractSummary, 50)));
-  if (state.verdict) l2.push(`sentinel:${verdictColor(state.verdict)}`);
-  if (state.readOnly) l2.push(dim("[read-only]"));
-  if (l2.length > 0) parts.push(l2.join("  "));
-
-  return parts;
+function buildLines(state) {
+  const lines = [];
+  const width = Math.min(72, state.columns || 72);
+  const rule = dim("─".repeat(width));
+  lines.push(rule);
+  const title = truncate(state.taskName || state.repoName || "waterbrother", Math.max(24, width - 28));
+  const scope = state.contractSummary ? `scope: ${truncate(state.contractSummary, 28)}` : null;
+  const headline = [bold(title), "▸", formatPass(state.activePass || state.taskState || "idle"), scope ? dim(scope) : null].filter(Boolean).join("  ");
+  lines.push(headline);
+  if (state.summary) lines.push(truncate(state.summary, width));
+  if (state.issues && state.issues.length > 0) {
+    for (const issue of state.issues.slice(0, 2)) {
+      lines.push(`  ${yellow("⚠")} ${truncate(issue, width - 6)}`);
+    }
+  } else if (state.verdict) {
+    const verdictLine = formatVerdict(state.verdict);
+    if (verdictLine) lines.push(`  ${verdictLine}`);
+  }
+  if (state.actions?.length > 0) {
+    lines.push(dim(`  ${state.actions.join(" · ")}`));
+  }
+  lines.push(rule);
+  return lines;
 }
 
 export function createPanelRenderer({ output } = {}) {
   const stream = output || process.stdout;
   let enabled = true;
   let lastState = null;
-  let visible = false;
 
   function renderPanel(state) {
-    if (!enabled || !stream.isTTY) return;
+    if (!enabled) return;
     lastState = state;
-    const lines = formatPanelLine(state);
-    if (lines.length === 0) return;
-
-    // Print panel lines separated by border
-    const width = Math.min(stream.columns || 80, 120);
-    const border = dim("─".repeat(width));
-    const panelText = lines.join("\n");
-
-    if (visible) {
-      // Just print the panel as a status update
-      stream.write(`${border}\n${panelText}\n${border}\n`);
-    } else {
-      stream.write(`${border}\n${panelText}\n${border}\n`);
-      visible = true;
-    }
-  }
-
-  function hidePanel() {
-    visible = false;
-  }
-
-  function showPanel() {
-    if (lastState) renderPanel(lastState);
-  }
-
-  function setEnabled(next) {
-    enabled = Boolean(next);
-    if (!enabled) hidePanel();
+    const lines = buildLines({ ...state, columns: stream.columns || 80 });
+    stream.write(`${lines.join("\n")}\n`);
   }
 
-  function dispose() {
-    enabled = false;
-    visible = false;
-    lastState = null;
-  }
+  function hidePanel() {}
+  function showPanel() { if (lastState) renderPanel(lastState); }
+  function setEnabled(next) { enabled = Boolean(next); }
+  function dispose() { enabled = false; lastState = null; }
 
   return {
     renderPanel,
@@ -125,30 +78,31 @@ export function createPanelRenderer({ output } = {}) {
     setEnabled,
     dispose,
     get enabled() { return enabled; },
-    get visible() { return visible; }
+    get visible() { return Boolean(lastState); }
   };
 }
 
-export function buildPanelState({
-  cwd,
-  task,
-  agent,
-  receipt,
-  impactSummary
-} = {}) {
+export function buildPanelState({ cwd, task, agent, receipt, runtime } = {}) {
   const repoName = cwd ? cwd.split(/[/\\]/).pop() : "";
+  const review = receipt?.review || null;
+  const challenge = receipt?.challenge || null;
+  const issues = [];
+  if (review?.concerns?.length) issues.push(...review.concerns);
+  if (challenge?.concerns?.length) {
+    for (const concern of challenge.concerns) {
+      if (!issues.includes(concern)) issues.push(concern);
+    }
+  }
   return {
     repoName,
     taskName: task?.name || null,
-    branch: task?.branch || null,
-    mode: agent?.getExperienceMode?.() || null,
-    autonomy: agent?.getAutonomyMode?.() || null,
-    taskState: task?.state || null,
     contractSummary: task?.activeContract?.summary || null,
-    checkpointId: task?.currentCheckpoint || null,
-    latestReceiptId: task?.latestReceiptId || receipt?.id || null,
-    verdict: receipt?.review?.verdict || task?.lastVerdict || null,
-    impactSummary: impactSummary || null,
+    taskState: task?.state || null,
+    activePass: runtime?.activePass || task?.lastPass || null,
+    summary: runtime?.panelSummary || challenge?.summary || review?.summary || null,
+    issues,
+    verdict: review?.verdict || task?.lastVerdict || null,
+    actions: Array.isArray(runtime?.actionHints) ? runtime.actionHints : [],
     readOnly: agent?.getExperienceMode?.() === "auditor"
   };
 }

package/src/router.js

@@ -0,0 +1,88 @@
+function normalize(text) {
+  return String(text || "").trim();
+}
+
+function lower(text) {
+  return normalize(text).toLowerCase();
+}
+
+function looksLikeWorkRequest(text) {
+  const raw = normalize(text);
+  if (!raw) return false;
+  if (raw.startsWith("/")) return false;
+  const l = raw.toLowerCase();
+  if (/^(hi|hello|thanks|thank you|help|what can you do)\b/.test(l)) return false;
+  if (/^(build it|go|check it|ship it|fix these|ignore|challenge harder|think deeper)\b/.test(l)) return false;
+  if (/^[1-9]\d*$/.test(l)) return false;
+  const verbStart = /^(add|build|implement|create|fix|refactor|remove|update|wire|support|migrate|improve|audit|review|debug|investigate|clean up|set up|setup|rewrite|port|optimize)\b/;
+  const suffixHint = /( to the | for the | in the | across | using | with | without )/;
+  return verbStart.test(l) || suffixHint.test(l) || (!l.endsWith("?") && raw.split(/\s+/).length >= 3);
+}
+
+function inferPassFromText(text) {
+  const l = lower(text);
+  if (!l) return null;
+  if (/^(ship it|accept|merge it|looks good ship it)\b/.test(l)) return { intent: "accept", confidence: "high" };
+  if (/^(fix these|fix that|address those|redo|rebuild|try again|patch it|build it|go ahead|go$|implement it)\b/.test(l)) return { intent: "build", confidence: "high" };
+  if (/^(check it|what'?s wrong|what is wrong|review it|challenge( harder)?|find bugs|poke holes|stress test it)\b/.test(l)) return { intent: "challenge", confidence: "high" };
+  if (/^(what am i not thinking of|what else|what if|surprise me|invent|give me alternatives|think wider|out of the box)\b/.test(l)) return { intent: "invent", confidence: "high" };
+  if (/^(should we|which should|which option|what should we|think deeper|tell me more about|compare |tradeoff|jwt or |sessions or |oauth|oauth2)\b/.test(l)) return { intent: "decide", confidence: "medium" };
+  if (/^[1-9]\d*$/.test(l)) return { intent: "choose", confidence: "high", optionIndex: Number.parseInt(l, 10) };
+  const moreMatch = l.match(/^(tell me more about|more on|details on|expand)\s+(\d+)\b/);
+  if (moreMatch) return { intent: "decision-detail", confidence: "high", optionIndex: Number.parseInt(moreMatch[2], 10) };
+  if (/^ignore\b/.test(l)) return { intent: "ignore", confidence: "medium" };
+  return null;
+}
+
+export function deriveTaskNameFromPrompt(text) {
+  const raw = normalize(text)
+    .replace(/["'`]/g, "")
+    .replace(/[?!.]+$/g, "")
+    .replace(/^please\s+/i, "")
+    .trim();
+  if (!raw) return `task-${Date.now().toString(36)}`;
+  const words = raw.split(/\s+/).slice(0, 6);
+  return words.join(" ");
+}
+
+export function routeNaturalInput(text, { task = null } = {}) {
+  const raw = normalize(text);
+  if (!raw || raw.startsWith("/")) return { kind: "none", confidence: "low" };
+
+  const routed = inferPassFromText(raw);
+  if (routed) return { kind: routed.intent, confidence: routed.confidence, raw, ...routed };
+
+  if (!task && looksLikeWorkRequest(raw)) {
+    return { kind: "start-work", confidence: "medium", raw, taskName: deriveTaskNameFromPrompt(raw) };
+  }
+
+  if (task) {
+    if (task.state === "decision-ready") {
+      if (/^(go|build it|do it|sounds good|recommended)\b/i.test(raw)) {
+        return { kind: "choose-recommended-and-build", confidence: "high", raw };
+      }
+    }
+    if (task.state === "review-ready") {
+      if (/^(fix these|fix them|address those|redo)\b/i.test(raw)) {
+        return { kind: "fix-review-findings", confidence: "high", raw };
+      }
+      if (/^(think deeper|re-think|rethink|step back)\b/i.test(raw)) {
+        return { kind: "decide", confidence: "high", raw };
+      }
+    }
+  }
+
+  return { kind: "chat", confidence: "low", raw };
+}
+
+export function nextActionsForState({ task, receipt } = {}) {
+  if (!task) return [];
+  if (task.state === "decision-ready") return ["1", "2", "3", "go", "tell me more about 2"];
+  if (task.state === "build-ready") return ["build it", "check it", "think deeper"];
+  if (task.state === "review-ready") {
+    const blocked = receipt?.review?.verdict === "block" || (Array.isArray(receipt?.verification) && receipt.verification.some((v) => !v.ok));
+    return blocked ? ["fix these", "ignore", "challenge harder"] : ["accept", "redo", "challenge harder", "ship it"];
+  }
+  if (task.state === "accepted") return ["close", "start next task"];
+  return [];
+}