@nanhara/hara 0.112.0 → 0.112.2

package/CHANGELOG.md

@@ -5,6 +5,26 @@ 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.112.2 — moving/resizing the window no longer garbles the UI
+
+- **Terminal resize no longer stacks the status row + input box into a garble.** ink 6.8's resize
+  handler only clears the screen when the terminal gets *narrower*; on a *widen* (or a resize it doesn't
+  classify as narrowing) it just re-renders, so the old frame — reflowed at the new width — is never
+  erased, and the ~125ms spinner tick stacks a fresh copy each time (the "I moved the window and the UI
+  filled up with repeated `waiting for the model…` lines"). hara now hooks the resize event and, on ANY
+  resize, resets ink's tracked output (debounced across a drag's burst of events) so the next render
+  starts clean and subsequent ticks erase correctly. Not "just the terminal" — a real repaint fix.
+
+## 0.112.1 — the background-job indicator is now LIVE (even at idle)
+
+- **`⚙ N bg running` updates in real time — including when hara is idle.** In 0.112.0 the indicator only
+  refreshed while a turn was running, so once the agent finished but a background task (a preview server,
+  a watcher, a long render) was still going, the idle prompt looked exactly like "nothing running" — and
+  the user reads that as *"why did it just stop?"*. Now `jobs.ts` emits on every start / self-exit / kill
+  and the status row subscribes, so the indicator appears the moment a task starts, updates as tasks
+  finish on their own, and clears when the last one ends — event-driven, no polling. (`/jobs` remains the
+  on-demand detailed view.)
+
 ## 0.112.0 — /jobs: see (and manage) what's running in the background
 
 - **`/jobs` — a user-facing view of the agent's background shell jobs** (dev servers, watchers, long

package/dist/exec/jobs.js

@@ -7,6 +7,26 @@ import { shellCommand } from "../sandbox.js";
 const MAX_BUF = 64 * 1024; // retain only the tail of each job's combined output
 const jobs = new Map();
 let seq = 0;
+const jobsListeners = new Set();
+/** Subscribe to job start/exit/kill. Lets the UI show "a background task is running" LIVE — crucially at
+ *  IDLE too: a turn ending doesn't mean the background work did, and without this the user reads the idle
+ *  prompt as "it stopped". Returns an unsubscribe. */
+export function onJobsChange(fn) {
+    jobsListeners.add(fn);
+    return () => {
+        jobsListeners.delete(fn);
+    };
+}
+function emitJobsChange() {
+    for (const fn of jobsListeners) {
+        try {
+            fn();
+        }
+        catch {
+            /* a listener must never break job bookkeeping */
+        }
+    }
+}
 let hooked = false;
 function ensureExitCleanup() {
     if (hooked)
@@ -29,6 +49,7 @@ export function startJob(command, cwd, mode) {
         if (job.status === "running") {
             job.status = "exited";
             job.code = code;
+            emitJobsChange(); // a job finishing ON ITS OWN (no user action) must update the UI — this is the idle case
         }
     });
     child.on("error", (e) => {
@@ -36,9 +57,11 @@ export function startJob(command, cwd, mode) {
             job.status = "exited";
             job.code = -1;
             job.buf = (job.buf + `\n[spawn error] ${e.message}`).slice(-MAX_BUF);
+            emitJobsChange();
         }
     });
     jobs.set(job.id, job);
+    emitJobsChange();
     return job.id;
 }
 export function listJobs() {
@@ -64,6 +87,7 @@ export function killJob(id) {
         /* already gone */
     }
     j.status = "killed";
+    emitJobsChange();
     return true;
 }
 /** Terminate every running job — registered on process exit so dev servers don't outlive hara. */

package/dist/tui/App.js

@@ -18,7 +18,7 @@ import { accent } from "./theme.js";
 import { renderMarkdown } from "../md.js";
 import { clearTodos, currentTodos, onTodosChange } from "../tools/todo.js";
 import { onTurnPhase, turnPhase } from "../agent/phase.js";
-import { listJobs } from "../exec/jobs.js";
+import { listJobs, onJobsChange } from "../exec/jobs.js";
 import { ModelPicker } from "./model-picker.js";
 let _id = 0;
 const nid = () => ++_id;
@@ -273,7 +273,7 @@ function StatusRow({ working, todos, queued }) {
     // watcher) without asking. Live while working (spinner ticks re-render); best-effort at idle (/jobs is
     // the authoritative on-demand view). Re-read each render.
     const bg = listJobs().filter((j) => j.status === "running").length;
-    const bgTag = bg ? ` · ⚙ ${bg} bg (/jobs)` : "";
+    const bgTag = bg ? ` · ⚙ ${bg} bg running (/jobs)` : "";
     if (!working) {
         return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: `  ${IDLE_HINTS}${bgTag}` }) }));
     }
@@ -389,6 +389,12 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
         });
         return unsub;
     }, []);
+    // Subscribe to background-job start/exit/kill so the `⚙ N bg` indicator is LIVE — crucially at idle.
+    // A job finishing on its own, or a preview server still running after a turn ends, now refreshes the
+    // status row; without it the idle prompt reads as "it stopped". Bumping a nonce forces the re-render;
+    // StatusRow re-reads listJobs().
+    const [, setJobsTick] = useState(0);
+    useEffect(() => onJobsChange(() => setJobsTick((n) => n + 1)), []);
     // 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.
     // The array identities are fresh each flush so React/ink re-render exactly the minimal live region.

package/dist/tui/run.js

@@ -6,7 +6,35 @@ import { createElement } from "react";
 import { App } from "./App.js";
 export async function runTui(props) {
     const instance = render(createElement(App, props));
-    await instance.waitUntilExit();
+    // Resize repaint fix. ink 6.8's own resize handler only clears the screen when the terminal gets
+    // NARROWER; on a WIDEN (or a resize it doesn't classify as narrowing) it just re-renders, so the old
+    // frame — reflowed at the new width — is never erased, and the ~125ms spinner tick stacks a fresh copy
+    // each time (the "moved the window and the UI stacked up" garble). We complement it: on ANY resize,
+    // clear ink's tracked output so the next render starts clean. Debounced by a microtask so a burst of
+    // resize events during a window drag collapses to one clear.
+    const out = process.stdout;
+    let pending = false;
+    const onResize = () => {
+        if (pending)
+            return;
+        pending = true;
+        queueMicrotask(() => {
+            pending = false;
+            try {
+                instance.clear();
+            }
+            catch {
+                /* best-effort — never let a repaint fix crash the session */
+            }
+        });
+    };
+    out.on("resize", onResize);
+    try {
+        await instance.waitUntilExit();
+    }
+    finally {
+        out.off("resize", onResize);
+    }
 }
 // A tiny ink yes/no prompt for pre-TUI confirms (e.g. the first-run "create AGENTS.md?" offer).
 // MUST be ink, NOT readline: a readline question before the main TUI leaves stdin in a state ink

package/package.json

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