@nanhara/hara 0.99.2 → 0.100.0

package/CHANGELOG.md

@@ -5,6 +5,47 @@ All notable changes to `@nanhara/hara`.
 > Versioning (pre-1.0, SemVer-style): the **minor** (middle) number bumps for a **new feature**; the
 > **patch** (last) number bumps for **optimizations/fixes of existing features**.
 
+## 0.100.0 — the agent keeps its own attention: system-reminders + anti-drift compaction
+
+Distilled from a source-level study of Claude Code v1.0.33's agent internals (the Ie1/WD5 reminder
+layer and the AU2 compaction template).
+
+- **system-reminder injection layer.** An event queue (`agent/reminders.ts`) that lands queued context
+  as ONE `<system-reminder>`-wrapped message before the next model call — visible to the model, never
+  rendered in the transcript, and always carrying the "ignore unless relevant" disclaimer so a nudge
+  can't derail unrelated work. Quiet (sub-agent) runs neither drain nor push, so parallel fan-outs
+  can't steal the main conversation's reminders. First wired event:
+- **Todo attention-refresh.** When a checklist has unfinished items and goes 5 tool-rounds untouched,
+  the model gets a reminder re-showing the authoritative list and asking for a status pass — so long
+  tasks stop silently abandoning their own plan. Any `todo_write` resets the clock; after firing it
+  re-arms (at most one nag per 5 rounds).
+- **Compaction brief: 6 → 8 sections (anti-drift).** `/compact` and auto-compaction now also preserve
+  **All user messages** — your own words survive verbatim, in order, however hard the history is
+  squeezed — and **Key technical concepts**, so the next turn doesn't re-derive the stack.
+  (`COMPACT_SYSTEM` moved to `agent/compact.ts` where tests pin the structure.)
+
+## 0.99.3 — TUI: rock-steady input box (constant-height chrome) + plan mode grows a real handshake
+
+Built from a source-level study of codex-rs (bottom-anchored viewport, plan cells) and Claude Code
+(flexShrink-pinned bottom region, ExitPlanMode handshake).
+
+- **The input box no longer jumps at turn boundaries.** The bottom chrome is now a CONSTANT-height
+  stack: a permanent one-row status slot above the box swaps its content — spinner + verb + queue count
+  while working ⇄ dim key hints when idle — instead of appearing/disappearing (the old `Working` block +
+  `⌨ working` hint row cost ±3 rows at every turn start/end). The shift+tab picker (`ModeLine`, now ONE
+  row with short inline descriptions) swaps into the SAME slot, so popping/auto-hiding it moves nothing.
+  The todo panel no longer folds on a 30s timer (which yanked the box up while you read) — it folds to
+  its one-line summary when the NEXT turn starts, coinciding with your own submit.
+  - `tui/App.tsx`: `StatusRow`/`ModeLine` + the constant slot; fold-on-submit; `tui/InputBox.tsx`: the
+    working-hint row and two-row ModeBar are gone (mode still reads colored in the footer).
+- **Plan mode: the MODEL now decides when the plan is ready** (Claude-Code style), instead of hara
+  nagging "proceed?" after every read-only turn. A run-scoped `exit_plan` tool (new `extraTools` option
+  on `runAgent` — per-run tools, never registered globally) is offered only in plan mode; when the model
+  calls it, the plan renders as a bordered `╭─ Plan` block (codex ProposedPlanCell-style) and THEN the
+  proceed picker appears. Investigation/Q&A turns end quietly, still in plan mode.
+  - `agent/loop.ts`: `opts.extraTools` (advertised post-filter, resolved before the registry);
+    `index.ts`: plan branch rewired + `PLAN_SYSTEM` teaches the exit_plan contract.
+
 ## 0.99.2 — TUI: steadier input box + transient approval selector
 
 - **Approval-mode selector is now transient, not always-on chrome.** The persistent two-row ModeBar under every

package/README.md

@@ -13,7 +13,7 @@
 **Highlights**
 - **An org, not just an agent** — `hara org "<task>"` routes work to the role that *owns* it; `hara plan "<task>"` decomposes a task into a verified DAG of atoms (frame → atomize → sequence → execute → **verify gate**), and `hara plan --parallel` runs independent atoms concurrently.
 - **Drive it from chat** — `hara gateway` runs your local hara from **Telegram · WeChat · Discord · Feishu/Lark · Slack · Mattermost · Matrix · DingTalk · WeCom · Signal** (10 platforms), with **two-way images** (send a photo → it sees it; ask for a file → it sends one), per-chat resumable sessions, and project roaming. Connects out — no public webhook. See **[docs/gateway.md](docs/gateway.md)**.
-- **Real terminal UX** — an **ink TUI**: bottom-pinned input box, **plan mode** (read-only → propose a plan → approve → execute), selectable approvals with "don't ask again", windowed reasoning, **paste images** (Ctrl+V) for vision models, light/dark theme.
+- **Real terminal UX** — an **ink TUI**: bottom-pinned input box, **plan mode** (read-only investigation → the model submits its plan via `exit_plan` → approve → execute), selectable approvals with "don't ask again", windowed reasoning, **paste images** (Ctrl+V) for vision models, light/dark theme.
 - **Persistent memory + self-evolution** — `memory_*` tools over global/project `MEMORY.md`; the agent recalls before acting, **proactively saves** durable facts, and grows its own playbooks (a lexical guard screens what it writes). Inspect/consolidate it with **`hara memory show`** and **`hara memory distill`** (promote recent daily logs → durable memory). Lexical-first by design — semantic search is opt-in, never required.
 - **Multi-provider, all streamed** — Anthropic (Claude) or any OpenAI-compatible endpoint (Qwen/DashScope, GLM, Kimi, OpenAI) with live Markdown + visible reasoning.
 - **Delegate to other agents** — the **`external_agent`** tool hands a self-contained task to **Claude Code** or **Codex** running headless, and returns the result — so you pick the best engine per task. Gated by approval, trust-tiered, and never exposed to read-only sub-agents.

package/dist/agent/compact.js

@@ -3,6 +3,23 @@
 // which reuses the manual /compact path; this just decides *when* to fire.
 /** Auto-compact once the last turn used ≥ this % of the model's context window. */
 export const AUTO_COMPACT_PCT = 85;
+/** The compaction brief (shared by /compact and auto-compaction). Eight sections, mirroring Claude
+ *  Code's AU2 template — the two that matter most beyond the obvious: **All user messages** (the
+ *  user's own words survive verbatim, so however hard the history is squeezed, intent never drifts)
+ *  and **Key technical concepts** (the frameworks/APIs in play, so the next turn doesn't re-derive
+ *  the stack). Lives here (not index.ts) so tests can pin the structure. */
+export const COMPACT_SYSTEM = "Summarize the conversation so far into a structured, complete brief so the assistant can continue with NO " +
+    "loss of context. First think privately in a brief <analysis> scratchpad (what matters, what's in flight), " +
+    "then output ONLY the summary under these exact headings:\n" +
+    "1. Goal — the user's overall intent, in their own framing.\n" +
+    "2. Key technical concepts — the frameworks, tools, APIs, and domain ideas central to the work.\n" +
+    "3. Key decisions — choices made and why (so they aren't relitigated).\n" +
+    "4. Files & code — files created/changed and the important snippets, with why each matters.\n" +
+    "5. Errors & fixes — failures hit, how they were resolved, and any correction the user gave (quote pointed feedback verbatim).\n" +
+    "6. Current state — what works now / what is verified.\n" +
+    "7. All user messages — EVERY user message so far (excluding tool results), verbatim and in order; abbreviate only huge pasted blobs with […]. These are the ground truth of intent.\n" +
+    "8. Next step — the immediate next action, INCLUDING a direct verbatim quote of the user's most recent request so there is no drift.\n" +
+    "Be specific and concrete. Drop the <analysis>; output only the headed summary.";
 /** Whether to auto-compact now: enabled, the history is substantial enough to be worth summarizing, and the
  *  last turn filled the context past the threshold (so the NEXT turn would risk overflow). */
 export function shouldAutoCompact(ctxPct, historyLen, autoCompact, threshold = AUTO_COMPACT_PCT) {

package/dist/agent/loop.js

@@ -10,7 +10,8 @@ import { decideCommand, loadPermissionRules } from "../security/permissions.js";
 import { classifyRisk, guardianVeto, guardianEnabled, newBreaker, recordBlock } from "../security/guardian.js";
 import { subdirHint } from "../context/subdir-hints.js";
 import { classifyError, failoverAction, errorHint } from "./failover.js";
-import { currentTodos } from "../tools/todo.js";
+import { currentTodos, renderTodos } from "../tools/todo.js";
+import { drainReminders, wrapReminders, pushReminder, todoStaleReminder, TODO_STALE_ROUNDS } from "./reminders.js";
 /** Spinner verb (terminal mode + reused by TUI tests): when the agent has an in_progress todo,
  *  surface its activeForm/text so the bottom-of-screen line reads concretely ("▶ updating tests… 3s")
  *  instead of "working 3s". Pure: takes a snapshot + elapsed seconds. */
@@ -86,6 +87,9 @@ export async function runAgent(history, opts) {
     const guardianOn = !!opts.guardian && (opts.guardian.enabled ?? true) && guardianEnabled();
     const breaker = newBreaker();
     let breakerHalt = false; // set when a tripped breaker aborts this run
+    // Todo attention-refresh (à la Claude Code): tool rounds since the checklist was last touched while
+    // unfinished items exist. Main loop only — quiet (sub-agent) runs share the global list and must not nag.
+    let todoIdleRounds = 0;
     for (;;) {
         // Type-ahead steering: fold in anything the user submitted while the previous step ran, so it
         // reaches the model on this next call (drained after the last tool round; empty on the 1st pass).
@@ -93,7 +97,18 @@ export async function runAgent(history, opts) {
             for (const m of await opts.pendingInput())
                 history.push(m);
         }
-        const specs = opts.toolFilter ? toolSpecs().filter((t) => opts.toolFilter(t.name)) : toolSpecs();
+        // system-reminder injection: event-driven context queued since the last call (todo staleness today)
+        // lands as ONE wrapped user message the UI never renders. Quiet runs don't drain — a parallel
+        // sub-agent must not steal the main conversation's reminders.
+        if (!opts.quiet) {
+            const reminders = drainReminders();
+            if (reminders.length)
+                history.push({ role: "user", content: wrapReminders(reminders) });
+        }
+        const baseSpecs = opts.toolFilter ? toolSpecs().filter((t) => opts.toolFilter(t.name)) : toolSpecs();
+        const specs = opts.extraTools?.length
+            ? [...baseSpecs, ...opts.extraTools.map((t) => ({ name: t.name, description: t.description, input_schema: t.input_schema }))]
+            : baseSpecs;
         const sink = ctx.ui; // TUI mode: route output to ink instead of stdout
         const tty = stdout.isTTY && !opts.quiet && !sink;
         const md = tty && process.env.HARA_MD !== "0" ? makeRenderer(out) : null;
@@ -211,14 +226,16 @@ export async function runAgent(history, opts) {
         if (r.stop !== "tool_use")
             return;
         const plans = [];
+        // Extra (per-run) tools win over the registry so a run-scoped tool can't be shadowed by a global one.
+        const resolveTool = (name) => opts.extraTools?.find((t) => t.name === name) ?? getTool(name);
         for (const tu of r.toolUses) {
             if (breakerHalt) {
                 // Circuit-breaker halted the run: refuse every remaining call in this round with a clear message
                 // (no hang, no further tools) so the model + user get a definitive stop.
-                plans.push({ tu, tool: getTool(tu.name), denied: "Guardian circuit-breaker halted this run (too many high-risk actions blocked). Ask the user to review and re-run." });
+                plans.push({ tu, tool: resolveTool(tu.name), denied: "Guardian circuit-breaker halted this run (too many high-risk actions blocked). Ask the user to review and re-run." });
                 continue;
             }
-            const tool = getTool(tu.name);
+            const tool = resolveTool(tu.name);
             if (!tool) {
                 plans.push({ tu, tool: undefined, denied: `Unknown tool: ${tu.name}` });
                 continue;
@@ -344,6 +361,21 @@ export async function runAgent(history, opts) {
         }
         await flush();
         history.push({ role: "tool", results });
+        // Todo attention-refresh: a round that touched the checklist resets the clock; rounds that leave
+        // unfinished items untouched accumulate, and at TODO_STALE_ROUNDS the model gets a system-reminder
+        // re-showing the authoritative list (then the counter re-arms — at most one nag per N rounds).
+        if (!opts.quiet) {
+            if (r.toolUses.some((tu) => tu.name === "todo_write")) {
+                todoIdleRounds = 0;
+            }
+            else if (currentTodos().some((t) => t.status !== "done")) {
+                todoIdleRounds++;
+                if (todoIdleRounds >= TODO_STALE_ROUNDS) {
+                    pushReminder(todoStaleReminder(renderTodos(currentTodos())));
+                    todoIdleRounds = 0;
+                }
+            }
+        }
         if (breakerHalt) {
             // A tripped-and-declined circuit-breaker is a hard stop: end the run cleanly (the denial messages are
             // already in `results` so the model/user see why). Never spin further.

package/dist/agent/reminders.js

@@ -0,0 +1,38 @@
+// system-reminder injection (à la Claude Code's Ie1/WD5 event layer): event-driven context the model
+// should see on its NEXT call, injected as ONE `<system-reminder>`-wrapped user message. It rides the
+// provider history only — the UI transcript never renders it, so the user isn't bothered while the
+// model stays synchronized with system state (todo staleness today; file-change/diagnostic events can
+// plug in later via pushReminder).
+//
+// Claude Code's disclaimer is preserved: the model is told the context may be irrelevant, so an
+// injected nudge never derails an unrelated task.
+const queue = [];
+/** Queue a reminder for injection before the next model call (main loop only — quiet/sub-agent runs
+ *  neither push nor drain, so a parallel fan-out can't steal the main conversation's reminders). */
+export function pushReminder(text) {
+    const t = text.trim();
+    if (t)
+        queue.push(t);
+}
+/** Take everything queued (FIFO), clearing the queue. */
+export function drainReminders() {
+    if (!queue.length)
+        return [];
+    return queue.splice(0, queue.length);
+}
+/** Merge queued reminders into the single injected message. */
+export function wrapReminders(items) {
+    return ("<system-reminder>\n" +
+        items.join("\n\n") +
+        "\n\nThis context may or may not be relevant to your task — do not respond to it directly; ignore it unless it is relevant.\n" +
+        "</system-reminder>");
+}
+/** How many tool rounds a checklist may sit untouched (with unfinished items) before the model gets an
+ *  attention refresh. Reset on every todo_write; re-arms after firing so it nags at most once per N. */
+export const TODO_STALE_ROUNDS = 5;
+/** The staleness nudge: re-show the authoritative list + ask for a status pass. */
+export function todoStaleReminder(renderedTodos) {
+    return (`Your todo list has not been updated in a while. Current state:\n\n${renderedTodos}\n\n` +
+        "If you have completed or started items, update them with todo_write now (statuses drive the user's progress view). " +
+        "If the list no longer matches the work, rewrite it.");
+}

package/dist/index.js

@@ -24,7 +24,7 @@ import { clearEnrollment, enrollDevice, heartbeat, syncOrgRoles } from "./org-fl
 import { loadActiveProfile, listProfiles, useProfile, addProfile, upsertProfile, removeProfile, setModel as setProfileModel, resetModel as resetProfileModel, getProfile, effectiveModel, routingLabel, routeHost, activeId, resolveActive, setFlagOverride, writePin, removePin, pinFilePath, DEFAULT_ORG_ID, PERSONAL_ID, } from "./profile/profile.js";
 import { loadPermissionRules, scaffoldPermissions, globalPermissionsPath, projectPermissionsPath } from "./security/permissions.js";
 import { routingProvider } from "./agent/route.js";
-import { shouldAutoCompact } from "./agent/compact.js";
+import { shouldAutoCompact, COMPACT_SYSTEM } from "./agent/compact.js";
 import { formatContextReport } from "./agent/context-report.js";
 import { userTurnPreviews, rewindTo } from "./agent/rewind.js";
 import { checkpoint, listCheckpoints, restoreCheckpoint } from "./checkpoints.js";
@@ -691,9 +691,24 @@ async function nameSession(provider, history) {
         return titleFrom(history);
     }
 }
-const PLAN_SYSTEM = "You are in PLAN MODE. Investigate read-only (read_file / grep / glob / ls / web_fetch) and think, " +
-    "then propose a concise step-by-step plan for the task. Do NOT edit files or run commands yet — only plan. " +
-    "End your message with the plan as a short numbered list.";
+/** Render a proposed plan as a bordered block for the transcript (codex ProposedPlanCell-style).
+ *  Left-border-only frame — right-edge alignment against variable-width content is brittle, and the
+ *  open right side lets long lines wrap naturally. Emitted via the diff sink channel (renders verbatim,
+ *  not dimmed like notice). */
+const renderPlanBlock = (plan) => {
+    const lines = plan.replace(/\n+$/, "").split("\n");
+    const top = c.cyan("╭─ ") + c.bold(c.cyan("Plan")) + c.cyan(" " + "─".repeat(42));
+    const body = lines.map((l) => c.cyan("│ ") + l).join("\n");
+    return `${top}\n${body}\n${c.cyan("╰" + "─".repeat(48))}`;
+};
+// Plan mode's contract (Claude-Code style handshake): the MODEL decides when the plan is ready by
+// calling `exit_plan` — we never nag with a proceed-prompt after turns that were just investigation
+// or Q&A. codex's equivalent is the plan streaming to a dedicated cell + Enter-to-implement.
+const PLAN_SYSTEM = "You are in PLAN MODE — a read-only investigation phase. Explore with read_file / grep / glob / ls / " +
+    "web tools and think. Do NOT edit files or run mutating commands — only investigate and plan. " +
+    "When (and only when) you have a complete, actionable plan, call the `exit_plan` tool with the full plan " +
+    "(concise markdown, short numbered steps), then stop and wait for the user's decision. " +
+    "If the user is asking a question, or the plan isn't ready yet, just answer normally WITHOUT calling exit_plan.";
 const DISTILL_SYSTEM = "The session is ending. Reflect and persist only durable, reusable learnings: memory_write for facts / " +
     "conventions / the user's preferences, skill_create for reusable how-tos. Be selective — skip the trivial. Then reply DONE.";
 const MEMORY_DISTILL_SYSTEM = "You consolidate an agent's short-term daily memory logs into its durable long-term memory. You're given " +
@@ -701,16 +716,7 @@ const MEMORY_DISTILL_SYSTEM = "You consolidate an agent's short-term daily memor
     "conventions / user preferences from the logs that are NOT already captured, and persist each with " +
     "memory_write (target=memory, or target=user for preferences; pick the right scope=project|global). " +
     "Skip the ephemeral, the one-off, and anything already known. Be terse and de-duplicated. Then reply DONE.";
-const COMPACT_SYSTEM = "Summarize the conversation so far into a structured, complete brief so the assistant can continue with NO " +
-    "loss of context. First think privately in a brief <analysis> scratchpad (what matters, what's in flight), " +
-    "then output ONLY the summary under these exact headings:\n" +
-    "1. Goal — the user's overall intent, in their own framing.\n" +
-    "2. Key decisions — choices made and why (so they aren't relitigated).\n" +
-    "3. Files & code — files created/changed and the important snippets, with why each matters.\n" +
-    "4. Errors & fixes — failures hit, how they were resolved, and any correction the user gave (quote pointed feedback verbatim).\n" +
-    "5. Current state — what works now / what is verified.\n" +
-    "6. Next step — the immediate next action, INCLUDING a direct verbatim quote of the user's most recent request so there is no drift.\n" +
-    "Be specific and concrete. Drop the <analysis>; output only the headed summary.";
+// COMPACT_SYSTEM (the 8-section brief) lives in agent/compact.ts so tests can pin its structure.
 const workingSetFromSummary = (s) => s
     .split("\n")
     .map((l) => l.replace(/^[-*\d.\s]+/, "").trim())
@@ -3029,7 +3035,9 @@ program.action(async (opts) => {
                 };
                 const turnStart = Date.now(); // for the task-done notification (gated on elapsed)
                 if (appr === "plan") {
-                    // PLAN MODE: read-only investigate → propose a plan → selectable proceed → execute.
+                    // PLAN MODE: read-only investigate; the MODEL signals plan-readiness by calling `exit_plan`
+                    // (Claude-Code style handshake) — only then do we pop the proceed prompt. Turns that were just
+                    // investigation / Q&A end back at the input, still in plan mode, with no nagging.
                     const planImg = await resolveImages(images, h);
                     if (planImg.skip)
                         return;
@@ -3037,12 +3045,29 @@ program.action(async (opts) => {
                     recalledContext = "";
                     const pin = stats.input;
                     const pout = stats.output;
+                    // Run-scoped tool (never in the registry, so no other mode can see it): captures the proposed
+                    // plan and renders it as a bordered block (codex's ProposedPlanCell equivalent) via the sink.
+                    let proposedPlan = null;
+                    const exitPlanTool = {
+                        name: "exit_plan",
+                        description: "Call when your plan is complete and ready for the user to approve. Pass the FULL plan as concise " +
+                            "markdown (short numbered steps). This ends the planning phase — after calling it, stop and wait.",
+                        input_schema: { type: "object", properties: { plan: { type: "string", description: "the complete plan (markdown, short numbered steps)" } }, required: ["plan"] },
+                        kind: "read", // never prompts — submitting a plan is not a mutation
+                        run: async (input, tctx) => {
+                            proposedPlan = String(input?.plan ?? "").trim();
+                            if (proposedPlan)
+                                tctx.ui?.diff(renderPlanBlock(proposedPlan));
+                            return "Plan submitted to the user for approval. Stop now and wait for their decision — do not keep working.";
+                        },
+                    };
                     await runAgent(history, {
                         provider,
                         ctx: { cwd, sandbox, spawn, ui, ask: h.ask, describeImage: describeScreenshot, locate: locateScreenshot },
                         approval: "suggest",
                         confirm: h.confirm,
                         toolFilter: (n) => READONLY_TOOLS.has(n),
+                        extraTools: [exitPlanTool],
                         systemOverride: PLAN_SYSTEM,
                         memory: buildMemory(),
                         projectContext,
@@ -3056,6 +3081,11 @@ program.action(async (opts) => {
                     }
                     h.sink.usage(stats.input - pin, stats.output - pout);
                     saveSession(meta, history);
+                    if (!proposedPlan) {
+                        // No exit_plan this turn — the model was investigating or answering. Stay in plan mode quietly.
+                        notifyDone(cfg.notify, { message: meta.title || "plan turn complete", elapsedMs: Date.now() - turnStart });
+                        return;
+                    }
                     const choice = await h.select("hara has a plan — proceed?", [
                         { label: "Yes, and auto-apply edits", value: "auto-edit" },
                         { label: "Yes, approve each edit", value: "suggest" },

package/dist/org/roles.js

@@ -22,13 +22,37 @@ export function orgRolesDir() {
 export function claudeAgentsDir(cwd) {
     return join(findProjectRoot(cwd), ".claude", "agents");
 }
-/** Accept Claude-Code `tools:` (comma string or list) as an alias for hara's allowTools. */
-function claudeTools(v) {
-    if (Array.isArray(v))
-        return v;
-    if (typeof v === "string" && v.trim())
-        return v.split(",").map((s) => s.trim()).filter(Boolean);
-    return undefined;
+/** Claude-Code tool names → hara tool names, for `.claude/agents` interop. Without this, a CC agent
+ *  with `tools: Read, Edit, Bash` produced allowTools that matched ZERO hara tools — the role spawned
+ *  with an empty toolbox. Unknown names pass through verbatim (they may be hara names already). */
+const CLAUDE_TOOL_MAP = {
+    read: "read_file",
+    edit: "edit_file",
+    write: "write_file",
+    bash: "bash",
+    grep: "grep",
+    glob: "glob",
+    ls: "ls",
+    webfetch: "web_fetch",
+    websearch: "web_search",
+    agent: "agent",
+    task: "agent",
+    todowrite: "todo_write",
+    notebookedit: "edit_file",
+};
+/** Accept Claude-Code `tools:` (comma string or list) as an alias for hara's allowTools —
+ *  translating CC tool names to hara's. "All tools" / "*" means unrestricted → undefined. */
+export function claudeTools(v) {
+    const raw = Array.isArray(v)
+        ? v
+        : typeof v === "string" && v.trim()
+            ? v.split(",").map((s) => s.trim()).filter(Boolean)
+            : null;
+    if (!raw || !raw.length)
+        return undefined;
+    if (raw.some((t) => /^(\*|all tools?)$/i.test(t)))
+        return undefined; // unrestricted
+    return raw.map((t) => CLAUDE_TOOL_MAP[t.toLowerCase().replace(/[^a-z]/g, "")] ?? t);
 }
 function parseFrontmatter(text) {
     const m = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(text);
@@ -83,7 +107,9 @@ export function loadRoles(cwd) {
                     description: fm.description || "",
                     owns: Array.isArray(fm.owns) ? fm.owns : [],
                     rejects: Array.isArray(fm.rejects) ? fm.rejects : [],
-                    model: fm.model || undefined,
+                    // Claude-Code model ALIASES (sonnet/opus/haiku/inherit) aren't hara model ids — treat as
+                    // "inherit the session model" rather than passing a string no provider resolves.
+                    model: fm.model && !/^(sonnet|opus|haiku|inherit)$/i.test(String(fm.model)) ? fm.model : undefined,
                     allowTools: Array.isArray(fm.allowTools) ? fm.allowTools : claudeTools(fm.tools),
                     denyTools: Array.isArray(fm.denyTools) ? fm.denyTools : undefined,
                     system: body,

package/dist/tui/App.js

@@ -1,20 +1,22 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // The hara TUI (ink). Layout, top to bottom:
-//   <Static>   committed transcript — rendered once each, scrolls into native scrollback
-//   current    the in-progress turn's blocks (assistant text / reasoning / tool / diff), live
-//   <Working>  spinner while a turn runs (Esc interrupts)
-//   <InputBox> the pinned, bordered prompt (or a confirm prompt when a tool needs approval)
+//   <Static>    committed transcript — rendered once each, scrolls into native scrollback
+//   current     the in-progress turn's blocks (assistant text / reasoning / tool / diff), live
+//   <TodoPanel> live checklist (when the agent keeps one)
+//   status slot ALWAYS one row: StatusRow (spinner while working / key hints idle) ⇄ ModeLine
+//               (shift+tab picker) — constant height so the input box never bobs at turn boundaries
+//   <InputBox>  the bordered prompt (or a confirm prompt when a tool needs approval)
 //
 // The agent machinery is injected via `onSubmit` (a turn runner) so this view is testable with
 // ink-testing-library against a fake runner — no provider/network needed.
 import { Box, Static, Text, useApp, useInput, useStdout } from "ink";
 import { memo, useCallback, useEffect, useRef, useState } from "react";
-import { InputBox } from "./InputBox.js";
+import { InputBox, MODES, approvalColor } from "./InputBox.js";
 import { activity } from "../activity.js";
 import { ctxPctFor } from "../statusbar.js";
 import { accent } from "./theme.js";
 import { renderMarkdown } from "../md.js";
-import { currentTodos, onTodosChange } from "../tools/todo.js";
+import { clearTodos, currentTodos, onTodosChange } from "../tools/todo.js";
 let _id = 0;
 const nid = () => ++_id;
 const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
@@ -218,25 +220,50 @@ export function spinnerVerb(list, elapsedSec) {
     }
     return `working ${elapsedSec}s · esc to interrupt`;
 }
+// The status row — ALWAYS rendered, exactly one content row (codex-style: the bottom pane keeps a
+// constant-height status slot and swaps its CONTENT). This is the anti-bob keystone: the old
+// `Working` block appeared at turn start and vanished at turn end (±2 rows), so the input box
+// jumped up 3 rows at every turn boundary (together with the ⌨-hint line, now folded in here).
+// Working → spinner + verb + queue count; idle → dim key hints. Same height either way → zero shift.
+//
 // The spinner is the only element that animates continuously while a turn runs — and because ink
-// redraws the WHOLE dynamic region (input box + mode bar included) on any change, its tick rate sets
-// a floor on full-frame redraws over the life of a turn. At ~8fps (125ms) the braille glyph still
-// reads as smooth motion but cuts those forced redraws ~20% vs 100ms — meaningfully calmer over a
-// slow/remote link. Elapsed seconds come from a wall-clock start, so the "Ns" text stays exact and
-// stable (it only changes once per second, not coupled to the glyph frame).
+// redraws the WHOLE dynamic region (input box included) on any change, its tick rate sets a floor on
+// full-frame redraws over the life of a turn. At ~8fps (125ms) the braille glyph still reads as
+// smooth motion — meaningfully calmer over a slow/remote link. Elapsed seconds come from a
+// wall-clock start, so the "Ns" text stays exact and stable.
 const SPINNER_FRAME_MS = 125;
-function Working({ todos }) {
+const IDLE_HINTS = "⏎ send · @ file · ctrl+v image · ctrl+t transcript · shift+tab mode";
+function StatusRow({ working, todos, queued }) {
     const [frame, setFrame] = useState(0);
     const startRef = useRef(Date.now());
     useEffect(() => {
+        if (!working)
+            return;
         startRef.current = Date.now();
         const id = setInterval(() => setFrame((x) => x + 1), SPINNER_FRAME_MS);
         return () => clearInterval(id);
-    }, []);
+    }, [working]);
+    if (!working) {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: `  ${IDLE_HINTS}` }) }));
+    }
     const frames = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
     const elapsedSec = Math.floor((Date.now() - startRef.current) / 1000);
-    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "yellow", children: frames[frame % frames.length] }), _jsx(Text, { dimColor: true, children: ` ${spinnerVerb(todos, elapsedSec)}` })] }));
+    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "yellow", children: frames[frame % frames.length] }), _jsx(Text, { dimColor: true, children: ` ${spinnerVerb(todos, elapsedSec)} · ⏎ queues${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.
+const MODE_HINT = {
+    suggest: "confirms edits+cmds",
+    "auto-edit": "auto edits · asks cmds",
+    "full-auto": "no prompts ⚠",
+    plan: "read-only → plan",
+};
+// Transient approval-mode line: popped by shift+tab in PLACE of the StatusRow (equal-height swap —
+// one row for one row, so the picker appearing/auto-hiding never moves the input box). All modes
+// listed, the active one colored, with the active mode's short description inline.
+const ModeLine = memo(function ModeLine({ approval }) {
+    return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [MODES.map((m, i) => (_jsxs(Text, { children: [i > 0 ? "  " : "  ", m === approval ? _jsx(Text, { color: approvalColor(m), bold: true, children: `◆ ${m}` }) : _jsx(Text, { dimColor: true, children: m })] }, m))), _jsx(Text, { dimColor: true, children: ` · ${MODE_HINT[approval]} · ⇄ shift+tab` })] }) }));
+});
 // Live task panel: renders the current todo_write checklist between the in-progress turn output
 // and the input box. Highlights the in_progress item; caps at 8 rows and folds the rest into
 // `… +N pending/done`. Hidden when the list is empty.
@@ -290,10 +317,6 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
     // Live checklist mirror: TodoPanel reads this, and `Working` derives its spinner verb from the
     // in_progress item. The tool emits on every todo_write — keeps the UI in lockstep with the agent.
     const [todos, setTodos] = useState(() => currentTodos());
-    // Collapse-after-turn: once a turn ends, leave the panel visible briefly (so the user sees the
-    // final state) then fold it into a single-line "Todos: N/M done" notice in history. Cleared if
-    // a new turn starts before the timer fires.
-    const collapseTimerRef = useRef(null);
     const ctrlRef = useRef(null);
     const queueRef = useRef([]); // type-ahead: FIFO of messages entered while working
     const [pool, setPool] = useState([]); // type-ahead pool: queued message lines, shown above the input
@@ -323,17 +346,8 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
     useEffect(() => {
         const unsub = onTodosChange((list) => {
             setTodos([...list]); // copy so React sees a new array (the tool reuses one)
-            // A change mid-turn cancels any pending collapse — the user is still working with this list.
-            if (collapseTimerRef.current) {
-                clearTimeout(collapseTimerRef.current);
-                collapseTimerRef.current = null;
-            }
         });
-        return () => {
-            unsub();
-            if (collapseTimerRef.current)
-                clearTimeout(collapseTimerRef.current);
-        };
+        return unsub;
     }, []);
     // Reconcile the synchronously-mutated live buffer into React state, at most once per ~33ms. First
     // append any finalized blocks to <Static> (once, in order), then publish the remaining live tail.
@@ -418,6 +432,15 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
             setPool(queueRef.current.map((q) => q.line.trim() || "🖼 (image)"));
             return;
         }
+        // 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.
+        if (currentTodos().length) {
+            const list = currentTodos();
+            const done = list.filter((td) => td.status === "done").length;
+            setHistory((h) => [...h, { id: nid(), kind: "notice", text: `  ✓ Todos: ${done}/${list.length} done` }]);
+            clearTodos(); // emits → the panel unmounts via onTodosChange
+        }
         if (images?.length)
             noteVisionIfNeeded(); // one-shot inline notice on first image of the session
         setHistory((h) => [...h, { id: nid(), kind: "user", text: t }]); // t already carries any [Image #N] tokens
@@ -482,20 +505,6 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
         setCurrent([]);
         setWorking(false);
         ctrlRef.current = null;
-        // Schedule a panel collapse: if there was a checklist this turn, fold it to a one-line summary
-        // in scrollback after ~30s of quiet (i.e. no new todo_write or new turn).
-        if (collapseTimerRef.current)
-            clearTimeout(collapseTimerRef.current);
-        if (currentTodos().length) {
-            collapseTimerRef.current = setTimeout(() => {
-                const list = currentTodos();
-                if (!list.length)
-                    return;
-                const done = list.filter((t) => t.status === "done").length;
-                setHistory((h) => [...h, { id: nid(), kind: "notice", text: `  ✓ Todos: ${done}/${list.length} done` }]);
-                collapseTimerRef.current = null;
-            }, 30_000);
-        }
     }, [working, prompt, askText, onSubmit, pushCurrent, model, exit, drainQueue, noteVisionIfNeeded]);
     // Drain the type-ahead pool: when the turn finishes (working → false) and nothing awaits a choice, COALESCE
     // every pooled message into ONE turn and send it — additions/clarifications go to the agent together, in order.
@@ -578,5 +587,5 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
     });
     if (showTranscript)
         return _jsx(Transcript, { items: [...history, ...current], onClose: () => setShowTranscript(false) });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: header ? [{ id: -1, kind: "notice", text: "" }, ...history] : history, children: (item) => (item.id === -1 ? _jsx(HeaderCard, { ...header }, "hdr") : _jsx(Block, { item: item }, item.id)) }), current.map((item) => (_jsx(Block, { item: item, open: reasoningOpen }, item.id))), !prompt && _jsx(TodoPanel, { todos: todos }), working && !prompt && _jsx(Working, { todos: todos }), 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))) })), _jsx(InputBox, { status: status, cwd: cwd, model: model, route: header?.routeHost, isActive: !prompt, working: working && !askText, queued: pool.length, vim: vim, showModeSelector: modeSelector, onSubmit: handleSubmit, onClipboardImage: onClipboardImage })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: header ? [{ id: -1, kind: "notice", text: "" }, ...history] : history, children: (item) => (item.id === -1 ? _jsx(HeaderCard, { ...header }, "hdr") : _jsx(Block, { item: item }, item.id)) }), current.map((item) => (_jsx(Block, { item: item, open: reasoningOpen }, item.id))), _jsx(TodoPanel, { todos: todos }), 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 })] }));
 }

package/dist/tui/InputBox.js

@@ -1,7 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // The framed input box (ink): a rounded, dim-bordered box (codex polish) wrapping the prompt line,
-// with a single dim footer line rendered BELOW the box (model · approval · route · cwd · usage · ctx)
-// and the ModeBar under that. Pure-ish: pass `width` to make rendering deterministic in tests.
+// with a single dim footer line rendered BELOW the box (model · approval · route · cwd · usage · ctx).
+// The approval-mode picker and working/queue status live OUTSIDE this component (App's constant-height
+// StatusRow/ModeLine slot above the box). Pure-ish: pass `width` for deterministic tests.
 //
 // Render-stability principles (codex-style, for slow/remote terminals): ink erases and rewrites the
 // ENTIRE dynamic region on every frame, so the box's cost scales with (a) how many lines it occupies
@@ -35,7 +36,7 @@ export function footerCwd(abs, home = process.env.HOME ?? "", maxLen = 28) {
     const slash = tail.indexOf("/");
     return "…" + (slash > 0 ? tail.slice(slash) : tail);
 }
-/** Approval-mode accent color, shared by the footer indicator + the transient ModeBar. full-auto is
+/** Approval-mode accent color, shared by the footer indicator + App's transient ModeLine. full-auto is
  *  the dangerous one (red), plan is read-only (cyan), the edit modes are green. */
 export function approvalColor(a) {
     return a === "full-auto" ? "red" : a === "plan" ? "cyan" : "green";
@@ -79,20 +80,6 @@ const TopBorder = memo(function TopBorder({ name, width }) {
     const left = Math.max(2, width - name.length - 7); // ╭(1)+ " "(1)+●(1)+" name "(len+2)+"─╮"(2)
     return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "╭" + "─".repeat(left) + " " }), _jsx(Text, { color: "cyan", children: "\u25CF" }), _jsx(Text, { bold: true, children: ` ${name} ` }), _jsx(Text, { dimColor: true, children: "─╮" })] }));
 });
-const MODE_DESC = {
-    suggest: "confirms edits & commands",
-    "auto-edit": "auto-applies edits · asks before commands",
-    "full-auto": "runs everything — no prompts  ⚠",
-    plan: "investigate read-only, then propose a plan to approve",
-};
-// Transient approval-mode selector: popped by shift+tab and auto-hidden after a beat (App owns the
-// timer) so it isn't always-on chrome. All modes listed, the active one highlighted (red for the
-// dangerous full-auto) with a one-line description and the shift+tab hint. When hidden, the current
-// mode still reads (colored) from the footer line — this just adds the full picker + descriptions.
-const ModeBar = memo(function ModeBar({ approval }) {
-    const warn = approval === "full-auto";
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: MODES.map((m, i) => (_jsxs(Text, { children: [i > 0 ? "   " : "  ", m === approval ? _jsx(Text, { color: warn ? "red" : m === "plan" ? "cyan" : "green", bold: true, children: `◆ ${m}` }) : _jsx(Text, { dimColor: true, children: m })] }, m))) }), _jsx(Text, { dimColor: true, children: `    ${MODE_DESC[approval]} · shift+tab ⇄` })] }));
-});
 /** The active `@mention` token immediately left of the cursor (for the file popup), or null. */
 function activeMention(value, cursor) {
     const m = /(?:^|\s)@([^\s@]*)$/.exec(value.slice(0, cursor));
@@ -242,9 +229,9 @@ const InputLine = memo(function InputLine({ value, cursor, width, gutter, gutter
     }
     return (_jsx(Box, { flexDirection: "column", children: rows.map((row, i) => (_jsxs(Box, { children: [_jsx(Text, { color: gutterColor, children: i === 0 ? gutter : "  " }), _jsx(Text, { children: renderRow(value, row, cursor, true, i === rows.length - 1, `r${i}_`) })] }, i))) }));
 });
-/** Bordered prompt box + one dim status footer (model · approval · route · cwd · usage · ctx) +
- *  ModeBar, with an @path popup. */
-export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboardImage, isActive = true, working = false, queued = 0, vim = false, showModeSelector = false, placeholder = "Type a task · /help · @file · Ctrl+V paste image · shift+tab mode · Esc interrupts", }) {
+/** Bordered prompt box + one dim status footer (model · approval · route · cwd · usage · ctx),
+ *  with an @path popup. */
+export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboardImage, isActive = true, vim = false, placeholder = "Type a task · /help · @file · Ctrl+V paste image · shift+tab mode · Esc interrupts", }) {
     const { stdout } = useStdout();
     const w = width ?? stdout?.columns ?? 80;
     const [value, setValue] = useState("");
@@ -408,5 +395,5 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
     // + corners and everything aligns column-for-column.
     const innerW = Math.max(1, w - 4);
     const cwdShort = footerCwd(cwd);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TopBorder, { name: status.sessionName || "session", width: w }), _jsx(Box, { borderStyle: "round", borderTop: false, borderColor: "gray", borderDimColor: true, paddingX: 1, width: w, children: _jsx(InputLine, { value: value, cursor: cursor, width: innerW, gutter: gutter, gutterColor: gutterColor, placeholder: placeholder }) }), vim ? _jsx(Text, { dimColor: true, children: mode === "normal" ? "  -- NORMAL --  i/a insert · h l 0 $ w b e move · x dd D cw p edit" : "  -- INSERT --  Esc → normal" }) : null, _jsx(Footer, { model: model, s: status, cwdShort: cwdShort, route: route }), working ? _jsx(Text, { dimColor: true, children: `  ⌨ working — Enter queues your message${queued ? ` · ${queued} queued` : ""} · Esc interrupts` }) : null, popupOpen ? _jsx(MentionPopup, { items: candidates, selected: selIdx, query: mention.query }) : null, showModeSelector ? _jsx(ModeBar, { approval: status.approval }) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TopBorder, { name: status.sessionName || "session", width: w }), _jsx(Box, { borderStyle: "round", borderTop: false, borderColor: "gray", borderDimColor: true, paddingX: 1, width: w, children: _jsx(InputLine, { value: value, cursor: cursor, width: innerW, gutter: gutter, gutterColor: gutterColor, placeholder: placeholder }) }), vim ? _jsx(Text, { dimColor: true, children: mode === "normal" ? "  -- NORMAL --  i/a insert · h l 0 $ w b e move · x dd D cw p edit" : "  -- INSERT --  Esc → normal" }) : null, _jsx(Footer, { model: model, s: status, cwdShort: cwdShort, route: route }), popupOpen ? _jsx(MentionPopup, { items: candidates, selected: selIdx, query: mention.query }) : null] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.99.2",
+  "version": "0.100.0",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "dist/index.js"