greprag 5.76.0 → 5.78.0

package/dist/commands/init.js

@@ -719,6 +719,7 @@ function applyGrokHooks(config) {
     add('PreToolUse', '*', 'guard', 5, 'guard');
     add('Stop', '', 'store', 15, 'turn capture');
     add('Stop', '', 'drain', 8, 'inbox drain');
+    add('PostCompact', '', 'recompact', 15, 'Interrupt re-announce');
     add('PostCompact', '', 'session-id', 5, 'session-id');
     return changes;
 }
@@ -1411,14 +1412,27 @@ function applyCodexHooks(config) {
     else {
         changes.push('Codex Stop hook already configured (skipped)');
     }
-    const postCompactHook = {
+    const postCompactAnnounceHook = {
+        matcher: 'manual|auto',
+        hooks: [commandHook('recompact', 10, 'Re-announcing GrepRAG primers')],
+    };
+    if (!hasGrepragHookWithMatcher(config.hooks.PostCompact, 'recompact', postCompactAnnounceHook.matcher)) {
+        if (!config.hooks.PostCompact)
+            config.hooks.PostCompact = [];
+        config.hooks.PostCompact.push(postCompactAnnounceHook);
+        changes.push('Added Codex PostCompact hook (Interrupt re-announce)');
+    }
+    else {
+        changes.push('Codex PostCompact Interrupt re-announce hook already configured (skipped)');
+    }
+    const postCompactSessionHook = {
         matcher: 'manual|auto',
         hooks: [commandHook('session-id', 3, 'Restoring GrepRAG session id')],
     };
-    if (!hasGrepragHookWithMatcher(config.hooks.PostCompact, 'session-id', postCompactHook.matcher)) {
+    if (!hasGrepragHookWithMatcher(config.hooks.PostCompact, 'session-id', postCompactSessionHook.matcher)) {
         if (!config.hooks.PostCompact)
             config.hooks.PostCompact = [];
-        config.hooks.PostCompact.push(postCompactHook);
+        config.hooks.PostCompact.push(postCompactSessionHook);
         changes.push('Added Codex PostCompact hook (session-id awareness)');
     }
     else {
@@ -1432,6 +1446,7 @@ function normalizeCodexHookCommands(hooks) {
     const desired = {
         recap: { timeout: 10, statusMessage: 'Loading GrepRAG memory' },
         'codex-recap': { timeout: 10, statusMessage: 'Loading GrepRAG memory' },
+        recompact: { timeout: 10, statusMessage: 'Re-announcing GrepRAG primers' },
         'session-id': { timeout: 3, statusMessage: 'Loading GrepRAG session id' },
         drain: { timeout: 5, statusMessage: 'Draining GrepRAG inbox' },
         'codex-notify': { timeout: 300, statusMessage: 'Checking GrepRAG inbox', runner: 'greprag-codex-hook' },

package/dist/commands/opencode-interrupt.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OPENCODE_QUOTA_WAITLIST_ANNOUNCE = exports.opencodeRegistry = void 0;
 exports.buildOpenCodeEnv = buildOpenCodeEnv;
 exports.getOpenCodeAnnounces = getOpenCodeAnnounces;
+exports.getOpenCodePersistentAnnounces = getOpenCodePersistentAnnounces;
 exports.getOpenCodeReminders = getOpenCodeReminders;
 const reminder_registry_1 = require("./reminder-registry");
+const app_settings_1 = require("../app-settings");
 /** The opencode registry is DERIVED from the canon, never hand-whitelisted.
  *  Every REGISTRY module ships to opencode unless it declares a `harnesses`
  *  list excluding it (reminder-types.ts) — so a new module wired into
@@ -44,11 +46,18 @@ function buildOpenCodeEnv(params) {
         updateAvailable: params.updateAvailable ?? null,
         procedureAnnounces: params.procedureAnnounces ?? [],
         mirroredSkills: params.mirroredSkills,
+        personaAnnounce: params.personaAnnounce ?? null,
     };
 }
 function getOpenCodeAnnounces(env) {
-    return [...(0, reminder_registry_1.collectAnnounces)(env, exports.opencodeRegistry), exports.OPENCODE_QUOTA_WAITLIST_ANNOUNCE];
+    return [...(0, reminder_registry_1.collectAnnounces)(env, (0, app_settings_1.filterEnabledInterrupts)(exports.opencodeRegistry)), exports.OPENCODE_QUOTA_WAITLIST_ANNOUNCE];
+}
+/** OpenCode rebuilds output.system for every model call. Persona is the one
+ *  startup primer that must remain behaviorally active on later calls, so the
+ *  plugin replays this shared-registry module from its bounded session cache. */
+function getOpenCodePersistentAnnounces(env) {
+    return (0, reminder_registry_1.collectAnnounces)(env, (0, app_settings_1.filterEnabledInterrupts)(exports.opencodeRegistry.filter((m) => m.id === 'persona-announce')));
 }
 function getOpenCodeReminders(env) {
-    return (0, reminder_registry_1.collectReminders)(env, exports.opencodeRegistry);
+    return (0, reminder_registry_1.collectReminders)(env, (0, app_settings_1.filterEnabledInterrupts)(exports.opencodeRegistry));
 }

package/dist/commands/persona-reminder.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.personaAnnounceModule = void 0;
+exports.personaAnnounceModule = {
+    id: 'persona-announce',
+    detect: () => ({ tier: 'silent' }),
+    announce: (env) => env.personaAnnounce || null,
+    reminder: () => null,
+};

package/dist/commands/persona.js

@@ -0,0 +1,191 @@
+"use strict";
+/** greprag persona — tenant-scoped speaking instructions. adr: adr/persona.md
+ *
+ * Thin HTTP wrapper over /v1/persona. The server owns built-in template content;
+ * custom text is sent verbatim and injected without rewriting.
+ */
+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.runPersona = runPersona;
+const fs = __importStar(require("fs"));
+function getConfig() {
+    return {
+        apiUrl: process.env.GREPRAG_API_URL || 'https://api.greprag.com',
+        apiKey: process.env.GREPRAG_API_KEY || '',
+    };
+}
+function getFlag(args, flag) {
+    const idx = args.indexOf(flag);
+    return idx === -1 || idx + 1 >= args.length ? undefined : args[idx + 1];
+}
+const HELP = `greprag persona — tenant-scoped instructions for how agents speak to you
+
+USAGE
+  greprag persona list
+      List built-in Persona templates.
+
+  greprag persona use <template>
+      Activate a built-in template, e.g. vibe-shaper.
+
+  greprag persona set <text>
+  greprag persona set --file <path>
+  greprag persona set --stdin
+      Save and activate a custom Persona verbatim.
+
+  greprag persona show
+      Show the active Persona.
+
+  greprag persona clear
+      Remove the active Persona.`;
+async function api(method, pathname, body) {
+    const cfg = getConfig();
+    if (!cfg.apiKey) {
+        console.error('GREPRAG_API_KEY not set — run `greprag init` first.');
+        process.exit(1);
+    }
+    const res = await fetch(`${cfg.apiUrl}${pathname}`, {
+        method,
+        headers: {
+            'Authorization': `Bearer ${cfg.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    let data = {};
+    try {
+        data = await res.json();
+    }
+    catch { /* non-JSON */ }
+    return { ok: res.ok, status: res.status, data };
+}
+function fail(data, status) {
+    console.error(`Error${status ? ` (${status})` : ''}: ${data.error || 'request failed'}`);
+    process.exit(1);
+}
+function readPersonaInput(args) {
+    const file = getFlag(args, '--file');
+    if (file) {
+        try {
+            return file === '-' ? fs.readFileSync(0, 'utf-8') : fs.readFileSync(file, 'utf-8');
+        }
+        catch (err) {
+            console.error(`persona set: could not read --file ${file}: ${err.message}`);
+            process.exit(1);
+        }
+    }
+    if (args.includes('--stdin')) {
+        try {
+            return fs.readFileSync(0, 'utf-8');
+        }
+        catch (err) {
+            console.error(`persona set: could not read stdin: ${err.message}`);
+            process.exit(1);
+        }
+    }
+    return args.filter((a) => a !== '--stdin').join(' ');
+}
+async function list() {
+    const { ok, status, data } = await api('GET', '/v1/persona/templates');
+    if (!ok)
+        fail(data, status);
+    const templates = data.templates || [];
+    if (!templates.length) {
+        console.log('No built-in Persona templates.');
+        return;
+    }
+    console.log('Built-in Persona templates:\n');
+    for (const t of templates) {
+        console.log(`  ${t.id} — ${t.name}`);
+        console.log(`      ${t.description}`);
+    }
+}
+async function useTemplate(id) {
+    if (!id) {
+        console.error('Usage: greprag persona use <template>');
+        process.exit(1);
+    }
+    const { ok, status, data } = await api('PUT', '/v1/persona/template', { templateId: id });
+    if (!ok)
+        fail(data, status);
+    const p = data.persona;
+    console.log(`Persona active: ${p.templateId} (built-in template)`);
+}
+async function set(args) {
+    const content = readPersonaInput(args);
+    const { ok, status, data } = await api('PUT', '/v1/persona/custom', { content });
+    if (!ok)
+        fail(data, status);
+    const p = data.persona;
+    console.log(`Persona active: custom (${p.content?.length ?? content.length} chars)`);
+}
+async function show() {
+    const { ok, status, data } = await api('GET', '/v1/persona');
+    if (!ok)
+        fail(data, status);
+    const p = data.persona;
+    if (!p) {
+        console.log('No Persona set.');
+        return;
+    }
+    const source = p.mode === 'template' ? `template ${p.templateId}` : 'custom';
+    console.log(`Persona (${source})`);
+    console.log('');
+    console.log(p.content || '');
+}
+async function clear() {
+    const { ok, status, data } = await api('DELETE', '/v1/persona');
+    if (!ok)
+        fail(data, status);
+    console.log(data.removed ? 'Persona cleared.' : 'No Persona was set.');
+}
+async function runPersona(args) {
+    const sub = args[0];
+    const rest = args.slice(1);
+    if (!sub || sub === '--help' || sub === '-h' || sub === 'help') {
+        console.log(HELP);
+        return;
+    }
+    switch (sub) {
+        case 'list': return list();
+        case 'use': return useTemplate(rest[0]);
+        case 'set': return set(rest);
+        case 'show': return show();
+        case 'clear': return clear();
+        default:
+            console.error(`Unknown persona command: ${sub}\n`);
+            console.log(HELP);
+            process.exit(1);
+    }
+}

package/dist/commands/reminder-registry.js

@@ -28,6 +28,7 @@ const skill_mirror_reminder_1 = require("./skill-mirror-reminder");
 const procedure_reminder_1 = require("./procedure-reminder");
 const loadout_reminder_1 = require("./loadout-reminder");
 const delivery_reminder_1 = require("./delivery-reminder");
+const persona_reminder_1 = require("./persona-reminder");
 /** Registry order = display order. THE single agent-facing announce/reminder assembly:
  *  the hook does I/O → fills ReminderEnv → collectAnnounces (SessionStart) / collectReminders
  *  (per turn) render every module here in this order. A module may own either surface or both;
@@ -46,6 +47,7 @@ exports.REGISTRY = [
     skill_mirror_reminder_1.skillMirrorAnnounceModule, // native-equivalent activation index for load-only mirrored skills
     procedure_reminder_1.procedureAnnounceModule, // active project procedures, rendered generically from operator-owned installs
     delivery_reminder_1.deliveryControlModule, // repo-scoped announce-first Delivery System pilot (all harnesses)
+    persona_reminder_1.personaAnnounceModule, // tenant-scoped Persona, shared across projects/harnesses
     loadout_reminder_1.loadoutRegistrarModule, // equipped loadouts: one advisor announce each + per-turn keyword Match (docs/loadout.md)
     setup_reminder_1.setupWarningModule,
     version_reminder_1.versionUpgradeModule, // Deficiency-gated announce — silent unless a newer release exists

package/dist/commands/status.js

@@ -191,6 +191,7 @@ function buildStatus(cwd, platform = 'all') {
         pre_tool_use_chip_guard: hasCodexHook(codexHooks.hooks?.PreToolUse, 'codex-pretooluse')
             || hasCodexHook(codexHooks.hooks?.PreToolUse, 'codex-chip-hook'),
         stop_store: hasCodexHook(codexHooks.hooks?.Stop, 'codex-store'),
+        post_compact_reannounce: hasCodexHook(codexHooks.hooks?.PostCompact, 'recompact'),
         post_compact_session_id: hasCodexHook(codexHooks.hooks?.PostCompact, 'session-id'),
     };
     const opencodePluginInstalled = fs.existsSync(opencodePluginPath);

package/dist/hook.js

@@ -83,6 +83,7 @@ const guard_1 = require("./guard");
 // auto-silences when resolved (the arm-check pattern). The hook below assembles the
 // live env (ALL I/O) and emits; the modules are pure.
 const reminder_registry_1 = require("./commands/reminder-registry");
+const app_settings_1 = require("./app-settings");
 const inbox_primer_reminder_1 = require("./commands/inbox-primer-reminder");
 const skill_activation_manifest_1 = require("./skill-activation-manifest");
 const worktree_state_1 = require("./worktree-state");
@@ -1613,11 +1614,29 @@ async function recap(input, mode = 'plain', opts = {}) {
             return empty;
         }
     })();
+    // Tenant Persona primer. The server owns both template resolution and
+    // the provenance envelope; harnesses transport it unchanged. adr: adr/persona.md
+    const personaPromise = (async () => {
+        try {
+            const res = await fetch(`${cfg.apiUrl}/v1/persona`, {
+                headers: { 'Authorization': `Bearer ${cfg.apiKey}` },
+            });
+            if (!res.ok)
+                return null;
+            const data = await res.json();
+            return typeof data.announce === 'string' && data.announce.length > 0
+                ? data.announce
+                : null;
+        }
+        catch {
+            return null;
+        }
+    })();
     const updateAvailablePromise = checkForUpdate();
     const bodyPromise = (!opts.compact && anchor.sessionStartRecap)
         ? (0, opencode_plugin_helpers_1.buildRecapBody)(cfg.apiUrl, cfg.apiKey, anchor)
         : Promise.resolve('');
-    const [, corpusApiDocs, docPointers, enrichmentDown, skillGains, mirroredSkills, loadoutState, updateAvailable, body,] = await Promise.all([
+    const [, corpusApiDocs, docPointers, enrichmentDown, skillGains, mirroredSkills, loadoutState, personaAnnounce, updateAvailable, body,] = await Promise.all([
         matchsetPromise,
         corpusApiDocsPromise,
         docPointersPromise,
@@ -1625,6 +1644,7 @@ async function recap(input, mode = 'plain', opts = {}) {
         skillGainsPromise,
         mirroredSkillsPromise,
         loadoutStatePromise,
+        personaPromise,
         updateAvailablePromise,
         bodyPromise,
     ]);
@@ -1704,11 +1724,14 @@ async function recap(input, mode = 'plain', opts = {}) {
         mirroredSkills,
         procedureAnnounces,
         equippedLoadouts,
+        personaAnnounce,
         updateAvailable,
         activeCommandDrift: activeCommandDrift(),
         loadoutUpdateRequired,
     };
-    let announceReg = (0, reminder_injector_1.mechanicKilled)() ? reminder_registry_1.REGISTRY.filter(m => m.id !== 'mechanic-friction') : reminder_registry_1.REGISTRY;
+    let announceReg = (0, app_settings_1.filterEnabledInterrupts)(reminder_registry_1.REGISTRY);
+    if ((0, reminder_injector_1.mechanicKilled)())
+        announceReg = announceReg.filter(m => m.id !== 'mechanic-friction');
     if (!announceShort)
         announceReg = announceReg.filter(m => m.id !== 'watcher-arm');
     // PostCompact: a compaction wiped the once-loaded SessionStart announces from context.
@@ -2191,7 +2214,7 @@ async function coordinateGate(input) {
         toolCommand: typeof toolInput.command === 'string' ? toolInput.command : '',
         collisionPeers: peers,
     };
-    const fired = (0, reminder_registry_1.collectReminders)(env, (0, reminder_registry_1.commandModules)());
+    const fired = (0, reminder_registry_1.collectReminders)(env, (0, app_settings_1.filterEnabledInterrupts)((0, reminder_registry_1.commandModules)()));
     if (!fired.length)
         return;
     // Effect: inject as additionalContext — advisory heads-up, NO permission pause.
@@ -2264,7 +2287,10 @@ async function main() {
         // opt out per-module with reannounceOnCompact:false) so the doctrine the compaction
         // wiped (incl. the watcher-arm announce) returns. additionalContext = the JSON form
         // PostCompact injects. adr: adr/monitor-resilience.md, docs/reminder-interrupt.md
-        await recap(input, 'additionalContext', { compact: true });
+        await recap(input, 'additionalContext', {
+            compact: true,
+            platform: harness === 'grok' ? 'grok' : undefined,
+        });
     }
     else if (subcommand === 'codex-recap') {
         await recap(input, 'additionalContext', { platform: 'codex' });

package/dist/index.js

@@ -66,6 +66,7 @@ const doc_1 = require("./commands/doc");
 const parity_1 = require("./commands/parity");
 const agents_1 = require("./commands/agents");
 const loadout_1 = require("./commands/loadout");
+const persona_1 = require("./commands/persona");
 const assistant_1 = require("./commands/assistant");
 const email_1 = require("./commands/email");
 const sms_1 = require("./commands/sms");
@@ -79,6 +80,7 @@ const crush_stats_1 = require("./commands/crush-stats");
 const archive_1 = require("./commands/archive");
 const inbox_watch_1 = require("./commands/inbox-watch");
 const grok_spawn_1 = require("./commands/grok-spawn");
+const app_1 = require("./commands/app");
 const inbox_attachments_1 = require("./inbox-attachments");
 const discord_1 = require("./commands/discord");
 const project_anchor_1 = require("./project-anchor");
@@ -1284,6 +1286,8 @@ const HELP = `
 greprag — agent memory for Claude Code, Codex, OpenCode, and Grok Build
 
 Commands:
+  (no command)                    Open the local GrepRAG app
+  app | dashboard [--port N]      Open the local app (use --no-open on remote machines)
   init [--api-key <key>] [--tenant-id <handle>]
                                   Auto-detect/ask for Codex, Claude Code, or OpenCode
   init --claude [--api-key <key>] [--tenant-id <handle>]
@@ -1568,6 +1572,14 @@ Loadout (gift a skill bundle to another tenant — offer, never auto-install):
   loadout unequip <name> [--delete-skills]
                                 Stop a loadout's auto-inflate.
 
+Persona (tenant-scoped speaking instructions):
+  persona list                  List built-in Persona templates.
+  persona use <template>        Activate a built-in Persona template.
+  persona set <text>|--file <f>|--stdin
+                                Save and activate a custom Persona verbatim.
+  persona show                  Show the active Persona.
+  persona clear                 Remove the active Persona.
+
 GrepRAG Instructions (canonical global/repo CLAUDE.md + AGENTS.md):
   instructions pull <file> [--scope global|repo] [--push]
                                 Pull disk instructions into canon.
@@ -1607,6 +1619,7 @@ Other:
                                 full --help — the complete, always-current guide.
 
 Examples:
+  greprag                                            # open the local customer app
   greprag init                                       # standard repo setup
   greprag init --global                              # Cowork / unanchored sessions
   greprag init --all                                 # register every sibling repo for inbox
@@ -1639,6 +1652,7 @@ const HELP_ALL_GROUPS = [
     ['delivery', delivery_1.runDelivery],
     ['assistant', assistant_1.runAssistant],
     ['instructions', agents_1.runInstructions],
+    ['persona', persona_1.runPersona],
     ['doc', doc_1.runDoc],
     ['skill', skill_1.runSkill],
     ['opencode', opencode],
@@ -1833,7 +1847,11 @@ async function printHelpAll() {
 async function main() {
     const args = process.argv.slice(2);
     const command = args[0];
-    if (!command || command === 'help' || command === '--help' || command === '-h') {
+    if (!command) {
+        await (0, app_1.runApp)([]);
+        return;
+    }
+    if (command === 'help' || command === '--help' || command === '-h') {
         if (args.includes('--all')) {
             await printHelpAll();
             return;
@@ -1850,6 +1868,8 @@ async function main() {
     ensureEnv();
     const subArgs = args.slice(1);
     switch (command) {
+        case 'app':
+        case 'dashboard': return (0, app_1.runApp)(subArgs);
         case 'init': {
             if (subArgs.includes('--help') || subArgs.includes('-h') || subArgs.includes('help')) {
                 console.log(INIT_HELP);
@@ -1871,6 +1891,7 @@ async function main() {
             const name = getFlag(args, '--name');
             const root = getFlag(args, '--root');
             await (0, init_1.runInit)({ apiKey, tenantId, installWatcher, global, claude, opencode, codex, grok, all, name, root });
+            console.log('\n  Open your local settings any time with: greprag\n');
             return;
         }
         case 'project-id': {
@@ -1926,6 +1947,7 @@ async function main() {
         case 'instructions': return (0, agents_1.runInstructions)(subArgs); // Canonical GrepRAG Instructions + rendered followers
         case 'agents': return (0, agents_1.runAgents)(subArgs); // Deprecated alias for GrepRAG Instructions
         case 'loadout': return (0, loadout_1.runLoadout)(subArgs); // Loadout: cross-tenant skill-bundle gifting (docs/loadout.md)
+        case 'persona': return (0, persona_1.runPersona)(subArgs); // tenant-scoped speaking instructions
         case 'assistant': return (0, assistant_1.runAssistant)(subArgs); // designate this project as the tenant's Assistant (role flag)
         case 'opencode': return opencode(subArgs);
         case 'grok': return (0, grok_spawn_1.runGrok)(subArgs);