@gamaze/hicortex 0.22.3 → 0.23.0

package/dist/sweep-volatile.d.ts

@@ -0,0 +1,55 @@
+/**
+ * `hicortex sweep-volatile` (#489, deliverable iii — owner decision 3).
+ *
+ * The ONE-SHOT store sweep: the live corpus already holds the GH-status /
+ * version-bump rows gold set A adjudicated ("not healthy to have GH in mem").
+ * This command reuses the SAME deterministic gate the distill path applies
+ * (distiller.ts isVolatileStatusEntry — one gate, one meaning) over the stored
+ * corpus. Mirrors `dedup`:
+ *
+ *   - DRY RUN by default: report candidates only, zero writes.
+ *   - `--apply` is explicit and ordered capture-lock (fail fast) →
+ *     pre-sweep backup (abort ALL writes if it fails) → one transaction.
+ *   - NO hard deletes: swept rows are DEMOTED via storage.absorbMemory —
+ *     status 'absorbed' (recall-invisible everywhere: vector + FTS rows
+ *     dropped, and every read path already handles the state), plain row +
+ *     links retained as evidence. Recovery posture = the dedup posture: the
+ *     pre-sweep backup IS the rollback. The shared absorb primitive means no
+ *     new status vocabulary to thread through candidate paths.
+ *   - Tags cleared + domain NULL'd before absorb (dedup's rule: an absorbed
+ *     row must not count in moduleIndex/tag recomputes).
+ *   - Audit trail: one `volatile_sweep_log` row per swept memory (migration
+ *     v23) — inspectable forever, never silent. No runtime consumer; the
+ *     CAPTURE-side volatility gate is the re-ingest safety net.
+ *
+ * Server-mode only (needs the local DB), like dedup/relink/classify-domains.
+ */
+import { acquireCaptureLock } from "./capture.js";
+export interface SweepVolatileOptions {
+    /** Execute the sweep. Default false = dry run (report only, zero writes). */
+    apply?: boolean;
+    /** DB path override (tests / manual snapshot verification). */
+    dbPath?: string;
+    /** State dir override (tests). Defaults to ~/.hicortex. Backup lands under
+     *  here/backups/. */
+    stateDir?: string;
+    /** Config override (tests). Defaults to reading stateDir/config.json. */
+    config?: Record<string, unknown> | null;
+    /** Capture-lock acquirer override (tests). Defaults to capture.ts's lock. */
+    acquireLock?: typeof acquireCaptureLock;
+}
+export interface SweepVolatileReport {
+    dryRun: boolean;
+    /** Live rows the gate flags, in store order. Empty when the kill-switch is
+     *  off (the sweep is inert without the gate — same release-managed switch,
+     *  one meaning). */
+    candidates: Array<{
+        id: string;
+        preview: string;
+    }>;
+    /** --apply only: rows actually swept (absorbed). */
+    swept?: number;
+    /** --apply only: path to the pre-sweep backup. */
+    backupPath?: string;
+}
+export declare function runSweepVolatile(options?: SweepVolatileOptions): Promise<SweepVolatileReport>;

package/dist/sweep-volatile.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * `hicortex sweep-volatile` (#489, deliverable iii — owner decision 3).
+ *
+ * The ONE-SHOT store sweep: the live corpus already holds the GH-status /
+ * version-bump rows gold set A adjudicated ("not healthy to have GH in mem").
+ * This command reuses the SAME deterministic gate the distill path applies
+ * (distiller.ts isVolatileStatusEntry — one gate, one meaning) over the stored
+ * corpus. Mirrors `dedup`:
+ *
+ *   - DRY RUN by default: report candidates only, zero writes.
+ *   - `--apply` is explicit and ordered capture-lock (fail fast) →
+ *     pre-sweep backup (abort ALL writes if it fails) → one transaction.
+ *   - NO hard deletes: swept rows are DEMOTED via storage.absorbMemory —
+ *     status 'absorbed' (recall-invisible everywhere: vector + FTS rows
+ *     dropped, and every read path already handles the state), plain row +
+ *     links retained as evidence. Recovery posture = the dedup posture: the
+ *     pre-sweep backup IS the rollback. The shared absorb primitive means no
+ *     new status vocabulary to thread through candidate paths.
+ *   - Tags cleared + domain NULL'd before absorb (dedup's rule: an absorbed
+ *     row must not count in moduleIndex/tag recomputes).
+ *   - Audit trail: one `volatile_sweep_log` row per swept memory (migration
+ *     v23) — inspectable forever, never silent. No runtime consumer; the
+ *     CAPTURE-side volatility gate is the re-ingest safety net.
+ *
+ * Server-mode only (needs the local DB), like dedup/relink/classify-domains.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSweepVolatile = runSweepVolatile;
+const paths_js_1 = require("./paths.js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const db_js_1 = require("./db.js");
+const storage = __importStar(require("./storage.js"));
+const distiller_js_1 = require("./distiller.js");
+const capture_js_1 = require("./capture.js");
+const config_read_js_1 = require("./config-read.js");
+const calibration_js_1 = require("./calibration.js");
+const backup_js_1 = require("./backup.js");
+const HICORTEX_HOME = (0, paths_js_1.hicortexHome)();
+/** Pre-sweep backup filename pattern — scoped retention (like pre-dedup). */
+const PRE_SWEEP_BACKUP_PATTERN = /^pre-sweep-volatile-.*\.db$/;
+function readConfig(stateDir) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(stateDir, "config.json"), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Live-row filter: active or content-rewritten rows only. Already-retired
+ *  states are not candidates — 'absorbed' is invisible already; 'superseded'
+ *  / 'retracted' are demoted already. */
+const LIVE_ROW_WHERE = `COALESCE(status, '') NOT IN ('absorbed', 'superseded', 'retracted')`;
+/**
+ * Pre-sweep DB backup to <stateDir>/backups/pre-sweep-volatile-<ISO>.db,
+ * pruned to `backupRetention` newest (pattern-scoped, like pre-dedup).
+ * THROWS on failure — runSweepVolatile aborts the whole sweep when it does.
+ */
+async function takePreSweepBackup(db, stateDir, config) {
+    const backupDir = (0, node_path_1.join)(stateDir, "backups");
+    (0, node_fs_1.mkdirSync)(backupDir, { recursive: true });
+    const backupPath = (0, node_path_1.join)(backupDir, `pre-sweep-volatile-${new Date().toISOString().replace(/[:.]/g, "-")}.db`);
+    await db.backup(backupPath);
+    const retention = (0, config_read_js_1.readNonNegativeConfig)(config ?? {}, "backupRetention", backup_js_1.DEFAULT_BACKUP_RETENTION);
+    (0, backup_js_1.pruneBackupArtifacts)(backupDir, retention, PRE_SWEEP_BACKUP_PATTERN);
+    return backupPath;
+}
+async function runSweepVolatile(options = {}) {
+    const stateDir = options.stateDir ?? HICORTEX_HOME;
+    const config = options.config !== undefined ? options.config : readConfig(stateDir);
+    // Server-mode only — client installs have no local DB.
+    if (config?.mode === "client") {
+        throw new Error("[hicortex] sweep-volatile is server-mode only (it needs the local DB). " +
+            `This machine is a client of ${config.serverUrl ?? "a remote server"} — run sweep-volatile on the server.`);
+    }
+    const apply = options.apply ?? false;
+    const dbPath = (0, db_js_1.resolveDbPath)(options.dbPath);
+    const db = (0, db_js_1.initDb)(dbPath);
+    try {
+        console.log(`[hicortex] sweep-volatile starting (${apply ? "APPLY" : "dry-run"}): db ${dbPath}`);
+        const rows = db
+            .prepare(`SELECT id, content FROM memories WHERE ${LIVE_ROW_WHERE}`)
+            .all();
+        const candidates = calibration_js_1.VOLATILE_STATUS_FILTER
+            ? rows
+                .filter((r) => (0, distiller_js_1.isVolatileStatusEntry)(r.content))
+                .map((r) => ({ id: r.id, preview: r.content.slice(0, 120) }))
+            : [];
+        if (!calibration_js_1.VOLATILE_STATUS_FILTER) {
+            console.warn("[hicortex] sweep-volatile: the volatility gate is switched off in this release (VOLATILE_STATUS_FILTER) — nothing to sweep.");
+        }
+        const report = { dryRun: !apply, candidates };
+        console.log(`[hicortex] sweep-volatile: ${candidates.length} volatile row(s) among ${rows.length} live (` +
+            `${apply ? "demoting via absorb" : "dry run — zero writes"})`);
+        if (!apply) {
+            for (const c of candidates) {
+                console.log(`[hicortex]   ${c.id.slice(0, 8)}: "${c.preview}"`);
+            }
+            if (candidates.length === 0)
+                console.log("[hicortex]   (nothing matched the gate)");
+            return report;
+        }
+        if (candidates.length === 0)
+            return report;
+        // --apply: fail fast on a busy capture lock — the audit rows and absorb
+        // writes must not race a nightly/capture run (dedup posture).
+        const acquireLock = options.acquireLock ?? capture_js_1.acquireCaptureLock;
+        const releaseLock = await acquireLock(stateDir, 0);
+        if (!releaseLock) {
+            throw new Error("[hicortex] sweep-volatile --apply aborted: another capture/nightly run holds the lock. Retry when it finishes.");
+        }
+        try {
+            // Backup FIRST — abort entirely (no writes attempted) if it fails.
+            let backupPath;
+            try {
+                backupPath = await takePreSweepBackup(db, stateDir, config);
+            }
+            catch (err) {
+                throw new Error(`[hicortex] sweep-volatile --apply aborted: backup failed (${err instanceof Error ? err.message : String(err)}). No rows swept.`);
+            }
+            console.log(`[hicortex] Backup written: ${backupPath}`);
+            report.backupPath = backupPath;
+            // ONE transaction: audit row + tag/domain clear + absorb per row. Any
+            // failure rolls back the whole sweep (all-or-nothing, like /distill's
+            // insert phase) — a partial sweep is never left behind.
+            const sweep = db.transaction(() => {
+                const clearTags = db.prepare("DELETE FROM memory_tags WHERE memory_id = ?");
+                const audit = db.prepare("INSERT OR REPLACE INTO volatile_sweep_log (memory_id, swept_at, preview) VALUES (?, ?, ?)");
+                const now = new Date().toISOString();
+                for (const c of candidates) {
+                    audit.run(c.id, now, c.preview);
+                    clearTags.run(c.id);
+                    storage.updateMemory(db, c.id, { domain: null });
+                    storage.absorbMemory(db, c.id);
+                }
+            });
+            sweep();
+            report.swept = candidates.length;
+            console.log(`[hicortex] sweep-volatile: swept (absorbed) ${report.swept} row(s); ` +
+                `rollback = restore ${backupPath}`);
+            return report;
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/types.d.ts

@@ -37,9 +37,13 @@ export interface Memory {
      * never config: NULL/absent = active (the default, and every pre-v14 row);
      * 'superseded'/'retracted' = marked stale or wrong (demoted in ranking);
      * 'corrected' = rewritten in place (does NOT demote — demoting it would
-     * bury the correction); 'absorbed' = invisible to recall (trigger memory
-     * folded into a corrected target — no vector/FTS row, plain row + link
-     * kept as evidence and rollback reference).
+     * bury the correction); 'absorbed' = invisible to recall (no vector/FTS
+     * row, plain row + links kept as evidence and rollback reference). Writers
+     * of 'absorbed': the reconsolidation rewrite path (trigger folded into a
+     * corrected target), dedup merge losers (#392), and the one-shot
+     * `sweep-volatile` demotion (#489 — volatile rows retire through the SAME
+     * primitive, so no new status vocabulary exists to thread through read
+     * paths; recovery is the pre-sweep backup).
      */
     status?: string | null;
     /**
@@ -128,8 +132,13 @@ export interface ResolutionBandStat {
     merge_below_gate: number;
     /** Sum of verdict confidences (divide by `pairs` for the mean). Deterministic merges count 1.0 each. */
     conf_sum: number;
-    /** Deterministic band only: clusters refused by the metadata rails. */
-    metadata_skipped?: number;
+    /**
+     * Deterministic band only: clusters refused by the project rail. #206
+     * decision 2 renamed this from `metadata_skipped` when the source_agent
+     * rail was removed — pre-rename cumulative values stay on disk unread
+     * (their semantics conflated both rails).
+     */
+    project_skipped?: number;
 }
 /**
  * Report of the deterministic merge zone (#392) — the band at/above the merge
@@ -151,8 +160,8 @@ export interface DeterministicMergeZoneReport {
     losers_merged: number;
     /** Loser links re-pointed onto canonicals this run. */
     links_repointed: number;
-    /** Clusters skipped — members disagree on project / source_agent. */
-    skipped_metadata_mismatch: number;
+    /** Clusters skipped — members disagree on project (#206 decision 2: the source_agent rail is removed). */
+    skipped_project_mismatch: number;
     /**
      * #393 guard-C: clusters skipped because a member pair holds a `conflicts`
      * link — a judge-flagged genuine conflict is never blended, both records
@@ -251,27 +260,15 @@ export interface ConsolidationReport {
             heuristic_fallback?: number;
             failed: number;
         };
-        /** Supersession detection (#191 Phase B) — runs after linking, before decay/prune. */
-        supersession?: {
-            /** Decision/correction-shaped candidates examined this run. */
-            scanned: number;
-            /** Older-neighbor pairs actually sent to the classify-tier LLM. */
-            evaluated: number;
-            /** Pairs the LLM judged superseded — a `superseded_by` link was created. */
-            superseded: number;
-            /** Pairs skipped on a parse/infra error (retried naturally next night). */
-            skipped_infra: number;
-            /** Pairs skipped because a superseded_by link already existed (either direction). */
-            skipped_idempotent: number;
-            /** supersessionCursor after this run (unchanged in dry-run). */
-            cursor: number;
-        };
         /**
-         * Reconsolidation (#384) — runs after supersession, before decay/prune.
+         * Reconsolidation (#384) — runs after linking, before decay/prune.
          * Since #392 this is THE unified resolution stage: its verdict also carries
          * a `merge` disposition, and the deterministic merge zone (pairs at/above
          * the merge ceiling — release-managed since #408) runs inside it,
-         * LLM-free, before the scan.
+         * LLM-free, before the scan. Since #206-B (owner decision 6) it is also
+         * the ONLY true-update detector — the standalone supersession stage
+         * (3.7, #191 Phase B) is retired into its `supersedes` verdict action,
+         * and its former `supersession` report slot no longer exists.
          */
         reconsolidation?: {
             /** Candidates examined this run (rowid > cursor; no shape filter). */
@@ -358,11 +355,12 @@ export interface ConsolidationReport {
              */
             skipped_above_ceiling: number;
             /**
-             * #392: judged merge pairs refused by the metadata rails (project /
-             * source_agent disagreement). Both memories kept; the cursor advances —
-             * the verdict was rendered, this is not an infra failure.
+             * #392: judged merge pairs refused by the project rail (project
+             * disagreement — the only metadata rail, #206 decision 2). Both
+             * memories kept; the cursor advances — the verdict was rendered, this
+             * is not an infra failure.
              */
-            skipped_metadata_mismatch: number;
+            skipped_project_mismatch: number;
             /**
              * #393 guard-C: verdicts that flagged a genuine conflict — a `conflicts`
              * link was written, both memories stay live (no status change, no

package/dist/wrapper-prompt.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The shared wrapper-prompt classifier (#489).
+ *
+ * ONE function imported by BOTH recall layers — the CC hook client
+ * (recall-hook-cli.ts buildHookRequest) and the server handler
+ * (recall-index.ts handleRecallIndex) — so the two can never drift on what
+ * counts as harness plumbing.
+ *
+ * What CC delivers as user-role wrapper messages (wild-verified over 250
+ * sampled session files + the latest live recall_pushes rows, #489
+ * refinement): `<task-notification>`, `<agent-message>`, local-command-caveat`,
+ * `<command-name>`/`<command-message>`/`<command-args>` (slash-command
+ * envelope), `<local-command-stdout>`, `<system-reminder>`, and
+ * `[Request interrupted…]` markers. These reach /recall-index verbatim today —
+ * ~15% of live pushes — inflating shown_count, burning hook latency, and
+ * polluting the Memory Precision denominator.
+ *
+ * The rule (owner decision 4, refinement A1 — skip ONLY pure plumbing):
+ * strip every known wrapper element, then measure PAYLOAD PROSE = the text
+ * left outside wrappers PLUS the bodies of `<result>` elements and
+ * `<agent-message>` elements (the payload channels — a subagent hand-back is
+ * real prose even though it arrives wrapped; the gold-set exception recalled
+ * usefully). Pure wrapper ⟺ payload prose is shorter than
+ * RECALL_MIN_PROMPT_CHARS — the SAME bar as the short-prompt gate: one
+ * constant, one meaning, "enough words to recall on". `<summary>` ("Agent X
+ * finished") and `<note>` are plumbing, never prose — otherwise every
+ * notification would pass and the skip would never fire.
+ *
+ * Conservative by construction:
+ *   - NO wrapper marker at all → not a pure wrapper, whatever the length (a
+ *     short plain prompt is the short-prompt gate's business, not this one).
+ *   - A malformed or truncated wrapper does not match its strip regex, so its
+ *     text counts as payload prose → not a pure wrapper → recalls.
+ *   - An empty string is NOT classified here — the caller's empty check owns
+ *     that case.
+ */
+/**
+ * True when the prompt is PURE plumbing: after removing known wrapper
+ * elements, the payload prose (leftover text + result/agent-message bodies)
+ * is shorter than RECALL_MIN_PROMPT_CHARS. False for anything prose-bearing,
+ * malformed, wrapper-free, or empty — those recall exactly as today.
+ */
+export declare function isPureWrapperPrompt(prompt: string): boolean;

package/dist/wrapper-prompt.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * The shared wrapper-prompt classifier (#489).
+ *
+ * ONE function imported by BOTH recall layers — the CC hook client
+ * (recall-hook-cli.ts buildHookRequest) and the server handler
+ * (recall-index.ts handleRecallIndex) — so the two can never drift on what
+ * counts as harness plumbing.
+ *
+ * What CC delivers as user-role wrapper messages (wild-verified over 250
+ * sampled session files + the latest live recall_pushes rows, #489
+ * refinement): `<task-notification>`, `<agent-message>`, local-command-caveat`,
+ * `<command-name>`/`<command-message>`/`<command-args>` (slash-command
+ * envelope), `<local-command-stdout>`, `<system-reminder>`, and
+ * `[Request interrupted…]` markers. These reach /recall-index verbatim today —
+ * ~15% of live pushes — inflating shown_count, burning hook latency, and
+ * polluting the Memory Precision denominator.
+ *
+ * The rule (owner decision 4, refinement A1 — skip ONLY pure plumbing):
+ * strip every known wrapper element, then measure PAYLOAD PROSE = the text
+ * left outside wrappers PLUS the bodies of `<result>` elements and
+ * `<agent-message>` elements (the payload channels — a subagent hand-back is
+ * real prose even though it arrives wrapped; the gold-set exception recalled
+ * usefully). Pure wrapper ⟺ payload prose is shorter than
+ * RECALL_MIN_PROMPT_CHARS — the SAME bar as the short-prompt gate: one
+ * constant, one meaning, "enough words to recall on". `<summary>` ("Agent X
+ * finished") and `<note>` are plumbing, never prose — otherwise every
+ * notification would pass and the skip would never fire.
+ *
+ * Conservative by construction:
+ *   - NO wrapper marker at all → not a pure wrapper, whatever the length (a
+ *     short plain prompt is the short-prompt gate's business, not this one).
+ *   - A malformed or truncated wrapper does not match its strip regex, so its
+ *     text counts as payload prose → not a pure wrapper → recalls.
+ *   - An empty string is NOT classified here — the caller's empty check owns
+ *     that case.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPureWrapperPrompt = isPureWrapperPrompt;
+const calibration_js_1 = require("./calibration.js");
+/**
+ * Opening-tag detector — the precondition: only a prompt that actually
+ * CARRIES a known wrapper marker can be a pure wrapper. Bare and unclosed
+ * tags both match this; the strip pass below then decides how much survives
+ * as prose.
+ */
+const WRAPPER_MARKER = /<(?:task-notification|agent-message|local-command-caveat|command-name|command-message|command-args|local-command-stdout|system-reminder|result)\b/;
+/** Interrupt-marker presence — carries the same precondition weight as a
+ *  wrapper tag (a marker-only prompt has no tags to detect). */
+const INTERRUPT_MARKER_ANY = /\[Request interrupted by user[^\]]*\]/;
+/**
+ * Wrapper element signatures. Non-greedy, bounded (the cleanMessageContent
+ * regex posture — no unbounded backtracking on pathological input; bodies
+ * beyond the cap fail to match and count as prose, the conservative
+ * direction). `[\s\S]` so multi-line bodies strip correctly.
+ *
+ * Payload channels (`task-notification`'s `<result>`, `agent-message` bodies)
+ * are handled separately below — their content is EXTRACTED as prose, not
+ * stripped as plumbing.
+ */
+const WRAPPER_ELEMENTS = [
+    // task-notification: envelope stripped; an inner <result> body is harvested
+    // as prose by PAYLOAD_ELEMENT_BODIES (runs BEFORE this strip).
+    /<task-notification[^>]*>[\s\S]{0,50000}?<\/task-notification>/g,
+    /<local-command-caveat>[\s\S]{0,10000}?<\/local-command-caveat>/g,
+    /<command-name>[\s\S]{0,1000}?<\/command-name>/g,
+    /<command-message>[\s\S]{0,5000}?<\/command-message>/g,
+    /<command-args>[\s\S]{0,10000}?<\/command-args>/g,
+    /<local-command-stdout[^>]*>[\s\S]{0,100000}?<\/local-command-stdout>/g,
+    /<system-reminder[^>]*>[\s\S]{0,10000}?<\/system-reminder>/g,
+    // Payload-channel ENVELOPES strip here too — AFTER their bodies were
+    // harvested below (harvest runs first). The tags themselves are plumbing:
+    // an empty <agent-message></agent-message> must leave nothing behind, and
+    // a lone <result>…</result> must measure only its body.
+    /<agent-message[^>]*>[\s\S]{0,100000}?<\/agent-message>/g,
+    /<result[^>]*>[\s\S]{0,100000}?<\/result>/g,
+];
+/**
+ * Payload channels — bodies that COUNT AS PROSE even though they sit inside a
+ * wrapper: the `<result>` of a task-notification (a report) and the full body
+ * of an `<agent-message>` (inter-agent prose, e.g. a subagent hand-back).
+ * `<agent-message>` is NOT in WRAPPER_ELEMENTS for exactly this reason: its
+ * whole body is payload, so it is harvested here and never stripped.
+ */
+const PAYLOAD_ELEMENT_BODIES = [
+    /<result[^>]*>([\s\S]{0,100000}?)<\/result>/g,
+    /<agent-message[^>]*>([\s\S]{0,100000}?)<\/agent-message>/g,
+];
+/** Interrupt markers — whole-line plumbing (either flavor). */
+const INTERRUPT_MARKER = /^\s*\[Request interrupted by user[^\]]*\]\s*$/gm;
+/**
+ * True when the prompt is PURE plumbing: after removing known wrapper
+ * elements, the payload prose (leftover text + result/agent-message bodies)
+ * is shorter than RECALL_MIN_PROMPT_CHARS. False for anything prose-bearing,
+ * malformed, wrapper-free, or empty — those recall exactly as today.
+ */
+function isPureWrapperPrompt(prompt) {
+    if (!prompt)
+        return false;
+    if (!WRAPPER_MARKER.test(prompt) && !INTERRUPT_MARKER_ANY.test(prompt))
+        return false;
+    let payload = "";
+    // Harvest payload-channel bodies FIRST (agent-message is never stripped;
+    // task-notification's <result> is harvested before its envelope strips).
+    for (const re of PAYLOAD_ELEMENT_BODIES) {
+        for (const m of prompt.matchAll(re)) {
+            payload += " " + (m[1] ?? "");
+        }
+    }
+    // Strip the remaining wrapper envelopes + interrupt markers; what is left
+    // over is outside-wrapper prose.
+    let rest = prompt;
+    for (const re of WRAPPER_ELEMENTS) {
+        rest = rest.replace(re, " ");
+    }
+    rest = rest.replace(INTERRUPT_MARKER, " ");
+    payload += " " + rest;
+    // Whitespace-collapsed length is the prose bar — indentation and newlines
+    // are not words.
+    const prose = payload.replace(/\s+/g, " ").trim();
+    return prose.length < calibration_js_1.RECALL_MIN_PROMPT_CHARS;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.22.3",
+  "version": "0.23.0",
   "description": "Persistent agent identity for AI agents \u2014 a hand-edited identity layer, nightly-distilled experience, and lessons injected every session, shared across your whole fleet. Works with Hermes, OpenClaw, Claude Code, Pi, and opencode.",
   "main": "dist/index.js",
   "bin": {

package/server.json

@@ -3,12 +3,12 @@
   "name": "io.github.gamaze-labs/hicortex",
   "title": "Hicortex \u2014 AI Fleet Memory",
   "description": "Shared fleet memory for AI agents: nightly self-correction, recall every prompt (supported agents).",
-  "version": "0.22.3",
+  "version": "0.23.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@gamaze/hicortex",
-      "version": "0.22.3",
+      "version": "0.23.0",
       "transport": {
         "type": "stdio",
         "command": "npx",