@nanhara/hara 0.105.0 → 0.107.0

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.107.0 — interjection triage: the model is the scheduler, the todo list is the queue
+
+- **Mid-task messages get triaged, not blindly folded in.** Typing while hara works always reached
+  the model between tool calls (type-ahead steering) — but nothing told it HOW to handle the
+  interjection. Now every mid-task message carries a triage contract, backed by a standing policy in
+  the system prompt: a **refinement** folds into the current task immediately; a **new independent
+  task** goes onto the todo queue (`todo_write`, one-line acknowledgment, current work continues);
+  something **urgent** — a bug, "stop", "this first" — finishes the current step safely (no half-done
+  edits), re-plans the queue, and switches immediately. Same architecture codex and Claude Code
+  landed on: no engine-level priority scheduler — classification is exactly what the model is best
+  at, and the todo list (with its live panel + attention refresh) is the task queue.
+
+## 0.106.0 — gateway session hygiene
+
+- **Idle chats auto-rotate to a fresh thread.** A WeChat/Feishu chat is one endless surface — days-old
+  context used to pile onto every new ask and the agent answered from stale state. Now a chat idle
+  past **8 hours** (HARA_GATEWAY_IDLE_HOURS to tune; 0 disables) starts the next message on a fresh
+  session, with a one-time notice carrying `/resume <id>` — the old thread persists, nothing is lost.
+  Same-afternoon follow-ups continue as before.
+
 ## 0.105.0 — fan-outs synthesize before acting
 
 - **Synthesis nudge** (the last adopted item from the Claude Code internals study — their KN5

package/dist/agent/loop.js

@@ -59,7 +59,9 @@ you can do. When analyzing a project, start wide in ONE batch — manifest (pack
 pyproject.toml / go.mod), README, build/CI config — then chase only what the task needs with narrow
 grep/glob; don't read whole large files when a targeted search answers the question. For broad,
 open-ended exploration (more than ~3 searches), spawn \`agent\` sub-agents — several in one response for
-independent questions (role "explore") — each returns conclusions, not dumps. For a multi-step task, call \`todo_write\` to plan a short checklist and keep it updated as
+independent questions (role "explore") — each returns conclusions, not dumps. Messages the user sends
+mid-task arrive marked as interjections — triage them (refine current / queue as todo / urgent-switch)
+instead of blindly folding everything into the current task; the todo list is your task queue. For a multi-step task, call \`todo_write\` to plan a short checklist and keep it updated as
 you go (one item in_progress at a time) — skip it for trivial one-step tasks. You have a persistent
 memory: use memory_search before answering about prior decisions,
 conventions, or the user's preferences, and memory_write to proactively save durable facts you learn.

package/dist/agent/reminders.js

@@ -30,6 +30,15 @@ export function wrapReminders(items) {
 /** 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;
+/** Prefix for a message the user sent MID-TASK (type-ahead steering). Carries the triage contract
+ *  inline (self-contained even for role-overridden runs): the model — not the engine — is the
+ *  scheduler, and the todo list is the task queue (codex/Claude-Code's model too: neither ships an
+ *  engine-level priority scheduler; classification is exactly what the LLM is best at). */
+export const INTERJECT_PREFIX = "[Sent while you were working on the above — TRIAGE before continuing: " +
+    "a refinement/correction of the current task → fold it in now; " +
+    "a NEW independent task → todo_write it onto the queue, acknowledge in one line, continue the current task; " +
+    "URGENT (a bug, \"stop\", \"this first\") → finish the current step safely (no half-done edits), " +
+    "todo_write the re-plan (current task → pending, this → in_progress), and switch to it immediately.]";
 /** Parallel fan-outs at/above this size get a synthesis nudge (CC's KN5 synthesizer, hara-shaped:
  *  instead of a dedicated merger agent, the MAIN model is reminded to merge before acting). */
 export const SYNTHESIS_MIN_AGENTS = 3;

package/dist/gateway/serve.js

@@ -245,6 +245,10 @@ export async function runGateway(opts) {
             }
         }
         const ctx = chatContext(adapter.name, m.chatId, cwd); // this chat's current { cwd, sessionId }
+        if (ctx.rotatedFrom) {
+            // Idle auto-rotation just happened (session hygiene): tell the user ONCE, with the escape hatch.
+            await adapter.send(m.chatId, `🧵 fresh thread (chat was idle) — /resume ${ctx.rotatedFrom.slice(-18)} continues the previous one`);
+        }
         const cmd = parseCommand(m.text);
         if (cmd) {
             if (cmd.cmd === "help")

package/dist/gateway/sessions.js

@@ -8,6 +8,16 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { createHash } from "node:crypto";
+/** Idle window before a chat auto-rotates to a FRESH session (hours). A WeChat/Feishu chat is one
+ *  endless surface — without this, days-old context piles onto every new ask and the agent answers
+ *  from stale state (the "gateway answers with old context" report). Default 8h: overnight gaps start
+ *  clean, a same-afternoon follow-up continues. HARA_GATEWAY_IDLE_HOURS tunes it; 0 disables. */
+export function idleRotationMs() {
+    const raw = Number(process.env.HARA_GATEWAY_IDLE_HOURS ?? 8);
+    if (!Number.isFinite(raw) || raw <= 0)
+        return 0; // 0/garbage → disabled
+    return raw * 3_600_000;
+}
 const dir = () => join(homedir(), ".hara", "gateway");
 const file = () => join(dir(), "chats.json");
 const mapKey = (platform, chatId) => `${platform}:${chatId}`;
@@ -37,17 +47,27 @@ export function chatContext(platform, chatId, defaultCwd) {
     const m = load();
     const k = mapKey(platform, chatId);
     const e = m[k];
+    const now = Date.now();
     if (!e) {
-        const fresh = { cwd: defaultCwd, sessionId: deriveId(platform, chatId, defaultCwd, 0), fork: 0 };
+        const fresh = { cwd: defaultCwd, sessionId: deriveId(platform, chatId, defaultCwd, 0), fork: 0, lastUsed: now };
         m[k] = fresh;
         save(m);
         return { cwd: fresh.cwd, sessionId: fresh.sessionId, voice: false };
     }
-    if (!e.cwd) {
+    if (!e.cwd)
         e.cwd = defaultCwd; // migrate an old (pre-cwd) entry, preserving its existing sessionId
-        save(m);
+    // Session hygiene: a chat idle past the window rotates to a fresh thread (same mechanics as /new).
+    // The OLD id is returned so the gateway can offer "/resume <id>" — nothing is lost, sessions persist.
+    const idleMs = idleRotationMs();
+    let rotatedFrom;
+    if (idleMs > 0 && typeof e.lastUsed === "number" && now - e.lastUsed > idleMs && e.sessionId) {
+        rotatedFrom = e.sessionId;
+        e.fork = (e.fork ?? 0) + 1;
+        e.sessionId = deriveId(platform, chatId, e.cwd, e.fork);
     }
-    return { cwd: e.cwd, sessionId: e.sessionId, voice: !!e.voice };
+    e.lastUsed = now;
+    save(m);
+    return { cwd: e.cwd, sessionId: e.sessionId, voice: !!e.voice, ...(rotatedFrom ? { rotatedFrom } : {}) };
 }
 /** `/voice` — toggle whether this chat's replies are spoken (TTS audio); returns the new state. */
 export function toggleVoice(platform, chatId) {

package/dist/index.js

@@ -26,6 +26,7 @@ import { loadPermissionRules, scaffoldPermissions, globalPermissionsPath, projec
 import { routingProvider } from "./agent/route.js";
 import { shouldAutoCompact, COMPACT_SYSTEM, buildFileRestore } from "./agent/compact.js";
 import { recentTouched } from "./agent/touched.js";
+import { INTERJECT_PREFIX } from "./agent/reminders.js";
 import { checkForUpdate } from "./update-check.js";
 import { formatContextReport } from "./agent/context-report.js";
 import { userTurnPreviews, rewindTo } from "./agent/rewind.js";
@@ -3054,7 +3055,7 @@ program.action(async (opts) => {
                         const attach = !r2.skip && r2.attach?.length ? r2.attach : undefined;
                         if (!body.trim() && !attach)
                             continue; // image-only message whose image was skipped → nothing to add
-                        out.push({ role: "user", content: `[I sent this while you were working on the above]\n\n${body}`, ...(attach ? { images: attach } : {}) });
+                        out.push({ role: "user", content: `${INTERJECT_PREFIX}\n\n${body}`, ...(attach ? { images: attach } : {}) });
                     }
                     return out;
                 };

package/package.json

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