@hmharness/kernel 0.5.3 → 0.5.4

package/dist/loop.js

@@ -8,12 +8,16 @@
  * transcript is compacted against the context budget.
  */
 import { compactMessages, compactWithDigest, transcriptChars } from "./context.js";
-import { adaptiveContextChars } from "./window.js";
+import { adaptiveContextChars, adaptiveMaxTurns } from "./window.js";
 import { chat } from "./provider.js";
 export async function runLoop(opts) {
     const { provider, registry, ctx, events } = opts;
     const modelCall = opts.chatImpl ?? chat;
-    const maxTurns = opts.maxTurns ?? 25;
+    // Turn limit scales with the model's context window: 25 for small models,
+    // up to 80 for 1M-window models. The context compaction keeps the
+    // transcript within budget throughout, so the real ceiling is how many
+    // reasoning turns the model can sustain, not raw token count.
+    const maxTurns = opts.maxTurns ?? adaptiveMaxTurns(provider);
     const budget = opts.maxContextChars ?? adaptiveContextChars(provider);
     const working = [...opts.messages];
     let toolUses = 0;
@@ -108,7 +112,7 @@ export async function runLoop(opts) {
             });
         }
     }
-    const text = `Turn budget exhausted (${maxTurns}). Last state preserved in the session log.`;
+    const text = `Turn limit reached (${maxTurns} turns). The session is preserved — continue with "hmh resume" or just send another message to pick up where this left off.`;
     events?.onFinal?.(text, maxTurns);
     return { text, turns: maxTurns, toolUses, messages: working, usage };
 }

package/dist/window.d.ts

@@ -38,3 +38,13 @@ export declare function adaptiveContextChars(p: {
     model: string;
     contextWindow?: number;
 }): number;
+/** Adaptive turn limit: larger context windows sustain more turns before
+ *  quality degrades (the context budget system compacts throughout, so the
+ *  real ceiling is how many turns the model can reason over, not raw token
+ *  count). Floor 25 (small models), cap 80 (even 1M windows don't need more).
+ *  This fixes the "25 turns auto-stop" complaint — the context engineering
+ *  was working fine, the turn cap was the bottleneck. */
+export declare function adaptiveMaxTurns(p: {
+    model: string;
+    contextWindow?: number;
+}): number;

package/dist/window.js

@@ -45,3 +45,13 @@ export function contextBudgetChars(windowTokens) {
 export function adaptiveContextChars(p) {
     return contextBudgetChars(contextWindowFor(p).windowTokens);
 }
+/** Adaptive turn limit: larger context windows sustain more turns before
+ *  quality degrades (the context budget system compacts throughout, so the
+ *  real ceiling is how many turns the model can reason over, not raw token
+ *  count). Floor 25 (small models), cap 80 (even 1M windows don't need more).
+ *  This fixes the "25 turns auto-stop" complaint — the context engineering
+ *  was working fine, the turn cap was the bottleneck. */
+export function adaptiveMaxTurns(p) {
+    const budget = contextBudgetChars(contextWindowFor(p).windowTokens);
+    return Math.max(25, Math.min(80, Math.floor(budget / 4000)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmharness/kernel",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "hmharness kernel: tool registry, provider adapters, the agent loop, session log, config. Zero runtime dependencies (Node >=22 native fetch).",
   "type": "module",
   "main": "dist/index.js",