greprag 5.79.0 → 5.80.0

package/dist/commands/announce.js

@@ -0,0 +1,97 @@
+"use strict";
+/** `greprag announce` — print the full SessionStart announce.
+ *
+ *  The Claude Code harness inlines only ~2KB of hook context (measured; see
+ *  ANNOUNCE_INLINE_BUDGET). The recap hook therefore parks the complete announce
+ *  under ~/.greprag/announce/<session>.md and inlines a pointer naming this
+ *  command. Without it the overflow is unreachable — which is exactly the
+ *  failure this exists to end.
+ *
+ *  adr: adr/announce-inline-budget.md
+ */
+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.runAnnounce = runAnnounce;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const session_id_1 = require("../session-id");
+function announceDir() {
+    return path.join(os.homedir(), '.greprag', 'announce');
+}
+/** Newest cached announce, by mtime. Used when no session id is given — the
+ *  common case, since an agent asking for its own announce rarely wants to
+ *  first go find its session id. */
+function newestCached() {
+    try {
+        const dir = announceDir();
+        const files = fs.readdirSync(dir)
+            .filter(f => f.endsWith('.md'))
+            .map(f => ({ f, t: fs.statSync(path.join(dir, f)).mtimeMs }))
+            .sort((a, b) => b.t - a.t);
+        return files.length ? path.join(dir, files[0].f) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function runAnnounce(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write('greprag announce — print the full SessionStart announce\n\n'
+            + 'USAGE\n'
+            + '  greprag announce [--session <8hex>] [--path]\n\n'
+            + '  The harness inlines only ~2KB of session-start context. The rest is\n'
+            + '  parked on disk; this prints all of it.\n\n'
+            + '  --session <8hex>  a specific session (default: most recent)\n'
+            + '  --path            print the cache file path instead of its contents\n');
+        return;
+    }
+    const i = args.indexOf('--session');
+    const wanted = i !== -1 ? args[i + 1] : undefined;
+    const file = wanted
+        ? path.join(announceDir(), `${(0, session_id_1.truncateSessionId)(wanted) || wanted}.md`)
+        : newestCached();
+    if (!file || !fs.existsSync(file)) {
+        process.stderr.write('No cached announce found. It is written at SessionStart, so a session '
+            + 'must have started since this greprag version was installed.\n');
+        process.exitCode = 1;
+        return;
+    }
+    if (args.includes('--path')) {
+        process.stdout.write(file + '\n');
+        return;
+    }
+    process.stdout.write(fs.readFileSync(file, 'utf-8').trimEnd() + '\n');
+}

package/dist/commands/init.js

@@ -1459,13 +1459,26 @@ function applySettings(settings, apiKey) {
         matcher: '',
         hooks: [{ type: 'command', command: 'greprag-hook store', timeout: 10000 }],
     };
+    // Migrate stale installs onto the every-source matcher. `hasGrepragHook` only
+    // asks whether a recap hook EXISTS, so an install written by an older version
+    // kept its narrow matcher forever while init reported "already configured".
+    // Field state 2026-09-03: `matcher: 'startup'`, so a resumed session — and
+    // every /new and dashboard-dispatched agent — got no announce at all, Persona
+    // included. Same failure and same fix as the Grok path above.
+    // adr: adr/announce-inline-budget.md
+    const retargetedRecap = settings.hooks.SessionStart
+        ? retargetGrepragHookMatcher(settings.hooks.SessionStart, 'recap', ['startup', 'startup|resume', 'startup|resume|compact', 'startup|clear|compact'], recapHook.matcher)
+        : 0;
+    if (retargetedRecap > 0) {
+        changes.push(`Retargeted SessionStart recap matcher to every source (${retargetedRecap})`);
+    }
     if (!hasGrepragHook(settings.hooks.SessionStart, 'recap')) {
         if (!settings.hooks.SessionStart)
             settings.hooks.SessionStart = [];
         settings.hooks.SessionStart.push(recapHook);
         changes.push('Added SessionStart hook (memory recap + inbox digest)');
     }
-    else {
+    else if (retargetedRecap === 0) {
         changes.push('SessionStart hook already configured (skipped)');
     }
     if (!hasGrepragHook(settings.hooks.Stop, 'store')) {

package/dist/commands/reminder-registry.js

@@ -5,10 +5,12 @@
  *  PURE over ReminderEnv — the hook assembles env (i/o) and emits the returned lines;
  *  a broken module never blocks a turn (fail-open per module). */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compactReannounceModules = exports.commandModules = exports.promptModules = exports.harnessModules = exports.REGISTRY = void 0;
+exports.ANNOUNCE_HARNESS_CAP = exports.ANNOUNCE_INLINE_BUDGET = exports.compactReannounceModules = exports.commandModules = exports.promptModules = exports.harnessModules = exports.REGISTRY = void 0;
 exports.collectReminders = collectReminders;
 exports.bootOrder = bootOrder;
 exports.collectAnnounces = collectAnnounces;
+exports.collectAnnounceBlocks = collectAnnounceBlocks;
+exports.fitAnnounceBudget = fitAnnounceBudget;
 const os_primer_reminder_1 = require("./os-primer-reminder");
 const inbox_primer_reminder_1 = require("./inbox-primer-reminder");
 const load_primer_reminder_1 = require("./load-primer-reminder");
@@ -147,3 +149,89 @@ function collectAnnounces(env, registry = exports.REGISTRY) {
     }
     return out;
 }
+/** Same as collectAnnounces, but keeps each block paired with the module that
+ *  produced it so the budget fitter can rank and name them.
+ *  adr: adr/announce-inline-budget.md */
+function collectAnnounceBlocks(env, registry = exports.REGISTRY) {
+    const out = [];
+    for (const m of bootOrder(registry)) {
+        let a = null;
+        try {
+            a = m.announce(env);
+        }
+        catch {
+            continue;
+        }
+        if (a)
+            out.push({ id: m.id, text: a });
+    }
+    return out;
+}
+/** Bytes of SessionStart context a harness will actually inline. MEASURED, not
+ *  guessed: Claude Code wraps any hook output over 2048 bytes in
+ *  `<persisted-output>`, spills the full text to a tool-results file, and injects
+ *  only "Preview (first 2KB)". This is true of BOTH raw stdout and the
+ *  `additionalContext` envelope — the cap is on inline context, not the channel.
+ *  Measured 2026-09-03 with an 80-marker ruler: markers 250..2000 arrived, 2250
+ *  and beyond did not. 1800 leaves headroom for the harness's own wrapper text.
+ *  adr: adr/announce-inline-budget.md */
+exports.ANNOUNCE_INLINE_BUDGET = 1650;
+/** The harness's hard ceiling. Past this, output is replaced by a 2KB preview and
+ *  a `<persisted-output>` file reference. ANNOUNCE_INLINE_BUDGET must stay under
+ *  it with room for the trailing memory-recap pointer. */
+exports.ANNOUNCE_HARNESS_CAP = 2048;
+/** Inline-worthiness ranking, most-keepable first. The rule: a block earns inline
+ *  space when it is SHORT, SESSION-SPECIFIC, and available nowhere else. A block
+ *  that is long, static, and already loadable on demand does not — it is exactly
+ *  what `greprag load` exists for. Anything unlisted sorts last.
+ *
+ *  Persona leads because it is 523 bytes of tenant-set speaking instructions that
+ *  no other surface carries. The grepragOS laws are deliberately NOT here: 1753
+ *  bytes of static doctrine that `greprag load os` already serves on demand, which
+ *  until now consumed the entire budget and starved everything behind it. */
+const ANNOUNCE_PRIORITY = [
+    'persona-announce',
+    'setup-warning',
+    'version-upgrade',
+    'enrichment-health',
+    'watcher-arm',
+    'skill-mirror-announce',
+    'delivery-control',
+    'doc-pointer-announce',
+];
+function announceRank(id) {
+    const i = ANNOUNCE_PRIORITY.indexOf(id);
+    return i === -1 ? ANNOUNCE_PRIORITY.length : i;
+}
+/** Fit the announce into the harness's inline budget.
+ *
+ *  Returns the blocks that fit (restored to boot order, so a primer still precedes
+ *  anything that depends on it) plus the ids that did not. The caller is expected
+ *  to persist the FULL text and give the agent a way to read it — dropping content
+ *  silently is the failure this whole mechanism exists to end.
+ *
+ *  A single block larger than the budget is never emitted; it would blow the cap
+ *  on its own and take everything after it down too. */
+function fitAnnounceBudget(blocks, budget = exports.ANNOUNCE_INLINE_BUDGET, reserve = 0) {
+    const order = new Map(blocks.map((b, i) => [b.id, i]));
+    const ranked = [...blocks].sort((a, b) => {
+        const d = announceRank(a.id) - announceRank(b.id);
+        return d !== 0 ? d : (order.get(a.id) - order.get(b.id));
+    });
+    const kept = [];
+    const droppedIds = [];
+    let used = reserve;
+    const SEP = 2; // the '\n\n' join between blocks
+    for (const b of ranked) {
+        const cost = b.text.length + (kept.length ? SEP : 0);
+        if (used + cost <= budget) {
+            kept.push(b);
+            used += cost;
+        }
+        else {
+            droppedIds.push(b.id);
+        }
+    }
+    kept.sort((a, b) => order.get(a.id) - order.get(b.id));
+    return { kept, droppedIds };
+}

package/dist/hook.js

@@ -40,8 +40,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.announceCachePath = announceCachePath;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const crypto = __importStar(require("crypto"));
 const proc_1 = require("./proc");
 const docptr_refs_1 = require("./docptr-refs");
@@ -1334,6 +1336,43 @@ function grokSidecarHead(short, full) {
         + 'Chip: `greprag load grok-chip-spawn` then `greprag grok spawn`. Helper: spawn_subagent. Parent keeps ONE watch. Peers: `greprag inbox watchers` then `greprag send`.\n'
         + 'If a greprag inbox monitor is already listed, do not start another. Instant exit = already armed.\n\n';
 }
+/** Where the full, unabridged announce is parked for on-demand reading.
+ *  adr: adr/announce-inline-budget.md */
+function announceCachePath(short) {
+    return path.join(os.homedir(), '.greprag', 'announce', `${short}.md`);
+}
+/** Assemble the SessionStart announce so it SURVIVES the harness's inline cap.
+ *
+ *  Writes the full text to the announce cache, inlines the highest-value blocks
+ *  that fit the budget, and — when anything was left out — appends one line that
+ *  NAMES the omitted sections and the command that prints them. The old behavior
+ *  emitted all 18.5KB and let the harness silently keep the first 2KB.
+ *
+ *  Returns null when there is nothing to announce. */
+function buildInlineAnnounce(blocks, short) {
+    if (!blocks.length)
+        return null;
+    const full = blocks.map(b => b.text).join('\n\n');
+    if (short) {
+        try {
+            const file = announceCachePath(short);
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, full, 'utf-8');
+        }
+        catch { /* cache is a convenience; never block session start */ }
+    }
+    // Reserve room for the pointer line before fitting, so adding it can never be
+    // what pushes the payload over the cap.
+    const POINTER_RESERVE = 220;
+    const { kept, droppedIds } = (0, reminder_registry_1.fitAnnounceBudget)(blocks, reminder_registry_1.ANNOUNCE_INLINE_BUDGET, POINTER_RESERVE);
+    if (!droppedIds.length)
+        return kept.map(b => b.text).join('\n\n') || null;
+    const names = droppedIds.join(', ');
+    const pointer = `[greprag announce — ${droppedIds.length} more section(s) not inlined `
+        + `(harness caps SessionStart context at ${reminder_registry_1.ANNOUNCE_INLINE_BUDGET}b): ${names}. `
+        + `Read them with \`greprag announce\`.]`;
+    return [...kept.map(b => b.text), pointer].join('\n\n');
+}
 function writeRecapOutput(text, mode, grokShort, grokFull) {
     if (grokShort)
         (0, grok_session_1.writeGrokSidecar)(grokShort, grokSidecarHead(grokShort, grokFull) + (text || ''));
@@ -1737,7 +1776,12 @@ async function recap(input, mode = 'plain', opts = {}) {
     // adr: adr/monitor-resilience.md, docs/reminder-interrupt.md
     if (opts.compact)
         announceReg = (0, reminder_registry_1.compactReannounceModules)(announceReg);
-    const announceBlock = (0, reminder_registry_1.collectAnnounces)(announceEnv, announceReg).join('\n\n') || null;
+    // Fit the announce to what the harness will actually inline (2048 bytes; see
+    // ANNOUNCE_INLINE_BUDGET). The full text is persisted first and the overflow is
+    // NAMED, so nothing is lost silently — the failure this replaces was an 18.5KB
+    // announce of which only the first ~2KB ever reached a session, with no signal
+    // that the rest existed. adr: adr/announce-inline-budget.md
+    const announceBlock = buildInlineAnnounce((0, reminder_registry_1.collectAnnounceBlocks)(announceEnv, announceReg), (0, session_id_1.truncateSessionId)(input.session_id));
     if (opts.compact) {
         writeRecapOutput(announceBlock ? announceBlock + '\n' : '', mode, grokShort, input.session_id);
         return;
@@ -1773,7 +1817,17 @@ async function recap(input, mode = 'plain', opts = {}) {
         parts.push(announceBlock);
         parts.push('');
     }
-    parts.push(body);
+    // The memory recap shares the SAME inline cap as the announce — it is appended
+    // to the very payload the harness truncates. Inline it only if it fits in what
+    // the announce left; otherwise name the command that prints it. Silently
+    // emitting a body that pushes the payload over the cap is what made the whole
+    // announce disappear. adr: adr/announce-inline-budget.md
+    const usedSoFar = parts.join('\n').length;
+    const roomForBody = reminder_registry_1.ANNOUNCE_INLINE_BUDGET - usedSoFar;
+    parts.push(body.length <= roomForBody
+        ? body
+        : '[greprag memory — session recap not inlined (over the SessionStart cap). '
+            + 'Read it with `greprag memory recap`.]');
     writeRecapOutput(parts.join('\n') + '\n', mode, grokShort, input.session_id);
 }
 /** Arm-state detection moved LOCAL (2026-06-04). The former `isSessionArmed`
@@ -2233,7 +2287,12 @@ async function main() {
     }
     const harness = (0, harness_1.inferCurrentHarness)();
     if (subcommand === 'recap') {
-        await recap(input, harness === 'grok' ? 'additionalContext' : 'plain', {
+        // ALWAYS additionalContext. Raw stdout is treated by the Claude Code harness
+        // like command output: past ~2KB it spills to a file and injects a preview,
+        // which silently ate ~89% of an 18.7KB announce (Persona sits at byte 10,841).
+        // additionalContext is the documented injection channel. Grok keeps its
+        // sidecar via the platform arg. adr: adr/announce-delivery-channel.md
+        await recap(input, 'additionalContext', {
             platform: harness === 'grok' ? 'grok' : undefined,
         });
     }

package/dist/index.js

@@ -299,6 +299,10 @@ function readProjectRegistry() {
  *    desk ensure   idempotently spawn a detached desk-line if none is running
  *    desk status   is a desk-line up + what local truth would it report now
  *  adr: adr/desk-line-relay.md */
+async function runAnnounce(args) {
+    const { runAnnounce: run } = await Promise.resolve().then(() => __importStar(require('./commands/announce')));
+    run(args);
+}
 async function runDesk(args) {
     ensureEnv(); // load ~/.greprag/.env so GREPRAG_API_KEY is present (self-heals in the detached child)
     const sub = args[0] || 'status';
@@ -1906,6 +1910,10 @@ async function main() {
             return;
         }
         case 'inbox': return inbox(subArgs);
+        // The full SessionStart announce. The harness inlines only ~2KB of it, so the
+        // overflow is parked here and the inline pointer names this command.
+        // adr: adr/announce-inline-budget.md
+        case 'announce': return runAnnounce(subArgs);
         case 'desk': return runDesk(subArgs);
         case 'email': return (0, email_1.runEmail)(subArgs);
         case 'send': return send(subArgs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "greprag",
-  "version": "5.79.0",
+  "version": "5.80.0",
   "description": "Private GrepRAG client for existing Claude Code, Codex, OpenCode, and Grok Build tenants.",
   "main": "dist/index.js",
   "bin": {