@nanhara/hara 0.104.0 → 0.106.0

package/CHANGELOG.md

@@ -5,6 +5,22 @@ 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.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
+  synthesizer, hara-shaped): when a round returns **3+ parallel agent reports**, a silent
+  system-reminder tells the model to merge them first — reconcile overlaps and conflicts explicitly,
+  note what only one report saw, state the merged conclusion — instead of anchoring on whichever
+  report happens to sit last in context. Rides the 0.100.0 reminder layer; no new machinery.
+
 ## 0.104.0 — compaction keeps your working files + honest context accounting
 
 Closes the last two adopted items from the Claude Code internals study, and un-breaks the release

package/dist/agent/loop.js

@@ -11,7 +11,7 @@ import { classifyRisk, guardianVeto, guardianEnabled, newBreaker, recordBlock }
 import { subdirHint } from "../context/subdir-hints.js";
 import { classifyError, failoverAction, errorHint } from "./failover.js";
 import { currentTodos, renderTodos } from "../tools/todo.js";
-import { drainReminders, wrapReminders, pushReminder, todoStaleReminder, TODO_STALE_ROUNDS } from "./reminders.js";
+import { drainReminders, wrapReminders, pushReminder, todoStaleReminder, TODO_STALE_ROUNDS, synthesisReminder, SYNTHESIS_MIN_AGENTS } from "./reminders.js";
 import { setTurnPhase } from "./phase.js";
 import { recordTouch } from "./touched.js";
 import { resolve as resolvePath } from "node:path";
@@ -422,6 +422,14 @@ export async function runAgent(history, opts) {
         }
         await flush();
         history.push({ role: "tool", results });
+        // Synthesis nudge (CC's KN5, hara-shaped): a round that fanned out to several parallel agents just
+        // produced N independent reports — remind the model to merge/reconcile them before acting, instead
+        // of anchoring on whichever report happens to sit last in context.
+        if (!opts.quiet) {
+            const fanout = r.toolUses.filter((tu) => tu.name === "agent").length;
+            if (fanout >= SYNTHESIS_MIN_AGENTS)
+                pushReminder(synthesisReminder(fanout));
+        }
         // 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).

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;
+/** 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;
+/** The synthesis nudge: N independent reports just landed — reconcile before acting. */
+export function synthesisReminder(n) {
+    return (`You just received ${n} parallel agent reports. Before acting, SYNTHESIZE them into one coherent ` +
+        "picture: reconcile overlaps and conflicts explicitly (say which report wins and why), note anything " +
+        "only one report saw, and state the merged conclusion. Don't act on a single report in isolation.");
+}
 /** 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` +

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/package.json

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