@vincemakes/kiso-core 0.1.2 → 0.1.4

package/dist/kernel/loop.js

@@ -27,14 +27,14 @@
  * re-stream that duplicates output or tool calls.
  */
 import { isAdapterEvent } from "../protocol/adapter.js";
-import { estimateTokens, KEEP_RECENT_TURNS, microcompact } from "./compaction.js";
+import { estimateTokens, microcompact } from "./compaction.js";
 import { EventLog } from "./event-log.js";
 import { ToolRegistry } from "../tools/registry.js";
 import { validateArgs } from "../tools/validate.js";
 import { NoOpHooks } from "./hooks.js";
 import { resolveModeProfile } from "./mode.js";
 import { denialResult } from "./permission.js";
-import { messagesToEvents, projectMessages } from "./project.js";
+import { messagesToEvents, MICROCOMPACTABLE, projectMessages } from "./project.js";
 export const DEFAULT_MAX_TURNS = 10;
 export const DEFAULT_MAX_RETRIES = 2;
 export async function* loop(config) {
@@ -797,19 +797,42 @@ function sleep(ms, signal) {
     });
 }
 /**
- * C 区: the boundary seq for a microcompact — the seq of the user input
- * KEEP_RECENT_TURNS+1 places from the end (everything BEFORE that user
- * input is old enough to clear; the recent turns stay intact). Undefined
- * when the history is too short to clear anything.
+ * C 区 (自举 #3): how many of the NEWEST compactable tool results survive a
+ * microcompact boundary — the model must keep reasoning over the recent
+ * results, whatever turn they belong to.
+ */
+const KEEP_COMPACTABLE_RESULTS = 4;
+/**
+ * C 区: the boundary seq for a microcompact — drawn by COMPACTABLE-RESULT
+ * recentness, never user turns: a SINGLE user turn that reads several big
+ * files (the coding agent's main overflow shape) crosses the threshold and
+ * must trigger. The newest KEEP_COMPACTABLE_RESULTS still-visible
+ * compactable tool results stay intact; the boundary points AT the
+ * (K+1)th-newest of them, so it and everything older is cleared. Results
+ * already cleared by an earlier boundary do not count toward the kept
+ * window — each new boundary makes progress. Undefined when fewer than
+ * K+1 compactable results remain (the kept window is the whole context).
  */
 function microcompactBoundarySeq(events) {
-    const userSeqs = [];
+    const callName = new Map();
+    let lastCleared = -1;
+    for (const ev of events) {
+        if (ev.type === "tool_call_end")
+            callName.set(ev.callId, ev.name);
+        if (ev.type === "microcompacted" && ev.beforeSeq > lastCleared)
+            lastCleared = ev.beforeSeq;
+    }
+    const visible = [];
     for (const ev of events) {
-        if (ev.type === "user_input")
-            userSeqs.push(ev.seq);
+        if (ev.type !== "tool_result" || ev.seq <= lastCleared)
+            continue;
+        const name = callName.get(ev.callId);
+        if (name !== undefined && MICROCOMPACTABLE.has(name))
+            visible.push(ev.seq);
     }
-    const boundary = userSeqs[userSeqs.length - KEEP_RECENT_TURNS - 1];
-    return boundary !== undefined ? boundary - 1 : undefined;
+    if (visible.length <= KEEP_COMPACTABLE_RESULTS)
+        return undefined;
+    return visible[visible.length - KEEP_COMPACTABLE_RESULTS - 1];
 }
 /** A signal that never aborts — for executions outside any abort scope. */
 const NEVER_ABORT = {

package/dist/kernel/project.d.ts

@@ -22,6 +22,13 @@
 import type { Event } from "../protocol/events.js";
 import type { EventInput } from "./event-log.js";
 import type { AssistantBlock, Message, MessageSource } from "../protocol/messages.js";
+/**
+ * C 区: tools whose output is eligible for microcompact clearing — reads,
+ * listings, searches, and shell output. write/edit outputs are short and
+ * never cleared. Exported so the loop's boundary computation (自举 #3)
+ * counts exactly the results the projection can clear.
+ */
+export declare const MICROCOMPACTABLE: Set<string>;
 /** The tag that makes a tool result un-clearable (C 区). */
 export declare const DO_NOT_COMPACT = "do-not-compact";
 /**

package/dist/kernel/project.js

@@ -22,9 +22,10 @@
 /**
  * C 区: tools whose output is eligible for microcompact clearing — reads,
  * listings, searches, and shell output. write/edit outputs are short and
- * never cleared.
+ * never cleared. Exported so the loop's boundary computation (自举 #3)
+ * counts exactly the results the projection can clear.
  */
-const MICROCOMPACTABLE = new Set(["read_file", "list_dir", "search_text", "shell"]);
+export const MICROCOMPACTABLE = new Set(["read_file", "list_dir", "search_text", "shell"]);
 /** The tag that makes a tool result un-clearable (C 区). */
 export const DO_NOT_COMPACT = "do-not-compact";
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-core",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "kiso(\u57fa\u790e) core \u2014 protocol, event log, loop, hooks, modes, permissions, compaction, delivery truth. The 2,000-line kernel at the bottom of the kiso framework.",
   "type": "module",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "openai"
   ],
   "devDependencies": {
-    "@vincemakes/kiso-evals": "0.1.2",
+    "@vincemakes/kiso-evals": "0.1.4",
     "@types/node": "^26.1.2",
     "typescript": "^5.7.2",
     "vitest": "^3.0.0"