@nanhara/hara 0.125.0 → 0.125.3

package/dist/session/task.js

@@ -3,6 +3,9 @@ export const TASK_SCHEMA_VERSION = 1;
 export const MAX_TASK_OBJECTIVE_CHARS = 4096;
 export const MAX_TASK_STEERING_CHARS = 24_000;
 export const MAX_TASK_STEERING_ENTRIES = 24;
+export const MAX_TASK_BRIEF_GOAL_CHARS = 2_000;
+export const MAX_TASK_BRIEF_LIST_ENTRIES = 12;
+export const MAX_TASK_BRIEF_ITEM_CHARS = 800;
 function iso(at = new Date()) {
     return typeof at === "string" ? at : at.toISOString();
 }
@@ -16,12 +19,42 @@ function validId(value) {
 function validTimestamp(value) {
     return typeof value === "string" && value.length > 0 && Number.isFinite(Date.parse(value));
 }
+function boundedList(value, fallback) {
+    if (!Array.isArray(value))
+        return [fallback];
+    const out = value
+        .filter((item) => typeof item === "string")
+        .map((item) => boundedText(item, MAX_TASK_BRIEF_ITEM_CHARS))
+        .filter(Boolean)
+        .slice(0, MAX_TASK_BRIEF_LIST_ENTRIES);
+    return out.length ? out : [fallback];
+}
+function validBriefList(value) {
+    return Array.isArray(value) &&
+        value.length > 0 &&
+        value.length <= MAX_TASK_BRIEF_LIST_ENTRIES &&
+        value.every((item) => typeof item === "string" && item.length > 0 && item.length <= MAX_TASK_BRIEF_ITEM_CHARS);
+}
 export function newTurnInteraction() {
     return { kind: "turn", turnId: randomUUID() };
 }
 export function newSteerInteraction(expectedTurnId) {
     return { kind: "steer", expectedTurnId, turnId: randomUUID() };
 }
+/** Resolve a UI-delivery hint against authoritative task state. `steer` is never itself proof that an
+ * executable task is running: controls also occupy the composer briefly, and a real turn may finish between
+ * enqueue and dequeue. Preserve the submitted turn id but promote late input to a new turn. Only an explicit
+ * continuation path may opt into reopening a paused/completed task; stale live-turn ids remain hard errors
+ * in `continueTaskExecution`. */
+export function routeTaskInteraction(task, interaction, options = {}) {
+    const steerable = !!task && (task.status === "running" || options.allowInactive === true);
+    if (interaction.kind !== "steer" || steerable)
+        return { interaction, recoveredMissingTask: false };
+    return {
+        interaction: { kind: "turn", turnId: interaction.turnId },
+        recoveredMissingTask: true,
+    };
+}
 export function createTaskExecution(objective, turnId, at = new Date()) {
     const now = iso(at);
     return {
@@ -35,6 +68,35 @@ export function createTaskExecution(objective, turnId, at = new Date()) {
         startedAt: now,
     };
 }
+/** Attach or revise the explicit understanding checkpoint. Revision is intentional: steering may add a
+ * constraint or convert an investigation into an approved change, while the original request remains intact. */
+export function applyTaskBrief(task, input, at = new Date()) {
+    if (!task)
+        return { ok: false, reason: "there is no task to brief" };
+    if (task.status !== "running")
+        return { ok: false, reason: `task ${task.id} is ${task.status}, not running` };
+    const intent = input.intent;
+    if (intent !== "answer" && intent !== "investigate" && intent !== "change") {
+        return { ok: false, reason: "intent must be answer, investigate, or change" };
+    }
+    if (typeof input.goal !== "string" || !input.goal.trim()) {
+        return { ok: false, reason: "goal must be a non-empty string" };
+    }
+    const now = iso(at);
+    const brief = {
+        intent,
+        goal: boundedText(input.goal, MAX_TASK_BRIEF_GOAL_CHARS),
+        constraints: boundedList(input.constraints, "preserve unrelated user work and stated boundaries"),
+        acceptance: boundedList(input.acceptance, intent === "change" ? "the requested change is verified" : "the answer is supported by relevant evidence"),
+        steps: boundedList(input.steps, intent === "change" ? "inspect, change, and verify" : "inspect and report"),
+        createdAt: now,
+    };
+    return {
+        ok: true,
+        brief,
+        task: { ...task, brief, updatedAt: now },
+    };
+}
 export function continueTaskExecution(task, interaction, at = new Date()) {
     if (!task)
         return { ok: false, reason: "there is no task to steer" };
@@ -171,6 +233,9 @@ export function taskExecutionContext(task, interaction, todos = []) {
         steeringNote,
         "Conversation messages provide evidence and refinements, but the task objective above remains authoritative until an explicit new task starts.",
     ];
+    // The accepted brief is deliberately absent here. `taskExecutionContext` is the stable per-interaction
+    // identity/recovery snapshot, while runAgent composes the current brief dynamically on every model round.
+    // Duplicating it here would leave the pre-run version in the prompt after a mid-run task_intake revision.
     if (todos.length) {
         lines.push("## Persisted execution checkpoint", ...todos.slice(0, 24).map((todo) => {
             const mark = todo.status === "done" ? "done" : todo.status === "in_progress" ? "in progress" : "pending";
@@ -189,6 +254,7 @@ export function formatTaskExecution(task) {
         `task ${task.id.slice(0, 8)} · ${task.status}`,
         `turn ${task.turnId.slice(0, 8)} · outcome ${task.lastOutcome ?? "running"}`,
         `objective: ${task.objective}`,
+        `brief: ${task.brief ? `${task.brief.intent} · ${task.brief.goal}` : "(not accepted yet)"}`,
         `steering: ${task.steering?.length ?? 0}`,
     ].join("\n");
 }
@@ -205,6 +271,18 @@ export function isTaskExecution(value) {
         (task.endedAt !== undefined && !validTimestamp(task.endedAt)) ||
         (task.lastOutcome !== undefined && task.lastOutcome !== "completed" && task.lastOutcome !== "error" && task.lastOutcome !== "empty" && task.lastOutcome !== "halted" && task.lastOutcome !== "interrupted"))
         return false;
+    if (task.brief !== undefined) {
+        if (!task.brief || typeof task.brief !== "object" || Array.isArray(task.brief))
+            return false;
+        const brief = task.brief;
+        if ((brief.intent !== "answer" && brief.intent !== "investigate" && brief.intent !== "change") ||
+            typeof brief.goal !== "string" || brief.goal.length === 0 || brief.goal.length > MAX_TASK_BRIEF_GOAL_CHARS ||
+            !validBriefList(brief.constraints) ||
+            !validBriefList(brief.acceptance) ||
+            !validBriefList(brief.steps) ||
+            !validTimestamp(brief.createdAt))
+            return false;
+    }
     if (task.steering === undefined)
         return true;
     if (!Array.isArray(task.steering) || task.steering.length > MAX_TASK_STEERING_ENTRIES)

package/dist/statusbar.js

@@ -13,10 +13,23 @@ const fmtTok = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`);
 const truncate = (s, max) => (s.length <= max ? s : s.slice(0, Math.max(0, max - 1)) + "…");
 const rule = (n) => c.dim("─".repeat(Math.max(0, n)));
 export function contextWindow(model) {
-    const m = model.toLowerCase();
+    // Provider prefixes are common (`qwen/qwen3.7-plus`). Match the actual model id and prefer exact
+    // documented Coding Plan families over broad words such as "coder"/"max": those previously labeled
+    // qwen3-coder-next and qwen3-max as 1M, causing the context guard to overfeed their 262k windows.
+    const m = model.toLowerCase().split("/").at(-1) ?? model.toLowerCase();
     if (/haiku/.test(m))
         return 200_000;
-    if (/(opus|sonnet|fable)|claude-4|qwen3|glm-[45]|max-2026|coder|1m/.test(m))
+    if (/^qwen3\.[567]-plus(?:-|$)/.test(m) || /^qwen3-coder-plus(?:-|$)/.test(m))
+        return 1_000_000;
+    if (/^(?:qwen3-max-2026-01-23|qwen3-coder-next)(?:-|$)/.test(m) || /^kimi-k2\.5(?:-|$)/.test(m))
+        return 262_144;
+    if (/^glm-(?:5|4\.7)(?:-|$)/.test(m))
+        return 202_752;
+    if (/^minimax-m2\.5(?:-|$)/.test(m))
+        return 196_608;
+    if (/qwen3\.6[-:]27b/.test(m))
+        return 262_144;
+    if (/(opus|sonnet|fable)|claude-4|1m/.test(m))
         return 1_000_000;
     return 200_000;
 }

package/dist/tools/builtin.js

@@ -213,6 +213,9 @@ registerTool({
     kind: "exec",
     requiresProjectWorkspace: true,
     async run(input, ctx) {
+        if (input.background !== undefined && typeof input.background !== "boolean") {
+            return "Error: `background` must be a boolean (true or false), not a string or another truthy value.";
+        }
         const protectedReason = sensitiveShellCommandReason(String(input.command ?? ""), ctx.cwd);
         if (protectedReason) {
             return (`Blocked: shell command crosses Hara's protected secret boundary (${protectedReason}). ` +

package/dist/tui/App.js

@@ -21,6 +21,16 @@ import { onTurnPhase, turnPhase } from "../agent/phase.js";
 import { listJobs, onJobsChange } from "../exec/jobs.js";
 import { ModelPicker } from "./model-picker.js";
 import { newSteerInteraction, newTurnInteraction, requestsTaskContinuation } from "../session/task.js";
+/** Composer work and executable task work are different states. Slash controls (for example `/model`)
+ * may keep the TUI busy while opening a picker or doing local bookkeeping, but there is no model task to
+ * steer. `/continue` and user-invocable skill commands are executable Agent turns. */
+export function submissionCanBeSteered(line, agentSlashCommands = []) {
+    const value = line.trim();
+    const slash = /^\/([a-z][\w-]*)(?:\s|$)/i.exec(value);
+    if (!slash)
+        return true;
+    return slash[1].toLowerCase() === "continue" || agentSlashCommands.includes(slash[1]);
+}
 let _id = 0;
 const nid = () => ++_id;
 const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
@@ -265,7 +275,7 @@ export function spinnerVerb(list, elapsedSec) {
 // wall-clock start, so the "Ns" text stays exact and stable.
 const SPINNER_FRAME_MS = 125;
 const IDLE_HINTS = "⏎ send · @ file · ctrl+v image · ctrl+t transcript · shift+tab mode";
-function StatusRow({ working, todos, queued }) {
+function StatusRow({ working, steerable, todos, queued }) {
     const [frame, setFrame] = useState(0);
     const [phase, setPhase] = useState(() => turnPhase());
     const startRef = useRef(Date.now());
@@ -290,7 +300,7 @@ function StatusRow({ working, todos, queued }) {
     // Pre-first-token honesty (codex-parity): "waiting for the model" reads very differently from a
     // generic "working" when the network is slow — the user knows the request is out, not dead.
     const verb = (phase === "waiting" ? `waiting for the model… ${elapsedSec}s · esc to interrupt` : spinnerVerb(todos, elapsedSec)) + bgTag;
-    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "yellow", children: frames[frame % frames.length] }), _jsx(Text, { dimColor: true, children: ` ${verb} · ⏎ steers · /next queues${queued ? ` (${queued})` : ""}` })] }));
+    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "yellow", children: frames[frame % frames.length] }), _jsx(Text, { dimColor: true, children: ` ${verb} · ${steerable ? "⏎ steers · /next queues" : "⏎ queues next"}${queued ? ` (${queued})` : ""}` })] }));
 }
 // Short per-mode descriptions for the ONE-ROW mode line (the old two-row ModeBar's long sentences
 // don't fit inline). Full behavior is documented in /help; this line is a switching aid, not a manual.
@@ -341,7 +351,7 @@ const TodoPanel = memo(function TodoPanel({ todos }) {
                 return (_jsx(Text, { color: inProg ? accent() : undefined, bold: inProg, dimColor: done, children: `  ${TODO_MARK[t.status]} ${t.text}` }, i));
             }), hiddenSummary ? _jsx(Text, { dimColor: true, children: hiddenSummary }) : null] }));
 });
-export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval, onClipboardImage, vim, visionNotice }) {
+export function App({ initialStatus, model, cwd, header, onSubmit, agentSlashCommands = [], cycleApproval, onClipboardImage, vim, visionNotice, }) {
     const { exit } = useApp();
     const { stdout: termOut } = useStdout();
     // Live tail budget: terminal rows minus the rest of the dynamic chrome (todo panel ≤10, status slot,
@@ -462,12 +472,12 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
     const drainQueue = useCallback(() => {
         if (!queueRef.current.length)
             return [];
-        const barrier = queueRef.current.findIndex((item) => item.mode === "next");
+        const barrier = queueRef.current.findIndex((item) => item.mode !== "steer");
         const batch = (barrier < 0 ? queueRef.current : queueRef.current.slice(0, barrier));
         if (!batch.length)
             return [];
         queueRef.current = barrier < 0 ? [] : queueRef.current.slice(barrier);
-        setPool(queueRef.current.map((item) => `${item.mode === "next" ? "next: " : ""}${item.line.trim() || "🖼 (image)"}`));
+        setPool(queueRef.current.map((item) => `${item.mode === "next" ? "next: " : item.mode === "control" ? "control: " : ""}${item.line.trim() || "🖼 (image)"}`));
         if (batch.some((b) => b.images?.length))
             noteVisionIfNeeded();
         for (const b of batch)
@@ -498,25 +508,37 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
             // Enter steers the live turn; `/next …` creates an explicit queue barrier for a separate next task.
             // Once such a barrier exists, later type-ahead stays behind it instead of leaking backward.
             const expectedTurnId = activeTurnRef.current;
-            if (!expectedTurnId)
-                return;
             const next = /^\/(?:next|queue)(?:\s+([\s\S]+))?$/.exec(t);
             if (next && !next[1]?.trim() && !images?.length) {
                 pushCurrent("notice", "usage: /next <message>  (queues a separate task after the current turn)");
                 return;
             }
-            const behindBarrier = queueRef.current.some((item) => item.mode === "next");
-            if (next || behindBarrier) {
-                queueRef.current.push({ mode: "next", line: next?.[1]?.trim() || line, images });
+            // A control command can be "working" without owning a TaskExecution. Input typed during that UI
+            // operation is a real next turn, never a steer and never disposable. The same next barrier keeps
+            // later messages ordered behind it.
+            const queuedLine = next?.[1]?.trim() || line;
+            const queuedControl = !submissionCanBeSteered(queuedLine, agentSlashCommands);
+            const behindBarrier = !expectedTurnId ||
+                queueRef.current.some((item) => item.mode !== "steer");
+            if (queuedControl) {
+                queueRef.current.push({ mode: "control", line: queuedLine, images });
+            }
+            else if (next || behindBarrier) {
+                queueRef.current.push({ mode: "next", line: queuedLine, images });
             }
             else {
                 queueRef.current.push({ mode: "steer", line, images, expectedTurnId });
             }
-            setPool(queueRef.current.map((item) => `${item.mode === "next" ? "next: " : ""}${item.line.trim() || "🖼 (image)"}`));
+            setPool(queueRef.current.map((item) => `${item.mode === "next" ? "next: " : item.mode === "control" ? "control: " : ""}${item.line.trim() || "🖼 (image)"}`));
             return;
         }
         const interaction = forcedInteraction ?? newTurnInteraction();
-        activeTurnRef.current = interaction.turnId;
+        // Only a model task may receive type-ahead steering. A slash control still sets `working` so its
+        // picker/output is serialized, but leaves this ref empty; submissions then queue as ordinary turns.
+        activeTurnRef.current =
+            interaction.kind === "steer" || submissionCanBeSteered(t, agentSlashCommands)
+                ? interaction.turnId
+                : null;
         // Fold the previous turn's checklist NOW, at the natural boundary (a new task begins). The old
         // 30s-idle timer yanked the input box UP by the panel's height while the user was reading/typing
         // (anti-bob); folding on submit means the shrink coincides with the user's own action.
@@ -655,7 +677,7 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
         ctrlRef.current = null;
         if (activeTurnRef.current === interaction.turnId)
             activeTurnRef.current = null;
-    }, [working, prompt, askText, onSubmit, pushCurrent, model, exit, drainQueue, noteVisionIfNeeded]);
+    }, [working, prompt, askText, onSubmit, agentSlashCommands, pushCurrent, model, exit, drainQueue, noteVisionIfNeeded]);
     // A message can arrive after runAgent's final pending-input drain but before the view flips to idle. Late
     // steer groups retain expectedTurnId; explicit `/next` groups start ordinary task turns in FIFO order.
     useEffect(() => {
@@ -669,8 +691,12 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
             for (let at = 0; at < batch.length;) {
                 const mode = batch[at].mode;
                 let end = at + 1;
-                while (end < batch.length && batch[end].mode === mode)
-                    end++;
+                // Controls are barriers and always execute one-at-a-time. Task steering/next messages may still
+                // coalesce within their own adjacent group to preserve the established type-ahead behavior.
+                if (mode !== "control") {
+                    while (end < batch.length && batch[end].mode === mode)
+                        end++;
+                }
                 const group = batch.slice(at, end);
                 const line = group.map((item) => item.line).join("\n\n");
                 const images = group.flatMap((item) => item.images ?? []);
@@ -755,5 +781,7 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
                     const r = picker.resolve;
                     setPicker(null);
                     r(null);
-                } })), prompt && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", children: `  ${stripAnsi(prompt.title)}` }), prompt.options.map((o, i) => (_jsx(Text, { color: i === promptSel ? "cyan" : undefined, bold: i === promptSel, children: (i === promptSel ? " ❯ " : "   ") + `${i + 1}. ` + o.label }, i))), _jsx(Text, { dimColor: true, children: `   ↑↓ or 1–${prompt.options.length} to choose · Enter · Esc cancels` })] })), askText && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", children: `  ? ${stripAnsi(askText.title)}` }), _jsx(Text, { dimColor: true, children: "   type your answer below · Enter to send · Esc cancels" })] })), pool.length > 0 && !prompt && !askText && (_jsx(Box, { flexDirection: "column", children: pool.map((l, i) => (_jsx(Text, { color: accent(), children: `  › ${l.length > 72 ? l.slice(0, 72) + "…" : l}` }, i))) })), modeSelector ? _jsx(ModeLine, { approval: status.approval }) : _jsx(StatusRow, { working: working, todos: todos, queued: pool.length }), _jsx(InputBox, { status: status, cwd: cwd, model: model, route: header?.routeHost, isActive: !prompt, vim: vim, onSubmit: handleSubmit, onClipboardImage: onClipboardImage })] }));
+                } })), prompt && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", children: `  ${stripAnsi(prompt.title)}` }), prompt.options.map((o, i) => (_jsx(Text, { color: i === promptSel ? "cyan" : undefined, bold: i === promptSel, children: (i === promptSel ? " ❯ " : "   ") + `${i + 1}. ` + o.label }, i))), _jsx(Text, { dimColor: true, children: `   ↑↓ or 1–${prompt.options.length} to choose · Enter · Esc cancels` })] })), askText && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", children: `  ? ${stripAnsi(askText.title)}` }), _jsx(Text, { dimColor: true, children: "   type your answer below · Enter to send · Esc cancels" })] })), pool.length > 0 && !prompt && !askText && (_jsx(Box, { flexDirection: "column", children: pool.map((l, i) => (_jsx(Text, { color: accent(), children: `  › ${l.length > 72 ? l.slice(0, 72) + "…" : l}` }, i))) })), modeSelector
+                ? _jsx(ModeLine, { approval: status.approval })
+                : _jsx(StatusRow, { working: working, steerable: !!activeTurnRef.current, todos: todos, queued: pool.length }), _jsx(InputBox, { status: status, cwd: cwd, model: model, route: header?.routeHost, isActive: !prompt, vim: vim, onSubmit: handleSubmit, onClipboardImage: onClipboardImage })] }));
 }

package/dist/tui/model-picker.js

@@ -5,10 +5,11 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // thin ink shell over it (like the Transcript overlay).
 import { Box, Text, useInput } from "ink";
 import { useState } from "react";
+import { supportsReasoningStyle } from "../providers/reasoning.js";
 /** The levels ←→ cycles for a style. Binary thinking toggles (DashScope enable_thinking, Ollama think)
  *  show off/on; graded styles (OpenAI/Anthropic effort/budget) show the full dial; `none` → no control. */
-export function levelsFor(style) {
-    if (style === "none")
+export function levelsFor(style, model = "") {
+    if (!supportsReasoningStyle(style, model))
         return [];
     if (style === "enable_thinking" || style === "ollama_think")
         return ["off", "high"]; // "high" renders as "on"
@@ -24,14 +25,14 @@ export function levelLabel(style, e) {
 }
 /** Pure navigation: ↑↓ moves through models (wrapping); ←→ cycles the thinking level for the endpoint's
  *  style. No-ops when there are no models / the style has no levels. Exported for tests. */
-export function movePicker(s, key, modelCount, style) {
+export function movePicker(s, key, modelCount, style, model = "") {
     if (key === "up" || key === "down") {
         if (modelCount <= 0)
             return s;
         const d = key === "down" ? 1 : -1;
         return { ...s, modelIdx: (s.modelIdx + d + modelCount) % modelCount };
     }
-    const levels = levelsFor(style);
+    const levels = levelsFor(style, model);
     if (!levels.length)
         return s;
     const cur = Math.max(0, levels.indexOf(s.effort));
@@ -41,21 +42,23 @@ export function movePicker(s, key, modelCount, style) {
 export function ModelPicker({ models, style, current, effort, onSelect, onCancel, }) {
     const start = Math.max(0, models.indexOf(current ?? ""));
     const [s, setS] = useState({ modelIdx: start, effort });
+    const selectedModel = models[s.modelIdx] ?? current ?? "";
+    const levels = levelsFor(style, selectedModel);
     useInput((_input, key) => {
         if (key.escape)
             return onCancel();
         if (key.return)
-            return onSelect(models[s.modelIdx] ?? current ?? "", s.effort);
+            return onSelect(selectedModel, levels.length ? s.effort : undefined);
         if (key.upArrow)
             setS((p) => movePicker(p, "up", models.length, style));
         else if (key.downArrow)
             setS((p) => movePicker(p, "down", models.length, style));
         else if (key.leftArrow)
-            setS((p) => movePicker(p, "left", models.length, style));
+            setS((p) => movePicker(p, "left", models.length, style, selectedModel));
         else if (key.rightArrow)
-            setS((p) => movePicker(p, "right", models.length, style));
+            setS((p) => movePicker(p, "right", models.length, style, selectedModel));
     });
-    const hasLevels = levelsFor(style).length > 0;
+    const hasLevels = levels.length > 0;
     const dial = hasLevels ? `thinking ◀ ${levelLabel(style, s.effort)} ▶` : "";
     return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", children: `  pick a model  ·  ↑↓ model  ·  ${hasLevels ? "←→ thinking  ·  " : ""}⏎ apply  ·  esc` }), models.length === 0 ? (_jsx(Text, { dimColor: true, children: "   (this endpoint doesn't list models — use /model <id> to set one directly)" })) : (models.map((m, i) => {
                 const on = i === s.modelIdx;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.125.0",
+  "version": "0.125.3",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "runtime-bootstrap.cjs"