@gamaze/hicortex 0.13.0 → 0.13.2

package/dist/transcript-reader.d.ts

@@ -7,6 +7,8 @@
  * The reader scans for new sessions since the last nightly run
  * and feeds them to the existing distiller pipeline.
  */
+import type { CursorMap } from "./capture-cursors.js";
+export type { CursorMap };
 export interface TranscriptBatch {
     sessionId: string;
     projectName: string;
@@ -18,6 +20,25 @@ export interface TranscriptBatch {
      * `claude-code/<project>`. Lets per-harness readers stamp their own origin.
      */
     sourceAgent?: string;
+    /**
+     * Per-session cursor key (`<prefix>:<sessionId>`) — the capture-cursors.json
+     * key whose value gates and advances this session's incremental capture (#189).
+     */
+    cursorKey: string;
+    /** Cursor value the delta starts from (entries already captured before this run). */
+    startCursor: number;
+    /**
+     * Shrink-guard generation for this session — woven into segment ids so
+     * post-reset segments can't collide with pre-reset ids on the content-blind
+     * server dedup. Advanced back to the store with the cursor.
+     */
+    generation: number;
+    /**
+     * End-cursor value for each delta entry (length === entries.length). The
+     * packer uses these to land segment boundaries on exact entry boundaries.
+     * JSONL: startCursor + i + 1. Hermes: the row's messages.id.
+     */
+    entryCursors: number[];
 }
 /**
  * Cheap pre-filter: skip CC session FILES with fewer than this many raw JSONL
@@ -36,4 +57,4 @@ export declare const MIN_TRANSCRIPT_ENTRIES = 4;
  * Read all CC transcripts modified since `since`.
  * Returns one batch per session file.
  */
-export declare function readCcTranscripts(since: Date, projectsDir?: string): TranscriptBatch[];
+export declare function readCcTranscripts(since: Date, projectsDir?: string, cursors?: CursorMap): TranscriptBatch[];

package/dist/transcript-reader.js

@@ -32,7 +32,7 @@ const CC_PROJECTS_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude
  * Read all CC transcripts modified since `since`.
  * Returns one batch per session file.
  */
-function readCcTranscripts(since, projectsDir = CC_PROJECTS_DIR) {
+function readCcTranscripts(since, projectsDir = CC_PROJECTS_DIR, cursors = {}) {
     const batches = [];
     let projectDirs;
     try {
@@ -74,7 +74,10 @@ function readCcTranscripts(since, projectsDir = CC_PROJECTS_DIR) {
             // Skip files not modified since last run
             if (fileStat.mtime <= since)
                 continue;
-            const batch = parseTranscriptFile(filePath, projectName);
+            const sessionId = (0, node_path_1.basename)(filePath, ".jsonl");
+            const key = `cc:${sessionId}`;
+            const pos = cursors[key] ?? { cursor: 0, gen: 0 };
+            const batch = parseTranscriptFile(filePath, projectName, key, pos.cursor, pos.gen);
             if (batch) {
                 batches.push(batch);
             }
@@ -83,10 +86,15 @@ function readCcTranscripts(since, projectsDir = CC_PROJECTS_DIR) {
     return batches;
 }
 /**
- * Parse a single .jsonl transcript file into a batch.
- * Returns null if the file has too few meaningful entries.
+ * Parse a single .jsonl transcript file into a delta batch.
+ *
+ * Returns null if the file has too few meaningful entries (whole-file gate) or
+ * the cursor already covers everything (nothing new since last capture, #189).
+ *
+ * @param cursorKey capture-cursors.json key for this session
+ * @param startCursor entries already captured (delta = entries.slice(startCursor))
  */
-function parseTranscriptFile(filePath, projectName) {
+function parseTranscriptFile(filePath, projectName, cursorKey, startCursor, generation) {
     let raw;
     try {
         raw = (0, node_fs_1.readFileSync)(filePath, "utf-8");
@@ -98,30 +106,55 @@ function parseTranscriptFile(filePath, projectName) {
     if (lines.length < exports.MIN_TRANSCRIPT_ENTRIES)
         return null; // degenerate/empty file
     const entries = [];
-    let lastTimestamp = "";
+    const timestamps = [];
     for (const line of lines) {
         try {
             const entry = JSON.parse(line);
             entries.push(entry);
-            if (entry.timestamp) {
-                lastTimestamp = entry.timestamp;
-            }
+            timestamps.push(typeof entry.timestamp === "string" ? entry.timestamp : "");
         }
         catch {
-            // Skip malformed lines
+            // Skip malformed lines — a permanently-malformed line is skipped
+            // identically every run, and a partial trailing write fails JSON.parse
+            // now and parses (at the same index) once fully flushed.
         }
     }
+    // Whole-file degeneracy gate stays on the full parse, not the delta.
     if (entries.length < exports.MIN_TRANSCRIPT_ENTRIES)
         return null;
-    // Extract session ID from filename (UUID.jsonl)
-    const sessionId = (0, node_path_1.basename)(filePath, ".jsonl");
+    // Shrink guard: a truncated/rotated file with fewer entries than the stored
+    // cursor → reset to 0 AND bump the generation. The generation is woven into
+    // the segment id downstream so the fresh file's segments can never collide
+    // with the pre-reset ids on the server's content-blind dedup (fix 8).
+    let start = startCursor;
+    let gen = generation;
+    if (start > entries.length) {
+        start = 0;
+        gen = generation + 1;
+    }
+    const delta = entries.slice(start);
+    if (delta.length === 0)
+        return null; // cursor already covers the whole file
+    // Per-entry end cursors: entry i (0-based in the delta) ends at start+i+1.
+    const entryCursors = delta.map((_, i) => start + i + 1);
+    // Date from the LAST timestamped entry in the delta (per-night created_at for
+    // multi-day sessions), falling back to today.
+    let lastTimestamp = "";
+    for (let i = start; i < entries.length; i++) {
+        if (timestamps[i])
+            lastTimestamp = timestamps[i];
+    }
     return {
-        sessionId,
+        sessionId: (0, node_path_1.basename)(filePath, ".jsonl"),
         projectName,
         date: lastTimestamp
             ? lastTimestamp.slice(0, 10)
             : new Date().toISOString().slice(0, 10),
-        entries,
+        entries: delta,
+        cursorKey,
+        startCursor: start,
+        generation: gen,
+        entryCursors,
     };
 }
 /**

package/dist/types.d.ts

@@ -115,6 +115,16 @@ export interface ConsolidationReport {
         calls_by_stage: Record<string, number>;
     };
 }
+/**
+ * A single per-stage override inside the nested `models` server-config block.
+ * Consumed by `applyModelsBlock` (llm.ts), which re-exports this type.
+ */
+export interface ModelTierOverride {
+    model?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    provider?: string;
+}
 /** Plugin configuration from openclaw.plugin.json configSchema. */
 export interface HicortexConfig {
     licenseKey?: string;
@@ -145,6 +155,16 @@ export interface HicortexConfig {
     classifyApiKey?: string;
     /** Optional provider for the classify endpoint (defaults to the base provider). */
     classifyProvider?: string;
+    /**
+     * Server config (NOT an OC-plugin key): nested per-stage model overrides.
+     * `{ score|distill|reflect|classify: { model?, baseUrl?, apiKey?, provider? } }`.
+     * Normalized onto the flat `llm*` / `distill*` / `reflect*` / `classify*`
+     * keys at read time (see applyModelsBlock in llm.ts); nested wins, and the
+     * flat keys remain supported at lower precedence. Happy path is a single model via
+     * `llmModel`; use this block only for per-stage routing. `score.provider` is
+     * ignored (base provider comes from llmBackend).
+     */
+    models?: Record<string, ModelTierOverride>;
     /** @deprecated Consolidation is owned by the server nightly. */
     consolidateHour?: number;
     /** @deprecated The OC plugin no longer opens its own database. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "Self-learning memory for AI agents \u2014 experience captured automatically, distilled into lessons overnight, shared across your whole fleet. Works with Hermes, OpenClaw, Claude Code, and Pi.",
   "main": "dist/index.js",
   "bin": {